From 5ff1f7237a4401fe44304f7cc631f2ac8a050c61 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 14 Feb 2023 21:35:16 +0800
Subject: [PATCH 01/80] initial commit of quantileGK

---
 .../AggregateFunctionQuantile.h               |   3 +
 .../AggregateFunctionQuantileGK.cpp           |  70 +++
 src/AggregateFunctions/QuantileGK.h           | 442 ++++++++++++++++++
 .../registerAggregateFunctions.cpp            |   2 +
 4 files changed, 517 insertions(+)
 create mode 100644 src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
 create mode 100644 src/AggregateFunctions/QuantileGK.h

diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index 49157acf690..ab7edcd082e 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -250,4 +250,7 @@ struct NameQuantilesBFloat16 { static constexpr auto name = "quantilesBFloat16";
 struct NameQuantileBFloat16Weighted { static constexpr auto name = "quantileBFloat16Weighted"; };
 struct NameQuantilesBFloat16Weighted { static constexpr auto name = "quantilesBFloat16Weighted"; };
 
+struct NameQuantileGK { static constexpr auto name = "quantileGK"; };
+struct NameQuantilesGK { static constexpr auto name = "quantilesGK"; };
+
 }
diff --git a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp b/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
new file mode 100644
index 00000000000..54174f3be44
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
@@ -0,0 +1,70 @@
+#include <AggregateFunctions/AggregateFunctionQuantile.h>
+#include <AggregateFunctions/QuantileGK.h>
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/Helpers.h>
+#include <DataTypes/DataTypeDate.h>
+#include <DataTypes/DataTypeDateTime.h>
+#include <Core/Field.h>
+
+namespace DB
+{
+
+namespace
+{
+
+template <typename Value, bool _> using FuncQuantileGK = AggregateFunctionQuantile<Value, QuantileGK<Value>, NameQuantileGK, true, void, false>;
+template <typename Value, bool _> using FuncQuantilesGK = AggregateFunctionQuantile<Value, QuantileGK<Value>, NameQuantilesGK, true, void, true>;
+
+
+template <template <typename, bool> class Function>
+AggregateFunctionPtr createAggregateFunctionQuantile(
+    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
+{
+    /// Second argument type check doesn't depend on the type of the first one.
+    Function<void, true>::assertSecondArg(argument_types);
+
+    const DataTypePtr & argument_type = argument_types[0];
+    WhichDataType which(argument_type);
+
+#define DISPATCH(TYPE) \
+    if (which.idx == TypeIndex::TYPE) \
+        return std::make_shared<Function<TYPE, true>>(argument_types, params);
+    FOR_BASIC_NUMERIC_TYPES(DISPATCH)
+#undef DISPATCH
+
+    if (which.idx == TypeIndex::Date) return std::make_shared<Function<DataTypeDate::FieldType, false>>(argument_types, params);
+    if (which.idx == TypeIndex::DateTime) return std::make_shared<Function<DataTypeDateTime::FieldType, false>>(argument_types, params);
+
+    if (which.idx == TypeIndex::Decimal32) return std::make_shared<Function<Decimal32, false>>(argument_types, params);
+    if (which.idx == TypeIndex::Decimal64) return std::make_shared<Function<Decimal64, false>>(argument_types, params);
+    if (which.idx == TypeIndex::Decimal128) return std::make_shared<Function<Decimal128, false>>(argument_types, params);
+    if (which.idx == TypeIndex::Decimal256) return std::make_shared<Function<Decimal256, false>>(argument_types, params);
+    if (which.idx == TypeIndex::DateTime64) return std::make_shared<Function<DateTime64, false>>(argument_types, params);
+
+    if (which.idx == TypeIndex::Int128) return std::make_shared<Function<Int128, true>>(argument_types, params);
+    if (which.idx == TypeIndex::UInt128) return std::make_shared<Function<UInt128, true>>(argument_types, params);
+    if (which.idx == TypeIndex::Int256) return std::make_shared<Function<Int256, true>>(argument_types, params);
+    if (which.idx == TypeIndex::UInt256) return std::make_shared<Function<UInt256, true>>(argument_types, params);
+
+    throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument for aggregate function {}",
+                    argument_type->getName(), name);
+}
+
+}
+
+
+void registerAggregateFunctionsQuantileGK(AggregateFunctionFactory & factory)
+{
+    /// For aggregate functions returning array we cannot return NULL on empty set.
+    AggregateFunctionProperties properties = { .returns_default_when_only_null = true };
+
+    factory.registerFunction(NameQuantileGK::name, createAggregateFunctionQuantile<FuncQuantileGK>);
+    factory.registerFunction(NameQuantilesGK::name, {createAggregateFunctionQuantile<FuncQuantilesGK>, properties});
+
+    /// 'median' is an alias for 'quantile'
+    factory.registerAlias("medianGK", NameQuantileGK::name);
+}
+
+
+
+}
diff --git a/src/AggregateFunctions/QuantileGK.h b/src/AggregateFunctions/QuantileGK.h
new file mode 100644
index 00000000000..dcc9172e928
--- /dev/null
+++ b/src/AggregateFunctions/QuantileGK.h
@@ -0,0 +1,442 @@
+#pragma once
+
+
+#include <cmath>
+#include <IO/WriteBuffer.h>
+#include <IO/ReadBuffer.h>
+#include <IO/WriteHelpers.h>
+#include <IO/ReadHelpers.h>
+
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+template <typename T>
+class GKSampler
+{
+public:
+    struct Stats
+    {
+        T value;      // the sampled value
+        Int64 g;      // the minimum rank jump from the previous value's minimum rank
+        Int64 delta;  // the maximum span of the rank
+
+        Stats(T value_, Int64 g_, Int64 delta_) : value(value_), g(g_), delta(delta_) { }
+    };
+
+    struct QueryResult
+    {
+        size_t index;
+        Int64 rank;
+        T value;
+
+        QueryResult(size_t index_, Int64 rank_, T value_) : index(index_), rank(rank_), value(value_) { }
+    };
+
+    GKSampler(
+        size_t compress_threshold_,
+        double relative_error_,
+        size_t count_ = 0,
+        bool compressed_ = false,
+        const std::vector<Stats> & sampled_ = {})
+        : compress_threshold(compress_threshold_)
+        , relative_error(relative_error_)
+        , count(count_)
+        , compressed(compressed_)
+        , sampled(sampled_)
+    {
+    }
+
+    void insert(T x)
+    {
+        head_sampled.push_back(x);
+        compressed = false;
+        if (head_sampled.size() >= default_head_size)
+        {
+            withHeadBufferInserted();
+            if (sampled.size() >= compress_threshold)
+            {
+                compress();
+            }
+        }
+    }
+
+    void query(const Float64 * percentiles, const size_t * indices, size_t size, T * result)
+    {
+        if (!head_sampled.empty())
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot operate on an uncompressed summary, call compress() first");
+
+        if (sampled.empty())
+        {
+            for (size_t i = 0; i < size; ++i)
+                result[i] = 0;
+            return;
+        }
+
+        Int64 current_max = std::numeric_limits<Int64>::min();
+        for (const auto & stats : sampled)
+            current_max = std::max(stats.delta + stats.g, current_max);
+        Int64 target_error = current_max/2;
+
+        size_t index= 0;
+        auto min_rank = sampled[0].g;
+        for (size_t i = 0; i < size; ++i)
+        {
+            double percentile = percentiles[indices[i]];
+            if (percentile <= relative_error)
+            {
+                result[indices[i]] = sampled.front().value;
+            }
+            else if (percentile >= 1 - relative_error)
+            {
+                result[indices[i]] = sampled.back().value;
+            }
+            else
+            {
+                QueryResult res = findApproxQuantile(index, min_rank, target_error, percentile);
+                index = res.index;
+                min_rank = res.rank;
+                result[indices[i]] = res.value;
+            }
+        }
+
+    }
+
+    void compress()
+    {
+        withHeadBufferInserted();
+        auto compressed_samples = doCompress(sampled, 2 * relative_error * count);
+
+        std::swap(sampled, compressed_samples);
+        compressed = true;
+    }
+
+
+    void merge(const GKSampler & other)
+    {
+        if (!head_sampled.empty() || !other.head_sampled.empty())
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Current buffer needs to be compressed before merge");
+
+        if (other.count == 0)
+            return;
+        else if (count == 0)
+        {
+            compress_threshold = other.compress_threshold;
+            relative_error = other.relative_error;
+            sampled = std::move(other.sampled);
+            count = other.count;
+            compressed = other.compressed;
+            return;
+        }
+        else
+        {
+            // Merge the two buffers.
+            // The GK algorithm is a bit unclear about it, but we need to adjust the statistics during the
+            // merging. The main idea is that samples that come from one side will suffer from the lack of
+            // precision of the other.
+            // As a concrete example, take two QuantileSummaries whose samples (value, g, delta) are:
+            // `a = [(0, 1, 0), (20, 99, 0)]` and `b = [(10, 1, 0), (30, 49, 0)]`
+            // This means `a` has 100 values, whose minimum is 0 and maximum is 20,
+            // while `b` has 50 values, between 10 and 30.
+            // The resulting samples of the merge will be:
+            // a+b = [(0, 1, 0), (10, 1, ??), (20, 99, ??), (30, 49, 0)]
+            // The values of `g` do not change, as they represent the minimum number of values between two
+            // consecutive samples. The values of `delta` should be adjusted, however.
+            // Take the case of the sample `10` from `b`. In the original stream, it could have appeared
+            // right after `0` (as expressed by `g=1`) or right before `20`, so `delta=99+0-1=98`.
+            // In the GK algorithm's style of working in terms of maximum bounds, one can observe that the
+            // maximum additional uncertainty over samples coming from `b` is `max(g_a + delta_a) =
+            // floor(2 * eps_a * n_a)`. Likewise, additional uncertainty over samples from `a` is
+            // `floor(2 * eps_b * n_b)`.
+            // Only samples that interleave the other side are affected. That means that samples from
+            // one side that are lesser (or greater) than all samples from the other side are just copied
+            // unmodified.
+            // If the merging instances have different `relativeError`, the resulting instance will carry
+            // the largest one: `eps_ab = max(eps_a, eps_b)`.
+            // The main invariant of the GK algorithm is kept:
+            // `max(g_ab + delta_ab) <= floor(2 * eps_ab * (n_a + n_b))` since
+            // `max(g_ab + delta_ab) <= floor(2 * eps_a * n_a) + floor(2 * eps_b * n_b)`
+            // Finally, one can see how the `insert(x)` operation can be expressed as `merge([(x, 1, 0])`
+            std::vector<Stats> merged_sampled;
+            merged_sampled.reserve(sampled.size() + other.sampled.size());
+            double merged_relative_error = std::max(relative_error, other.relative_error);
+            size_t merged_count = count + other.count;
+            Int64 additional_self_delta = std::floor(2 * other.relative_error * other.count);
+            Int64 additional_other_delta = std::floor(2 * relative_error * count);
+
+            // Do a merge of two sorted lists until one of the lists is fully consumed
+            size_t self_idx = 0;
+            size_t other_idx = 0;
+            while (self_idx < sampled.size() && other_idx < other.sampled.size())
+            {
+                Stats self_sample = sampled(self_idx);
+                Stats other_sample = other.sampled(other_idx);
+
+                // Detect next sample
+                Stats next_sample;
+                Int64 additional_delta = 0;
+                if (self_sample.value < other_sample.value)
+                {
+                    ++self_idx;
+                    next_sample = self_sample;
+                    additional_delta = other_idx > 0 ? additional_self_delta : 0;
+                }
+                else
+                {
+                    ++other_idx;
+                    next_sample = other_sample;
+                    additional_delta = self_idx > 0 ? additional_other_delta : 0;
+                }
+
+                // Insert it
+                next_sample.delta += additional_delta;
+                merged_sampled.push_back(next_sample);
+            }
+
+            // Copy the remaining samples from the other list
+            // (by construction, at most one `while` loop will run)
+            while (self_idx < sampled.size())
+            {
+                merged_sampled.push_back(sampled[self_idx]);
+                ++self_idx;
+            }
+            while (other_idx < other.sampled.size())
+            {
+                merged_sampled += other.sampled[other_idx];
+                ++other_idx;
+            }
+
+            auto compressed_sampled = doCompress(merged_sampled, 2 * merged_relative_error * merged_count);
+            compress_threshold = other.compress_threshold;
+            relative_error = merged_relative_error;
+            std::swap(compressed_sampled, sampled);
+            count = merged_count;
+            compressed = true;
+        }
+    }
+
+    void write(WriteBuffer & buf) const
+    {
+        writeIntBinary<size_t>(compress_threshold, buf);
+        writeFloatBinary<double>(relative_error, buf);
+        writeIntBinary<size_t>(count, buf);
+        writeIntBinary<size_t>(sampled.size(), buf);
+
+        for (const auto & stats : sampled)
+        {
+            writeFloatBinary<T>(stats.value, buf);
+            writeIntBinary<Int64>(stats.g, buf);
+            writeIntBinary<Int64>(stats.delta, buf);
+        }
+    }
+
+    void read(ReadBuffer & buf)
+    {
+        readIntBinary<size_t>(compress_threshold, buf);
+        readFloatBinary<double>(relative_error, buf);
+        readIntBinary<size_t>(count, buf);
+
+        size_t sampled_len = 0;
+        readIntBinary<size_t>(sampled_len, buf);
+        sampled.resize(sampled_len);
+
+        for (size_t i = 0; i < sampled_len; ++i)
+        {
+            auto stats = sampled[i];
+            readFloatBinary<T>(stats.value, buf);
+            readIntBinary<Int64>(stats.g, buf);
+            readIntBinary<Int64>(stats.delta, buf);
+        }
+    }
+
+private:
+    QueryResult findApproxQuantile(size_t index, Int64 min_rank_at_index, double target_error, double percentile)
+    {
+        Stats curr_sample = sampled[index];
+        Int64 rank = std::ceil(percentile * count);
+        size_t i = index;
+        Int64 min_rank = min_rank_at_index;
+        while (i < sampled.size() - 1)
+        {
+            Int64 max_rank = min_rank + curr_sample.delta;
+            if (max_rank - target_error <= rank && rank <= min_rank + target_error)
+                return {i, min_rank, curr_sample.value};
+            else
+            {
+                ++i;
+                curr_sample = sampled[i];
+                min_rank += curr_sample.g;
+            }
+        }
+        return {sampled.size()-1, 0, sampled.back().value};
+    }
+
+    void withHeadBufferInserted()
+    {
+        if (head_sampled.empty())
+            return;
+
+        size_t current_count = count;
+        std::sort(head_sampled.begin(), head_sampled.end());
+        std::vector<Stats> new_samples;
+        new_samples.reserve(sampled.size() + head_sampled.size());
+
+        size_t sample_idx = 0;
+        size_t ops_idx = 0;
+        for (; ops_idx < head_sampled.size(); ++ops_idx)
+        {
+            T current_sample = head_sampled[ops_idx];
+
+            // Add all the samples before the next observation.
+            while (sample_idx < sampled.size() && sampled[sample_idx] <= current_sample)
+            {
+                new_samples.push_back(sampled[sample_idx]);
+                ++sample_idx;
+            }
+
+            // If it is the first one to insert, of if it is the last one
+            ++current_count;
+            Int64 delta;
+            if (new_samples.empty() || (sample_idx == sampled.size() && ops_idx == (head_sampled.size() - 1)))
+                delta = 0;
+            else
+                delta = std::floor(2 * relative_error * current_count);
+
+            new_samples.emplace_back(current_sample, 1, delta);
+        }
+
+        // Add all the remaining existing samples
+        for (; sample_idx < sampled.size(); ++sample_idx)
+            new_samples.push_back(sampled[sample_idx]);
+
+        std::swap(sampled, new_samples);
+        head_sampled.clear();
+        count = current_count;
+    }
+
+
+    static std::vector<Stats> doCompress(const std::vector<Stats> & current_samples, double merge_threshold)
+    {
+        if (current_samples.empty())
+            return {};
+
+        std::vector<Stats> res;
+        // Start for the last element, which is always part of the set.
+        // The head contains the current new head, that may be merged with the current element.
+        auto head = current_samples.back();
+        ssize_t i = current_samples.size() - 2;
+
+        // Do not compress the last element
+        while (i >= 1)
+        {
+            // The current sample:
+            const auto & sample1 = current_samples[i];
+            // Do we need to compress?
+            if (sample1.g + head.g + head.delta < merge_threshold)
+            {
+                // Do not insert yet, just merge the current element into the head.
+                head.g += sample1.g;
+            }
+            else
+            {
+                // Prepend the current head, and keep the current sample as target for merging.
+                res.insert(res.begin(), head);
+                head = sample1;
+            }
+            --i;
+        }
+
+        res.insert(res.begin(), head);
+        // If necessary, add the minimum element:
+        auto curr_head = current_samples.front();
+
+        // don't add the minimum element if `currentSamples` has only one element (both `currHead` and
+        // `head` point to the same element)
+        if (curr_head.value <= head.value && current_samples.size() > 1)
+            res.insert(res.begin(), current_samples.front());
+
+        return res;
+    }
+
+    size_t compress_threshold;
+    double relative_error;
+    size_t count = 0;
+    bool compressed;
+
+    std::vector<Stats> sampled;
+    std::vector<T> head_sampled;
+
+    static constexpr size_t default_head_size = 50000;
+};
+
+
+template <typename Value>
+struct QuantileGK
+{
+public:
+    using Data = GKSampler<Value>;
+    Data data;
+
+    void add(const Value & x)
+    {
+        data.insert(x);
+    }
+
+    template <typename Weight>
+    void add(const Value &, const Weight &)
+    {
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method add with weight is not implemented for GKSampler");
+    }
+
+    void merge(const QuantileGK & rhs)
+    {
+        data.merge(rhs);
+    }
+
+    void serialize(WriteBuffer & buf) const
+    {
+        data.write(buf);
+    }
+
+    void deserialize(ReadBuffer & buf)
+    {
+        data.read(buf);
+    }
+
+    /// Get the value of the `level` quantile. The level must be between 0 and 1.
+    Value get(Float64 level)
+    {
+        Value res;
+        size_t indice = 0;
+        data.query(&level, &indice, 1, &res);
+        return res;
+    }
+
+
+    /// Get the `size` values of `levels` quantiles. Write `size` results starting with `result` address.
+    /// indices - an array of index levels such that the corresponding elements will go in ascending order.
+    void getMany(const Float64 * levels, const size_t * indices, size_t size, Value * result)
+    {
+        data.query(levels, indices, size, result);
+    }
+
+    Float64 getFloat64(Float64 level)
+    {
+        return static_cast<Float64>(get(level));
+    }
+
+    void getManyFloat(const Float64 * levels, const size_t * indices, size_t size, Float64 * result)
+    {
+        std::vector<Value> values;
+        getMany(levels, indices, size, values.data());
+
+        for (size_t i=0; i<size; ++i)
+            result[i] = static_cast<Float64>(values[i]);
+    }
+};
+
+}
diff --git a/src/AggregateFunctions/registerAggregateFunctions.cpp b/src/AggregateFunctions/registerAggregateFunctions.cpp
index 598c2681ba2..b053f8e30bc 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.cpp
+++ b/src/AggregateFunctions/registerAggregateFunctions.cpp
@@ -32,6 +32,7 @@ void registerAggregateFunctionsQuantileTDigest(AggregateFunctionFactory &);
 void registerAggregateFunctionsQuantileTDigestWeighted(AggregateFunctionFactory &);
 void registerAggregateFunctionsQuantileBFloat16(AggregateFunctionFactory &);
 void registerAggregateFunctionsQuantileBFloat16Weighted(AggregateFunctionFactory &);
+void registerAggregateFunctionsQuantileGK(AggregateFunctionFactory &);
 void registerAggregateFunctionsSequenceMatch(AggregateFunctionFactory &);
 void registerAggregateFunctionWindowFunnel(AggregateFunctionFactory &);
 void registerAggregateFunctionRate(AggregateFunctionFactory &);
@@ -119,6 +120,7 @@ void registerAggregateFunctions()
         registerAggregateFunctionsQuantileTDigestWeighted(factory);
         registerAggregateFunctionsQuantileBFloat16(factory);
         registerAggregateFunctionsQuantileBFloat16Weighted(factory);
+        registerAggregateFunctionsQuantileGK(factory);
         registerAggregateFunctionsSequenceMatch(factory);
         registerAggregateFunctionWindowFunnel(factory);
         registerAggregateFunctionRate(factory);

From 2aaa04420c05b3fc9be13434e84e6f77b5f4e3b9 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Wed, 15 Feb 2023 18:06:09 +0800
Subject: [PATCH 02/80] finish debug of quantileGK

---
 .../AggregateFunctionQuantile.h               | 18 ++++-
 .../AggregateFunctionQuantileGK.cpp           |  4 +-
 src/AggregateFunctions/QuantileGK.h           | 80 ++++++++++++-------
 .../0_stateless/02661_quantile_gk.reference   | 10 +++
 .../queries/0_stateless/02661_quantile_gk.sql | 13 +++
 5 files changed, 91 insertions(+), 34 deletions(-)
 create mode 100644 tests/queries/0_stateless/02661_quantile_gk.reference
 create mode 100644 tests/queries/0_stateless/02661_quantile_gk.sql

diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index ab7edcd082e..6bc058d9e30 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -29,6 +29,7 @@ namespace ErrorCodes
 }
 
 template <typename> class QuantileTiming;
+template <typename> class QuantileGK;
 
 
 /** Generic aggregate function for calculation of quantiles.
@@ -60,6 +61,7 @@ private:
     using ColVecType = ColumnVectorOrDecimal<Value>;
 
     static constexpr bool returns_float = !(std::is_same_v<FloatReturnType, void>);
+    static constexpr bool is_quantile_gk = std::is_same_v<Data, QuantileGK<Value>>;
     static_assert(!is_decimal<Value> || !returns_float);
 
     QuantileLevels<Float64> levels;
@@ -67,22 +69,36 @@ private:
     /// Used when there are single level to get.
     Float64 level = 0.5;
 
+    /// Used when function name is "quantileGK" or "quantilesGK"
+    size_t accuracy = 10000;
+
     DataTypePtr & argument_type;
 
 public:
     AggregateFunctionQuantile(const DataTypes & argument_types_, const Array & params)
         : IAggregateFunctionDataHelper<Data, AggregateFunctionQuantile<Value, Data, Name, has_second_arg, FloatReturnType, returns_many>>(
             argument_types_, params, createResultType(argument_types_))
-        , levels(params, returns_many)
+        , levels(is_quantile_gk ? Array(params.begin() + 1, params.end()) : params, returns_many)
         , level(levels.levels[0])
         , argument_type(this->argument_types[0])
     {
         if (!returns_many && levels.size() > 1)
             throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} require one parameter or less", getName());
+
+        if constexpr (is_quantile_gk)
+            accuracy = params[0].get<UInt64>();
     }
 
     String getName() const override { return Name::name; }
 
+    void create(AggregateDataPtr __restrict place) const override /// NOLINT
+    {
+        if constexpr (is_quantile_gk)
+            new (place) Data(accuracy);
+        else
+            new (place) Data;
+    }
+
     static DataTypePtr createResultType(const DataTypes & argument_types_)
     {
         DataTypePtr res;
diff --git a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp b/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
index 54174f3be44..6ba963cae37 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
@@ -12,8 +12,8 @@ namespace DB
 namespace
 {
 
-template <typename Value, bool _> using FuncQuantileGK = AggregateFunctionQuantile<Value, QuantileGK<Value>, NameQuantileGK, true, void, false>;
-template <typename Value, bool _> using FuncQuantilesGK = AggregateFunctionQuantile<Value, QuantileGK<Value>, NameQuantilesGK, true, void, true>;
+template <typename Value, bool _> using FuncQuantileGK = AggregateFunctionQuantile<Value, QuantileGK<Value>, NameQuantileGK, false, void, false>;
+template <typename Value, bool _> using FuncQuantilesGK = AggregateFunctionQuantile<Value, QuantileGK<Value>, NameQuantilesGK, false, void, true>;
 
 
 template <template <typename, bool> class Function>
diff --git a/src/AggregateFunctions/QuantileGK.h b/src/AggregateFunctions/QuantileGK.h
index dcc9172e928..87887f2d99d 100644
--- a/src/AggregateFunctions/QuantileGK.h
+++ b/src/AggregateFunctions/QuantileGK.h
@@ -25,7 +25,8 @@ public:
         Int64 g;      // the minimum rank jump from the previous value's minimum rank
         Int64 delta;  // the maximum span of the rank
 
-        Stats(T value_, Int64 g_, Int64 delta_) : value(value_), g(g_), delta(delta_) { }
+        Stats() = default;
+        Stats(T value_, Int64 g_, Int64 delta_) : value(value_), g(g_), delta(delta_) {}
     };
 
     struct QueryResult
@@ -37,20 +38,24 @@ public:
         QueryResult(size_t index_, Int64 rank_, T value_) : index(index_), rank(rank_), value(value_) { }
     };
 
-    GKSampler(
-        size_t compress_threshold_,
+    GKSampler() = default;
+
+    explicit GKSampler(
         double relative_error_,
+        size_t compress_threshold_ = default_compress_threshold,
         size_t count_ = 0,
         bool compressed_ = false,
         const std::vector<Stats> & sampled_ = {})
-        : compress_threshold(compress_threshold_)
-        , relative_error(relative_error_)
+        : relative_error(relative_error_)
+        , compress_threshold(compress_threshold_)
         , count(count_)
         , compressed(compressed_)
         , sampled(sampled_)
     {
     }
 
+    bool isCompressed() const { return compressed; }
+
     void insert(T x)
     {
         head_sampled.push_back(x);
@@ -59,9 +64,7 @@ public:
         {
             withHeadBufferInserted();
             if (sampled.size() >= compress_threshold)
-            {
                 compress();
-            }
         }
     }
 
@@ -73,7 +76,7 @@ public:
         if (sampled.empty())
         {
             for (size_t i = 0; i < size; ++i)
-                result[i] = 0;
+                result[i] = T();
             return;
         }
 
@@ -165,16 +168,16 @@ public:
             merged_sampled.reserve(sampled.size() + other.sampled.size());
             double merged_relative_error = std::max(relative_error, other.relative_error);
             size_t merged_count = count + other.count;
-            Int64 additional_self_delta = std::floor(2 * other.relative_error * other.count);
-            Int64 additional_other_delta = std::floor(2 * relative_error * count);
+            Int64 additional_self_delta = static_cast<Int64>(std::floor(2 * other.relative_error * other.count));
+            Int64 additional_other_delta = static_cast<Int64>(std::floor(2 * relative_error * count));
 
             // Do a merge of two sorted lists until one of the lists is fully consumed
             size_t self_idx = 0;
             size_t other_idx = 0;
             while (self_idx < sampled.size() && other_idx < other.sampled.size())
             {
-                Stats self_sample = sampled(self_idx);
-                Stats other_sample = other.sampled(other_idx);
+                const Stats & self_sample = sampled[self_idx];
+                const Stats & other_sample = other.sampled[other_idx];
 
                 // Detect next sample
                 Stats next_sample;
@@ -206,7 +209,7 @@ public:
             }
             while (other_idx < other.sampled.size())
             {
-                merged_sampled += other.sampled[other_idx];
+                merged_sampled.emplace_back(other.sampled[other_idx]);
                 ++other_idx;
             }
 
@@ -240,6 +243,9 @@ public:
         readFloatBinary<double>(relative_error, buf);
         readIntBinary<size_t>(count, buf);
 
+        /// Always compress before serialization
+        compressed = true;
+
         size_t sampled_len = 0;
         readIntBinary<size_t>(sampled_len, buf);
         sampled.resize(sampled_len);
@@ -257,7 +263,7 @@ private:
     QueryResult findApproxQuantile(size_t index, Int64 min_rank_at_index, double target_error, double percentile)
     {
         Stats curr_sample = sampled[index];
-        Int64 rank = std::ceil(percentile * count);
+        Int64 rank = static_cast<Int64>(std::ceil(percentile * count));
         size_t i = index;
         Int64 min_rank = min_rank_at_index;
         while (i < sampled.size() - 1)
@@ -292,7 +298,7 @@ private:
             T current_sample = head_sampled[ops_idx];
 
             // Add all the samples before the next observation.
-            while (sample_idx < sampled.size() && sampled[sample_idx] <= current_sample)
+            while (sample_idx < sampled.size() && sampled[sample_idx].value <= current_sample)
             {
                 new_samples.push_back(sampled[sample_idx]);
                 ++sample_idx;
@@ -304,7 +310,7 @@ private:
             if (new_samples.empty() || (sample_idx == sampled.size() && ops_idx == (head_sampled.size() - 1)))
                 delta = 0;
             else
-                delta = std::floor(2 * relative_error * current_count);
+                delta = static_cast<Int64>(std::floor(2 * relative_error * current_count));
 
             new_samples.emplace_back(current_sample, 1, delta);
         }
@@ -362,24 +368,29 @@ private:
         return res;
     }
 
-    size_t compress_threshold;
     double relative_error;
+    size_t compress_threshold;
     size_t count = 0;
     bool compressed;
 
     std::vector<Stats> sampled;
     std::vector<T> head_sampled;
 
+    static constexpr size_t default_compress_threshold = 10000;
     static constexpr size_t default_head_size = 50000;
 };
 
-
 template <typename Value>
-struct QuantileGK
+class QuantileGK
 {
-public:
+private:
     using Data = GKSampler<Value>;
-    Data data;
+    mutable Data data;
+
+public:
+    QuantileGK() = default;
+
+    explicit QuantileGK(size_t accuracy) : data(1.0 / static_cast<double>(accuracy)) { }
 
     void add(const Value & x)
     {
@@ -394,11 +405,17 @@ public:
 
     void merge(const QuantileGK & rhs)
     {
-        data.merge(rhs);
+        if (!data.isCompressed())
+            data.compress();
+
+        data.merge(rhs.data);
     }
 
     void serialize(WriteBuffer & buf) const
     {
+        if (!data.isCompressed())
+            data.compress();
+
         data.write(buf);
     }
 
@@ -410,32 +427,33 @@ public:
     /// Get the value of the `level` quantile. The level must be between 0 and 1.
     Value get(Float64 level)
     {
+        if (!data.isCompressed())
+            data.compress();
+
         Value res;
         size_t indice = 0;
         data.query(&level, &indice, 1, &res);
         return res;
     }
 
-
     /// Get the `size` values of `levels` quantiles. Write `size` results starting with `result` address.
     /// indices - an array of index levels such that the corresponding elements will go in ascending order.
     void getMany(const Float64 * levels, const size_t * indices, size_t size, Value * result)
     {
+        if (!data.isCompressed())
+            data.compress();
+
         data.query(levels, indices, size, result);
     }
 
-    Float64 getFloat64(Float64 level)
+    Float64 getFloat64(Float64 /*level*/)
     {
-        return static_cast<Float64>(get(level));
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method getFloat64 is not implemented for GKSampler");
     }
 
-    void getManyFloat(const Float64 * levels, const size_t * indices, size_t size, Float64 * result)
+    void getManyFloat(const Float64 * /*levels*/, const size_t * /*indices*/, size_t /*size*/, Float64 * /*result*/)
     {
-        std::vector<Value> values;
-        getMany(levels, indices, size, values.data());
-
-        for (size_t i=0; i<size; ++i)
-            result[i] = static_cast<Float64>(values[i]);
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method getManyFloat is not implemented for GKSampler");
     }
 };
 
diff --git a/tests/queries/0_stateless/02661_quantile_gk.reference b/tests/queries/0_stateless/02661_quantile_gk.reference
new file mode 100644
index 00000000000..be9ea2f0e80
--- /dev/null
+++ b/tests/queries/0_stateless/02661_quantile_gk.reference
@@ -0,0 +1,10 @@
+[1,1,0]
+7
+[250,500,750,1,1000,1,1000]
+[1,1,2]
+[250,500,750]	1000	[1,1000]	500500
+[1,1,1,1,1]
+[1,156,156,296,715]
+[93,192,251,306,770]
+[99,199,249,313,776]
+[100,200,250,314,777]
diff --git a/tests/queries/0_stateless/02661_quantile_gk.sql b/tests/queries/0_stateless/02661_quantile_gk.sql
new file mode 100644
index 00000000000..2fe8fa33d0a
--- /dev/null
+++ b/tests/queries/0_stateless/02661_quantile_gk.sql
@@ -0,0 +1,13 @@
+with arrayJoin([0, 1, 2, 10]) as x select quantilesGK(100, 0.5, 0.4, 0.1)(x);
+with arrayJoin([0, 6, 7, 9, 10]) as x select quantileGK(100, 0.5)(x);
+
+select quantilesGK(10000, 0.25, 0.5, 0.75, 0.0, 1.0, 0, 1)(number + 1) from numbers(1000);
+select quantilesGK(10000, 0.01, 0.1, 0.11)(number + 1) from numbers(10);
+
+with number + 1 as col select quantilesGK(10000, 0.25, 0.5, 0.75)(col), count(col), quantilesGK(10000, 0.0, 1.0)(col), sum(col) from numbers(1000);
+
+select quantilesGK(1, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesGK(10, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesGK(100, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesGK(1000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesGK(10000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);

From dd1e550da64cc614253a682694f5d45df7f33506 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Wed, 15 Feb 2023 18:08:11 +0800
Subject: [PATCH 03/80] fix code style

---
 src/AggregateFunctions/AggregateFunctionQuantileGK.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp b/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
index 6ba963cae37..44d676e7003 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
@@ -9,13 +9,17 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+}
+
 namespace
 {
 
 template <typename Value, bool _> using FuncQuantileGK = AggregateFunctionQuantile<Value, QuantileGK<Value>, NameQuantileGK, false, void, false>;
 template <typename Value, bool _> using FuncQuantilesGK = AggregateFunctionQuantile<Value, QuantileGK<Value>, NameQuantilesGK, false, void, true>;
 
-
 template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
     const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)

From a478e57905d02cbe05deac2855a02d622c91221c Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Wed, 15 Feb 2023 18:28:05 +0800
Subject: [PATCH 04/80] fix code style

---
 src/AggregateFunctions/QuantileGK.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/AggregateFunctions/QuantileGK.h b/src/AggregateFunctions/QuantileGK.h
index 87887f2d99d..6dba8ac5723 100644
--- a/src/AggregateFunctions/QuantileGK.h
+++ b/src/AggregateFunctions/QuantileGK.h
@@ -13,6 +13,7 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int LOGICAL_ERROR;
+    extern const int NOT_IMPLEMENTED;
 }
 
 template <typename T>

From ddba07b9c32fef84e764972c241991e7dec72745 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Wed, 15 Feb 2023 21:19:50 +0800
Subject: [PATCH 05/80] improve performance

---
 src/AggregateFunctions/QuantileGK.h | 77 ++++++++++++++++-------------
 1 file changed, 44 insertions(+), 33 deletions(-)

diff --git a/src/AggregateFunctions/QuantileGK.h b/src/AggregateFunctions/QuantileGK.h
index 6dba8ac5723..3616a276559 100644
--- a/src/AggregateFunctions/QuantileGK.h
+++ b/src/AggregateFunctions/QuantileGK.h
@@ -1,7 +1,8 @@
 #pragma once
 
-
 #include <cmath>
+#include <base/sort.h>
+#include <Common/RadixSort.h>
 #include <IO/WriteBuffer.h>
 #include <IO/ReadBuffer.h>
 #include <IO/WriteHelpers.h>
@@ -53,6 +54,8 @@ public:
         , compressed(compressed_)
         , sampled(sampled_)
     {
+        sampled.reserve(compress_threshold);
+        backup_sampled.reserve(compress_threshold);
     }
 
     bool isCompressed() const { return compressed; }
@@ -113,9 +116,8 @@ public:
     void compress()
     {
         withHeadBufferInserted();
-        auto compressed_samples = doCompress(sampled, 2 * relative_error * count);
 
-        std::swap(sampled, compressed_samples);
+        doCompress(2 * relative_error * count);
         compressed = true;
     }
 
@@ -165,8 +167,8 @@ public:
             // `max(g_ab + delta_ab) <= floor(2 * eps_ab * (n_a + n_b))` since
             // `max(g_ab + delta_ab) <= floor(2 * eps_a * n_a) + floor(2 * eps_b * n_b)`
             // Finally, one can see how the `insert(x)` operation can be expressed as `merge([(x, 1, 0])`
-            std::vector<Stats> merged_sampled;
-            merged_sampled.reserve(sampled.size() + other.sampled.size());
+            backup_sampled.clear();
+            backup_sampled.reserve(sampled.size() + other.sampled.size());
             double merged_relative_error = std::max(relative_error, other.relative_error);
             size_t merged_count = count + other.count;
             Int64 additional_self_delta = static_cast<Int64>(std::floor(2 * other.relative_error * other.count));
@@ -198,27 +200,28 @@ public:
 
                 // Insert it
                 next_sample.delta += additional_delta;
-                merged_sampled.push_back(next_sample);
+                backup_sampled.emplace_back(std::move(next_sample));
             }
 
             // Copy the remaining samples from the other list
             // (by construction, at most one `while` loop will run)
             while (self_idx < sampled.size())
             {
-                merged_sampled.push_back(sampled[self_idx]);
+                backup_sampled.emplace_back(sampled[self_idx]);
                 ++self_idx;
             }
             while (other_idx < other.sampled.size())
             {
-                merged_sampled.emplace_back(other.sampled[other_idx]);
+                backup_sampled.emplace_back(other.sampled[other_idx]);
                 ++other_idx;
             }
 
-            auto compressed_sampled = doCompress(merged_sampled, 2 * merged_relative_error * merged_count);
-            compress_threshold = other.compress_threshold;
+            std::swap(sampled, backup_sampled);
             relative_error = merged_relative_error;
-            std::swap(compressed_sampled, sampled);
             count = merged_count;
+            compress_threshold = other.compress_threshold;
+
+            doCompress(2 * merged_relative_error * merged_count);
             compressed = true;
         }
     }
@@ -287,13 +290,18 @@ private:
         if (head_sampled.empty())
             return;
 
-        size_t current_count = count;
-        std::sort(head_sampled.begin(), head_sampled.end());
-        std::vector<Stats> new_samples;
-        new_samples.reserve(sampled.size() + head_sampled.size());
+        bool use_radix_sort = head_sampled.size() >= 256 && (is_arithmetic_v<T> && !is_big_int_v<T>);
+        if (use_radix_sort)
+            RadixSort<RadixSortNumTraits<T>>::executeLSD(head_sampled.data(), head_sampled.size());
+        else
+            ::sort(head_sampled.begin(), head_sampled.end());
+
+        backup_sampled.clear();
+        backup_sampled.reserve(sampled.size() + head_sampled.size());
 
         size_t sample_idx = 0;
         size_t ops_idx = 0;
+        size_t current_count = count;
         for (; ops_idx < head_sampled.size(); ++ops_idx)
         {
             T current_sample = head_sampled[ops_idx];
@@ -301,47 +309,47 @@ private:
             // Add all the samples before the next observation.
             while (sample_idx < sampled.size() && sampled[sample_idx].value <= current_sample)
             {
-                new_samples.push_back(sampled[sample_idx]);
+                backup_sampled.emplace_back(sampled[sample_idx]);
                 ++sample_idx;
             }
 
             // If it is the first one to insert, of if it is the last one
             ++current_count;
             Int64 delta;
-            if (new_samples.empty() || (sample_idx == sampled.size() && ops_idx == (head_sampled.size() - 1)))
+            if (backup_sampled.empty() || (sample_idx == sampled.size() && ops_idx == (head_sampled.size() - 1)))
                 delta = 0;
             else
                 delta = static_cast<Int64>(std::floor(2 * relative_error * current_count));
 
-            new_samples.emplace_back(current_sample, 1, delta);
+            backup_sampled.emplace_back(current_sample, 1, delta);
         }
 
         // Add all the remaining existing samples
         for (; sample_idx < sampled.size(); ++sample_idx)
-            new_samples.push_back(sampled[sample_idx]);
+            backup_sampled.emplace_back(sampled[sample_idx]);
 
-        std::swap(sampled, new_samples);
+        std::swap(sampled, backup_sampled);
         head_sampled.clear();
         count = current_count;
     }
 
 
-    static std::vector<Stats> doCompress(const std::vector<Stats> & current_samples, double merge_threshold)
+    void doCompress(double merge_threshold)
     {
-        if (current_samples.empty())
-            return {};
+        if (sampled.empty())
+            return;
 
-        std::vector<Stats> res;
+        backup_sampled.clear();
         // Start for the last element, which is always part of the set.
         // The head contains the current new head, that may be merged with the current element.
-        auto head = current_samples.back();
-        ssize_t i = current_samples.size() - 2;
+        Stats head = sampled.back();
+        ssize_t i = sampled.size() - 2;
 
         // Do not compress the last element
         while (i >= 1)
         {
             // The current sample:
-            const auto & sample1 = current_samples[i];
+            const auto & sample1 = sampled[i];
             // Do we need to compress?
             if (sample1.g + head.g + head.delta < merge_threshold)
             {
@@ -351,22 +359,23 @@ private:
             else
             {
                 // Prepend the current head, and keep the current sample as target for merging.
-                res.insert(res.begin(), head);
+                backup_sampled.push_back(head);
                 head = sample1;
             }
             --i;
         }
 
-        res.insert(res.begin(), head);
+        backup_sampled.push_back(head);
         // If necessary, add the minimum element:
-        auto curr_head = current_samples.front();
+        auto curr_head = sampled.front();
 
         // don't add the minimum element if `currentSamples` has only one element (both `currHead` and
         // `head` point to the same element)
-        if (curr_head.value <= head.value && current_samples.size() > 1)
-            res.insert(res.begin(), current_samples.front());
+        if (curr_head.value <= head.value && sampled.size() > 1)
+            backup_sampled.emplace_back(sampled.front());
 
-        return res;
+        std::reverse(backup_sampled.begin(), backup_sampled.end());
+        std::swap(sampled, backup_sampled);
     }
 
     double relative_error;
@@ -375,6 +384,8 @@ private:
     bool compressed;
 
     std::vector<Stats> sampled;
+    std::vector<Stats> backup_sampled;
+
     std::vector<T> head_sampled;
 
     static constexpr size_t default_compress_threshold = 10000;

From c417f03bdd00ff99239dcb47c3ad14c05df25ee1 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Wed, 15 Feb 2023 22:00:04 +0800
Subject: [PATCH 06/80] improve performance

---
 src/AggregateFunctions/QuantileGK.h | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/AggregateFunctions/QuantileGK.h b/src/AggregateFunctions/QuantileGK.h
index 3616a276559..1e3d361d29b 100644
--- a/src/AggregateFunctions/QuantileGK.h
+++ b/src/AggregateFunctions/QuantileGK.h
@@ -46,16 +46,16 @@ public:
         double relative_error_,
         size_t compress_threshold_ = default_compress_threshold,
         size_t count_ = 0,
-        bool compressed_ = false,
-        const std::vector<Stats> & sampled_ = {})
+        bool compressed_ = false)
         : relative_error(relative_error_)
         , compress_threshold(compress_threshold_)
         , count(count_)
         , compressed(compressed_)
-        , sampled(sampled_)
     {
         sampled.reserve(compress_threshold);
         backup_sampled.reserve(compress_threshold);
+
+        head_sampled.reserve(default_head_size);
     }
 
     bool isCompressed() const { return compressed; }
@@ -133,9 +133,11 @@ public:
         {
             compress_threshold = other.compress_threshold;
             relative_error = other.relative_error;
-            sampled = std::move(other.sampled);
             count = other.count;
             compressed = other.compressed;
+
+            sampled.resize(other.sampled.size());
+            memcpy(sampled.data(), other.sampled.data(), sizeof(Stats) * other.sampled.size());
             return;
         }
         else
@@ -383,10 +385,10 @@ private:
     size_t count = 0;
     bool compressed;
 
-    std::vector<Stats> sampled;
-    std::vector<Stats> backup_sampled;
+    PaddedPODArray<Stats> sampled;
+    PaddedPODArray<Stats> backup_sampled;
 
-    std::vector<T> head_sampled;
+    PaddedPODArray<T> head_sampled;
 
     static constexpr size_t default_compress_threshold = 10000;
     static constexpr size_t default_head_size = 50000;

From 966c5484e6f164d2fa4db33fbe7f4faee85650be Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Thu, 16 Feb 2023 10:22:58 +0800
Subject: [PATCH 07/80] fix code style

---
 src/AggregateFunctions/AggregateFunctionQuantileGK.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp b/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
index 44d676e7003..1303dd46105 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
@@ -56,7 +56,6 @@ AggregateFunctionPtr createAggregateFunctionQuantile(
 
 }
 
-
 void registerAggregateFunctionsQuantileGK(AggregateFunctionFactory & factory)
 {
     /// For aggregate functions returning array we cannot return NULL on empty set.
@@ -69,6 +68,4 @@ void registerAggregateFunctionsQuantileGK(AggregateFunctionFactory & factory)
     factory.registerAlias("medianGK", NameQuantileGK::name);
 }
 
-
-
 }

From 384888421e5a809c9d755f6e2b94e632f1305a4a Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Thu, 16 Feb 2023 18:27:50 +0800
Subject: [PATCH 08/80] improve checking for accuracy param in quantileGK

---
 .../AggregateFunctionQuantile.h               | 24 ++++++++++++++++---
 src/AggregateFunctions/QuantileGK.h           | 15 +++++++-----
 2 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index 6bc058d9e30..deb83d342b0 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -26,6 +26,7 @@ namespace ErrorCodes
 {
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int LOGICAL_ERROR;
 }
 
 template <typename> class QuantileTiming;
@@ -70,7 +71,7 @@ private:
     Float64 level = 0.5;
 
     /// Used when function name is "quantileGK" or "quantilesGK"
-    size_t accuracy = 10000;
+    ssize_t accuracy = 10000;
 
     DataTypePtr & argument_type;
 
@@ -83,10 +84,27 @@ public:
         , argument_type(this->argument_types[0])
     {
         if (!returns_many && levels.size() > 1)
-            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} require one parameter or less", getName());
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} require one level parameter or less", getName());
 
         if constexpr (is_quantile_gk)
-            accuracy = params[0].get<UInt64>();
+        {
+            const auto & accuracy_field = params[0];
+            if (!isInt64OrUInt64FieldType(accuracy_field.getType()))
+                throw Exception(
+                    ErrorCodes::LOGICAL_ERROR, "Aggregate function {} require accuracy parameter with integer type", getName());
+
+            if (accuracy_field.getType() == Field::Types::Int64)
+                accuracy = accuracy_field.get<Int64>();
+            else
+                accuracy = accuracy_field.get<UInt64>();
+
+            if (accuracy <= 0)
+                throw Exception(
+                    ErrorCodes::LOGICAL_ERROR,
+                    "Aggregate function {} require accuracy parameter with positive value but is {}",
+                    getName(),
+                    accuracy);
+        }
     }
 
     String getName() const override { return Name::name; }
diff --git a/src/AggregateFunctions/QuantileGK.h b/src/AggregateFunctions/QuantileGK.h
index 1e3d361d29b..c75005d65db 100644
--- a/src/AggregateFunctions/QuantileGK.h
+++ b/src/AggregateFunctions/QuantileGK.h
@@ -59,6 +59,7 @@ public:
     }
 
     bool isCompressed() const { return compressed; }
+    void setCompressed() { compressed = true; }
 
     void insert(T x)
     {
@@ -115,6 +116,9 @@ public:
 
     void compress()
     {
+        if (compressed)
+            return;
+
         withHeadBufferInserted();
 
         doCompress(2 * relative_error * count);
@@ -124,9 +128,6 @@ public:
 
     void merge(const GKSampler & other)
     {
-        if (!head_sampled.empty() || !other.head_sampled.empty())
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Current buffer needs to be compressed before merge");
-
         if (other.count == 0)
             return;
         else if (count == 0)
@@ -169,6 +170,8 @@ public:
             // `max(g_ab + delta_ab) <= floor(2 * eps_ab * (n_a + n_b))` since
             // `max(g_ab + delta_ab) <= floor(2 * eps_a * n_a) + floor(2 * eps_b * n_b)`
             // Finally, one can see how the `insert(x)` operation can be expressed as `merge([(x, 1, 0])`
+            compress();
+
             backup_sampled.clear();
             backup_sampled.reserve(sampled.size() + other.sampled.size());
             double merged_relative_error = std::max(relative_error, other.relative_error);
@@ -249,9 +252,6 @@ public:
         readFloatBinary<double>(relative_error, buf);
         readIntBinary<size_t>(count, buf);
 
-        /// Always compress before serialization
-        compressed = true;
-
         size_t sampled_len = 0;
         readIntBinary<size_t>(sampled_len, buf);
         sampled.resize(sampled_len);
@@ -427,6 +427,7 @@ public:
 
     void serialize(WriteBuffer & buf) const
     {
+        /// Always compress before serialization
         if (!data.isCompressed())
             data.compress();
 
@@ -436,6 +437,8 @@ public:
     void deserialize(ReadBuffer & buf)
     {
         data.read(buf);
+
+        data.setCompressed();
     }
 
     /// Get the value of the `level` quantile. The level must be between 0 and 1.

From d0a59e44f1f07d347a2f0b6e6716a9c2baddd851 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Mon, 20 Feb 2023 10:27:13 +0800
Subject: [PATCH 09/80] add docs

---
 .../reference/quantileGK.md                   | 55 +++++++++++++++++++
 .../reference/quantiles.md                    | 44 +++++++++++++++
 2 files changed, 99 insertions(+)
 create mode 100644 docs/en/sql-reference/aggregate-functions/reference/quantileGK.md

diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantileGK.md b/docs/en/sql-reference/aggregate-functions/reference/quantileGK.md
new file mode 100644
index 00000000000..4690a497589
--- /dev/null
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantileGK.md
@@ -0,0 +1,55 @@
+---
+slug: /en/sql-reference/aggregate-functions/reference/quantileGK
+sidebar_position: 204
+---
+
+# quantileGK
+
+Computes the [quantile](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](https://dl.acm.org/doi/10.1145/375663.375670) algorithm.
+
+
+**Syntax**
+
+``` sql
+quantileGK(accuracy, level)(expr)
+```
+
+Alias: `medianGK`.
+
+**Arguments**
+
+-   `accuracy` — Accuracy of quantile. Constant positive integer. The larger the better.
+
+-   `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. Default value: 0.5. At `level=0.5` the function calculates [median](https://en.wikipedia.org/wiki/Median).
+
+-   `expr` — Expression over the column values resulting in numeric [data types](../../../sql-reference/data-types/index.md#data_types), [Date](../../../sql-reference/data-types/date.md) or [DateTime](../../../sql-reference/data-types/datetime.md).
+
+
+**Returned value**
+
+-   Quantile of the specified level and accuracy.
+
+
+Type:
+
+-   [Float64](../../../sql-reference/data-types/float.md) for numeric data type input.
+-   [Date](../../../sql-reference/data-types/date.md) if input values have the `Date` type.
+-   [DateTime](../../../sql-reference/data-types/datetime.md) if input values have the `DateTime` type.
+
+**Example**
+
+``` sql
+WITH arrayJoin([0, 6, 7, 9, 10]) AS x
+SELECT quantileGK(100, 0.5)(x)
+
+
+┌─quantileGK(100, 0.5)(x)─┐
+│                       7 │
+└─────────────────────────┘
+```
+
+
+**See Also**
+
+-   [median](../../../sql-reference/aggregate-functions/reference/median.md#median)
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles)
diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
index 57151915336..8f4d000c7e9 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
@@ -114,3 +114,47 @@ Result:
 │ [249.75,499.5,749.25,899.1,949.05,989.01,998.001]                   │
 └─────────────────────────────────────────────────────────────────────┘
 ```
+
+## quantilesGK
+
+Exactly computes the [quantiles](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](https://dl.acm.org/doi/10.1145/375663.375670) algorithm.
+
+**Syntax**
+
+``` sql
+quantileGK(accuracy, level1, level2, ...)(expr)
+```
+
+**Arguments**
+
+-   `expr` — Expression over the column values resulting in numeric [data types](../../../sql-reference/data-types/index.md#data_types), [Date](../../../sql-reference/data-types/date.md) or [DateTime](../../../sql-reference/data-types/datetime.md).
+
+**Parameters**
+
+-   `accuracy` — Accuracy of quantile. Constant positive integer. The larger the better.
+
+-   `levelN` — Level of quantile. Constant floating-point number from 0 to 1.
+
+**Returned value**
+
+-   [Array](../../../sql-reference/data-types/array.md) of quantiles of the specified levels.
+
+Type of array values:
+
+-   [Float64](../../../sql-reference/data-types/float.md) for numeric data type input.
+-   [Date](../../../sql-reference/data-types/date.md) if input values have the `Date` type.
+-   [DateTime](../../../sql-reference/data-types/datetime.md) if input values have the `DateTime` type.
+
+**Example**
+
+Query:
+
+
+``` sql
+WITH arrayJoin([0, 6, 7, 9, 10]) AS x
+SELECT quantilesGK(100, 0.1, 0.2, 0.3)(x)
+
+┌─quantilesGK(100, 0.1, 0.2, 0.3)(x)─┐
+│ [0,0,6]                            │
+└────────────────────────────────────┘
+```

From daaca43a7e1b69c71358085e3b0c0af165077235 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Mon, 20 Feb 2023 10:28:35 +0800
Subject: [PATCH 10/80] fix text

---
 .../en/sql-reference/aggregate-functions/reference/quantiles.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
index 8f4d000c7e9..3ad64c111db 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
@@ -122,7 +122,7 @@ Exactly computes the [quantiles](https://en.wikipedia.org/wiki/Quantile) of a nu
 **Syntax**
 
 ``` sql
-quantileGK(accuracy, level1, level2, ...)(expr)
+quantilesGK(accuracy, level1, level2, ...)(expr)
 ```
 
 **Arguments**

From 68bc4f2cb6b0870cd070a2f480257df058ba3247 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Wed, 22 Feb 2023 10:08:21 +0800
Subject: [PATCH 11/80] fix typo

---
 src/AggregateFunctions/AggregateFunctionQuantile.h | 6 +++---
 src/AggregateFunctions/QuantileGK.h                | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index deb83d342b0..8ffdd05a797 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -84,14 +84,14 @@ public:
         , argument_type(this->argument_types[0])
     {
         if (!returns_many && levels.size() > 1)
-            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} require one level parameter or less", getName());
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires one level parameter or less", getName());
 
         if constexpr (is_quantile_gk)
         {
             const auto & accuracy_field = params[0];
             if (!isInt64OrUInt64FieldType(accuracy_field.getType()))
                 throw Exception(
-                    ErrorCodes::LOGICAL_ERROR, "Aggregate function {} require accuracy parameter with integer type", getName());
+                    ErrorCodes::LOGICAL_ERROR, "Aggregate function {} requires accuracy parameter with integer type", getName());
 
             if (accuracy_field.getType() == Field::Types::Int64)
                 accuracy = accuracy_field.get<Int64>();
@@ -101,7 +101,7 @@ public:
             if (accuracy <= 0)
                 throw Exception(
                     ErrorCodes::LOGICAL_ERROR,
-                    "Aggregate function {} require accuracy parameter with positive value but is {}",
+                    "Aggregate function {} requires accuracy parameter with positive value but is {}",
                     getName(),
                     accuracy);
         }
diff --git a/src/AggregateFunctions/QuantileGK.h b/src/AggregateFunctions/QuantileGK.h
index c75005d65db..fc11125e284 100644
--- a/src/AggregateFunctions/QuantileGK.h
+++ b/src/AggregateFunctions/QuantileGK.h
@@ -73,7 +73,7 @@ public:
         }
     }
 
-    void query(const Float64 * percentiles, const size_t * indices, size_t size, T * result)
+    void query(const Float64 * percentiles, const size_t * indices, size_t size, T * result) const
     {
         if (!head_sampled.empty())
             throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot operate on an uncompressed summary, call compress() first");
@@ -266,7 +266,7 @@ public:
     }
 
 private:
-    QueryResult findApproxQuantile(size_t index, Int64 min_rank_at_index, double target_error, double percentile)
+    QueryResult findApproxQuantile(size_t index, Int64 min_rank_at_index, double target_error, double percentile) const
     {
         Stats curr_sample = sampled[index];
         Int64 rank = static_cast<Int64>(std::ceil(percentile * count));

From 8ba11dc994c7dcb223ace57ad24c019ae06ea42d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=89=AC?= <654010905@qq.com>
Date: Tue, 7 Mar 2023 16:35:18 +0800
Subject: [PATCH 12/80] Update
 src/AggregateFunctions/AggregateFunctionQuantile.h

Co-authored-by: Vladimir C <vdimir@clickhouse.com>
---
 src/AggregateFunctions/AggregateFunctionQuantile.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index 8ffdd05a797..1aa8fc89de8 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -70,7 +70,7 @@ private:
     /// Used when there are single level to get.
     Float64 level = 0.5;
 
-    /// Used when function name is "quantileGK" or "quantilesGK"
+    /// Used for the approximate version of the algorithm (Greenwald-Khanna)
     ssize_t accuracy = 10000;
 
     DataTypePtr & argument_type;

From 62116d244cec4b59a42bbf4095f6b7faf98a7a3b Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 7 Mar 2023 17:54:21 +0800
Subject: [PATCH 13/80] change as requested

---
 .../{quantileGK.md => quantileApprox.md}      |  2 +-
 .../AggregateFunctionQuantile.h               | 24 ++++++++-------
 ...pp => AggregateFunctionQuantileApprox.cpp} | 14 ++++-----
 .../{QuantileGK.h => QuantileApprox.h}        | 18 ++++++------
 .../registerAggregateFunctions.cpp            |  4 +--
 ...erence => 02661_quantile_approx.reference} |  0
 .../0_stateless/02661_quantile_approx.sql     | 29 +++++++++++++++++++
 .../queries/0_stateless/02661_quantile_gk.sql | 13 ---------
 8 files changed, 62 insertions(+), 42 deletions(-)
 rename docs/en/sql-reference/aggregate-functions/reference/{quantileGK.md => quantileApprox.md} (92%)
 rename src/AggregateFunctions/{AggregateFunctionQuantileGK.cpp => AggregateFunctionQuantileApprox.cpp} (78%)
 rename src/AggregateFunctions/{QuantileGK.h => QuantileApprox.h} (97%)
 rename tests/queries/0_stateless/{02661_quantile_gk.reference => 02661_quantile_approx.reference} (100%)
 create mode 100644 tests/queries/0_stateless/02661_quantile_approx.sql
 delete mode 100644 tests/queries/0_stateless/02661_quantile_gk.sql

diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantileGK.md b/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
similarity index 92%
rename from docs/en/sql-reference/aggregate-functions/reference/quantileGK.md
rename to docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
index 4690a497589..d725c982af0 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/quantileGK.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
@@ -5,7 +5,7 @@ sidebar_position: 204
 
 # quantileGK
 
-Computes the [quantile](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](https://dl.acm.org/doi/10.1145/375663.375670) algorithm.
+Computes the [quantile](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](http://infolab.stanford.edu/~datar/courses/cs361a/papers/quantiles.pdf) algorithm.
 
 
 **Syntax**
diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index 8ffdd05a797..dc6daebff72 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -30,7 +30,7 @@ namespace ErrorCodes
 }
 
 template <typename> class QuantileTiming;
-template <typename> class QuantileGK;
+template <typename> class QuantileApprox;
 
 
 /** Generic aggregate function for calculation of quantiles.
@@ -62,7 +62,7 @@ private:
     using ColVecType = ColumnVectorOrDecimal<Value>;
 
     static constexpr bool returns_float = !(std::is_same_v<FloatReturnType, void>);
-    static constexpr bool is_quantile_gk = std::is_same_v<Data, QuantileGK<Value>>;
+    static constexpr bool is_quantile_approx = std::is_same_v<Data, QuantileApprox<Value>>;
     static_assert(!is_decimal<Value> || !returns_float);
 
     QuantileLevels<Float64> levels;
@@ -70,7 +70,7 @@ private:
     /// Used when there are single level to get.
     Float64 level = 0.5;
 
-    /// Used when function name is "quantileGK" or "quantilesGK"
+    /// Used when function name is "quantileApprox" or "quantilesApprox"
     ssize_t accuracy = 10000;
 
     DataTypePtr & argument_type;
@@ -79,19 +79,23 @@ public:
     AggregateFunctionQuantile(const DataTypes & argument_types_, const Array & params)
         : IAggregateFunctionDataHelper<Data, AggregateFunctionQuantile<Value, Data, Name, has_second_arg, FloatReturnType, returns_many>>(
             argument_types_, params, createResultType(argument_types_))
-        , levels(is_quantile_gk ? Array(params.begin() + 1, params.end()) : params, returns_many)
+        , levels(is_quantile_approx && !params.empty() ? Array(params.begin() + 1, params.end()) : params, returns_many)
         , level(levels.levels[0])
         , argument_type(this->argument_types[0])
     {
         if (!returns_many && levels.size() > 1)
             throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires one level parameter or less", getName());
 
-        if constexpr (is_quantile_gk)
+        if constexpr (is_quantile_approx)
         {
+            if (params.empty())
+                throw Exception(
+                    ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires at least one param", getName());
+
             const auto & accuracy_field = params[0];
             if (!isInt64OrUInt64FieldType(accuracy_field.getType()))
                 throw Exception(
-                    ErrorCodes::LOGICAL_ERROR, "Aggregate function {} requires accuracy parameter with integer type", getName());
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Aggregate function {} requires accuracy parameter with integer type", getName());
 
             if (accuracy_field.getType() == Field::Types::Int64)
                 accuracy = accuracy_field.get<Int64>();
@@ -100,7 +104,7 @@ public:
 
             if (accuracy <= 0)
                 throw Exception(
-                    ErrorCodes::LOGICAL_ERROR,
+                    ErrorCodes::BAD_ARGUMENTS,
                     "Aggregate function {} requires accuracy parameter with positive value but is {}",
                     getName(),
                     accuracy);
@@ -111,7 +115,7 @@ public:
 
     void create(AggregateDataPtr __restrict place) const override /// NOLINT
     {
-        if constexpr (is_quantile_gk)
+        if constexpr (is_quantile_approx)
             new (place) Data(accuracy);
         else
             new (place) Data;
@@ -284,7 +288,7 @@ struct NameQuantilesBFloat16 { static constexpr auto name = "quantilesBFloat16";
 struct NameQuantileBFloat16Weighted { static constexpr auto name = "quantileBFloat16Weighted"; };
 struct NameQuantilesBFloat16Weighted { static constexpr auto name = "quantilesBFloat16Weighted"; };
 
-struct NameQuantileGK { static constexpr auto name = "quantileGK"; };
-struct NameQuantilesGK { static constexpr auto name = "quantilesGK"; };
+struct NameQuantileApprox { static constexpr auto name = "quantileApprox"; };
+struct NameQuantilesApprox { static constexpr auto name = "quantilesApprox"; };
 
 }
diff --git a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp b/src/AggregateFunctions/AggregateFunctionQuantileApprox.cpp
similarity index 78%
rename from src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
rename to src/AggregateFunctions/AggregateFunctionQuantileApprox.cpp
index 1303dd46105..2a913fdc956 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileApprox.cpp
@@ -1,5 +1,5 @@
 #include <AggregateFunctions/AggregateFunctionQuantile.h>
-#include <AggregateFunctions/QuantileGK.h>
+#include <AggregateFunctions/QuantileApprox.h>
 #include <AggregateFunctions/AggregateFunctionFactory.h>
 #include <AggregateFunctions/Helpers.h>
 #include <DataTypes/DataTypeDate.h>
@@ -17,8 +17,8 @@ namespace ErrorCodes
 namespace
 {
 
-template <typename Value, bool _> using FuncQuantileGK = AggregateFunctionQuantile<Value, QuantileGK<Value>, NameQuantileGK, false, void, false>;
-template <typename Value, bool _> using FuncQuantilesGK = AggregateFunctionQuantile<Value, QuantileGK<Value>, NameQuantilesGK, false, void, true>;
+template <typename Value, bool _> using FuncQuantileApprox = AggregateFunctionQuantile<Value, QuantileApprox<Value>, NameQuantileApprox, false, void, false>;
+template <typename Value, bool _> using FuncQuantilesApprox = AggregateFunctionQuantile<Value, QuantileApprox<Value>, NameQuantilesApprox, false, void, true>;
 
 template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
@@ -56,16 +56,16 @@ AggregateFunctionPtr createAggregateFunctionQuantile(
 
 }
 
-void registerAggregateFunctionsQuantileGK(AggregateFunctionFactory & factory)
+void registerAggregateFunctionsQuantileApprox(AggregateFunctionFactory & factory)
 {
     /// For aggregate functions returning array we cannot return NULL on empty set.
     AggregateFunctionProperties properties = { .returns_default_when_only_null = true };
 
-    factory.registerFunction(NameQuantileGK::name, createAggregateFunctionQuantile<FuncQuantileGK>);
-    factory.registerFunction(NameQuantilesGK::name, {createAggregateFunctionQuantile<FuncQuantilesGK>, properties});
+    factory.registerFunction(NameQuantileApprox::name, createAggregateFunctionQuantile<FuncQuantileApprox>);
+    factory.registerFunction(NameQuantilesApprox::name, {createAggregateFunctionQuantile<FuncQuantilesApprox>, properties});
 
     /// 'median' is an alias for 'quantile'
-    factory.registerAlias("medianGK", NameQuantileGK::name);
+    factory.registerAlias("medianApprox", NameQuantileApprox::name);
 }
 
 }
diff --git a/src/AggregateFunctions/QuantileGK.h b/src/AggregateFunctions/QuantileApprox.h
similarity index 97%
rename from src/AggregateFunctions/QuantileGK.h
rename to src/AggregateFunctions/QuantileApprox.h
index fc11125e284..8a2d5e5705f 100644
--- a/src/AggregateFunctions/QuantileGK.h
+++ b/src/AggregateFunctions/QuantileApprox.h
@@ -18,7 +18,7 @@ namespace ErrorCodes
 }
 
 template <typename T>
-class GKSampler
+class ApproxSampler
 {
 public:
     struct Stats
@@ -40,9 +40,9 @@ public:
         QueryResult(size_t index_, Int64 rank_, T value_) : index(index_), rank(rank_), value(value_) { }
     };
 
-    GKSampler() = default;
+    ApproxSampler() = default;
 
-    explicit GKSampler(
+    explicit ApproxSampler(
         double relative_error_,
         size_t compress_threshold_ = default_compress_threshold,
         size_t count_ = 0,
@@ -126,7 +126,7 @@ public:
     }
 
 
-    void merge(const GKSampler & other)
+    void merge(const ApproxSampler & other)
     {
         if (other.count == 0)
             return;
@@ -395,16 +395,16 @@ private:
 };
 
 template <typename Value>
-class QuantileGK
+class QuantileApprox
 {
 private:
-    using Data = GKSampler<Value>;
+    using Data = ApproxSampler<Value>;
     mutable Data data;
 
 public:
-    QuantileGK() = default;
+    QuantileApprox() = default;
 
-    explicit QuantileGK(size_t accuracy) : data(1.0 / static_cast<double>(accuracy)) { }
+    explicit QuantileApprox(size_t accuracy) : data(1.0 / static_cast<double>(accuracy)) { }
 
     void add(const Value & x)
     {
@@ -417,7 +417,7 @@ public:
         throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method add with weight is not implemented for GKSampler");
     }
 
-    void merge(const QuantileGK & rhs)
+    void merge(const QuantileApprox & rhs)
     {
         if (!data.isCompressed())
             data.compress();
diff --git a/src/AggregateFunctions/registerAggregateFunctions.cpp b/src/AggregateFunctions/registerAggregateFunctions.cpp
index b053f8e30bc..a4f40eb49a5 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.cpp
+++ b/src/AggregateFunctions/registerAggregateFunctions.cpp
@@ -32,7 +32,7 @@ void registerAggregateFunctionsQuantileTDigest(AggregateFunctionFactory &);
 void registerAggregateFunctionsQuantileTDigestWeighted(AggregateFunctionFactory &);
 void registerAggregateFunctionsQuantileBFloat16(AggregateFunctionFactory &);
 void registerAggregateFunctionsQuantileBFloat16Weighted(AggregateFunctionFactory &);
-void registerAggregateFunctionsQuantileGK(AggregateFunctionFactory &);
+void registerAggregateFunctionsQuantileApprox(AggregateFunctionFactory &);
 void registerAggregateFunctionsSequenceMatch(AggregateFunctionFactory &);
 void registerAggregateFunctionWindowFunnel(AggregateFunctionFactory &);
 void registerAggregateFunctionRate(AggregateFunctionFactory &);
@@ -120,7 +120,7 @@ void registerAggregateFunctions()
         registerAggregateFunctionsQuantileTDigestWeighted(factory);
         registerAggregateFunctionsQuantileBFloat16(factory);
         registerAggregateFunctionsQuantileBFloat16Weighted(factory);
-        registerAggregateFunctionsQuantileGK(factory);
+        registerAggregateFunctionsQuantileApprox(factory);
         registerAggregateFunctionsSequenceMatch(factory);
         registerAggregateFunctionWindowFunnel(factory);
         registerAggregateFunctionRate(factory);
diff --git a/tests/queries/0_stateless/02661_quantile_gk.reference b/tests/queries/0_stateless/02661_quantile_approx.reference
similarity index 100%
rename from tests/queries/0_stateless/02661_quantile_gk.reference
rename to tests/queries/0_stateless/02661_quantile_approx.reference
diff --git a/tests/queries/0_stateless/02661_quantile_approx.sql b/tests/queries/0_stateless/02661_quantile_approx.sql
new file mode 100644
index 00000000000..28e1630a27b
--- /dev/null
+++ b/tests/queries/0_stateless/02661_quantile_approx.sql
@@ -0,0 +1,29 @@
+with arrayJoin([0, 1, 2, 10]) as x select quantilesApprox(100, 0.5, 0.4, 0.1)(x);
+with arrayJoin([0, 6, 7, 9, 10]) as x select quantileApprox(100, 0.5)(x);
+
+select quantilesApprox(10000, 0.25, 0.5, 0.75, 0.0, 1.0, 0, 1)(number + 1) from numbers(1000);
+select quantilesApprox(10000, 0.01, 0.1, 0.11)(number + 1) from numbers(10);
+
+with number + 1 as col select quantilesApprox(10000, 0.25, 0.5, 0.75)(col), count(col), quantilesApprox(10000, 0.0, 1.0)(col), sum(col) from numbers(1000);
+
+select quantilesApprox(1, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesApprox(10, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesApprox(100, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesApprox(1000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesApprox(10000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+
+
+select quantileApprox() from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantileApprox(100) from numbers(10);
+select quantileApprox(100, 0.5) from numbers(10);
+select quantileApprox(100, 0.5, 0.75) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantileApprox('abc', 0.5) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantileApprox(1.23, 0.5) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantileApprox(-100, 0.5) from numbers(10); -- { serverError BAD_ARGUMENTS }
+
+select quantilesApprox() from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantilesApprox(100) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantilesApprox(100, 0.5) from numbers(10);
+select quantilesApprox('abc', 0.5, 0.75) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantilesApprox(1.23, 0.5, 0.75) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantilesApprox(-100, 0.5, 0.75) from numbers(10); -- { serverError BAD_ARGUMENTS }
diff --git a/tests/queries/0_stateless/02661_quantile_gk.sql b/tests/queries/0_stateless/02661_quantile_gk.sql
deleted file mode 100644
index 2fe8fa33d0a..00000000000
--- a/tests/queries/0_stateless/02661_quantile_gk.sql
+++ /dev/null
@@ -1,13 +0,0 @@
-with arrayJoin([0, 1, 2, 10]) as x select quantilesGK(100, 0.5, 0.4, 0.1)(x);
-with arrayJoin([0, 6, 7, 9, 10]) as x select quantileGK(100, 0.5)(x);
-
-select quantilesGK(10000, 0.25, 0.5, 0.75, 0.0, 1.0, 0, 1)(number + 1) from numbers(1000);
-select quantilesGK(10000, 0.01, 0.1, 0.11)(number + 1) from numbers(10);
-
-with number + 1 as col select quantilesGK(10000, 0.25, 0.5, 0.75)(col), count(col), quantilesGK(10000, 0.0, 1.0)(col), sum(col) from numbers(1000);
-
-select quantilesGK(1, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
-select quantilesGK(10, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
-select quantilesGK(100, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
-select quantilesGK(1000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
-select quantilesGK(10000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);

From 6cc4b4b1b4db4c07c4b29834daac84e5124c163c Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 7 Mar 2023 17:58:30 +0800
Subject: [PATCH 14/80] renaming functions

---
 .../reference/quantileApprox.md                  | 16 ++++++++--------
 .../aggregate-functions/reference/quantiles.md   | 12 ++++++------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md b/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
index d725c982af0..788f4754324 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
@@ -1,9 +1,9 @@
 ---
-slug: /en/sql-reference/aggregate-functions/reference/quantileGK
+slug: /en/sql-reference/aggregate-functions/reference/quantileApprox
 sidebar_position: 204
 ---
 
-# quantileGK
+# quantileApprox
 
 Computes the [quantile](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](http://infolab.stanford.edu/~datar/courses/cs361a/papers/quantiles.pdf) algorithm.
 
@@ -11,10 +11,10 @@ Computes the [quantile](https://en.wikipedia.org/wiki/Quantile) of a numeric dat
 **Syntax**
 
 ``` sql
-quantileGK(accuracy, level)(expr)
+quantileApprox(accuracy, level)(expr)
 ```
 
-Alias: `medianGK`.
+Alias: `medianApprox`.
 
 **Arguments**
 
@@ -40,12 +40,12 @@ Type:
 
 ``` sql
 WITH arrayJoin([0, 6, 7, 9, 10]) AS x
-SELECT quantileGK(100, 0.5)(x)
+SELECT quantileApprox(100, 0.5)(x)
 
 
-┌─quantileGK(100, 0.5)(x)─┐
-│                       7 │
-└─────────────────────────┘
+┌─quantileApprox(100, 0.5)(x)─┐
+│                           7 │
+└──────────────----───────────┘
 ```
 
 
diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
index 3ad64c111db..ec5855397ce 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
@@ -115,14 +115,14 @@ Result:
 └─────────────────────────────────────────────────────────────────────┘
 ```
 
-## quantilesGK
+## quantilesApprox
 
 Exactly computes the [quantiles](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](https://dl.acm.org/doi/10.1145/375663.375670) algorithm.
 
 **Syntax**
 
 ``` sql
-quantilesGK(accuracy, level1, level2, ...)(expr)
+quantilesApprox(accuracy, level1, level2, ...)(expr)
 ```
 
 **Arguments**
@@ -152,9 +152,9 @@ Query:
 
 ``` sql
 WITH arrayJoin([0, 6, 7, 9, 10]) AS x
-SELECT quantilesGK(100, 0.1, 0.2, 0.3)(x)
+SELECT quantilesApprox(100, 0.1, 0.2, 0.3)(x)
 
-┌─quantilesGK(100, 0.1, 0.2, 0.3)(x)─┐
-│ [0,0,6]                            │
-└────────────────────────────────────┘
+┌─quantilesApprox(100, 0.1, 0.2, 0.3)(x)─┐
+│ [0,0,6]                                │
+└────────────────────────────────────────┘
 ```

From 9bd75020ffb75457d69558fd93ed56b854c14cf9 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 7 Mar 2023 18:27:02 +0800
Subject: [PATCH 15/80] fix failed uts

---
 .../AggregateFunctionQuantile.h               |  2 +-
 .../02661_quantile_approx.reference           | 27 ++++++++++++++++++
 .../0_stateless/02661_quantile_approx.sql     | 28 ++++++++++---------
 3 files changed, 43 insertions(+), 14 deletions(-)

diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index 650a16b5e87..10fe99f3e06 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -26,7 +26,7 @@ namespace ErrorCodes
 {
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
-    extern const int LOGICAL_ERROR;
+    extern const int BAD_ARGUMENTS;
 }
 
 template <typename> class QuantileTiming;
diff --git a/tests/queries/0_stateless/02661_quantile_approx.reference b/tests/queries/0_stateless/02661_quantile_approx.reference
index be9ea2f0e80..73d99112c0b 100644
--- a/tests/queries/0_stateless/02661_quantile_approx.reference
+++ b/tests/queries/0_stateless/02661_quantile_approx.reference
@@ -1,10 +1,37 @@
+-- { echoOn }
+with arrayJoin([0, 1, 2, 10]) as x select quantilesApprox(100, 0.5, 0.4, 0.1)(x);
 [1,1,0]
+with arrayJoin([0, 6, 7, 9, 10]) as x select quantileApprox(100, 0.5)(x);
 7
+select quantilesApprox(10000, 0.25, 0.5, 0.75, 0.0, 1.0, 0, 1)(number + 1) from numbers(1000);
 [250,500,750,1,1000,1,1000]
+select quantilesApprox(10000, 0.01, 0.1, 0.11)(number + 1) from numbers(10);
 [1,1,2]
+with number + 1 as col select quantilesApprox(10000, 0.25, 0.5, 0.75)(col), count(col), quantilesApprox(10000, 0.0, 1.0)(col), sum(col) from numbers(1000);
 [250,500,750]	1000	[1,1000]	500500
+select quantilesApprox(1, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
 [1,1,1,1,1]
+select quantilesApprox(10, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
 [1,156,156,296,715]
+select quantilesApprox(100, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
 [93,192,251,306,770]
+select quantilesApprox(1000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
 [99,199,249,313,776]
+select quantilesApprox(10000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
 [100,200,250,314,777]
+select quantileApprox()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantileApprox(100)(number) from numbers(10);
+4
+select quantileApprox(100, 0.5)(number) from numbers(10);
+4
+select quantileApprox(100, 0.5, 0.75)(number) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantileApprox('abc', 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantileApprox(1.23, 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantileApprox(-100, 0.5)(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantilesApprox()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantilesApprox(100)(number) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantilesApprox(100, 0.5)(number) from numbers(10);
+[4]
+select quantilesApprox('abc', 0.5, 0.75)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantilesApprox(1.23, 0.5, 0.75)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantilesApprox(-100, 0.5, 0.75)(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
diff --git a/tests/queries/0_stateless/02661_quantile_approx.sql b/tests/queries/0_stateless/02661_quantile_approx.sql
index 28e1630a27b..f27c8150ee9 100644
--- a/tests/queries/0_stateless/02661_quantile_approx.sql
+++ b/tests/queries/0_stateless/02661_quantile_approx.sql
@@ -1,3 +1,4 @@
+-- { echoOn }
 with arrayJoin([0, 1, 2, 10]) as x select quantilesApprox(100, 0.5, 0.4, 0.1)(x);
 with arrayJoin([0, 6, 7, 9, 10]) as x select quantileApprox(100, 0.5)(x);
 
@@ -13,17 +14,18 @@ select quantilesApprox(1000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(n
 select quantilesApprox(10000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
 
 
-select quantileApprox() from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
-select quantileApprox(100) from numbers(10);
-select quantileApprox(100, 0.5) from numbers(10);
-select quantileApprox(100, 0.5, 0.75) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
-select quantileApprox('abc', 0.5) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
-select quantileApprox(1.23, 0.5) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
-select quantileApprox(-100, 0.5) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantileApprox()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantileApprox(100)(number) from numbers(10);
+select quantileApprox(100, 0.5)(number) from numbers(10);
+select quantileApprox(100, 0.5, 0.75)(number) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantileApprox('abc', 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantileApprox(1.23, 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantileApprox(-100, 0.5)(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
 
-select quantilesApprox() from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
-select quantilesApprox(100) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
-select quantilesApprox(100, 0.5) from numbers(10);
-select quantilesApprox('abc', 0.5, 0.75) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
-select quantilesApprox(1.23, 0.5, 0.75) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
-select quantilesApprox(-100, 0.5, 0.75) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantilesApprox()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantilesApprox(100)(number) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantilesApprox(100, 0.5)(number) from numbers(10);
+select quantilesApprox('abc', 0.5, 0.75)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantilesApprox(1.23, 0.5, 0.75)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantilesApprox(-100, 0.5, 0.75)(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+-- { echoOff }

From a2a8cbb787f182831d70873374b93956c500deae Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 7 Mar 2023 21:41:45 +0800
Subject: [PATCH 16/80] add some more docs

---
 .../reference/quantileApprox.md               | 35 +++++++++++++----
 .../reference/quantiles.md                    | 38 +++++++++++++++----
 2 files changed, 59 insertions(+), 14 deletions(-)

diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md b/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
index 788f4754324..21b9a3500c4 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
@@ -5,8 +5,9 @@ sidebar_position: 204
 
 # quantileApprox
 
-Computes the [quantile](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](http://infolab.stanford.edu/~datar/courses/cs361a/papers/quantiles.pdf) algorithm.
+Computes the [quantile](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](http://infolab.stanford.edu/~datar/courses/cs361a/papers/quantiles.pdf) algorithm. The Greenwald-Khanna algorithm is an algorithm used to compute quantiles on a stream of data in a highly efficient manner. It was introduced by Michael Greenwald and Sanjeev Khanna in 2001. It is widely used in databases and big data systems where computing accurate quantiles on a large stream of data in real-time is necessary. The algorithm is highly efficient, taking only O(log n) space and O(log log n) time per item (where n is the size of the input). It is also highly accurate, providing an approximate quantile value with high probability. 
 
+`quantileApprox` is different from other quantile functions in ClickHouse, because it enables user to control the accuracy of the approximate quantile result.
 
 **Syntax**
 
@@ -18,7 +19,7 @@ Alias: `medianApprox`.
 
 **Arguments**
 
--   `accuracy` — Accuracy of quantile. Constant positive integer. The larger the better.
+-   `accuracy` — Accuracy of quantile. Constant positive integer. Larger accuracy value means less error. For example, if the accuracy argument is set to 100, the computed quantile will have an error no greater than 1% with high probability. There is a trade-off between the accuracy of the computed quantiles and the computational complexity of the algorithm. A larger accuracy requires more memory and computational resources to compute the quantile accurately, while a smaller accuracy argument allows for a faster and more memory-efficient computation but with a slightly lower accuracy.
 
 -   `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. Default value: 0.5. At `level=0.5` the function calculates [median](https://en.wikipedia.org/wiki/Median).
 
@@ -39,13 +40,33 @@ Type:
 **Example**
 
 ``` sql
-WITH arrayJoin([0, 6, 7, 9, 10]) AS x
-SELECT quantileApprox(100, 0.5)(x)
+SELECT quantileApprox(1, 0.25)(number + 1)
+FROM numbers(1000)
 
+┌─quantileApprox(1, 0.25)(plus(number, 1))─┐
+│                                        1 │
+└──────────────────────────────────────────┘
 
-┌─quantileApprox(100, 0.5)(x)─┐
-│                           7 │
-└──────────────----───────────┘
+SELECT quantileApprox(10, 0.25)(number + 1)
+FROM numbers(1000)
+
+┌─quantileApprox(10, 0.25)(plus(number, 1))─┐
+│                                       156 │
+└───────────────────────────────────────────┘
+
+SELECT quantileApprox(100, 0.25)(number + 1)
+FROM numbers(1000)
+
+┌─quantileApprox(100, 0.25)(plus(number, 1))─┐
+│                                        251 │
+└────────────────────────────────────────────┘
+
+SELECT quantileApprox(1000, 0.25)(number + 1)
+FROM numbers(1000)
+
+┌─quantileApprox(1000, 0.25)(plus(number, 1))─┐
+│                                         249 │
+└─────────────────────────────────────────────┘
 ```
 
 
diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
index ec5855397ce..663e8771723 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
@@ -117,7 +117,9 @@ Result:
 
 ## quantilesApprox
 
-Exactly computes the [quantiles](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](https://dl.acm.org/doi/10.1145/375663.375670) algorithm.
+Computes the [quantiles](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](http://infolab.stanford.edu/~datar/courses/cs361a/papers/quantiles.pdf) algorithm. The Greenwald-Khanna algorithm is an algorithm used to compute quantiles on a stream of data in a highly efficient manner. It was introduced by Michael Greenwald and Sanjeev Khanna in 2001. It is widely used in databases and big data systems where computing accurate quantiles on a large stream of data in real-time is necessary. The algorithm is highly efficient, taking only O(log n) space and O(log log n) time per item (where n is the size of the input stream). It is also highly accurate, providing approximate quantile values with high probability. 
+
+`quantilesApprox` is different from other quantiles functions in ClickHouse, because it enables user to control the accuracy of the approximate quantiles.
 
 **Syntax**
 
@@ -131,7 +133,7 @@ quantilesApprox(accuracy, level1, level2, ...)(expr)
 
 **Parameters**
 
--   `accuracy` — Accuracy of quantile. Constant positive integer. The larger the better.
+-   `accuracy` — Accuracy of quantile. Constant positive integer. Larger accuracy value means less error. For example, if the accuracy argument is set to 100, for example, the computed quantiles will have an error no greater than 1% with high probability. There is a trade-off between the accuracy of the computed quantiles and the computational complexity of the algorithm. A larger accuracy requires more memory and computational resources to compute the quantiles accurately, while a smaller accuracy argument allows for a faster and more memory-efficient computation but with a slightly lower accuracy.
 
 -   `levelN` — Level of quantile. Constant floating-point number from 0 to 1.
 
@@ -151,10 +153,32 @@ Query:
 
 
 ``` sql
-WITH arrayJoin([0, 6, 7, 9, 10]) AS x
-SELECT quantilesApprox(100, 0.1, 0.2, 0.3)(x)
+SELECT quantilesApprox(1, 0.25, 0.5, 0.75)(number + 1)
+FROM numbers(1000)
 
-┌─quantilesApprox(100, 0.1, 0.2, 0.3)(x)─┐
-│ [0,0,6]                                │
-└────────────────────────────────────────┘
+┌─quantilesApprox(1, 0.25, 0.5, 0.75)(plus(number, 1))─┐
+│ [1,1,1]                                              │
+└──────────────────────────────────────────────────────┘
+
+SELECT quantilesApprox(10, 0.25, 0.5, 0.75)(number + 1)
+FROM numbers(1000)
+
+┌─quantilesApprox(10, 0.25, 0.5, 0.75)(plus(number, 1))─┐
+│ [156,413,659]                                         │
+└───────────────────────────────────────────────────────┘
+
+
+SELECT quantilesApprox(100, 0.25, 0.5, 0.75)(number + 1)
+FROM numbers(1000)
+
+┌─quantilesApprox(100, 0.25, 0.5, 0.75)(plus(number, 1))─┐
+│ [251,498,741]                                          │
+└────────────────────────────────────────────────────────┘
+
+SELECT quantilesApprox(1000, 0.25, 0.5, 0.75)(number + 1)
+FROM numbers(1000)
+
+┌─quantilesApprox(1000, 0.25, 0.5, 0.75)(plus(number, 1))─┐
+│ [249,499,749]                                           │
+└─────────────────────────────────────────────────────────┘
 ```

From 713c7022acd88c0ec3c284d5bd1b2fbfe231977c Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Fri, 17 Mar 2023 18:19:29 +0800
Subject: [PATCH 17/80] fix docs

---
 .../aggregate-functions/reference/quantiles.md     | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
index 663e8771723..fe22ad7b048 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
@@ -117,9 +117,7 @@ Result:
 
 ## quantilesApprox
 
-Computes the [quantiles](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](http://infolab.stanford.edu/~datar/courses/cs361a/papers/quantiles.pdf) algorithm. The Greenwald-Khanna algorithm is an algorithm used to compute quantiles on a stream of data in a highly efficient manner. It was introduced by Michael Greenwald and Sanjeev Khanna in 2001. It is widely used in databases and big data systems where computing accurate quantiles on a large stream of data in real-time is necessary. The algorithm is highly efficient, taking only O(log n) space and O(log log n) time per item (where n is the size of the input stream). It is also highly accurate, providing approximate quantile values with high probability. 
-
-`quantilesApprox` is different from other quantiles functions in ClickHouse, because it enables user to control the accuracy of the approximate quantiles.
+`quantilesApprox` works similarly with `quantileApprox` but allows us to calculate quantities at different levels simultaneously and returns an array.
 
 **Syntax**
 
@@ -127,16 +125,6 @@ Computes the [quantiles](https://en.wikipedia.org/wiki/Quantile) of a numeric da
 quantilesApprox(accuracy, level1, level2, ...)(expr)
 ```
 
-**Arguments**
-
--   `expr` — Expression over the column values resulting in numeric [data types](../../../sql-reference/data-types/index.md#data_types), [Date](../../../sql-reference/data-types/date.md) or [DateTime](../../../sql-reference/data-types/datetime.md).
-
-**Parameters**
-
--   `accuracy` — Accuracy of quantile. Constant positive integer. Larger accuracy value means less error. For example, if the accuracy argument is set to 100, for example, the computed quantiles will have an error no greater than 1% with high probability. There is a trade-off between the accuracy of the computed quantiles and the computational complexity of the algorithm. A larger accuracy requires more memory and computational resources to compute the quantiles accurately, while a smaller accuracy argument allows for a faster and more memory-efficient computation but with a slightly lower accuracy.
-
--   `levelN` — Level of quantile. Constant floating-point number from 0 to 1.
-
 **Returned value**
 
 -   [Array](../../../sql-reference/data-types/array.md) of quantiles of the specified levels.

From 103bb9bf0353a5ad4cd50c90279f5036159d6e0b Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Wed, 15 Mar 2023 11:50:58 +0000
Subject: [PATCH 18/80] add a hilite-aware equality comparator and a sample
 test

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 162 ++++++++++++++++++++
 1 file changed, 162 insertions(+)
 create mode 100644 src/Parsers/tests/gtest_format_hiliting.cpp

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
new file mode 100644
index 00000000000..e6fac581c05
--- /dev/null
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -0,0 +1,162 @@
+#include <unordered_set>
+
+#include <gtest/gtest.h>
+#include <Parsers/IAST.h>
+#include <Common/StackTrace.h>
+
+std::string hilite(const std::string & s, const char * hilite_type)
+{
+    std::stringstream ss;
+    ss << hilite_type;
+    ss << s;
+    ss << DB::IAST::hilite_none;
+    return ss.str();
+}
+
+std::string keyword(const std::string & s)
+{
+    return hilite(s, DB::IAST::hilite_keyword);
+}
+
+std::string identifier(const std::string & s)
+{
+    return hilite(s, DB::IAST::hilite_identifier);
+}
+
+std::string alias(const std::string & s)
+{
+    return hilite(s, DB::IAST::hilite_alias);
+}
+
+std::string op(const std::string & s)
+{
+    return hilite(s, DB::IAST::hilite_operator);
+}
+
+std::string function(const std::string & s)
+{
+    return hilite(s, DB::IAST::hilite_function);
+}
+
+std::string substitution(const std::string & s)
+{
+    return hilite(s, DB::IAST::hilite_substitution);
+}
+
+
+bool are_equal_with_hilites(const std::string_view & left, const std::string_view & right)
+{
+    const char * left_it = left.begin();
+    const char * right_it = right.begin();
+    const char * left_hilite = DB::IAST::hilite_none;
+    const char * right_hilite = DB::IAST::hilite_none;
+    std::unordered_set<const char *> hilites = {DB::IAST::hilite_keyword, DB::IAST::hilite_identifier, DB::IAST::hilite_alias,
+                                                DB::IAST::hilite_function, DB::IAST::hilite_operator, DB::IAST::hilite_substitution,
+                                                DB::IAST::hilite_none};
+
+    while (true)
+    {
+        // Consume hilites.
+        bool changed_hilite = true;
+        while (changed_hilite)
+        {
+            changed_hilite = false;
+            for (const char * hilite : hilites)
+            {
+                if (std::string_view(left_it, left.end()).starts_with(hilite))
+                {
+                    left_hilite = hilite;
+                    left_it += strlen(hilite);
+                    changed_hilite = true;
+                }
+                if (std::string_view(right_it, right.end()).starts_with(hilite))
+                {
+                    right_hilite = hilite;
+                    right_it += strlen(hilite);
+                    changed_hilite = true;
+                }
+            }
+        }
+
+        if (left_it == left.end() && right_it == right.end())
+            return true;
+
+        if (left_it == left.end() || right_it == right.end())
+            return false;
+
+        // Lookup one character.
+        // Check characters match.
+        if (*left_it != *right_it)
+            return false;
+
+        // Check hilites match if it's not a whitespace.
+        if (!std::isspace(*left_it) && left_hilite != right_hilite)
+            return false;
+
+        // Consume one character.
+        left_it++;
+        right_it++;
+    }
+}
+
+TEST(HilitingTestSuit, TestTheTest)
+{
+    ASSERT_PRED2(are_equal_with_hilites, "", "");
+
+    std::unordered_set<const char *> hilites = {DB::IAST::hilite_keyword, DB::IAST::hilite_identifier, DB::IAST::hilite_alias,
+                                                DB::IAST::hilite_function, DB::IAST::hilite_operator, DB::IAST::hilite_substitution,
+                                                DB::IAST::hilite_none};
+    for (const char * hilite : hilites)
+    {
+        ASSERT_PRED2(are_equal_with_hilites, "", std::string_view(hilite));
+        ASSERT_PRED2(are_equal_with_hilites, std::string_view(hilite), "");
+    }
+
+    {
+        std::stringstream ss;
+        ss << DB::IAST::hilite_none << "select" << DB::IAST::hilite_none;
+        ASSERT_PRED2(are_equal_with_hilites, ss.str(), "select");
+    }
+
+    {
+        std::stringstream ss;
+        ss << DB::IAST::hilite_none << "\n " << "sel" << DB::IAST::hilite_none << "ect" << DB::IAST::hilite_none;
+        ASSERT_PRED2(are_equal_with_hilites, ss.str(), "\n select");
+    }
+
+    {
+        std::stringstream left;
+        left << DB::IAST::hilite_keyword << "keyword" << " long" << DB::IAST::hilite_none;
+        std::stringstream right;
+        right << DB::IAST::hilite_keyword << "keyword" << DB::IAST::hilite_none << " " << DB::IAST::hilite_keyword << "long";
+        ASSERT_PRED2(are_equal_with_hilites, left.str(), right.str());
+    }
+}
+
+TEST(HilitingTestSuit, HilitingTestName)
+{
+    using namespace DB;
+    std::string query = "with alias as (select * from table) select * from table";
+
+    std::stringstream expected;
+    expected << IAST::hilite_keyword << "WITH " << IAST::hilite_alias << "alias " << IAST::hilite_keyword << "AS " << IAST::hilite_none
+             << "(" << IAST::hilite_keyword << "SELECT " << IAST::hilite_none << "* " << IAST::hilite_keyword << "FROM "
+             << IAST::hilite_identifier << "table" << IAST::hilite_none << ")"
+             << IAST::hilite_keyword << "SELECT " << IAST::hilite_none << "* " << IAST::hilite_keyword << "FROM "
+             << IAST::hilite_identifier << "table" << IAST::hilite_none;
+
+    expected << keyword("WTH ") << alias("alias ") << keyword("AS ") << "("
+             << keyword("SELECT ") << "* " << keyword("FROM ")
+             << identifier("table") << ")"
+             << keyword("SELECT ") << "* " << keyword("FROM ")
+             << identifier("table");
+
+    DB::IAST * ast = parseQuery(*parser, query.begin(), query.end(), 0, 0);
+
+    DB::WriteBufferFromOwnString write_buffer;
+    DB::IAST::FormatSettings settings{write_buffer, true};
+    settings.hilite = true;
+    ast->format(settings);
+
+    ASSERT_PRED2(are_equal_with_hilites, expected.str(), write_buffer.str());
+}

From 086fe077c90aaa185e32006589d3ca962d0b466b Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Wed, 15 Mar 2023 14:30:31 +0000
Subject: [PATCH 19/80] cleanup

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 45 ++++++++++-----------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index e6fac581c05..7b49b39e7e9 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -2,6 +2,8 @@
 
 #include <gtest/gtest.h>
 #include <Parsers/IAST.h>
+#include <Parsers/parseQuery.h>
+#include <Parsers/ParserQuery.h>
 #include <Common/StackTrace.h>
 
 std::string hilite(const std::string & s, const char * hilite_type)
@@ -57,8 +59,8 @@ bool are_equal_with_hilites(const std::string_view & left, const std::string_vie
     while (true)
     {
         // Consume hilites.
-        bool changed_hilite = true;
-        while (changed_hilite)
+        bool changed_hilite = false;
+        do
         {
             changed_hilite = false;
             for (const char * hilite : hilites)
@@ -76,7 +78,7 @@ bool are_equal_with_hilites(const std::string_view & left, const std::string_vie
                     changed_hilite = true;
                 }
             }
-        }
+        } while (changed_hilite);
 
         if (left_it == left.end() && right_it == right.end())
             return true;
@@ -99,7 +101,7 @@ bool are_equal_with_hilites(const std::string_view & left, const std::string_vie
     }
 }
 
-TEST(HilitingTestSuit, TestTheTest)
+TEST(FormatHiliting, MetaTestAreEqualWithHilites)
 {
     ASSERT_PRED2(are_equal_with_hilites, "", "");
 
@@ -133,30 +135,27 @@ TEST(HilitingTestSuit, TestTheTest)
     }
 }
 
-TEST(HilitingTestSuit, HilitingTestName)
+void compare(const std::string & query, const std::stringstream & expected)
 {
     using namespace DB;
-    std::string query = "with alias as (select * from table) select * from table";
+    ParserQuery parser(query.data() + query.size());
+    ASTPtr ast = parseQuery(parser, query, 0, 0);
 
-    std::stringstream expected;
-    expected << IAST::hilite_keyword << "WITH " << IAST::hilite_alias << "alias " << IAST::hilite_keyword << "AS " << IAST::hilite_none
-             << "(" << IAST::hilite_keyword << "SELECT " << IAST::hilite_none << "* " << IAST::hilite_keyword << "FROM "
-             << IAST::hilite_identifier << "table" << IAST::hilite_none << ")"
-             << IAST::hilite_keyword << "SELECT " << IAST::hilite_none << "* " << IAST::hilite_keyword << "FROM "
-             << IAST::hilite_identifier << "table" << IAST::hilite_none;
-
-    expected << keyword("WTH ") << alias("alias ") << keyword("AS ") << "("
-             << keyword("SELECT ") << "* " << keyword("FROM ")
-             << identifier("table") << ")"
-             << keyword("SELECT ") << "* " << keyword("FROM ")
-             << identifier("table");
-
-    DB::IAST * ast = parseQuery(*parser, query.begin(), query.end(), 0, 0);
-
-    DB::WriteBufferFromOwnString write_buffer;
-    DB::IAST::FormatSettings settings{write_buffer, true};
+    WriteBufferFromOwnString write_buffer;
+    IAST::FormatSettings settings{write_buffer, true};
     settings.hilite = true;
     ast->format(settings);
 
     ASSERT_PRED2(are_equal_with_hilites, expected.str(), write_buffer.str());
 }
+
+TEST(FormatHiliting, SimpleSelect)
+{
+    std::string query = "select * from table";
+
+    std::stringstream expected;
+    expected << keyword("SELECT ") << "* " << keyword("FROM ")
+             << identifier("table");
+
+    compare(query, expected);
+}

From da5285004d4c69b56e642c105be6766b02a15032 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Wed, 15 Mar 2023 21:20:01 +0000
Subject: [PATCH 20/80] add failing tests

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 105 ++++++++++++++++++--
 1 file changed, 95 insertions(+), 10 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 7b49b39e7e9..ff6b7b45c5b 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -1,9 +1,9 @@
 #include <unordered_set>
 
-#include <gtest/gtest.h>
 #include <Parsers/IAST.h>
-#include <Parsers/parseQuery.h>
 #include <Parsers/ParserQuery.h>
+#include <Parsers/parseQuery.h>
+#include <gtest/gtest.h>
 #include <Common/StackTrace.h>
 
 std::string hilite(const std::string & s, const char * hilite_type)
@@ -52,9 +52,14 @@ bool are_equal_with_hilites(const std::string_view & left, const std::string_vie
     const char * right_it = right.begin();
     const char * left_hilite = DB::IAST::hilite_none;
     const char * right_hilite = DB::IAST::hilite_none;
-    std::unordered_set<const char *> hilites = {DB::IAST::hilite_keyword, DB::IAST::hilite_identifier, DB::IAST::hilite_alias,
-                                                DB::IAST::hilite_function, DB::IAST::hilite_operator, DB::IAST::hilite_substitution,
-                                                DB::IAST::hilite_none};
+    std::unordered_set<const char *> hilites
+        = {DB::IAST::hilite_keyword,
+           DB::IAST::hilite_identifier,
+           DB::IAST::hilite_alias,
+           DB::IAST::hilite_function,
+           DB::IAST::hilite_operator,
+           DB::IAST::hilite_substitution,
+           DB::IAST::hilite_none};
 
     while (true)
     {
@@ -105,9 +110,14 @@ TEST(FormatHiliting, MetaTestAreEqualWithHilites)
 {
     ASSERT_PRED2(are_equal_with_hilites, "", "");
 
-    std::unordered_set<const char *> hilites = {DB::IAST::hilite_keyword, DB::IAST::hilite_identifier, DB::IAST::hilite_alias,
-                                                DB::IAST::hilite_function, DB::IAST::hilite_operator, DB::IAST::hilite_substitution,
-                                                DB::IAST::hilite_none};
+    std::unordered_set<const char *> hilites
+        = {DB::IAST::hilite_keyword,
+           DB::IAST::hilite_identifier,
+           DB::IAST::hilite_alias,
+           DB::IAST::hilite_function,
+           DB::IAST::hilite_operator,
+           DB::IAST::hilite_substitution,
+           DB::IAST::hilite_none};
     for (const char * hilite : hilites)
     {
         ASSERT_PRED2(are_equal_with_hilites, "", std::string_view(hilite));
@@ -154,8 +164,83 @@ TEST(FormatHiliting, SimpleSelect)
     std::string query = "select * from table";
 
     std::stringstream expected;
-    expected << keyword("SELECT ") << "* " << keyword("FROM ")
-             << identifier("table");
+    expected << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table");
+
+    compare(query, expected);
+}
+
+TEST(FormatHiliting, ASTWithElement)
+{
+    std::string query = "with alias as (select * from table) select * from table";
+
+    std::stringstream expected;
+    expected << keyword("WITH ") << alias("alias ") << keyword("AS ")
+             << "(" << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table") << ") "
+             << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table");
+
+    compare(query, expected);
+}
+
+TEST(FormatHiliting, ASTWithAlias)
+{
+    std::string query = "select a + 1 as b, b";
+
+    std::stringstream expected;
+    expected << keyword("SELECT ") << identifier("a ") << op("+ ") << "1 " << keyword("AS ") << alias("b") << ", "
+             << identifier("b");
+
+    compare(query, expected);
+}
+
+TEST(FormatHiliting, ASTFunction)
+{
+    std::string query = "select * from view(select * from table)";
+
+    std::stringstream expected;
+    expected << keyword("SELECT ") << "* " << keyword("FROM ")
+             << function("view") << "(" << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table") << ")";
+
+    compare(query, expected);
+}
+
+TEST(FormatHiliting, ASTDictionaryAttributeDeclaration)
+{
+    std::string query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID)";
+
+    std::stringstream expected;
+    expected << keyword("CREATE DICTIONARY ") << "name "
+             << "(`Name` " << function("ClickHouseDataType ")
+             << keyword("DEFAULT ") << "'' "
+             << keyword("EXPRESSION ") << function("rand64() ")
+             << keyword("IS_OBJECT_ID") << ")";
+
+    compare(query, expected);
+}
+
+TEST(FormatHiliting, ASTDictionary_Source)
+{
+    std::string query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID) "
+                        "SOURCE(FILE(PATH 'path'))";
+
+    std::stringstream expected;
+    expected << keyword("CREATE DICTIONARY ") << "name "
+             << "(`Name` " << function("ClickHouseDataType ")
+             << keyword("DEFAULT ") << "'' "
+             << keyword("EXPRESSION ") << function("rand64() ")
+             << keyword("IS_OBJECT_ID") << ") "
+             << keyword("SOURCE") << "(" << keyword("FILE") << "(" << keyword("PATH ") << "'path'))";
+
+    compare(query, expected);
+}
+
+TEST(FormatHiliting, ASTKillQueryQuery)
+{
+    std::string query = "KILL QUERY ON CLUSTER clustername WHERE user = 'username' SYNC";
+
+    std::stringstream expected;
+    expected << keyword("KILL QUERY ON CLUSTER ") << "clustername "
+             << keyword("WHERE ") << identifier("user ") << op("= ") << "'username' "
+             << keyword("SYNC");
 
     compare(query, expected);
 }

From ed22d0f028ca15256d4807d879fe22a722f751e8 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Wed, 15 Mar 2023 21:20:56 +0000
Subject: [PATCH 21/80] fix bugs (now tests pass)

---
 src/Parsers/ASTDictionary.cpp                     | 4 ++--
 src/Parsers/ASTDictionaryAttributeDeclaration.cpp | 2 ++
 src/Parsers/ASTFunction.cpp                       | 2 +-
 src/Parsers/ASTKillQueryQuery.cpp                 | 4 +++-
 src/Parsers/ASTWithAlias.cpp                      | 2 ++
 src/Parsers/ASTWithElement.cpp                    | 1 +
 6 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/Parsers/ASTDictionary.cpp b/src/Parsers/ASTDictionary.cpp
index 66c1c3791b8..5716a713c0c 100644
--- a/src/Parsers/ASTDictionary.cpp
+++ b/src/Parsers/ASTDictionary.cpp
@@ -161,8 +161,8 @@ void ASTDictionary::formatImpl(const FormatSettings & settings, FormatState & st
 
     if (source)
     {
-        settings.ostr << (settings.hilite ? hilite_keyword : "") << settings.nl_or_ws << "SOURCE("
-            << (settings.hilite ? hilite_none : "");
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << settings.nl_or_ws << "SOURCE"
+            << (settings.hilite ? hilite_none : "") << "(";
         source->formatImpl(settings, state, frame);
         settings.ostr << ")";
     }
diff --git a/src/Parsers/ASTDictionaryAttributeDeclaration.cpp b/src/Parsers/ASTDictionaryAttributeDeclaration.cpp
index 760b96b0927..127b07fa685 100644
--- a/src/Parsers/ASTDictionaryAttributeDeclaration.cpp
+++ b/src/Parsers/ASTDictionaryAttributeDeclaration.cpp
@@ -66,6 +66,8 @@ void ASTDictionaryAttributeDeclaration::formatImpl(const FormatSettings & settin
 
     if (is_object_id)
         settings.ostr << ' ' << (settings.hilite ? hilite_keyword : "") << "IS_OBJECT_ID";
+
+    settings.ostr << (settings.hilite ? hilite_none : "");
 }
 
 }
diff --git a/src/Parsers/ASTFunction.cpp b/src/Parsers/ASTFunction.cpp
index fa4874d89b6..b3d2a262695 100644
--- a/src/Parsers/ASTFunction.cpp
+++ b/src/Parsers/ASTFunction.cpp
@@ -692,7 +692,7 @@ void ASTFunction::formatImplWithoutAlias(const FormatSettings & settings, Format
     {
         std::string nl_or_nothing = settings.one_line ? "" : "\n";
         std::string indent_str = settings.one_line ? "" : std::string(4u * frame.indent, ' ');
-        settings.ostr << (settings.hilite ? hilite_function : "") << name << "(" << nl_or_nothing;
+        settings.ostr << (settings.hilite ? hilite_function : "") << name << (settings.hilite ? hilite_none : "") << "(" << nl_or_nothing;
         FormatStateStacked frame_nested = frame;
         frame_nested.need_parens = false;
         ++frame_nested.indent;
diff --git a/src/Parsers/ASTKillQueryQuery.cpp b/src/Parsers/ASTKillQueryQuery.cpp
index 8bf99312544..a3c0f48f28a 100644
--- a/src/Parsers/ASTKillQueryQuery.cpp
+++ b/src/Parsers/ASTKillQueryQuery.cpp
@@ -29,11 +29,13 @@ void ASTKillQueryQuery::formatQueryImpl(const FormatSettings & settings, FormatS
             break;
     }
 
+    settings.ostr << (settings.hilite ? hilite_none : "");
+
     formatOnCluster(settings);
 
     if (where_expression)
     {
-        settings.ostr << " WHERE " << (settings.hilite ? hilite_none : "");
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << " WHERE " << (settings.hilite ? hilite_none : "");
         where_expression->formatImpl(settings, state, frame);
     }
 
diff --git a/src/Parsers/ASTWithAlias.cpp b/src/Parsers/ASTWithAlias.cpp
index 88f6568a719..1b5397654fd 100644
--- a/src/Parsers/ASTWithAlias.cpp
+++ b/src/Parsers/ASTWithAlias.cpp
@@ -20,7 +20,9 @@ void ASTWithAlias::formatImpl(const FormatSettings & settings, FormatState & sta
     /// This is needed because the query can become extraordinary large after substitution of aliases.
     if (!alias.empty() && !state.printed_asts_with_alias.emplace(frame.current_select, alias, getTreeHash()).second)
     {
+        settings.ostr << (settings.hilite ? IAST::hilite_identifier : "");
         settings.writeIdentifier(alias);
+        settings.ostr << (settings.hilite ? IAST::hilite_none : "");
     }
     else
     {
diff --git a/src/Parsers/ASTWithElement.cpp b/src/Parsers/ASTWithElement.cpp
index b517509c4bc..1cc669e36da 100644
--- a/src/Parsers/ASTWithElement.cpp
+++ b/src/Parsers/ASTWithElement.cpp
@@ -18,6 +18,7 @@ void ASTWithElement::formatImpl(const FormatSettings & settings, FormatState & s
 {
     std::string indent_str = settings.one_line ? "" : std::string(4 * frame.indent, ' ');
 
+    settings.ostr << (settings.hilite ? hilite_alias : "");
     settings.writeIdentifier(name);
     settings.ostr << (settings.hilite ? hilite_keyword : "") << " AS" << (settings.hilite ? hilite_none : "");
     settings.ostr << settings.nl_or_ws << indent_str;

From bf4a3a23fa0c4f4dbd57d5df41507ac70e976ca6 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Wed, 15 Mar 2023 23:56:20 +0000
Subject: [PATCH 22/80] compare string without hilites first, for easier debug

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 133 ++++++++++++++------
 1 file changed, 95 insertions(+), 38 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index ff6b7b45c5b..1d45b4444b9 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -45,45 +45,76 @@ std::string substitution(const std::string & s)
     return hilite(s, DB::IAST::hilite_substitution);
 }
 
+std::vector<const char *> HILITES =
+    {
+        DB::IAST::hilite_keyword,
+        DB::IAST::hilite_identifier,
+        DB::IAST::hilite_function,
+        DB::IAST::hilite_operator,
+        DB::IAST::hilite_alias,
+        DB::IAST::hilite_substitution,
+        DB::IAST::hilite_none
+    };
+
+[[maybe_unused]] const char * consume_hilites(const char ** it)
+{
+    const char * last_hilite = nullptr;
+    while (true)
+    {
+        bool changed_hilite = false;
+        for (const char * hilite : HILITES)
+        {
+            if (std::string_view(*it).starts_with(hilite))
+            {
+                *it += strlen(hilite);
+                changed_hilite = true;
+                last_hilite = hilite;
+            }
+        }
+        if (!changed_hilite)
+            break;
+    }
+    return last_hilite;
+}
+
+std::string remove_hilites(const std::string_view & string)
+{
+    const char * it = string.begin();
+    std::stringstream ss;
+    while (true)
+    {
+        consume_hilites(&it);
+        if (it == string.end())
+            return ss.str();
+        ss << *(it++);
+    }
+}
+
+bool are_equal_with_hilites_removed(const std::string_view & left, const std::string_view & right)
+{
+    return remove_hilites(left) == remove_hilites(right);
+}
 
 bool are_equal_with_hilites(const std::string_view & left, const std::string_view & right)
 {
+    if (!are_equal_with_hilites_removed(left, right))
+        return false;
+
     const char * left_it = left.begin();
     const char * right_it = right.begin();
     const char * left_hilite = DB::IAST::hilite_none;
     const char * right_hilite = DB::IAST::hilite_none;
-    std::unordered_set<const char *> hilites
-        = {DB::IAST::hilite_keyword,
-           DB::IAST::hilite_identifier,
-           DB::IAST::hilite_alias,
-           DB::IAST::hilite_function,
-           DB::IAST::hilite_operator,
-           DB::IAST::hilite_substitution,
-           DB::IAST::hilite_none};
 
     while (true)
     {
-        // Consume hilites.
-        bool changed_hilite = false;
-        do
-        {
-            changed_hilite = false;
-            for (const char * hilite : hilites)
-            {
-                if (std::string_view(left_it, left.end()).starts_with(hilite))
-                {
-                    left_hilite = hilite;
-                    left_it += strlen(hilite);
-                    changed_hilite = true;
-                }
-                if (std::string_view(right_it, right.end()).starts_with(hilite))
-                {
-                    right_hilite = hilite;
-                    right_it += strlen(hilite);
-                    changed_hilite = true;
-                }
-            }
-        } while (changed_hilite);
+        // Consume all prefix hilites, update the current hilite to be the last one.
+        const char * last_hilite = consume_hilites(&left_it);
+        if (last_hilite != nullptr)
+            left_hilite = last_hilite;
+
+        last_hilite = consume_hilites(&right_it);
+        if (last_hilite != nullptr)
+            right_hilite = last_hilite;
 
         if (left_it == left.end() && right_it == right.end())
             return true;
@@ -93,6 +124,7 @@ bool are_equal_with_hilites(const std::string_view & left, const std::string_vie
 
         // Lookup one character.
         // Check characters match.
+        // Redundant check, given the hilite-ignorant comparison at the beginning, but let's keep it just in case.
         if (*left_it != *right_it)
             return false;
 
@@ -106,19 +138,44 @@ bool are_equal_with_hilites(const std::string_view & left, const std::string_vie
     }
 }
 
+TEST(FormatHiliting, MetaTestConsumeHilites)
+{
+    using namespace DB;
+    std::stringstream ss;
+    // The order is different from the order in HILITES on purpose.
+    ss << IAST::hilite_keyword
+       << IAST::hilite_alias
+       << IAST::hilite_identifier
+       << IAST::hilite_none
+       << IAST::hilite_operator
+       << IAST::hilite_substitution
+       << IAST::hilite_function
+       << "test" << IAST::hilite_keyword;
+    std::string string = ss.str();
+    const char * it = string.c_str();
+    const char * expected_it = strchr(it, 't');
+    const char * last_hilite = consume_hilites(&it);
+    ASSERT_EQ(expected_it, it);
+    ASSERT_TRUE(last_hilite != nullptr);
+    ASSERT_EQ(IAST::hilite_function, last_hilite);
+}
+
+TEST(FormatHiliting, MetaTestRemoveHilites)
+{
+    using namespace DB;
+    std::stringstream ss;
+    ss << IAST::hilite_keyword
+       << "te" << IAST::hilite_alias << IAST::hilite_identifier
+       << "s" << IAST::hilite_none
+       << "t" << IAST::hilite_operator << IAST::hilite_substitution << IAST::hilite_function;
+    ASSERT_EQ("test", remove_hilites(ss.str()));
+}
+
 TEST(FormatHiliting, MetaTestAreEqualWithHilites)
 {
     ASSERT_PRED2(are_equal_with_hilites, "", "");
 
-    std::unordered_set<const char *> hilites
-        = {DB::IAST::hilite_keyword,
-           DB::IAST::hilite_identifier,
-           DB::IAST::hilite_alias,
-           DB::IAST::hilite_function,
-           DB::IAST::hilite_operator,
-           DB::IAST::hilite_substitution,
-           DB::IAST::hilite_none};
-    for (const char * hilite : hilites)
+    for (const char * hilite : HILITES)
     {
         ASSERT_PRED2(are_equal_with_hilites, "", std::string_view(hilite));
         ASSERT_PRED2(are_equal_with_hilites, std::string_view(hilite), "");

From 9e8ad944d663d5c2c90de19bfe06718db1419043 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 21 Mar 2023 12:32:03 +0000
Subject: [PATCH 23/80] fix symmetry

---
 src/Parsers/ASTDictionary.cpp                     |  3 ++-
 src/Parsers/ASTDictionaryAttributeDeclaration.cpp | 10 ++++------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/Parsers/ASTDictionary.cpp b/src/Parsers/ASTDictionary.cpp
index 5716a713c0c..e33a7de6836 100644
--- a/src/Parsers/ASTDictionary.cpp
+++ b/src/Parsers/ASTDictionary.cpp
@@ -162,7 +162,8 @@ void ASTDictionary::formatImpl(const FormatSettings & settings, FormatState & st
     if (source)
     {
         settings.ostr << (settings.hilite ? hilite_keyword : "") << settings.nl_or_ws << "SOURCE"
-            << (settings.hilite ? hilite_none : "") << "(";
+            << (settings.hilite ? hilite_none : "");
+        settings.ostr << "(";
         source->formatImpl(settings, state, frame);
         settings.ostr << ")";
     }
diff --git a/src/Parsers/ASTDictionaryAttributeDeclaration.cpp b/src/Parsers/ASTDictionaryAttributeDeclaration.cpp
index 127b07fa685..daf708c9478 100644
--- a/src/Parsers/ASTDictionaryAttributeDeclaration.cpp
+++ b/src/Parsers/ASTDictionaryAttributeDeclaration.cpp
@@ -56,18 +56,16 @@ void ASTDictionaryAttributeDeclaration::formatImpl(const FormatSettings & settin
     }
 
     if (hierarchical)
-        settings.ostr << ' ' << (settings.hilite ? hilite_keyword : "") << "HIERARCHICAL";
+        settings.ostr << ' ' << (settings.hilite ? hilite_keyword : "") << "HIERARCHICAL" << (settings.hilite ? hilite_none : "");
 
     if (bidirectional)
-        settings.ostr << ' ' << (settings.hilite ? hilite_keyword : "") << "BIDIRECTIONAL";
+        settings.ostr << ' ' << (settings.hilite ? hilite_keyword : "") << "BIDIRECTIONAL" << (settings.hilite ? hilite_none : "");
 
     if (injective)
-        settings.ostr << ' ' << (settings.hilite ? hilite_keyword : "") << "INJECTIVE";
+        settings.ostr << ' ' << (settings.hilite ? hilite_keyword : "") << "INJECTIVE" << (settings.hilite ? hilite_none : "");
 
     if (is_object_id)
-        settings.ostr << ' ' << (settings.hilite ? hilite_keyword : "") << "IS_OBJECT_ID";
-
-    settings.ostr << (settings.hilite ? hilite_none : "");
+        settings.ostr << ' ' << (settings.hilite ? hilite_keyword : "") << "IS_OBJECT_ID" << (settings.hilite ? hilite_none : "");
 }
 
 }

From 95a8905be649c6a99c082dd7f3e9ad51552d8c96 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 21 Mar 2023 12:32:45 +0000
Subject: [PATCH 24/80] split ostr writes for readability

---
 src/Parsers/ASTWithElement.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Parsers/ASTWithElement.cpp b/src/Parsers/ASTWithElement.cpp
index 1cc669e36da..c2cb1177c17 100644
--- a/src/Parsers/ASTWithElement.cpp
+++ b/src/Parsers/ASTWithElement.cpp
@@ -20,6 +20,7 @@ void ASTWithElement::formatImpl(const FormatSettings & settings, FormatState & s
 
     settings.ostr << (settings.hilite ? hilite_alias : "");
     settings.writeIdentifier(name);
+    settings.ostr << (settings.hilite ? hilite_none : "");
     settings.ostr << (settings.hilite ? hilite_keyword : "") << " AS" << (settings.hilite ? hilite_none : "");
     settings.ostr << settings.nl_or_ws << indent_str;
     dynamic_cast<const ASTWithAlias &>(*subquery).formatImplWithoutAlias(settings, state, frame);

From 134ec0f6b06480d5e8bc9baa84d2c75010126341 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 21 Mar 2023 12:33:28 +0000
Subject: [PATCH 25/80] remove const& from std::string_view

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 1d45b4444b9..d1e4b666e53 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -77,7 +77,7 @@ std::vector<const char *> HILITES =
     return last_hilite;
 }
 
-std::string remove_hilites(const std::string_view & string)
+std::string remove_hilites(std::string_view string)
 {
     const char * it = string.begin();
     std::stringstream ss;
@@ -90,12 +90,12 @@ std::string remove_hilites(const std::string_view & string)
     }
 }
 
-bool are_equal_with_hilites_removed(const std::string_view & left, const std::string_view & right)
+bool are_equal_with_hilites_removed(std::string_view left, std::string_view right)
 {
     return remove_hilites(left) == remove_hilites(right);
 }
 
-bool are_equal_with_hilites(const std::string_view & left, const std::string_view & right)
+bool are_equal_with_hilites(const std::string_view & left, std::string_view right)
 {
     if (!are_equal_with_hilites_removed(left, right))
         return false;

From ddfc72a6caa0579ae70c2b7034775eb7f0c3ca3e Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 21 Mar 2023 12:34:07 +0000
Subject: [PATCH 26/80] use () for c-tor, not {}

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index d1e4b666e53..2b69a29886c 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -209,7 +209,7 @@ void compare(const std::string & query, const std::stringstream & expected)
     ASTPtr ast = parseQuery(parser, query, 0, 0);
 
     WriteBufferFromOwnString write_buffer;
-    IAST::FormatSettings settings{write_buffer, true};
+    IAST::FormatSettings settings(write_buffer, true);
     settings.hilite = true;
     ast->format(settings);
 

From a4dfba11c5f6f2bc3c8d233296d9e60f3d10ce88 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 21 Mar 2023 12:35:20 +0000
Subject: [PATCH 27/80] replace std::string with String

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 34 ++++++++++-----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 2b69a29886c..478986f8e3f 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -6,7 +6,7 @@
 #include <gtest/gtest.h>
 #include <Common/StackTrace.h>
 
-std::string hilite(const std::string & s, const char * hilite_type)
+String hilite(const String & s, const char * hilite_type)
 {
     std::stringstream ss;
     ss << hilite_type;
@@ -15,32 +15,32 @@ std::string hilite(const std::string & s, const char * hilite_type)
     return ss.str();
 }
 
-std::string keyword(const std::string & s)
+String keyword(const String & s)
 {
     return hilite(s, DB::IAST::hilite_keyword);
 }
 
-std::string identifier(const std::string & s)
+String identifier(const String & s)
 {
     return hilite(s, DB::IAST::hilite_identifier);
 }
 
-std::string alias(const std::string & s)
+String alias(const String & s)
 {
     return hilite(s, DB::IAST::hilite_alias);
 }
 
-std::string op(const std::string & s)
+String op(const String & s)
 {
     return hilite(s, DB::IAST::hilite_operator);
 }
 
-std::string function(const std::string & s)
+String function(const String & s)
 {
     return hilite(s, DB::IAST::hilite_function);
 }
 
-std::string substitution(const std::string & s)
+String substitution(const String & s)
 {
     return hilite(s, DB::IAST::hilite_substitution);
 }
@@ -77,7 +77,7 @@ std::vector<const char *> HILITES =
     return last_hilite;
 }
 
-std::string remove_hilites(std::string_view string)
+String remove_hilites(std::string_view string)
 {
     const char * it = string.begin();
     std::stringstream ss;
@@ -151,7 +151,7 @@ TEST(FormatHiliting, MetaTestConsumeHilites)
        << IAST::hilite_substitution
        << IAST::hilite_function
        << "test" << IAST::hilite_keyword;
-    std::string string = ss.str();
+    String string = ss.str();
     const char * it = string.c_str();
     const char * expected_it = strchr(it, 't');
     const char * last_hilite = consume_hilites(&it);
@@ -202,7 +202,7 @@ TEST(FormatHiliting, MetaTestAreEqualWithHilites)
     }
 }
 
-void compare(const std::string & query, const std::stringstream & expected)
+void compare(const String & query, const std::stringstream & expected)
 {
     using namespace DB;
     ParserQuery parser(query.data() + query.size());
@@ -218,7 +218,7 @@ void compare(const std::string & query, const std::stringstream & expected)
 
 TEST(FormatHiliting, SimpleSelect)
 {
-    std::string query = "select * from table";
+    String query = "select * from table";
 
     std::stringstream expected;
     expected << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table");
@@ -228,7 +228,7 @@ TEST(FormatHiliting, SimpleSelect)
 
 TEST(FormatHiliting, ASTWithElement)
 {
-    std::string query = "with alias as (select * from table) select * from table";
+    String query = "with alias as (select * from table) select * from table";
 
     std::stringstream expected;
     expected << keyword("WITH ") << alias("alias ") << keyword("AS ")
@@ -240,7 +240,7 @@ TEST(FormatHiliting, ASTWithElement)
 
 TEST(FormatHiliting, ASTWithAlias)
 {
-    std::string query = "select a + 1 as b, b";
+    String query = "select a + 1 as b, b";
 
     std::stringstream expected;
     expected << keyword("SELECT ") << identifier("a ") << op("+ ") << "1 " << keyword("AS ") << alias("b") << ", "
@@ -251,7 +251,7 @@ TEST(FormatHiliting, ASTWithAlias)
 
 TEST(FormatHiliting, ASTFunction)
 {
-    std::string query = "select * from view(select * from table)";
+    String query = "select * from view(select * from table)";
 
     std::stringstream expected;
     expected << keyword("SELECT ") << "* " << keyword("FROM ")
@@ -262,7 +262,7 @@ TEST(FormatHiliting, ASTFunction)
 
 TEST(FormatHiliting, ASTDictionaryAttributeDeclaration)
 {
-    std::string query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID)";
+    String query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID)";
 
     std::stringstream expected;
     expected << keyword("CREATE DICTIONARY ") << "name "
@@ -276,7 +276,7 @@ TEST(FormatHiliting, ASTDictionaryAttributeDeclaration)
 
 TEST(FormatHiliting, ASTDictionary_Source)
 {
-    std::string query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID) "
+    String query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID) "
                         "SOURCE(FILE(PATH 'path'))";
 
     std::stringstream expected;
@@ -292,7 +292,7 @@ TEST(FormatHiliting, ASTDictionary_Source)
 
 TEST(FormatHiliting, ASTKillQueryQuery)
 {
-    std::string query = "KILL QUERY ON CLUSTER clustername WHERE user = 'username' SYNC";
+    String query = "KILL QUERY ON CLUSTER clustername WHERE user = 'username' SYNC";
 
     std::stringstream expected;
     expected << keyword("KILL QUERY ON CLUSTER ") << "clustername "

From cf057013edfd75599a1ffc6c5d2891a207fbe4fa Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Mon, 27 Mar 2023 17:04:14 +0100
Subject: [PATCH 28/80] hilite view()'s parenthesis as function as well

---
 src/Parsers/ASTFunction.cpp                 | 7 +++++--
 src/Parsers/tests/gtest_format_hiliting.cpp | 9 ++++++++-
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/Parsers/ASTFunction.cpp b/src/Parsers/ASTFunction.cpp
index b3d2a262695..6aac857ca9e 100644
--- a/src/Parsers/ASTFunction.cpp
+++ b/src/Parsers/ASTFunction.cpp
@@ -692,12 +692,15 @@ void ASTFunction::formatImplWithoutAlias(const FormatSettings & settings, Format
     {
         std::string nl_or_nothing = settings.one_line ? "" : "\n";
         std::string indent_str = settings.one_line ? "" : std::string(4u * frame.indent, ' ');
-        settings.ostr << (settings.hilite ? hilite_function : "") << name << (settings.hilite ? hilite_none : "") << "(" << nl_or_nothing;
+        settings.ostr << (settings.hilite ? hilite_function : "") << name << (settings.hilite ? hilite_none : "");
+        settings.ostr << (settings.hilite ? hilite_function : "") << "(" << (settings.hilite ? hilite_nano : "");
+        settings.ostr << nl_or_nothing;
         FormatStateStacked frame_nested = frame;
         frame_nested.need_parens = false;
         ++frame_nested.indent;
         query->formatImpl(settings, state, frame_nested);
-        settings.ostr << nl_or_nothing << indent_str << ")";
+        settings.ostr << nl_or_nothing << indent_str;
+        settings.ostr << (settings.hilite ? hilite_function : "") << ")" << (settings.hilite ? hilite_nano : "");
         return;
     }
 
diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 478986f8e3f..d4e7c9a0210 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -95,6 +95,13 @@ bool are_equal_with_hilites_removed(std::string_view left, std::string_view righ
     return remove_hilites(left) == remove_hilites(right);
 }
 
+/*
+ * Hilited queries cannot be compared symbol-by-symbol, as there's some frivolousness introduced with the hilites. Specifically:
+ * 1. Whitespaces could be hilited with any hilite type.
+ * 2. Hilite could or could be not reset with hilite_none before the next hilite, i.e. strings a and b are equal.
+ *      a. hilite_keyword foo hilite_none hilite_operator +
+ *      b. hilite_keyword foo hilite_operator +
+ */
 bool are_equal_with_hilites(const std::string_view & left, std::string_view right)
 {
     if (!are_equal_with_hilites_removed(left, right))
@@ -255,7 +262,7 @@ TEST(FormatHiliting, ASTFunction)
 
     std::stringstream expected;
     expected << keyword("SELECT ") << "* " << keyword("FROM ")
-             << function("view") << "(" << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table") << ")";
+             << function("view(") << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table") << function(")");
 
     compare(query, expected);
 }

From a862973f145d563fb58e69db12c3466ee715a404 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 28 Mar 2023 11:28:31 +0100
Subject: [PATCH 29/80] amend comment on hilite equality

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index d4e7c9a0210..3921094caa9 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -98,7 +98,7 @@ bool are_equal_with_hilites_removed(std::string_view left, std::string_view righ
 /*
  * Hilited queries cannot be compared symbol-by-symbol, as there's some frivolousness introduced with the hilites. Specifically:
  * 1. Whitespaces could be hilited with any hilite type.
- * 2. Hilite could or could be not reset with hilite_none before the next hilite, i.e. strings a and b are equal.
+ * 2. Hilite could or could be not reset with hilite_none before the next hilite, i.e. the following strings a and b are equal:
  *      a. hilite_keyword foo hilite_none hilite_operator +
  *      b. hilite_keyword foo hilite_operator +
  */

From e14675935a73764a2ff886c0566e249a5927331c Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 28 Mar 2023 11:29:16 +0100
Subject: [PATCH 30/80] remove const& from std::string_view

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 3921094caa9..2f0144fa240 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -102,7 +102,7 @@ bool are_equal_with_hilites_removed(std::string_view left, std::string_view righ
  *      a. hilite_keyword foo hilite_none hilite_operator +
  *      b. hilite_keyword foo hilite_operator +
  */
-bool are_equal_with_hilites(const std::string_view & left, std::string_view right)
+bool are_equal_with_hilites(std::string_view left, std::string_view right)
 {
     if (!are_equal_with_hilites_removed(left, right))
         return false;

From 36ef6228531c1c2111e3791e9af2e7a4122b75c7 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 28 Mar 2023 11:31:10 +0100
Subject: [PATCH 31/80] change compare signature to accept both args as String,
 for symmetry

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 2f0144fa240..682586e93a1 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -209,7 +209,7 @@ TEST(FormatHiliting, MetaTestAreEqualWithHilites)
     }
 }
 
-void compare(const String & query, const std::stringstream & expected)
+void compare(const String & query, const String & expected)
 {
     using namespace DB;
     ParserQuery parser(query.data() + query.size());
@@ -220,7 +220,12 @@ void compare(const String & query, const std::stringstream & expected)
     settings.hilite = true;
     ast->format(settings);
 
-    ASSERT_PRED2(are_equal_with_hilites, expected.str(), write_buffer.str());
+    ASSERT_PRED2(are_equal_with_hilites, expected, write_buffer.str());
+}
+
+void compare(const String & query, const std::stringstream & expected)
+{
+    return compare(query, expected.str());
 }
 
 TEST(FormatHiliting, SimpleSelect)

From a7614b844ee61e499016e7fd8a882303c7d29ad2 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 28 Mar 2023 11:45:48 +0100
Subject: [PATCH 32/80] rename const char * it into ptr

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 24 ++++++++++-----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 682586e93a1..491390a1f57 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -56,7 +56,7 @@ std::vector<const char *> HILITES =
         DB::IAST::hilite_none
     };
 
-[[maybe_unused]] const char * consume_hilites(const char ** it)
+[[maybe_unused]] const char * consume_hilites(const char ** ptr_ptr)
 {
     const char * last_hilite = nullptr;
     while (true)
@@ -64,9 +64,9 @@ std::vector<const char *> HILITES =
         bool changed_hilite = false;
         for (const char * hilite : HILITES)
         {
-            if (std::string_view(*it).starts_with(hilite))
+            if (std::string_view(*ptr_ptr).starts_with(hilite))
             {
-                *it += strlen(hilite);
+                *ptr_ptr += strlen(hilite);
                 changed_hilite = true;
                 last_hilite = hilite;
             }
@@ -79,14 +79,14 @@ std::vector<const char *> HILITES =
 
 String remove_hilites(std::string_view string)
 {
-    const char * it = string.begin();
+    const char * ptr = string.begin();
     std::stringstream ss;
     while (true)
     {
-        consume_hilites(&it);
-        if (it == string.end())
+        consume_hilites(&ptr);
+        if (ptr == string.end())
             return ss.str();
-        ss << *(it++);
+        ss << *(ptr++);
     }
 }
 
@@ -159,10 +159,10 @@ TEST(FormatHiliting, MetaTestConsumeHilites)
        << IAST::hilite_function
        << "test" << IAST::hilite_keyword;
     String string = ss.str();
-    const char * it = string.c_str();
-    const char * expected_it = strchr(it, 't');
-    const char * last_hilite = consume_hilites(&it);
-    ASSERT_EQ(expected_it, it);
+    const char * ptr = string.c_str();
+    const char * expected_ptr = strchr(ptr, 't');
+    const char * last_hilite = consume_hilites(&ptr);
+    ASSERT_EQ(expected_ptr, ptr);
     ASSERT_TRUE(last_hilite != nullptr);
     ASSERT_EQ(IAST::hilite_function, last_hilite);
 }
@@ -286,7 +286,7 @@ TEST(FormatHiliting, ASTDictionaryAttributeDeclaration)
     compare(query, expected);
 }
 
-TEST(FormatHiliting, ASTDictionary_Source)
+TEST(FormatHiliting, ASTDictionaryClassSourceKeyword)
 {
     String query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID) "
                         "SOURCE(FILE(PATH 'path'))";

From df5824a2d2d82eba41b87ccbff0a93a12401d09a Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 28 Mar 2023 11:59:04 +0100
Subject: [PATCH 33/80] contstruct string directly without std::stringstream in
 tests

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 50 +++++++++------------
 1 file changed, 21 insertions(+), 29 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 491390a1f57..a26906ae406 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -232,8 +232,7 @@ TEST(FormatHiliting, SimpleSelect)
 {
     String query = "select * from table";
 
-    std::stringstream expected;
-    expected << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table");
+    String expected = keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table");
 
     compare(query, expected);
 }
@@ -242,10 +241,9 @@ TEST(FormatHiliting, ASTWithElement)
 {
     String query = "with alias as (select * from table) select * from table";
 
-    std::stringstream expected;
-    expected << keyword("WITH ") << alias("alias ") << keyword("AS ")
-             << "(" << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table") << ") "
-             << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table");
+    String expected = keyword("WITH ") + alias("alias ") + keyword("AS ")
+             + "(" + keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table") + ") "
+             + keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table");
 
     compare(query, expected);
 }
@@ -254,9 +252,7 @@ TEST(FormatHiliting, ASTWithAlias)
 {
     String query = "select a + 1 as b, b";
 
-    std::stringstream expected;
-    expected << keyword("SELECT ") << identifier("a ") << op("+ ") << "1 " << keyword("AS ") << alias("b") << ", "
-             << identifier("b");
+    String expected = keyword("SELECT ") + identifier("a ") + op("+ ") + "1 " + keyword("AS ") + alias("b") + ", " + identifier("b");
 
     compare(query, expected);
 }
@@ -265,9 +261,8 @@ TEST(FormatHiliting, ASTFunction)
 {
     String query = "select * from view(select * from table)";
 
-    std::stringstream expected;
-    expected << keyword("SELECT ") << "* " << keyword("FROM ")
-             << function("view(") << keyword("SELECT ") << "* " << keyword("FROM ") << identifier("table") << function(")");
+    String expected = keyword("SELECT ") + "* " + keyword("FROM ")
+            + function("view(") + keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table") + function(")");
 
     compare(query, expected);
 }
@@ -276,12 +271,11 @@ TEST(FormatHiliting, ASTDictionaryAttributeDeclaration)
 {
     String query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID)";
 
-    std::stringstream expected;
-    expected << keyword("CREATE DICTIONARY ") << "name "
-             << "(`Name` " << function("ClickHouseDataType ")
-             << keyword("DEFAULT ") << "'' "
-             << keyword("EXPRESSION ") << function("rand64() ")
-             << keyword("IS_OBJECT_ID") << ")";
+    String expected = keyword("CREATE DICTIONARY ") + "name "
+            + "(`Name` " + function("ClickHouseDataType ")
+            + keyword("DEFAULT ") + "'' "
+            + keyword("EXPRESSION ") + function("rand64() ")
+            + keyword("IS_OBJECT_ID") + ")";
 
     compare(query, expected);
 }
@@ -291,13 +285,12 @@ TEST(FormatHiliting, ASTDictionaryClassSourceKeyword)
     String query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID) "
                         "SOURCE(FILE(PATH 'path'))";
 
-    std::stringstream expected;
-    expected << keyword("CREATE DICTIONARY ") << "name "
-             << "(`Name` " << function("ClickHouseDataType ")
-             << keyword("DEFAULT ") << "'' "
-             << keyword("EXPRESSION ") << function("rand64() ")
-             << keyword("IS_OBJECT_ID") << ") "
-             << keyword("SOURCE") << "(" << keyword("FILE") << "(" << keyword("PATH ") << "'path'))";
+    String expected = keyword("CREATE DICTIONARY ") + "name "
+            + "(`Name` " + function("ClickHouseDataType ")
+            + keyword("DEFAULT ") + "'' "
+            + keyword("EXPRESSION ") + function("rand64() ")
+            + keyword("IS_OBJECT_ID") + ") "
+            + keyword("SOURCE") + "(" + keyword("FILE") + "(" + keyword("PATH ") + "'path'))";
 
     compare(query, expected);
 }
@@ -306,10 +299,9 @@ TEST(FormatHiliting, ASTKillQueryQuery)
 {
     String query = "KILL QUERY ON CLUSTER clustername WHERE user = 'username' SYNC";
 
-    std::stringstream expected;
-    expected << keyword("KILL QUERY ON CLUSTER ") << "clustername "
-             << keyword("WHERE ") << identifier("user ") << op("= ") << "'username' "
-             << keyword("SYNC");
+    String expected = keyword("KILL QUERY ON CLUSTER ") + "clustername "
+            + keyword("WHERE ") + identifier("user ") + op("= ") + "'username' "
+            + keyword("SYNC");
 
     compare(query, expected);
 }

From 5681f2c13003ace59cf34d55045d966e52d8e5fc Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 28 Mar 2023 12:41:28 +0100
Subject: [PATCH 34/80] remove unused compare std::stringstream overload

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index a26906ae406..86e3b2bf2fa 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -223,11 +223,6 @@ void compare(const String & query, const String & expected)
     ASSERT_PRED2(are_equal_with_hilites, expected, write_buffer.str());
 }
 
-void compare(const String & query, const std::stringstream & expected)
-{
-    return compare(query, expected.str());
-}
-
 TEST(FormatHiliting, SimpleSelect)
 {
     String query = "select * from table";

From f36ad317516fc50676be994d7bbd28bd32f22422 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 28 Mar 2023 12:58:23 +0100
Subject: [PATCH 35/80] add bug: second parenthesis ) not hilited in CREATE
 TABLE name AS (SELECT *) COMMENT 'hello'

---
 src/Parsers/ASTCreateQuery.cpp              |  2 +-
 src/Parsers/tests/gtest_format_hiliting.cpp | 11 +++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/Parsers/ASTCreateQuery.cpp b/src/Parsers/ASTCreateQuery.cpp
index e28e863c21f..a2b41247ccc 100644
--- a/src/Parsers/ASTCreateQuery.cpp
+++ b/src/Parsers/ASTCreateQuery.cpp
@@ -443,7 +443,7 @@ void ASTCreateQuery::formatQueryImpl(const FormatSettings & settings, FormatStat
                       << (comment ? "(" : "")
                       << settings.nl_or_ws << (settings.hilite ? hilite_none : "");
         select->formatImpl(settings, state, frame);
-        settings.ostr << (comment ? ")" : "");
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << (comment ? ")" : "") << (settings.hilite ? hilite_none : "");
     }
 
     if (comment)
diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 86e3b2bf2fa..2d523cecf63 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -300,3 +300,14 @@ TEST(FormatHiliting, ASTKillQueryQuery)
 
     compare(query, expected);
 }
+
+TEST(FormatHiliting, ASTCreateQuery)
+{
+    // The misplaced space around ( is on purpose, as this bug will fixed in a separate PR.
+    String query = "CREATE TABLE name AS( SELECT *) COMMENT 'hello'";
+
+    String expected = keyword("CREATE TABLE ") + identifier("name ") + keyword("AS( SELECT ") + "*" + keyword(")")
+            + keyword("COMMENT") + "'hello'";
+
+    compare(query, expected);
+}

From ba17db5365049d9640f199704a1c80900e448061 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 28 Mar 2023 15:05:16 +0100
Subject: [PATCH 36/80] fix ASTCreateQuery test

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 2d523cecf63..a4cbcf10b3b 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -220,6 +220,7 @@ void compare(const String & query, const String & expected)
     settings.hilite = true;
     ast->format(settings);
 
+    ASSERT_PRED2(are_equal_with_hilites_removed, expected, write_buffer.str());
     ASSERT_PRED2(are_equal_with_hilites, expected, write_buffer.str());
 }
 
@@ -306,8 +307,8 @@ TEST(FormatHiliting, ASTCreateQuery)
     // The misplaced space around ( is on purpose, as this bug will fixed in a separate PR.
     String query = "CREATE TABLE name AS( SELECT *) COMMENT 'hello'";
 
-    String expected = keyword("CREATE TABLE ") + identifier("name ") + keyword("AS( SELECT ") + "*" + keyword(")")
-            + keyword("COMMENT") + "'hello'";
+    String expected = keyword("CREATE TABLE ") + "name " + keyword("AS( SELECT ") + "*" + keyword(") ")
+            + keyword("COMMENT ") + "'hello'";
 
     compare(query, expected);
 }

From d7d008c44dbb3afeff5f2a23913c72c430e3c1ae Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 28 Mar 2023 15:06:56 +0100
Subject: [PATCH 37/80] fix typo in hilite_none

---
 src/Parsers/ASTFunction.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Parsers/ASTFunction.cpp b/src/Parsers/ASTFunction.cpp
index 6aac857ca9e..99c2dbabdd7 100644
--- a/src/Parsers/ASTFunction.cpp
+++ b/src/Parsers/ASTFunction.cpp
@@ -693,14 +693,14 @@ void ASTFunction::formatImplWithoutAlias(const FormatSettings & settings, Format
         std::string nl_or_nothing = settings.one_line ? "" : "\n";
         std::string indent_str = settings.one_line ? "" : std::string(4u * frame.indent, ' ');
         settings.ostr << (settings.hilite ? hilite_function : "") << name << (settings.hilite ? hilite_none : "");
-        settings.ostr << (settings.hilite ? hilite_function : "") << "(" << (settings.hilite ? hilite_nano : "");
+        settings.ostr << (settings.hilite ? hilite_function : "") << "(" << (settings.hilite ? hilite_none : "");
         settings.ostr << nl_or_nothing;
         FormatStateStacked frame_nested = frame;
         frame_nested.need_parens = false;
         ++frame_nested.indent;
         query->formatImpl(settings, state, frame_nested);
         settings.ostr << nl_or_nothing << indent_str;
-        settings.ostr << (settings.hilite ? hilite_function : "") << ")" << (settings.hilite ? hilite_nano : "");
+        settings.ostr << (settings.hilite ? hilite_function : "") << ")" << (settings.hilite ? hilite_none : "");
         return;
     }
 

From e984e221ce2dc6dddece35b84c61aef9f1ae8ea4 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 28 Mar 2023 15:30:54 +0100
Subject: [PATCH 38/80] get rid of std::stringstream

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 89 ++++++++++++---------
 1 file changed, 53 insertions(+), 36 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index a4cbcf10b3b..978dc3507ac 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -8,11 +8,7 @@
 
 String hilite(const String & s, const char * hilite_type)
 {
-    std::stringstream ss;
-    ss << hilite_type;
-    ss << s;
-    ss << DB::IAST::hilite_none;
-    return ss.str();
+    return hilite_type + s + DB::IAST::hilite_none;
 }
 
 String keyword(const String & s)
@@ -80,13 +76,13 @@ std::vector<const char *> HILITES =
 String remove_hilites(std::string_view string)
 {
     const char * ptr = string.begin();
-    std::stringstream ss;
+    String string_without_hilites;
     while (true)
     {
         consume_hilites(&ptr);
         if (ptr == string.end())
-            return ss.str();
-        ss << *(ptr++);
+            return string_without_hilites;
+        string_without_hilites += *(ptr++);
     }
 }
 
@@ -148,18 +144,18 @@ bool are_equal_with_hilites(std::string_view left, std::string_view right)
 TEST(FormatHiliting, MetaTestConsumeHilites)
 {
     using namespace DB;
-    std::stringstream ss;
     // The order is different from the order in HILITES on purpose.
-    ss << IAST::hilite_keyword
-       << IAST::hilite_alias
-       << IAST::hilite_identifier
-       << IAST::hilite_none
-       << IAST::hilite_operator
-       << IAST::hilite_substitution
-       << IAST::hilite_function
-       << "test" << IAST::hilite_keyword;
-    String string = ss.str();
-    const char * ptr = string.c_str();
+    String s;
+    s += IAST::hilite_keyword;
+    s += IAST::hilite_alias;
+    s += IAST::hilite_identifier;
+    s += IAST::hilite_none;
+    s += IAST::hilite_operator;
+    s += IAST::hilite_substitution;
+    s += IAST::hilite_function;
+    s += "test";
+    s += IAST::hilite_keyword;
+    const char * ptr = s.c_str();
     const char * expected_ptr = strchr(ptr, 't');
     const char * last_hilite = consume_hilites(&ptr);
     ASSERT_EQ(expected_ptr, ptr);
@@ -170,16 +166,23 @@ TEST(FormatHiliting, MetaTestConsumeHilites)
 TEST(FormatHiliting, MetaTestRemoveHilites)
 {
     using namespace DB;
-    std::stringstream ss;
-    ss << IAST::hilite_keyword
-       << "te" << IAST::hilite_alias << IAST::hilite_identifier
-       << "s" << IAST::hilite_none
-       << "t" << IAST::hilite_operator << IAST::hilite_substitution << IAST::hilite_function;
-    ASSERT_EQ("test", remove_hilites(ss.str()));
+    String s;
+    s += IAST::hilite_keyword;
+    s += "te";
+    s += IAST::hilite_alias;
+    s += IAST::hilite_identifier;
+    s += "s";
+    s += IAST::hilite_none;
+    s += "t";
+    s += IAST::hilite_operator;
+    s += IAST::hilite_substitution;
+    s += IAST::hilite_function;
+    ASSERT_EQ("test", remove_hilites(s));
 }
 
 TEST(FormatHiliting, MetaTestAreEqualWithHilites)
 {
+    using namespace DB;
     ASSERT_PRED2(are_equal_with_hilites, "", "");
 
     for (const char * hilite : HILITES)
@@ -189,23 +192,37 @@ TEST(FormatHiliting, MetaTestAreEqualWithHilites)
     }
 
     {
-        std::stringstream ss;
-        ss << DB::IAST::hilite_none << "select" << DB::IAST::hilite_none;
-        ASSERT_PRED2(are_equal_with_hilites, ss.str(), "select");
+        String s;
+        s += IAST::hilite_none;
+        s += "select";
+        s += IAST::hilite_none;
+        ASSERT_PRED2(are_equal_with_hilites, s, "select");
     }
 
     {
-        std::stringstream ss;
-        ss << DB::IAST::hilite_none << "\n " << "sel" << DB::IAST::hilite_none << "ect" << DB::IAST::hilite_none;
-        ASSERT_PRED2(are_equal_with_hilites, ss.str(), "\n select");
+        String s;
+        s += DB::IAST::hilite_none;
+        s += "\n sel";
+        s += DB::IAST::hilite_none;
+        s += "ect";
+        s += DB::IAST::hilite_none;
+        ASSERT_PRED2(are_equal_with_hilites, s, "\n select");
     }
 
     {
-        std::stringstream left;
-        left << DB::IAST::hilite_keyword << "keyword" << " long" << DB::IAST::hilite_none;
-        std::stringstream right;
-        right << DB::IAST::hilite_keyword << "keyword" << DB::IAST::hilite_none << " " << DB::IAST::hilite_keyword << "long";
-        ASSERT_PRED2(are_equal_with_hilites, left.str(), right.str());
+        String left;
+        left += DB::IAST::hilite_keyword;
+        left += "keyword long";
+        left += DB::IAST::hilite_none;
+
+        String right;
+        right += DB::IAST::hilite_keyword;
+        right += "keyword";
+        right += DB::IAST::hilite_none;
+        right += " ";
+        right += DB::IAST::hilite_keyword;
+        right += "long";
+        ASSERT_PRED2(are_equal_with_hilites, left, right);
     }
 }
 

From 35937adcaabb9d9076d92d91fe9ee866894b7af9 Mon Sep 17 00:00:00 2001
From: avogar <avogar@clickhouse.com>
Date: Thu, 30 Mar 2023 19:15:28 +0000
Subject: [PATCH 39/80] Support more types in CapnProto format

---
 docs/en/interfaces/formats.md                 |  45 ++---
 src/Formats/CapnProtoUtils.cpp                | 155 ++++++++++++++----
 .../Formats/Impl/CapnProtoRowInputFormat.cpp  |  81 ++++-----
 .../Formats/Impl/CapnProtoRowOutputFormat.cpp |  44 ++++-
 .../02705_capnp_more_types.reference          |   3 +
 .../0_stateless/02705_capnp_more_types.sh     |  17 ++
 .../format_schemas/02705_big_numbers.capnp    |  10 ++
 .../format_schemas/02705_map.capnp            |  14 ++
 8 files changed, 273 insertions(+), 96 deletions(-)
 create mode 100644 tests/queries/0_stateless/02705_capnp_more_types.reference
 create mode 100755 tests/queries/0_stateless/02705_capnp_more_types.sh
 create mode 100644 tests/queries/0_stateless/format_schemas/02705_big_numbers.capnp
 create mode 100644 tests/queries/0_stateless/format_schemas/02705_map.capnp

diff --git a/docs/en/interfaces/formats.md b/docs/en/interfaces/formats.md
index d996ccb7b89..9cd081f0f2e 100644
--- a/docs/en/interfaces/formats.md
+++ b/docs/en/interfaces/formats.md
@@ -1610,29 +1610,34 @@ See also [Format Schema](#formatschema).
 
 The table below shows supported data types and how they match ClickHouse [data types](/docs/en/sql-reference/data-types/index.md) in `INSERT` and `SELECT` queries.
 
-| CapnProto data type (`INSERT`)   | ClickHouse data type                                                                                                   | CapnProto data type (`SELECT`) |
-|----------------------------------|------------------------------------------------------------------------------------------------------------------------|------------------------------|
-| `UINT8`, `BOOL`                  | [UInt8](/docs/en/sql-reference/data-types/int-uint.md)                                                                 | `UINT8`                      |
-| `INT8`                           | [Int8](/docs/en/sql-reference/data-types/int-uint.md)                                                                  | `INT8`                       |
-| `UINT16`                         | [UInt16](/docs/en/sql-reference/data-types/int-uint.md), [Date](/docs/en/sql-reference/data-types/date.md)             | `UINT16`                     |
-| `INT16`                          | [Int16](/docs/en/sql-reference/data-types/int-uint.md)                                                                 | `INT16`                      |
-| `UINT32`                         | [UInt32](/docs/en/sql-reference/data-types/int-uint.md), [DateTime](/docs/en/sql-reference/data-types/datetime.md)     | `UINT32`                     |
-| `INT32`                          | [Int32](/docs/en/sql-reference/data-types/int-uint.md)                                                                 | `INT32`                      |
-| `UINT64`                         | [UInt64](/docs/en/sql-reference/data-types/int-uint.md)                                                                | `UINT64`                     |
-| `INT64`                          | [Int64](/docs/en/sql-reference/data-types/int-uint.md), [DateTime64](/docs/en/sql-reference/data-types/datetime.md)    | `INT64`                      |
-| `FLOAT32`                        | [Float32](/docs/en/sql-reference/data-types/float.md)                                                                  | `FLOAT32`                    |
-| `FLOAT64`                        | [Float64](/docs/en/sql-reference/data-types/float.md)                                                                  | `FLOAT64`                    |
-| `TEXT, DATA`                     | [String](/docs/en/sql-reference/data-types/string.md), [FixedString](/docs/en/sql-reference/data-types/fixedstring.md) | `TEXT, DATA`                 |
-| `union(T, Void), union(Void, T)` | [Nullable(T)](/docs/en/sql-reference/data-types/date.md)                                                               | `union(T, Void), union(Void, T)`                 |
-| `ENUM`                           | [Enum(8\                                                                                                               |16)](/docs/en/sql-reference/data-types/enum.md)  | `ENUM`                         |
-| `LIST`                           | [Array](/docs/en/sql-reference/data-types/array.md)                                                                    | `LIST`                       |
-| `STRUCT`                         | [Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                                    | `STRUCT`                     |
-| `UINT32`                         | [IPv4](/docs/en/sql-reference/data-types/domains/ipv4.md)                                                              | `UINT32`                     |
-| `DATA`                           | [IPv6](/docs/en/sql-reference/data-types/domains/ipv6.md)                                                              | `DATA`                       |
+| CapnProto data type (`INSERT`)                       | ClickHouse data type                                                                                                                                                           | CapnProto data type (`SELECT`)                       |
+|------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------|
+| `UINT8`, `BOOL`                                      | [UInt8](/docs/en/sql-reference/data-types/int-uint.md)                                                                                                                         | `UINT8`                                              |
+| `INT8`                                               | [Int8](/docs/en/sql-reference/data-types/int-uint.md)                                                                                                                          | `INT8`                                               |
+| `UINT16`                                             | [UInt16](/docs/en/sql-reference/data-types/int-uint.md), [Date](/docs/en/sql-reference/data-types/date.md)                                                                     | `UINT16`                                             |
+| `INT16`                                              | [Int16](/docs/en/sql-reference/data-types/int-uint.md)                                                                                                                         | `INT16`                                              |
+| `UINT32`                                             | [UInt32](/docs/en/sql-reference/data-types/int-uint.md), [DateTime](/docs/en/sql-reference/data-types/datetime.md)                                                             | `UINT32`                                             |
+| `INT32`                                              | [Int32](/docs/en/sql-reference/data-types/int-uint.md), [Decimal32](/docs/en/sql-reference/data-types/decimal.md)                                                              | `INT32`                                              |
+| `UINT64`                                             | [UInt64](/docs/en/sql-reference/data-types/int-uint.md)                                                                                                                        | `UINT64`                                             |
+| `INT64`                                              | [Int64](/docs/en/sql-reference/data-types/int-uint.md), [DateTime64](/docs/en/sql-reference/data-types/datetime.md), [Decimal64](/docs/en/sql-reference/data-types/decimal.md) | `INT64`                                              |
+| `FLOAT32`                                            | [Float32](/docs/en/sql-reference/data-types/float.md)                                                                                                                          | `FLOAT32`                                            |
+| `FLOAT64`                                            | [Float64](/docs/en/sql-reference/data-types/float.md)                                                                                                                          | `FLOAT64`                                            |
+| `TEXT, DATA`                                         | [String](/docs/en/sql-reference/data-types/string.md), [FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                         | `TEXT, DATA`                                         |
+| `union(T, Void), union(Void, T)`                     | [Nullable(T)](/docs/en/sql-reference/data-types/date.md)                                                                                                                       | `union(T, Void), union(Void, T)`                     |
+| `ENUM`                                               | [Enum(8/16)](/docs/en/sql-reference/data-types/enum.md)                                                                                                                        | `ENUM`                                               |
+| `LIST`                                               | [Array](/docs/en/sql-reference/data-types/array.md)                                                                                                                            | `LIST`                                               |
+| `STRUCT`                                             | [Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                                                                                            | `STRUCT`                                             |
+| `UINT32`                                             | [IPv4](/docs/en/sql-reference/data-types/domains/ipv4.md)                                                                                                                      | `UINT32`                                             |
+| `DATA`                                               | [IPv6](/docs/en/sql-reference/data-types/domains/ipv6.md)                                                                                                                      | `DATA`                                               |
+| `DATA`                                               | [Int128/UInt128/Int256/UInt256](/docs/en/sql-reference/data-types/int-uint.md)                                                                                                 | `DATA`                                               |
+| `DATA`                                               | [Decimal128/Decimal256](/docs/en/sql-reference/data-types/decimal.md)                                                                                                          | `DATA`                                               |
+| `STRUCT(entries LIST(STRUCT(key Key, value Value)))` | [Map](/docs/en/sql-reference/data-types/map.md)                                                                                                                                | `STRUCT(entries LIST(STRUCT(key Key, value Value)))` |
+
+Integer types can be converted into each other during input/output.
 
 For working with `Enum` in CapnProto format use the [format_capn_proto_enum_comparising_mode](/docs/en/operations/settings/settings-formats.md/#format_capn_proto_enum_comparising_mode) setting.
 
-Arrays can be nested and can have a value of the `Nullable` type as an argument. `Tuple` type also can be nested.
+Arrays can be nested and can have a value of the `Nullable` type as an argument. `Tuple` and `Map` types also can be nested.
 
 ### Inserting and Selecting Data {#inserting-and-selecting-data-capnproto}
 
diff --git a/src/Formats/CapnProtoUtils.cpp b/src/Formats/CapnProtoUtils.cpp
index a557b762672..78bc90e001e 100644
--- a/src/Formats/CapnProtoUtils.cpp
+++ b/src/Formats/CapnProtoUtils.cpp
@@ -9,6 +9,7 @@
 #include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeString.h>
+#include <DataTypes/DataTypeMap.h>
 #include <DataTypes/IDataType.h>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/join.hpp>
@@ -264,23 +265,25 @@ static bool checkTupleType(const capnp::Type & capnp_type, const DataTypePtr & d
         return false;
     }
 
-    if (!tuple_data_type->haveExplicitNames())
+    bool have_explicit_names = false;
+    const auto & nested_names = tuple_data_type->getElementNames();
+    for (uint32_t i = 0; i != nested_names.size(); ++i)
     {
-        error_message += "Only named Tuple can be converted to CapnProto Struct";
-        return false;
-    }
-    for (const auto & name : tuple_data_type->getElementNames())
-    {
-        KJ_IF_MAYBE(field, struct_schema.findFieldByName(name))
+        if (have_explicit_names)
         {
-            if (!checkCapnProtoType(field->getType(), nested_types[tuple_data_type->getPositionByName(name)], mode, error_message, name))
+            KJ_IF_MAYBE (field, struct_schema.findFieldByName(nested_names[i]))
+            {
+                if (!checkCapnProtoType(field->getType(), nested_types[tuple_data_type->getPositionByName(nested_names[i])], mode, error_message, nested_names[i]))
+                    return false;
+            }
+            else
+            {
+                error_message += "CapnProto struct doesn't contain a field with name " + nested_names[i];
                 return false;
+            }
         }
-        else
-        {
-            error_message += "CapnProto struct doesn't contain a field with name " + name;
+        else if (!checkCapnProtoType(struct_schema.getFields()[i].getType(), nested_types[tuple_data_type->getPositionByName(nested_names[i])], mode, error_message, nested_names[i]))
             return false;
-        }
     }
 
     return true;
@@ -307,41 +310,129 @@ static bool checkArrayType(const capnp::Type & capnp_type, const DataTypePtr & d
     return checkCapnProtoType(list_schema.getElementType(), nested_type, mode, error_message, column_name);
 }
 
+static bool checkMapType(const capnp::Type & capnp_type, const DataTypePtr & data_type, FormatSettings::EnumComparingMode mode, String & error_message)
+{
+    /// We output/input Map type as follow CapnProto schema
+    ///
+    /// struct Map {
+    ///     struct Entry {
+    ///         key @0: Key;
+    ///         value @1: Value;
+    ///     }
+    ///     entries @0 :List(Entry);
+    /// }
+
+    if (!capnp_type.isStruct())
+        return false;
+    auto struct_schema = capnp_type.asStruct();
+
+    if (checkIfStructContainsUnnamedUnion(struct_schema))
+    {
+        error_message += "CapnProto struct contains unnamed union";
+        return false;
+    }
+
+    if (struct_schema.getFields().size() != 1)
+    {
+        error_message += "CapnProto struct that represents Map type can contain only one field";
+        return false;
+    }
+
+    const auto & field_type = struct_schema.getFields()[0].getType();
+    if (!field_type.isList())
+    {
+        error_message += "Field of CapnProto struct that represents Map is not a list";
+        return false;
+    }
+
+    auto list_element_type = field_type.asList().getElementType();
+    if (!list_element_type.isStruct())
+    {
+        error_message += "Field of CapnProto struct that represents Map is not a list of structs";
+        return false;
+    }
+
+    auto key_value_struct = list_element_type.asStruct();
+    if (checkIfStructContainsUnnamedUnion(key_value_struct))
+    {
+        error_message += "CapnProto struct contains unnamed union";
+        return false;
+    }
+
+    if (key_value_struct.getFields().size() != 2)
+    {
+        error_message += "Key-value structure for Map struct should have exactly 2 fields";
+        return false;
+    }
+
+    const auto & map_type = assert_cast<const DataTypeMap &>(*data_type);
+    DataTypes types = {map_type.getKeyType(), map_type.getValueType()};
+    Names names = {"key", "value"};
+
+    for (size_t i = 0; i != types.size(); ++i)
+    {
+        KJ_IF_MAYBE(field, key_value_struct.findFieldByName(names[i]))
+        {
+            if (!checkCapnProtoType(field->getType(), types[i], mode, error_message, names[i]))
+                return false;
+        }
+        else
+        {
+            error_message += R"(Key-value structure for Map struct should have exactly 2 fields with names "key" and "value")";
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool isCapnInteger(const capnp::Type & capnp_type)
+{
+    return capnp_type.isInt8() || capnp_type.isUInt8() || capnp_type.isInt16() || capnp_type.isUInt16() || capnp_type.isInt32()
+        || capnp_type.isUInt32() || capnp_type.isInt64() || capnp_type.isUInt64();
+}
+
 static bool checkCapnProtoType(const capnp::Type & capnp_type, const DataTypePtr & data_type, FormatSettings::EnumComparingMode mode, String & error_message, const String & column_name)
 {
     switch (data_type->getTypeId())
     {
         case TypeIndex::UInt8:
-            return capnp_type.isBool() || capnp_type.isUInt8();
-        case TypeIndex::Date: [[fallthrough]];
-        case TypeIndex::UInt16:
+            return capnp_type.isBool() || isCapnInteger(capnp_type);
+        case TypeIndex::Int8: [[fallthrough]];
+        case TypeIndex::Int16: [[fallthrough]];
+        case TypeIndex::UInt16: [[fallthrough]];
+        case TypeIndex::Int32: [[fallthrough]];
+        case TypeIndex::UInt32: [[fallthrough]];
+        case TypeIndex::Int64: [[fallthrough]];
+        case TypeIndex::UInt64:
+            /// Allow integer conversions durin input/output.
+            return isCapnInteger(capnp_type);
+        case TypeIndex::Date:
             return capnp_type.isUInt16();
         case TypeIndex::DateTime: [[fallthrough]];
-        case TypeIndex::IPv4: [[fallthrough]];
-        case TypeIndex::UInt32:
+        case TypeIndex::IPv4:
             return capnp_type.isUInt32();
-        case TypeIndex::UInt64:
-            return capnp_type.isUInt64();
-        case TypeIndex::Int8:
-            return capnp_type.isInt8();
-        case TypeIndex::Int16:
-            return capnp_type.isInt16();
         case TypeIndex::Date32: [[fallthrough]];
-        case TypeIndex::Decimal32: [[fallthrough]];
-        case TypeIndex::Int32:
+        case TypeIndex::Decimal32:
             return capnp_type.isInt32();
         case TypeIndex::DateTime64: [[fallthrough]];
-        case TypeIndex::Decimal64: [[fallthrough]];
-        case TypeIndex::Int64:
-            return capnp_type.isInt64();
-        case TypeIndex::Float32:
-            return capnp_type.isFloat32();
+        case TypeIndex::Decimal64:
+            return capnp_type.isUInt64();
+        case TypeIndex::Float32:[[fallthrough]];
         case TypeIndex::Float64:
-            return capnp_type.isFloat64();
+            /// Allow converting between Float32 and isFloat64
+            return capnp_type.isFloat32() || capnp_type.isFloat64();
         case TypeIndex::Enum8:
             return checkEnums<Int8>(capnp_type, data_type, mode, INT8_MAX, error_message);
         case TypeIndex::Enum16:
             return checkEnums<Int16>(capnp_type, data_type, mode, INT16_MAX, error_message);
+        case TypeIndex::Int128: [[fallthrough]];
+        case TypeIndex::UInt128: [[fallthrough]];
+        case TypeIndex::Int256: [[fallthrough]];
+        case TypeIndex::UInt256: [[fallthrough]];
+        case TypeIndex::Decimal128: [[fallthrough]];
+        case TypeIndex::Decimal256:
+            return capnp_type.isData();
         case TypeIndex::Tuple:
             return checkTupleType(capnp_type, data_type, mode, error_message);
         case TypeIndex::Nullable:
@@ -359,6 +450,8 @@ static bool checkCapnProtoType(const capnp::Type & capnp_type, const DataTypePtr
         case TypeIndex::IPv6: [[fallthrough]];
         case TypeIndex::String:
             return capnp_type.isText() || capnp_type.isData();
+        case TypeIndex::Map:
+            return checkMapType(capnp_type, data_type, mode, error_message);
         default:
             return false;
     }
diff --git a/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp b/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
index 9f37bcc3219..84ea27618d0 100644
--- a/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
+++ b/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
@@ -16,6 +16,7 @@
 #include <Columns/ColumnLowCardinality.h>
 #include <Columns/ColumnNullable.h>
 #include <Columns/ColumnDecimal.h>
+#include <Columns/ColumnMap.h>
 
 #include <DataTypes/DataTypeEnum.h>
 #include <DataTypes/DataTypeArray.h>
@@ -23,6 +24,7 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypeLowCardinality.h>
+#include <DataTypes/DataTypeMap.h>
 
 namespace DB
 {
@@ -80,22 +82,36 @@ kj::Array<capnp::word> CapnProtoRowInputFormat::readMessage()
     return msg;
 }
 
-static void insertSignedInteger(IColumn & column, const DataTypePtr & column_type, Int64 value)
+static void insertInteger(IColumn & column, const DataTypePtr & column_type, UInt64 value)
 {
     switch (column_type->getTypeId())
     {
         case TypeIndex::Int8:
             assert_cast<ColumnInt8 &>(column).insertValue(value);
             break;
+        case TypeIndex::UInt8:
+            assert_cast<ColumnUInt8 &>(column).insertValue(value);
+            break;
         case TypeIndex::Int16:
             assert_cast<ColumnInt16 &>(column).insertValue(value);
             break;
+        case TypeIndex::Date: [[fallthrough]];
+        case TypeIndex::UInt16:
+            assert_cast<ColumnUInt16 &>(column).insertValue(value);
+            break;
         case TypeIndex::Int32:
             assert_cast<ColumnInt32 &>(column).insertValue(static_cast<Int32>(value));
             break;
+        case TypeIndex::DateTime: [[fallthrough]];
+        case TypeIndex::UInt32:
+            assert_cast<ColumnUInt32 &>(column).insertValue(static_cast<UInt32>(value));
+            break;
         case TypeIndex::Int64:
             assert_cast<ColumnInt64 &>(column).insertValue(value);
             break;
+        case TypeIndex::UInt64:
+            assert_cast<ColumnUInt64 &>(column).insertValue(value);
+            break;
         case TypeIndex::DateTime64:
             assert_cast<ColumnDecimal<DateTime64> &>(column).insertValue(value);
             break;
@@ -110,32 +126,6 @@ static void insertSignedInteger(IColumn & column, const DataTypePtr & column_typ
     }
 }
 
-static void insertUnsignedInteger(IColumn & column, const DataTypePtr & column_type, UInt64 value)
-{
-    switch (column_type->getTypeId())
-    {
-        case TypeIndex::UInt8:
-            assert_cast<ColumnUInt8 &>(column).insertValue(value);
-            break;
-        case TypeIndex::Date: [[fallthrough]];
-        case TypeIndex::UInt16:
-            assert_cast<ColumnUInt16 &>(column).insertValue(value);
-            break;
-        case TypeIndex::DateTime: [[fallthrough]];
-        case TypeIndex::UInt32:
-            assert_cast<ColumnUInt32 &>(column).insertValue(static_cast<UInt32>(value));
-            break;
-        case TypeIndex::UInt64:
-            assert_cast<ColumnUInt64 &>(column).insertValue(value);
-            break;
-        case TypeIndex::IPv4:
-            assert_cast<ColumnIPv4 &>(column).insertValue(IPv4(static_cast<UInt32>(value)));
-            break;
-        default:
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Column type is not an unsigned integer.");
-    }
-}
-
 static void insertFloat(IColumn & column, const DataTypePtr & column_type, Float64 value)
 {
     switch (column_type->getTypeId())
@@ -152,8 +142,11 @@ static void insertFloat(IColumn & column, const DataTypePtr & column_type, Float
 }
 
 template <typename Value>
-static void insertString(IColumn & column, Value value)
+static void insertData(IColumn & column, const DataTypePtr & column_type, Value value)
 {
+    if (column_type->haveMaximumSizeOfValue() && value.size() != column_type->getSizeOfValueInMemory())
+        throw Exception(ErrorCodes::INCORRECT_DATA, "Unexpected size of {} value: {}", column_type->getName(), value.size());
+
     column.insertData(reinterpret_cast<const char *>(value.begin()), value.size());
 }
 
@@ -166,10 +159,10 @@ static void insertEnum(IColumn & column, const DataTypePtr & column_type, const
     switch (enum_comparing_mode)
     {
         case FormatSettings::EnumComparingMode::BY_VALUES:
-            insertSignedInteger(column, nested_type, Int64(enumerant.getOrdinal()));
+            insertInteger(column, nested_type, Int64(enumerant.getOrdinal()));
             return;
         case FormatSettings::EnumComparingMode::BY_NAMES:
-            insertSignedInteger(column, nested_type, Int64(enum_type->getValue(String(enumerant.getProto().getName()))));
+            insertInteger(column, nested_type, Int64(enum_type->getValue(String(enumerant.getProto().getName()))));
             return;
         case FormatSettings::EnumComparingMode::BY_NAMES_CASE_INSENSITIVE:
         {
@@ -179,7 +172,7 @@ static void insertEnum(IColumn & column, const DataTypePtr & column_type, const
             {
                 if (compareEnumNames(name, enum_name, enum_comparing_mode))
                 {
-                    insertSignedInteger(column, nested_type, Int64(enum_type->getValue(name)));
+                    insertInteger(column, nested_type, Int64(enum_type->getValue(name)));
                     break;
                 }
             }
@@ -202,22 +195,22 @@ static void insertValue(IColumn & column, const DataTypePtr & column_type, const
     switch (value.getType())
     {
         case capnp::DynamicValue::Type::INT:
-            insertSignedInteger(column, column_type, value.as<Int64>());
+            insertInteger(column, column_type, value.as<Int64>());
             break;
         case capnp::DynamicValue::Type::UINT:
-            insertUnsignedInteger(column, column_type, value.as<UInt64>());
+            insertInteger(column, column_type, value.as<UInt64>());
             break;
         case capnp::DynamicValue::Type::FLOAT:
             insertFloat(column, column_type, value.as<Float64>());
             break;
         case capnp::DynamicValue::Type::BOOL:
-            insertUnsignedInteger(column, column_type, UInt64(value.as<bool>()));
+            insertInteger(column, column_type, UInt64(value.as<bool>()));
             break;
         case capnp::DynamicValue::Type::DATA:
-            insertString(column, value.as<capnp::Data>());
+            insertData(column, column_type, value.as<capnp::Data>());
             break;
         case capnp::DynamicValue::Type::TEXT:
-            insertString(column, value.as<capnp::Text>());
+            insertData(column, column_type, value.as<capnp::Text>());
             break;
         case capnp::DynamicValue::Type::ENUM:
             if (column_type->getTypeId() == TypeIndex::Enum8)
@@ -260,14 +253,26 @@ static void insertValue(IColumn & column, const DataTypePtr & column_type, const
             {
                 auto & tuple_column = assert_cast<ColumnTuple &>(column);
                 const auto * tuple_type = assert_cast<const DataTypeTuple *>(column_type.get());
-                for (size_t i = 0; i != tuple_column.tupleSize(); ++i)
+                bool have_explicit_names = tuple_type->haveExplicitNames();
+                auto struct_schema = struct_value.getSchema();
+                for (uint32_t i = 0; i != tuple_column.tupleSize(); ++i)
                     insertValue(
                         tuple_column.getColumn(i),
                         tuple_type->getElements()[i],
                         tuple_type->getElementNames()[i],
-                        struct_value.get(tuple_type->getElementNames()[i]),
+                        struct_value.get(have_explicit_names ? struct_schema.getFieldByName(tuple_type->getElementNames()[i]) : struct_schema.getFields()[i]),
                         enum_comparing_mode);
             }
+            else if (isMap(column_type))
+            {
+                const auto & map_type = assert_cast<const DataTypeMap &>(*column_type);
+                DataTypes key_value_types = {map_type.getKeyType(), map_type.getValueType()};
+                Names key_value_names = {"key", "value"};
+                auto entries_type = std::make_shared<DataTypeArray>(std::make_shared<DataTypeTuple>(key_value_types, key_value_names));
+                auto & entries_column = assert_cast<ColumnMap &>(column).getNestedColumn();
+                auto entries_field = struct_value.getSchema().getFields()[0];
+                insertValue(entries_column, entries_type, column_name, struct_value.get(entries_field), enum_comparing_mode);
+            }
             else
             {
                 /// It can be nested column from Nested type.
diff --git a/src/Processors/Formats/Impl/CapnProtoRowOutputFormat.cpp b/src/Processors/Formats/Impl/CapnProtoRowOutputFormat.cpp
index c0f61bbd586..0225680b396 100644
--- a/src/Processors/Formats/Impl/CapnProtoRowOutputFormat.cpp
+++ b/src/Processors/Formats/Impl/CapnProtoRowOutputFormat.cpp
@@ -14,12 +14,14 @@
 #include <Columns/ColumnTuple.h>
 #include <Columns/ColumnLowCardinality.h>
 #include <Columns/ColumnDecimal.h>
+#include <Columns/ColumnMap.h>
 
 #include <DataTypes/DataTypeArray.h>
 #include <DataTypes/DataTypeEnum.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypeLowCardinality.h>
+#include <DataTypes/DataTypeMap.h>
 
 namespace DB
 {
@@ -177,18 +179,46 @@ static std::optional<capnp::DynamicValue::Reader> convertToDynamicValue(
             else if (isTuple(data_type))
             {
                 const auto * tuple_data_type = assert_cast<const DataTypeTuple *>(data_type.get());
-                auto nested_types = tuple_data_type->getElements();
+                const auto & nested_types = tuple_data_type->getElements();
+                const auto & nested_names = tuple_data_type->getElementNames();
                 const auto & nested_columns = assert_cast<const ColumnTuple *>(column.get())->getColumns();
-                for (const auto & name : tuple_data_type->getElementNames())
+                bool have_explicit_names = tuple_data_type->haveExplicitNames();
+                for (uint32_t i = 0; i != nested_names.size(); ++i)
                 {
-                    auto pos = tuple_data_type->getPositionByName(name);
-                    auto field_builder
-                        = initStructFieldBuilder(nested_columns[pos], row_num, struct_builder, nested_struct_schema.getFieldByName(name));
-                    auto value = convertToDynamicValue(nested_columns[pos], nested_types[pos], row_num, column_name, field_builder, enum_comparing_mode, temporary_text_data_storage);
+                    capnp::StructSchema::Field nested_field = have_explicit_names ? nested_struct_schema.getFieldByName(nested_names[i]) : nested_struct_schema.getFields()[i];
+                    auto field_builder = initStructFieldBuilder(nested_columns[i], row_num, struct_builder, nested_field);
+                    auto value = convertToDynamicValue(nested_columns[i], nested_types[i], row_num, nested_names[i], field_builder, enum_comparing_mode, temporary_text_data_storage);
                     if (value)
-                        struct_builder.set(name, *value);
+                        struct_builder.set(nested_field, *value);
                 }
             }
+            else if (isMap(data_type))
+            {
+                /// We output Map type as follow CapnProto schema
+                ///
+                /// struct Map {
+                ///     struct Entry {
+                ///         key @0: Key;
+                ///         value @1: Value;
+                ///     }
+                ///     entries @0 :List(Entry);
+                /// }
+                ///
+                /// And we don't need to check that struct have this form here because we checked it before.
+                const auto & map_type = assert_cast<const DataTypeMap &>(*data_type);
+                DataTypes key_value_types = {map_type.getKeyType(), map_type.getValueType()};
+                Names key_value_names = {"key", "value"};
+                auto entries_type = std::make_shared<DataTypeArray>(std::make_shared<DataTypeTuple>(key_value_types, key_value_names));
+
+                /// Nested column in Map is actually Array(Tuple), so we can output it according to "entries" field schema.
+                const auto & entries_column = assert_cast<const ColumnMap *>(column.get())->getNestedColumnPtr();
+
+                auto entries_field = nested_struct_schema.getFields()[0];
+                auto field_builder = initStructFieldBuilder(entries_column, row_num, struct_builder, entries_field);
+                auto entries_value = convertToDynamicValue(entries_column, entries_type, row_num, column_name, field_builder, enum_comparing_mode, temporary_text_data_storage);
+                if (entries_value)
+                    struct_builder.set(entries_field, *entries_value);
+            }
             else
             {
                 /// It can be nested column from Nested type.
diff --git a/tests/queries/0_stateless/02705_capnp_more_types.reference b/tests/queries/0_stateless/02705_capnp_more_types.reference
new file mode 100644
index 00000000000..9cacd1fe527
--- /dev/null
+++ b/tests/queries/0_stateless/02705_capnp_more_types.reference
@@ -0,0 +1,3 @@
+42	42	42	42	42.42	42.42
+{'Hello':42,'World':24}
+42	42	42	42	42	42	42	42
diff --git a/tests/queries/0_stateless/02705_capnp_more_types.sh b/tests/queries/0_stateless/02705_capnp_more_types.sh
new file mode 100755
index 00000000000..1f6b1f7c86b
--- /dev/null
+++ b/tests/queries/0_stateless/02705_capnp_more_types.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# Tags: no-fasttest, no-parallel, no-replicated-database
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+SCHEMADIR=$CURDIR/format_schemas
+$CLICKHOUSE_LOCAL -q "select 42::Int128 as int128, 42::UInt128 as uint128, 42::Int256 as int256, 42::UInt256 as uint256, 42.42::Decimal128(2) as decimal128, 42.42::Decimal256(2) as decimal256 format CapnProto settings format_schema='$SCHEMADIR/02705_big_numbers:Message'" | $CLICKHOUSE_LOCAL --input-format CapnProto --structure "int128 Int128, uint128 UInt128, int256 Int256, uint256 UInt256, decimal128 Decimal128(2), decimal256 Decimal256(2)" -q "select * from table" --format_schema="$SCHEMADIR/02705_big_numbers:Message"
+
+$CLICKHOUSE_LOCAL -q "select map('Hello', 42, 'World', 24) as map format CapnProto settings format_schema='$SCHEMADIR/02705_map:Message'" | $CLICKHOUSE_LOCAL  --input-format CapnProto --structure "map Map(String, UInt32)" --format_schema="$SCHEMADIR/02705_map:Message"  -q "select * from table"
+
+
+$CLICKHOUSE_LOCAL -q "select 42 as int8, 42 as uint8, 42 as int16, 42 as uint16, 42 as int32, 42 as uint32, 42 as int64, 42 as uint64 format CapnProto settings format_schema='$SCHEMADIR/02030_capnp_simple_types:Message'" | $CLICKHOUSE_LOCAL  --input-format CapnProto --structure "int8 UInt32, uint8 Int32, int16 Int8, uint16 UInt8, int32 UInt64, uint32 Int64, int64 UInt16, uint64 Int16" --format_schema="$SCHEMADIR/02030_capnp_simple_types:Message"  -q "select * from table"
+
+
+
diff --git a/tests/queries/0_stateless/format_schemas/02705_big_numbers.capnp b/tests/queries/0_stateless/format_schemas/02705_big_numbers.capnp
new file mode 100644
index 00000000000..67ef4637454
--- /dev/null
+++ b/tests/queries/0_stateless/format_schemas/02705_big_numbers.capnp
@@ -0,0 +1,10 @@
+@0xdbb9ad1f14bf0b36;
+
+struct Message {
+    int128 @0 :Data;
+    uint128 @1 :Data;
+    int256 @2 :Data;
+    uint256 @3 :Data;
+    decimal128 @4 :Data;
+    decimal256 @5 :Data;
+}
diff --git a/tests/queries/0_stateless/format_schemas/02705_map.capnp b/tests/queries/0_stateless/format_schemas/02705_map.capnp
new file mode 100644
index 00000000000..91f0125feeb
--- /dev/null
+++ b/tests/queries/0_stateless/format_schemas/02705_map.capnp
@@ -0,0 +1,14 @@
+@0xdbb9ad1f14bf0b36;
+
+struct Message {
+    struct Map {
+        struct Entry {
+            key @0 : Text;
+            value @1 : UInt32;
+        }
+
+        entries @0 : List(Entry);
+    }
+
+    map @0 : Map;
+}

From c23eec876ce05d7b1f2277ac41305a005b5915c9 Mon Sep 17 00:00:00 2001
From: avogar <avogar@clickhouse.com>
Date: Fri, 31 Mar 2023 14:38:16 +0000
Subject: [PATCH 40/80] Try to update arrow library with 11.0.0 release

---
 contrib/arrow                      |  2 +-
 contrib/arrow-cmake/CMakeLists.txt | 25 +++++++++++++++++++++----
 2 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/contrib/arrow b/contrib/arrow
index d03245f801f..1f1b3d35fb6 160000
--- a/contrib/arrow
+++ b/contrib/arrow
@@ -1 +1 @@
-Subproject commit d03245f801f798c63ee9a7d2b8914a9e5c5cd666
+Subproject commit 1f1b3d35fb6eb73e6492d3afd8a85cde848d174f
diff --git a/contrib/arrow-cmake/CMakeLists.txt b/contrib/arrow-cmake/CMakeLists.txt
index 4181f916d63..16198887075 100644
--- a/contrib/arrow-cmake/CMakeLists.txt
+++ b/contrib/arrow-cmake/CMakeLists.txt
@@ -202,6 +202,7 @@ set(ARROW_SRCS
         "${LIBRARY_DIR}/builder.cc"
         "${LIBRARY_DIR}/buffer.cc"
         "${LIBRARY_DIR}/chunked_array.cc"
+        "${LIBRARY_DIR}/chunk_resolver.cc"
         "${LIBRARY_DIR}/compare.cc"
         "${LIBRARY_DIR}/config.cc"
         "${LIBRARY_DIR}/datum.cc"
@@ -268,6 +269,10 @@ set(ARROW_SRCS
         "${LIBRARY_DIR}/util/uri.cc"
         "${LIBRARY_DIR}/util/utf8.cc"
         "${LIBRARY_DIR}/util/value_parsing.cc"
+        "${LIBRARY_DIR}/util/byte_size.cc"
+        "${LIBRARY_DIR}/util/debug.cc"
+        "${LIBRARY_DIR}/util/tracing.cc"
+        "${LIBRARY_DIR}/util/atfork_internal.cc"
         "${LIBRARY_DIR}/vendored/base64.cpp"
         "${LIBRARY_DIR}/vendored/datetime/tz.cpp"
 
@@ -301,9 +306,11 @@ set(ARROW_SRCS
         "${LIBRARY_DIR}/compute/exec/source_node.cc"
         "${LIBRARY_DIR}/compute/exec/sink_node.cc"
         "${LIBRARY_DIR}/compute/exec/order_by_impl.cc"
+        "${LIBRARY_DIR}/compute/exec/partition_util.cc"
         "${LIBRARY_DIR}/compute/function.cc"
         "${LIBRARY_DIR}/compute/function_internal.cc"
         "${LIBRARY_DIR}/compute/kernel.cc"
+        "${LIBRARY_DIR}/compute/light_array.cc"
         "${LIBRARY_DIR}/compute/registry.cc"
         "${LIBRARY_DIR}/compute/kernels/aggregate_basic.cc"
         "${LIBRARY_DIR}/compute/kernels/aggregate_mode.cc"
@@ -317,21 +324,28 @@ set(ARROW_SRCS
         "${LIBRARY_DIR}/compute/kernels/scalar_cast_boolean.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_cast_dictionary.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_cast_internal.cc"
+        "${LIBRARY_DIR}/compute/kernels/scalar_cast_extension.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_cast_nested.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_cast_numeric.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_cast_string.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_cast_temporal.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_compare.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_nested.cc"
+        "${LIBRARY_DIR}/compute/kernels/scalar_random.cc"
+        "${LIBRARY_DIR}/compute/kernels/scalar_round.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_set_lookup.cc"
-        "${LIBRARY_DIR}/compute/kernels/scalar_string.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_temporal_binary.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_temporal_unary.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_validity.cc"
         "${LIBRARY_DIR}/compute/kernels/scalar_if_else.cc"
+        "${LIBRARY_DIR}/compute/kernels/scalar_string_ascii.cc"
+        "${LIBRARY_DIR}/compute/kernels/scalar_string_utf8.cc"
         "${LIBRARY_DIR}/compute/kernels/util_internal.cc"
         "${LIBRARY_DIR}/compute/kernels/vector_array_sort.cc"
+        "${LIBRARY_DIR}/compute/kernels/vector_cumulative_ops.cc"
         "${LIBRARY_DIR}/compute/kernels/vector_hash.cc"
+        "${LIBRARY_DIR}/compute/kernels/vector_rank.cc"
+        "${LIBRARY_DIR}/compute/kernels/vector_select_k.cc"
         "${LIBRARY_DIR}/compute/kernels/vector_nested.cc"
         "${LIBRARY_DIR}/compute/kernels/vector_replace.cc"
         "${LIBRARY_DIR}/compute/kernels/vector_selection.cc"
@@ -340,13 +354,15 @@ set(ARROW_SRCS
         "${LIBRARY_DIR}/compute/exec/union_node.cc"
         "${LIBRARY_DIR}/compute/exec/key_hash.cc"
         "${LIBRARY_DIR}/compute/exec/key_map.cc"
-        "${LIBRARY_DIR}/compute/exec/key_compare.cc"
-        "${LIBRARY_DIR}/compute/exec/key_encode.cc"
         "${LIBRARY_DIR}/compute/exec/util.cc"
         "${LIBRARY_DIR}/compute/exec/hash_join_dict.cc"
         "${LIBRARY_DIR}/compute/exec/hash_join.cc"
         "${LIBRARY_DIR}/compute/exec/hash_join_node.cc"
         "${LIBRARY_DIR}/compute/exec/task_util.cc"
+        "${LIBRARY_DIR}/compute/row/encode_internal.cc"
+        "${LIBRARY_DIR}/compute/row/grouper.cc"
+        "${LIBRARY_DIR}/compute/row/compare_internal.cc"
+        "${LIBRARY_DIR}/compute/row/row_internal.cc"
 
         "${LIBRARY_DIR}/ipc/dictionary.cc"
         "${LIBRARY_DIR}/ipc/feather.cc"
@@ -357,7 +373,8 @@ set(ARROW_SRCS
         "${LIBRARY_DIR}/ipc/writer.cc"
 
         "${ARROW_SRC_DIR}/arrow/adapters/orc/adapter.cc"
-        "${ARROW_SRC_DIR}/arrow/adapters/orc/adapter_util.cc"
+        "${ARROW_SRC_DIR}/arrow/adapters/orc/util.cc"
+        "${ARROW_SRC_DIR}/arrow/adapters/orc/options.cc"
         )
 
 add_definitions(-DARROW_WITH_LZ4)

From 70fb4ad0b8bfeeeeca5ce3ed79060b53308eae88 Mon Sep 17 00:00:00 2001
From: avogar <avogar@clickhouse.com>
Date: Fri, 31 Mar 2023 15:56:54 +0000
Subject: [PATCH 41/80] Fix build

---
 .../Formats/Impl/ParquetBlockOutputFormat.cpp          | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp b/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp
index 759f773a574..b4ed337fa73 100644
--- a/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp
+++ b/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp
@@ -95,14 +95,14 @@ void ParquetBlockOutputFormat::consume(Chunk chunk)
         builder.version(getParquetVersion(format_settings));
         builder.compression(getParquetCompression(format_settings.parquet.output_compression_method));
         auto props = builder.build();
-        auto status = parquet::arrow::FileWriter::Open(
+        auto result = parquet::arrow::FileWriter::Open(
             *arrow_table->schema(),
             arrow::default_memory_pool(),
             sink,
-            props, /*parquet::default_writer_properties(),*/
-            &file_writer);
-        if (!status.ok())
-            throw Exception(ErrorCodes::UNKNOWN_EXCEPTION, "Error while opening a table: {}", status.ToString());
+            props);
+        if (!result.ok())
+            throw Exception(ErrorCodes::UNKNOWN_EXCEPTION, "Error while opening a table: {}", result.status().ToString());
+        file_writer = std::move(result.ValueOrDie());
     }
 
     // TODO: calculate row_group_size depending on a number of rows and table size

From 6a66c3bc23d0d08d49e702475ddc06b3405f67a4 Mon Sep 17 00:00:00 2001
From: avogar <avogar@clickhouse.com>
Date: Fri, 31 Mar 2023 18:37:12 +0000
Subject: [PATCH 42/80] Fix tests

---
 .../Formats/Impl/ArrowFieldIndexUtil.h         | 18 +++++-------------
 .../Formats/Impl/ORCBlockInputFormat.cpp       |  2 +-
 .../Formats/Impl/ParquetBlockInputFormat.cpp   |  2 +-
 3 files changed, 7 insertions(+), 15 deletions(-)

diff --git a/src/Processors/Formats/Impl/ArrowFieldIndexUtil.h b/src/Processors/Formats/Impl/ArrowFieldIndexUtil.h
index ba39d94fcf1..5aded52c612 100644
--- a/src/Processors/Formats/Impl/ArrowFieldIndexUtil.h
+++ b/src/Processors/Formats/Impl/ArrowFieldIndexUtil.h
@@ -21,9 +21,7 @@ namespace ErrorCodes
 {
     extern const int LOGICAL_ERROR;
 }
-/// For ORC format, index_nested_type = true, a nested type takes one index count. And the
-/// the start index for ORC format should be 1, since index 0 indicates to select all columns.
-template<bool index_nested_type>
+
 class ArrowFieldIndexUtil
 {
 public:
@@ -46,9 +44,7 @@ public:
         calculateFieldIndices(const arrow::Schema & schema)
     {
         std::unordered_map<std::string, std::pair<int, int>> result;
-        // For format like ORC, index = 0 indicates to select all columns, so we skip 0 and start
-        // from 1.
-        int index_start = index_nested_type;
+        int index_start = 0;
         for (int i = 0; i < schema.num_fields(); ++i)
         {
             const auto & field = schema.field(i);
@@ -94,17 +90,16 @@ public:
     }
 
     /// Count the number of indices for types.
-    /// For orc format, index_nested_type is true, a complex type takes one index.
     size_t countIndicesForType(std::shared_ptr<arrow::DataType> type)
     {
         if (type->id() == arrow::Type::LIST)
         {
-            return countIndicesForType(static_cast<arrow::ListType *>(type.get())->value_type()) + index_nested_type;
+            return countIndicesForType(static_cast<arrow::ListType *>(type.get())->value_type());
         }
 
         if (type->id() == arrow::Type::STRUCT)
         {
-            int indices = index_nested_type;
+            int indices = 0;
             auto * struct_type = static_cast<arrow::StructType *>(type.get());
             for (int i = 0; i != struct_type->num_fields(); ++i)
                 indices += countIndicesForType(struct_type->field(i)->type());
@@ -114,7 +109,7 @@ public:
         if (type->id() == arrow::Type::MAP)
         {
             auto * map_type = static_cast<arrow::MapType *>(type.get());
-            return countIndicesForType(map_type->key_type()) + countIndicesForType(map_type->item_type()) + index_nested_type;
+            return countIndicesForType(map_type->key_type()) + countIndicesForType(map_type->item_type()) ;
         }
 
         return 1;
@@ -144,8 +139,6 @@ private:
         index_info.first = current_start_index;
         if (field_type->id() == arrow::Type::STRUCT)
         {
-            current_start_index += index_nested_type;
-
             auto * struct_type = static_cast<arrow::StructType *>(field_type.get());
             for (int i = 0, n = struct_type->num_fields(); i < n; ++i)
             {
@@ -161,7 +154,6 @@ private:
             const auto * list_type = static_cast<arrow::ListType *>(field_type.get());
             const auto value_field = list_type->value_field();
             auto index_snapshot = current_start_index;
-            current_start_index += index_nested_type;
             calculateFieldIndices(*value_field, field_name, current_start_index, result, name_prefix);
             // The nested struct field has the same name as this list field.
             // rewrite it back to the original value.
diff --git a/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp b/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp
index 03f056e22b3..63d66cd75dd 100644
--- a/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp
@@ -129,7 +129,7 @@ void ORCBlockInputFormat::prepareReader()
         format_settings.null_as_default,
         format_settings.orc.case_insensitive_column_matching);
 
-    ArrowFieldIndexUtil<true> field_util(
+    ArrowFieldIndexUtil field_util(
         format_settings.orc.case_insensitive_column_matching,
         format_settings.orc.allow_missing_columns);
     include_indices = field_util.findRequiredIndices(getPort().getHeader(), *schema);
diff --git a/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp b/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp
index ef7575eca3c..d47e2c2953e 100644
--- a/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp
@@ -132,7 +132,7 @@ void ParquetBlockInputFormat::prepareReader()
         format_settings.null_as_default,
         format_settings.parquet.case_insensitive_column_matching);
 
-    ArrowFieldIndexUtil<false> field_util(
+    ArrowFieldIndexUtil field_util(
         format_settings.parquet.case_insensitive_column_matching,
         format_settings.parquet.allow_missing_columns);
     column_indices = field_util.findRequiredIndices(getPort().getHeader(), *schema);

From 264c129a960aeda2dfd7a112ae4471034f15136d Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Mon, 3 Apr 2023 12:54:34 +0100
Subject: [PATCH 43/80] fix misplaced ( in ASTCreateQuery.cpp

---
 src/Parsers/ASTCreateQuery.cpp              | 4 ++--
 src/Parsers/tests/gtest_format_hiliting.cpp | 5 ++---
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/Parsers/ASTCreateQuery.cpp b/src/Parsers/ASTCreateQuery.cpp
index a2b41247ccc..196681a8801 100644
--- a/src/Parsers/ASTCreateQuery.cpp
+++ b/src/Parsers/ASTCreateQuery.cpp
@@ -440,8 +440,8 @@ void ASTCreateQuery::formatQueryImpl(const FormatSettings & settings, FormatStat
     if (select)
     {
         settings.ostr << (settings.hilite ? hilite_keyword : "") << " AS"
-                      << (comment ? "(" : "")
-                      << settings.nl_or_ws << (settings.hilite ? hilite_none : "");
+                      << settings.nl_or_ws
+                      << (comment ? "(" : "") << (settings.hilite ? hilite_none : "");
         select->formatImpl(settings, state, frame);
         settings.ostr << (settings.hilite ? hilite_keyword : "") << (comment ? ")" : "") << (settings.hilite ? hilite_none : "");
     }
diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 978dc3507ac..b5614faab1b 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -321,10 +321,9 @@ TEST(FormatHiliting, ASTKillQueryQuery)
 
 TEST(FormatHiliting, ASTCreateQuery)
 {
-    // The misplaced space around ( is on purpose, as this bug will fixed in a separate PR.
-    String query = "CREATE TABLE name AS( SELECT *) COMMENT 'hello'";
+    String query = "CREATE TABLE name AS (SELECT *) COMMENT 'hello'";
 
-    String expected = keyword("CREATE TABLE ") + "name " + keyword("AS( SELECT ") + "*" + keyword(") ")
+    String expected = keyword("CREATE TABLE ") + "name " + keyword("AS (SELECT ") + "*" + keyword(") ")
             + keyword("COMMENT ") + "'hello'";
 
     compare(query, expected);

From 61cfad1f6d9c3f301c56df9abd2c722ad57e59bf Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Mon, 3 Apr 2023 13:39:17 +0100
Subject: [PATCH 44/80] extract hilite comparator into a utility

---
 src/CMakeLists.txt                           |   3 +-
 src/Parsers/tests/gtest_format_hiliting.cpp  | 101 +----------------
 utils/hilite_comparator/CMakeLists.txt       |   7 ++
 utils/hilite_comparator/HiliteComparator.cpp |  22 ++++
 utils/hilite_comparator/HiliteComparator.h   | 107 +++++++++++++++++++
 5 files changed, 140 insertions(+), 100 deletions(-)
 create mode 100644 utils/hilite_comparator/CMakeLists.txt
 create mode 100644 utils/hilite_comparator/HiliteComparator.cpp
 create mode 100644 utils/hilite_comparator/HiliteComparator.h

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 62005c76ce0..f6727bad0e8 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -608,7 +608,8 @@ if (ENABLE_TESTS)
         dbms
         clickhouse_common_config
         clickhouse_common_zookeeper
-        string_utils)
+        string_utils
+        hilite_comparator)
 
     if (TARGET ch_contrib::simdjson)
         target_link_libraries(unit_tests_dbms PRIVATE ch_contrib::simdjson)
diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index b5614faab1b..e6cb12bee54 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -6,6 +6,8 @@
 #include <gtest/gtest.h>
 #include <Common/StackTrace.h>
 
+#include <utils/hilite_comparator/HiliteComparator.h>
+
 String hilite(const String & s, const char * hilite_type)
 {
     return hilite_type + s + DB::IAST::hilite_none;
@@ -41,105 +43,6 @@ String substitution(const String & s)
     return hilite(s, DB::IAST::hilite_substitution);
 }
 
-std::vector<const char *> HILITES =
-    {
-        DB::IAST::hilite_keyword,
-        DB::IAST::hilite_identifier,
-        DB::IAST::hilite_function,
-        DB::IAST::hilite_operator,
-        DB::IAST::hilite_alias,
-        DB::IAST::hilite_substitution,
-        DB::IAST::hilite_none
-    };
-
-[[maybe_unused]] const char * consume_hilites(const char ** ptr_ptr)
-{
-    const char * last_hilite = nullptr;
-    while (true)
-    {
-        bool changed_hilite = false;
-        for (const char * hilite : HILITES)
-        {
-            if (std::string_view(*ptr_ptr).starts_with(hilite))
-            {
-                *ptr_ptr += strlen(hilite);
-                changed_hilite = true;
-                last_hilite = hilite;
-            }
-        }
-        if (!changed_hilite)
-            break;
-    }
-    return last_hilite;
-}
-
-String remove_hilites(std::string_view string)
-{
-    const char * ptr = string.begin();
-    String string_without_hilites;
-    while (true)
-    {
-        consume_hilites(&ptr);
-        if (ptr == string.end())
-            return string_without_hilites;
-        string_without_hilites += *(ptr++);
-    }
-}
-
-bool are_equal_with_hilites_removed(std::string_view left, std::string_view right)
-{
-    return remove_hilites(left) == remove_hilites(right);
-}
-
-/*
- * Hilited queries cannot be compared symbol-by-symbol, as there's some frivolousness introduced with the hilites. Specifically:
- * 1. Whitespaces could be hilited with any hilite type.
- * 2. Hilite could or could be not reset with hilite_none before the next hilite, i.e. the following strings a and b are equal:
- *      a. hilite_keyword foo hilite_none hilite_operator +
- *      b. hilite_keyword foo hilite_operator +
- */
-bool are_equal_with_hilites(std::string_view left, std::string_view right)
-{
-    if (!are_equal_with_hilites_removed(left, right))
-        return false;
-
-    const char * left_it = left.begin();
-    const char * right_it = right.begin();
-    const char * left_hilite = DB::IAST::hilite_none;
-    const char * right_hilite = DB::IAST::hilite_none;
-
-    while (true)
-    {
-        // Consume all prefix hilites, update the current hilite to be the last one.
-        const char * last_hilite = consume_hilites(&left_it);
-        if (last_hilite != nullptr)
-            left_hilite = last_hilite;
-
-        last_hilite = consume_hilites(&right_it);
-        if (last_hilite != nullptr)
-            right_hilite = last_hilite;
-
-        if (left_it == left.end() && right_it == right.end())
-            return true;
-
-        if (left_it == left.end() || right_it == right.end())
-            return false;
-
-        // Lookup one character.
-        // Check characters match.
-        // Redundant check, given the hilite-ignorant comparison at the beginning, but let's keep it just in case.
-        if (*left_it != *right_it)
-            return false;
-
-        // Check hilites match if it's not a whitespace.
-        if (!std::isspace(*left_it) && left_hilite != right_hilite)
-            return false;
-
-        // Consume one character.
-        left_it++;
-        right_it++;
-    }
-}
 
 TEST(FormatHiliting, MetaTestConsumeHilites)
 {
diff --git a/utils/hilite_comparator/CMakeLists.txt b/utils/hilite_comparator/CMakeLists.txt
new file mode 100644
index 00000000000..c4f567f436d
--- /dev/null
+++ b/utils/hilite_comparator/CMakeLists.txt
@@ -0,0 +1,7 @@
+clickhouse_add_executable (
+    hilite_comparator
+    HiliteComparator.h
+    HiliteComparator.cpp
+)
+
+target_link_libraries(hilite-comparator PRIVATE dbms)
diff --git a/utils/hilite_comparator/HiliteComparator.cpp b/utils/hilite_comparator/HiliteComparator.cpp
new file mode 100644
index 00000000000..b9597e44b6b
--- /dev/null
+++ b/utils/hilite_comparator/HiliteComparator.cpp
@@ -0,0 +1,22 @@
+#include "HiliteComparator.h"
+
+namespace HiliteComparator {
+
+std::vector<const char *> HILITES;
+
+[[maybe_unused]] const char * consume_hilites(const char ** ptr_ptr);
+
+String remove_hilites(std::string_view string);
+
+bool are_equal_with_hilites_removed(std::string_view left, std::string_view right);
+
+/*
+ * Hilited queries cannot be compared symbol-by-symbol, as there's some frivolousness introduced with the hilites. Specifically:
+ * 1. Whitespaces could be hilited with any hilite type.
+ * 2. Hilite could or could be not reset with hilite_none before the next hilite, i.e. the following strings a and b are equal:
+ *      a. hilite_keyword foo hilite_none hilite_operator +
+ *      b. hilite_keyword foo hilite_operator +
+ */
+bool are_equal_with_hilites(std::string_view left, std::string_view right);
+
+}
diff --git a/utils/hilite_comparator/HiliteComparator.h b/utils/hilite_comparator/HiliteComparator.h
new file mode 100644
index 00000000000..d93a0068704
--- /dev/null
+++ b/utils/hilite_comparator/HiliteComparator.h
@@ -0,0 +1,107 @@
+#pragma once
+
+#include <IAST.h>
+
+namespace HiliteComparator {
+
+std::vector<const char *> HILITES =
+    {
+        DB::IAST::hilite_keyword,
+        DB::IAST::hilite_identifier,
+        DB::IAST::hilite_function,
+        DB::IAST::hilite_operator,
+        DB::IAST::hilite_alias,
+        DB::IAST::hilite_substitution,
+        DB::IAST::hilite_none
+};
+
+[[maybe_unused]] const char * consume_hilites(const char ** ptr_ptr)
+{
+    const char * last_hilite = nullptr;
+    while (true)
+    {
+        bool changed_hilite = false;
+        for (const char * hilite : HILITES)
+        {
+            if (std::string_view(*ptr_ptr).starts_with(hilite))
+            {
+                *ptr_ptr += strlen(hilite);
+                changed_hilite = true;
+                last_hilite = hilite;
+            }
+        }
+        if (!changed_hilite)
+            break;
+    }
+    return last_hilite;
+}
+
+String remove_hilites(std::string_view string)
+{
+    const char * ptr = string.begin();
+    String string_without_hilites;
+    while (true)
+    {
+        consume_hilites(&ptr);
+        if (ptr == string.end())
+            return string_without_hilites;
+        string_without_hilites += *(ptr++);
+    }
+}
+
+bool are_equal_with_hilites_removed(std::string_view left, std::string_view right)
+{
+    return remove_hilites(left) == remove_hilites(right);
+}
+
+/*
+ * Hilited queries cannot be compared symbol-by-symbol, as there's some frivolousness introduced with the hilites. Specifically:
+ * 1. Whitespaces could be hilited with any hilite type.
+ * 2. Hilite could or could be not reset with hilite_none before the next hilite, i.e. the following strings a and b are equal:
+ *      a. hilite_keyword foo hilite_none hilite_operator +
+ *      b. hilite_keyword foo hilite_operator +
+ */
+bool are_equal_with_hilites(std::string_view left, std::string_view right)
+{
+    if (!are_equal_with_hilites_removed(left, right))
+        return false;
+
+    const char * left_it = left.begin();
+    const char * right_it = right.begin();
+    const char * left_hilite = DB::IAST::hilite_none;
+    const char * right_hilite = DB::IAST::hilite_none;
+
+    while (true)
+    {
+        // Consume all prefix hilites, update the current hilite to be the last one.
+        const char * last_hilite = consume_hilites(&left_it);
+        if (last_hilite != nullptr)
+            left_hilite = last_hilite;
+
+        last_hilite = consume_hilites(&right_it);
+        if (last_hilite != nullptr)
+            right_hilite = last_hilite;
+
+        if (left_it == left.end() && right_it == right.end())
+            return true;
+
+        if (left_it == left.end() || right_it == right.end())
+            return false;
+
+        // Lookup one character.
+        // Check characters match.
+        // Redundant check, given the hilite-ignorant comparison at the beginning, but let's keep it just in case.
+        if (*left_it != *right_it)
+            return false;
+
+        // Check hilites match if it's not a whitespace.
+        if (!std::isspace(*left_it) && left_hilite != right_hilite)
+            return false;
+
+        // Consume one character.
+        left_it++;
+        right_it++;
+    }
+}
+
+}

From 14b4fde1b43d5ba077186fe9067ad875f16973e4 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Mon, 3 Apr 2023 13:49:43 +0100
Subject: [PATCH 45/80] extract hilite comparator tests

---
 src/Parsers/tests/gtest_format_hiliting.cpp   | 85 ------------------
 .../gtest_hilite_comparator.cpp               | 89 +++++++++++++++++++
 2 files changed, 89 insertions(+), 85 deletions(-)
 create mode 100644 utils/hilite_comparator/gtest_hilite_comparator.cpp

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index e6cb12bee54..d46586997e0 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -44,91 +44,6 @@ String substitution(const String & s)
 }
 
 
-TEST(FormatHiliting, MetaTestConsumeHilites)
-{
-    using namespace DB;
-    // The order is different from the order in HILITES on purpose.
-    String s;
-    s += IAST::hilite_keyword;
-    s += IAST::hilite_alias;
-    s += IAST::hilite_identifier;
-    s += IAST::hilite_none;
-    s += IAST::hilite_operator;
-    s += IAST::hilite_substitution;
-    s += IAST::hilite_function;
-    s += "test";
-    s += IAST::hilite_keyword;
-    const char * ptr = s.c_str();
-    const char * expected_ptr = strchr(ptr, 't');
-    const char * last_hilite = consume_hilites(&ptr);
-    ASSERT_EQ(expected_ptr, ptr);
-    ASSERT_TRUE(last_hilite != nullptr);
-    ASSERT_EQ(IAST::hilite_function, last_hilite);
-}
-
-TEST(FormatHiliting, MetaTestRemoveHilites)
-{
-    using namespace DB;
-    String s;
-    s += IAST::hilite_keyword;
-    s += "te";
-    s += IAST::hilite_alias;
-    s += IAST::hilite_identifier;
-    s += "s";
-    s += IAST::hilite_none;
-    s += "t";
-    s += IAST::hilite_operator;
-    s += IAST::hilite_substitution;
-    s += IAST::hilite_function;
-    ASSERT_EQ("test", remove_hilites(s));
-}
-
-TEST(FormatHiliting, MetaTestAreEqualWithHilites)
-{
-    using namespace DB;
-    ASSERT_PRED2(are_equal_with_hilites, "", "");
-
-    for (const char * hilite : HILITES)
-    {
-        ASSERT_PRED2(are_equal_with_hilites, "", std::string_view(hilite));
-        ASSERT_PRED2(are_equal_with_hilites, std::string_view(hilite), "");
-    }
-
-    {
-        String s;
-        s += IAST::hilite_none;
-        s += "select";
-        s += IAST::hilite_none;
-        ASSERT_PRED2(are_equal_with_hilites, s, "select");
-    }
-
-    {
-        String s;
-        s += DB::IAST::hilite_none;
-        s += "\n sel";
-        s += DB::IAST::hilite_none;
-        s += "ect";
-        s += DB::IAST::hilite_none;
-        ASSERT_PRED2(are_equal_with_hilites, s, "\n select");
-    }
-
-    {
-        String left;
-        left += DB::IAST::hilite_keyword;
-        left += "keyword long";
-        left += DB::IAST::hilite_none;
-
-        String right;
-        right += DB::IAST::hilite_keyword;
-        right += "keyword";
-        right += DB::IAST::hilite_none;
-        right += " ";
-        right += DB::IAST::hilite_keyword;
-        right += "long";
-        ASSERT_PRED2(are_equal_with_hilites, left, right);
-    }
-}
-
 void compare(const String & query, const String & expected)
 {
     using namespace DB;
diff --git a/utils/hilite_comparator/gtest_hilite_comparator.cpp b/utils/hilite_comparator/gtest_hilite_comparator.cpp
new file mode 100644
index 00000000000..51ea92344e1
--- /dev/null
+++ b/utils/hilite_comparator/gtest_hilite_comparator.cpp
@@ -0,0 +1,89 @@
+#include <gtest/gtest.h>
+#include <Parsers/IAST.h>
+#include <utils/hilite_comparator/HiliteComparator.h>
+
+
+TEST(FormatHiliting, MetaTestConsumeHilites)
+{
+    using namespace DB;
+    // The order is different from the order in HILITES on purpose.
+    String s;
+    s += IAST::hilite_keyword;
+    s += IAST::hilite_alias;
+    s += IAST::hilite_identifier;
+    s += IAST::hilite_none;
+    s += IAST::hilite_operator;
+    s += IAST::hilite_substitution;
+    s += IAST::hilite_function;
+    s += "test";
+    s += IAST::hilite_keyword;
+    const char * ptr = s.c_str();
+    const char * expected_ptr = strchr(ptr, 't');
+    const char * last_hilite = consume_hilites(&ptr);
+    ASSERT_EQ(expected_ptr, ptr);
+    ASSERT_TRUE(last_hilite != nullptr);
+    ASSERT_EQ(IAST::hilite_function, last_hilite);
+}
+
+TEST(FormatHiliting, MetaTestRemoveHilites)
+{
+    using namespace DB;
+    String s;
+    s += IAST::hilite_keyword;
+    s += "te";
+    s += IAST::hilite_alias;
+    s += IAST::hilite_identifier;
+    s += "s";
+    s += IAST::hilite_none;
+    s += "t";
+    s += IAST::hilite_operator;
+    s += IAST::hilite_substitution;
+    s += IAST::hilite_function;
+    ASSERT_EQ("test", remove_hilites(s));
+}
+
+TEST(FormatHiliting, MetaTestAreEqualWithHilites)
+{
+    using namespace DB;
+    ASSERT_PRED2(are_equal_with_hilites, "", "");
+
+    for (const char * hilite : HILITES)
+    {
+        ASSERT_PRED2(are_equal_with_hilites, "", std::string_view(hilite));
+        ASSERT_PRED2(are_equal_with_hilites, std::string_view(hilite), "");
+    }
+
+    {
+        String s;
+        s += IAST::hilite_none;
+        s += "select";
+        s += IAST::hilite_none;
+        ASSERT_PRED2(are_equal_with_hilites, s, "select");
+    }
+
+    {
+        String s;
+        s += DB::IAST::hilite_none;
+        s += "\n sel";
+        s += DB::IAST::hilite_none;
+        s += "ect";
+        s += DB::IAST::hilite_none;
+        ASSERT_PRED2(are_equal_with_hilites, s, "\n select");
+    }
+
+    {
+        String left;
+        left += DB::IAST::hilite_keyword;
+        left += "keyword long";
+        left += DB::IAST::hilite_none;
+
+        String right;
+        right += DB::IAST::hilite_keyword;
+        right += "keyword";
+        right += DB::IAST::hilite_none;
+        right += " ";
+        right += DB::IAST::hilite_keyword;
+        right += "long";
+        ASSERT_PRED2(are_equal_with_hilites, left, right);
+    }
+}
\ No newline at end of file

From b275b619157a5a5eba7abb310384f9b2f85f55d3 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Mon, 3 Apr 2023 13:49:53 +0100
Subject: [PATCH 46/80] fix Parsers/IAST.h include

---
 utils/hilite_comparator/HiliteComparator.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils/hilite_comparator/HiliteComparator.h b/utils/hilite_comparator/HiliteComparator.h
index d93a0068704..53b2947c439 100644
--- a/utils/hilite_comparator/HiliteComparator.h
+++ b/utils/hilite_comparator/HiliteComparator.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <IAST.h>
+#include <Parsers/IAST.h>
 
 namespace HiliteComparator {
 

From c8ef87f98493e836238e22106ce1c916949a9b06 Mon Sep 17 00:00:00 2001
From: Robert Schulze <robert@clickhouse.com>
Date: Mon, 3 Apr 2023 13:57:16 +0000
Subject: [PATCH 47/80] Fix build

---
 src/Parsers/CMakeLists.txt                        |  4 ++++
 src/Parsers/HiliteComparator/CMakeLists.txt       |  6 ++++++
 .../Parsers/HiliteComparator/HiliteComparator.cpp | 15 +++++++--------
 .../Parsers/HiliteComparator/HiliteComparator.h   |  7 ++++---
 src/Parsers/tests/gtest_format_hiliting.cpp       |  6 +++---
 utils/hilite_comparator/CMakeLists.txt            |  7 -------
 6 files changed, 24 insertions(+), 21 deletions(-)
 create mode 100644 src/Parsers/HiliteComparator/CMakeLists.txt
 rename utils/hilite_comparator/HiliteComparator.h => src/Parsers/HiliteComparator/HiliteComparator.cpp (98%)
 rename utils/hilite_comparator/HiliteComparator.cpp => src/Parsers/HiliteComparator/HiliteComparator.h (91%)
 delete mode 100644 utils/hilite_comparator/CMakeLists.txt

diff --git a/src/Parsers/CMakeLists.txt b/src/Parsers/CMakeLists.txt
index 73d46593e04..d5cf2bd4784 100644
--- a/src/Parsers/CMakeLists.txt
+++ b/src/Parsers/CMakeLists.txt
@@ -22,3 +22,7 @@ endif()
 if (ENABLE_FUZZING)
     add_subdirectory(fuzzers)
 endif()
+
+if (ENABLE_TESTS)
+    add_subdirectory(HiliteComparator)
+endif ()
diff --git a/src/Parsers/HiliteComparator/CMakeLists.txt b/src/Parsers/HiliteComparator/CMakeLists.txt
new file mode 100644
index 00000000000..5bc738b3586
--- /dev/null
+++ b/src/Parsers/HiliteComparator/CMakeLists.txt
@@ -0,0 +1,6 @@
+add_library(hilite_comparator
+    HiliteComparator.h
+    HiliteComparator.cpp
+)
+
+target_link_libraries(hilite_comparator PRIVATE dbms)
diff --git a/utils/hilite_comparator/HiliteComparator.h b/src/Parsers/HiliteComparator/HiliteComparator.cpp
similarity index 98%
rename from utils/hilite_comparator/HiliteComparator.h
rename to src/Parsers/HiliteComparator/HiliteComparator.cpp
index 53b2947c439..38788d76bb9 100644
--- a/utils/hilite_comparator/HiliteComparator.h
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -1,6 +1,4 @@
-#pragma once
-
-#include <Parsers/IAST.h>
+#include "HiliteComparator.h"
 
 namespace HiliteComparator {
 
@@ -36,6 +34,11 @@ std::vector<const char *> HILITES =
     return last_hilite;
 }
 
+bool are_equal_with_hilites_removed(std::string_view left, std::string_view right)
+{
+    return remove_hilites(left) == remove_hilites(right);
+}
+
 String remove_hilites(std::string_view string)
 {
     const char * ptr = string.begin();
@@ -49,11 +52,6 @@ String remove_hilites(std::string_view string)
     }
 }
 
-bool are_equal_with_hilites_removed(std::string_view left, std::string_view right)
-{
-    return remove_hilites(left) == remove_hilites(right);
-}
-
 /*
  * Hilited queries cannot be compared symbol-by-symbol, as there's some frivolousness introduced with the hilites. Specifically:
  * 1. Whitespaces could be hilited with any hilite type.
@@ -104,4 +102,5 @@ bool are_equal_with_hilites(std::string_view left, std::string_view right)
     }
 }
 
+
 }
diff --git a/utils/hilite_comparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.h
similarity index 91%
rename from utils/hilite_comparator/HiliteComparator.cpp
rename to src/Parsers/HiliteComparator/HiliteComparator.h
index b9597e44b6b..78d2edacc59 100644
--- a/utils/hilite_comparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.h
@@ -1,9 +1,10 @@
-#include "HiliteComparator.h"
+#pragma once
+
+#include <Parsers/IAST.h>
+
 
 namespace HiliteComparator {
 
-std::vector<const char *> HILITES;
-
 [[maybe_unused]] const char * consume_hilites(const char ** ptr_ptr);
 
 String remove_hilites(std::string_view string);
diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index d46586997e0..2f2ea4f40a8 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -3,10 +3,10 @@
 #include <Parsers/IAST.h>
 #include <Parsers/ParserQuery.h>
 #include <Parsers/parseQuery.h>
+#include <Parsers/HiliteComparator/HiliteComparator.h>
 #include <gtest/gtest.h>
 #include <Common/StackTrace.h>
 
-#include <utils/hilite_comparator/HiliteComparator.h>
 
 String hilite(const String & s, const char * hilite_type)
 {
@@ -55,8 +55,8 @@ void compare(const String & query, const String & expected)
     settings.hilite = true;
     ast->format(settings);
 
-    ASSERT_PRED2(are_equal_with_hilites_removed, expected, write_buffer.str());
-    ASSERT_PRED2(are_equal_with_hilites, expected, write_buffer.str());
+    ASSERT_PRED2(HiliteComparator::are_equal_with_hilites_removed, expected, write_buffer.str());
+    ASSERT_PRED2(HiliteComparator::are_equal_with_hilites, expected, write_buffer.str());
 }
 
 TEST(FormatHiliting, SimpleSelect)
diff --git a/utils/hilite_comparator/CMakeLists.txt b/utils/hilite_comparator/CMakeLists.txt
deleted file mode 100644
index c4f567f436d..00000000000
--- a/utils/hilite_comparator/CMakeLists.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-clickhouse_add_executable (
-    hilite_comparator
-    HiliteComparator.h
-    HiliteComparator.cpp
-)
-
-target_link_libraries(hilite-comparator PRIVATE dbms)

From a7efb4a247f97c440e721bf5678da1c58d2b692c Mon Sep 17 00:00:00 2001
From: avogar <avogar@clickhouse.com>
Date: Mon, 3 Apr 2023 14:02:45 +0000
Subject: [PATCH 48/80] Fix tests, update working with column indexes in ORC
 format

---
 .../Formats/Impl/ORCBlockInputFormat.cpp          | 15 +++++++++++----
 .../0_stateless/00900_long_parquet_load.reference |  7 +++++--
 .../datapage_v2.snappy.parquet.columns            |  2 +-
 3 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp b/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp
index 63d66cd75dd..eae8f494c19 100644
--- a/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp
@@ -129,10 +129,17 @@ void ORCBlockInputFormat::prepareReader()
         format_settings.null_as_default,
         format_settings.orc.case_insensitive_column_matching);
 
-    ArrowFieldIndexUtil field_util(
-        format_settings.orc.case_insensitive_column_matching,
-        format_settings.orc.allow_missing_columns);
-    include_indices = field_util.findRequiredIndices(getPort().getHeader(), *schema);
+    const bool ignore_case = format_settings.orc.case_insensitive_column_matching;
+    std::unordered_set<String> nested_table_names;
+    if (format_settings.orc.import_nested)
+        nested_table_names = Nested::getAllTableNames(getPort().getHeader(), ignore_case);
+
+    for (int i = 0; i < schema->num_fields(); ++i)
+    {
+        const auto & name = schema->field(i)->name();
+        if (getPort().getHeader().has(name, ignore_case) || nested_table_names.contains(ignore_case ? boost::to_lower_copy(name) : name))
+            include_indices.push_back(i);
+    }
 }
 
 ORCSchemaReader::ORCSchemaReader(ReadBuffer & in_, const FormatSettings & format_settings_)
diff --git a/tests/queries/0_stateless/00900_long_parquet_load.reference b/tests/queries/0_stateless/00900_long_parquet_load.reference
index 72ec99ad2c6..1ca2fbc2fd6 100644
--- a/tests/queries/0_stateless/00900_long_parquet_load.reference
+++ b/tests/queries/0_stateless/00900_long_parquet_load.reference
@@ -92,8 +92,11 @@ idx10	['This','is','a','test']
 123	1
 456	2
 === Try load data from datapage_v2.snappy.parquet
-Code: 33. DB::ParsingEx---tion: Error while reading Parquet data: IOError: Unknown encoding type.: While executing ParquetBlockInputFormat: data for INSERT was parsed from stdin: (in query: INSERT INTO parquet_load FORMAT Parquet). (CANNOT_READ_ALL_DATA)
-
+abc	1	2	1	[1,2,3]
+abc	2	3	1	[]
+abc	3	4	1	[]
+\N	4	5	0	[1,2,3]
+abc	5	2	1	[1,2]
 === Try load data from datatype-date32.parquet
 1925-01-01
 1949-10-01
diff --git a/tests/queries/0_stateless/data_parquet/datapage_v2.snappy.parquet.columns b/tests/queries/0_stateless/data_parquet/datapage_v2.snappy.parquet.columns
index c6bb5057cc2..dc094bef8ed 100644
--- a/tests/queries/0_stateless/data_parquet/datapage_v2.snappy.parquet.columns
+++ b/tests/queries/0_stateless/data_parquet/datapage_v2.snappy.parquet.columns
@@ -1 +1 @@
-`a` Nullable(String), `b` Array(Nullable(Int32)), `c` Nullable(Float64), `d` Nullable(UInt8), `e` Array(Nullable(Int32))
+`a` Nullable(String), `b` Nullable(Int32), `c` Nullable(Float64), `d` Nullable(UInt8), `e` Array(Nullable(Int32))

From a06e1f4d59cf0200ae9bac9d92ef045722b73e2c Mon Sep 17 00:00:00 2001
From: Dmitry Novik <n0vik@clickhouse.com>
Date: Mon, 3 Apr 2023 15:46:32 +0000
Subject: [PATCH 49/80] Fix lambda type resolution

---
 src/Analyzer/LambdaNode.h                     |  8 ++++++-
 src/Analyzer/Passes/QueryAnalysisPass.cpp     |  7 ++++--
 src/Analyzer/QueryTreePassManager.cpp         | 18 ++++++++++----
 src/Planner/PlannerActionsVisitor.cpp         |  9 +++++--
 .../25401_nested_lambdas_types.reference      |  5 ++++
 .../25401_nested_lambdas_types.sql            | 24 +++++++++++++++++++
 6 files changed, 62 insertions(+), 9 deletions(-)
 create mode 100644 tests/queries/0_stateless/25401_nested_lambdas_types.reference
 create mode 100644 tests/queries/0_stateless/25401_nested_lambdas_types.sql

diff --git a/src/Analyzer/LambdaNode.h b/src/Analyzer/LambdaNode.h
index 5d8e53a464c..355ed77cc6a 100644
--- a/src/Analyzer/LambdaNode.h
+++ b/src/Analyzer/LambdaNode.h
@@ -86,7 +86,12 @@ public:
 
     DataTypePtr getResultType() const override
     {
-        return getExpression()->getResultType();
+        return result_type;
+    }
+
+    void resolve(DataTypePtr lambda_type)
+    {
+        result_type = std::move(lambda_type);
     }
 
     void dumpTreeImpl(WriteBuffer & buffer, FormatState & format_state, size_t indent) const override;
@@ -102,6 +107,7 @@ protected:
 
 private:
     Names argument_names;
+    DataTypePtr result_type;
 
     static constexpr size_t arguments_child_index = 0;
     static constexpr size_t expression_child_index = 1;
diff --git a/src/Analyzer/Passes/QueryAnalysisPass.cpp b/src/Analyzer/Passes/QueryAnalysisPass.cpp
index 76c780f25eb..3b27561450b 100644
--- a/src/Analyzer/Passes/QueryAnalysisPass.cpp
+++ b/src/Analyzer/Passes/QueryAnalysisPass.cpp
@@ -5085,8 +5085,11 @@ ProjectionNames QueryAnalyzer::resolveFunction(QueryTreeNodePtr & node, Identifi
                 arguments_projection_names[function_lambda_argument_index] = lambda_argument_projection_name_buffer.str();
             }
 
-            argument_types[function_lambda_argument_index] = std::make_shared<DataTypeFunction>(function_data_type_argument_types, lambda_to_resolve->getResultType());
-            argument_columns[function_lambda_argument_index].type = argument_types[function_lambda_argument_index];
+            auto lambda_resolved_type = std::make_shared<DataTypeFunction>(function_data_type_argument_types, lambda_to_resolve_typed.getExpression()->getResultType());
+            lambda_to_resolve_typed.resolve(lambda_resolved_type);
+
+            argument_types[function_lambda_argument_index] = lambda_resolved_type;
+            argument_columns[function_lambda_argument_index].type = lambda_resolved_type;
             function_arguments[function_lambda_argument_index] = std::move(lambda_to_resolve);
         }
 
diff --git a/src/Analyzer/QueryTreePassManager.cpp b/src/Analyzer/QueryTreePassManager.cpp
index 52fce8abaf2..a6da2a66615 100644
--- a/src/Analyzer/QueryTreePassManager.cpp
+++ b/src/Analyzer/QueryTreePassManager.cpp
@@ -115,13 +115,23 @@ private:
 
         for (size_t i = 0; i < expected_argument_types_size; ++i)
         {
-            // Skip lambdas
-            if (WhichDataType(expected_argument_types[i]).isFunction())
-                continue;
-
             const auto & expected_argument_type = expected_argument_types[i];
             const auto & actual_argument_type = actual_argument_columns[i].type;
 
+            if (!expected_argument_type)
+                throw Exception(ErrorCodes::LOGICAL_ERROR,
+                    "Function {} expected argument {} type is not set after running {} pass",
+                    function->toAST()->formatForErrorMessage(),
+                    i + 1,
+                    pass_name);
+
+            if (!actual_argument_type)
+                throw Exception(ErrorCodes::LOGICAL_ERROR,
+                    "Function {} actual argument {} type is not set after running {} pass",
+                    function->toAST()->formatForErrorMessage(),
+                    i + 1,
+                    pass_name);
+
             if (!expected_argument_type->equals(*actual_argument_type))
             {
                 /// Aggregate functions remove low cardinality for their argument types
diff --git a/src/Planner/PlannerActionsVisitor.cpp b/src/Planner/PlannerActionsVisitor.cpp
index 429815ad23f..1e6ef35f4ab 100644
--- a/src/Planner/PlannerActionsVisitor.cpp
+++ b/src/Planner/PlannerActionsVisitor.cpp
@@ -599,11 +599,16 @@ PlannerActionsVisitorImpl::NodeNameAndNodeMinLevel PlannerActionsVisitorImpl::vi
 
     auto lambda_node_name = calculateActionNodeName(node, *planner_context);
     auto function_capture = std::make_shared<FunctionCaptureOverloadResolver>(
-        lambda_actions, captured_column_names, lambda_arguments_names_and_types, result_type, lambda_expression_node_name);
+        lambda_actions, captured_column_names, lambda_arguments_names_and_types, lambda_node.getExpression()->getResultType(), lambda_expression_node_name);
     actions_stack.pop_back();
 
     // TODO: Pass IFunctionBase here not FunctionCaptureOverloadResolver.
-    actions_stack[level].addFunctionIfNecessary(lambda_node_name, std::move(lambda_children), function_capture);
+    const auto * actions_node = actions_stack[level].addFunctionIfNecessary(lambda_node_name, std::move(lambda_children), function_capture);
+
+    if (!result_type->equals(*actions_node->result_type))
+        throw Exception(ErrorCodes::LOGICAL_ERROR,
+            "Lambda resolved type {} is not equal to type from actions DAG {}",
+            result_type, actions_node->result_type);
 
     size_t actions_stack_size = actions_stack.size();
     for (size_t i = level + 1; i < actions_stack_size; ++i)
diff --git a/tests/queries/0_stateless/25401_nested_lambdas_types.reference b/tests/queries/0_stateless/25401_nested_lambdas_types.reference
new file mode 100644
index 00000000000..9502c314200
--- /dev/null
+++ b/tests/queries/0_stateless/25401_nested_lambdas_types.reference
@@ -0,0 +1,5 @@
+[0]	[[0]]
+[0]	[[0]]
+[0]	[[1]]
+[0]	[[1]]
+[0]	[[1]]
diff --git a/tests/queries/0_stateless/25401_nested_lambdas_types.sql b/tests/queries/0_stateless/25401_nested_lambdas_types.sql
new file mode 100644
index 00000000000..f9258d61900
--- /dev/null
+++ b/tests/queries/0_stateless/25401_nested_lambdas_types.sql
@@ -0,0 +1,24 @@
+SELECT
+    range(1),
+    arrayMap(x -> arrayMap(x -> x, range(x)), [1])
+SETTINGS allow_experimental_analyzer = 0;
+
+SELECT
+    range(1),
+    arrayMap(x -> arrayMap(x -> x, range(x)), [1])
+SETTINGS allow_experimental_analyzer = 1;
+
+SELECT
+    range(1),
+    arrayMap(x -> arrayMap(x -> 1, range(x)), [1])
+SETTINGS allow_experimental_analyzer = 0;
+
+SELECT
+    range(1),
+    arrayMap(x -> arrayMap(x -> 1, range(x)), [1])
+SETTINGS allow_experimental_analyzer = 1;
+
+SELECT
+    range(1),
+    arrayMap(x -> arrayMap(y -> 1, range(x)), [1])
+SETTINGS allow_experimental_analyzer = 1;

From d9e0b4d8fa05edefb4fdd22b0d1b6ecd85cc50f9 Mon Sep 17 00:00:00 2001
From: Dmitry Novik <n0vik@clickhouse.com>
Date: Mon, 3 Apr 2023 15:53:49 +0000
Subject: [PATCH 50/80] Rename test

---
 ...es.reference => 25401_analyzer_nested_lambdas_types.reference} | 0
 ..._lambdas_types.sql => 25401_analyzer_nested_lambdas_types.sql} | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/queries/0_stateless/{25401_nested_lambdas_types.reference => 25401_analyzer_nested_lambdas_types.reference} (100%)
 rename tests/queries/0_stateless/{25401_nested_lambdas_types.sql => 25401_analyzer_nested_lambdas_types.sql} (100%)

diff --git a/tests/queries/0_stateless/25401_nested_lambdas_types.reference b/tests/queries/0_stateless/25401_analyzer_nested_lambdas_types.reference
similarity index 100%
rename from tests/queries/0_stateless/25401_nested_lambdas_types.reference
rename to tests/queries/0_stateless/25401_analyzer_nested_lambdas_types.reference
diff --git a/tests/queries/0_stateless/25401_nested_lambdas_types.sql b/tests/queries/0_stateless/25401_analyzer_nested_lambdas_types.sql
similarity index 100%
rename from tests/queries/0_stateless/25401_nested_lambdas_types.sql
rename to tests/queries/0_stateless/25401_analyzer_nested_lambdas_types.sql

From 041994f081d89900a4597051aa7a9d8d5bb5a2c2 Mon Sep 17 00:00:00 2001
From: Dmitry Novik <n0vik@clickhouse.com>
Date: Mon, 3 Apr 2023 16:16:23 +0000
Subject: [PATCH 51/80] Rename test

---
 ...es.reference => 02707_analyzer_nested_lambdas_types.reference} | 0
 ..._lambdas_types.sql => 02707_analyzer_nested_lambdas_types.sql} | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/queries/0_stateless/{25401_analyzer_nested_lambdas_types.reference => 02707_analyzer_nested_lambdas_types.reference} (100%)
 rename tests/queries/0_stateless/{25401_analyzer_nested_lambdas_types.sql => 02707_analyzer_nested_lambdas_types.sql} (100%)

diff --git a/tests/queries/0_stateless/25401_analyzer_nested_lambdas_types.reference b/tests/queries/0_stateless/02707_analyzer_nested_lambdas_types.reference
similarity index 100%
rename from tests/queries/0_stateless/25401_analyzer_nested_lambdas_types.reference
rename to tests/queries/0_stateless/02707_analyzer_nested_lambdas_types.reference
diff --git a/tests/queries/0_stateless/25401_analyzer_nested_lambdas_types.sql b/tests/queries/0_stateless/02707_analyzer_nested_lambdas_types.sql
similarity index 100%
rename from tests/queries/0_stateless/25401_analyzer_nested_lambdas_types.sql
rename to tests/queries/0_stateless/02707_analyzer_nested_lambdas_types.sql

From a4fecb75de62194b72ff512d2e359a01db86bbde Mon Sep 17 00:00:00 2001
From: avogar <avogar@clickhouse.com>
Date: Mon, 3 Apr 2023 19:05:22 +0000
Subject: [PATCH 52/80] Try fix compatibility check, add expf and scalbnf
 implementation from musl

---
 base/glibc-compatibility/musl/expf.c    | 81 +++++++++++++++++++++++++
 base/glibc-compatibility/musl/scalbnf.c | 31 ++++++++++
 2 files changed, 112 insertions(+)
 create mode 100644 base/glibc-compatibility/musl/expf.c
 create mode 100644 base/glibc-compatibility/musl/scalbnf.c

diff --git a/base/glibc-compatibility/musl/expf.c b/base/glibc-compatibility/musl/expf.c
new file mode 100644
index 00000000000..0a59236d1c0
--- /dev/null
+++ b/base/glibc-compatibility/musl/expf.c
@@ -0,0 +1,81 @@
+/* origin: FreeBSD /usr/src/lib/msun/src/e_expf.c */
+/*
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include "libm.h"
+
+static const float
+    half[2] = {0.5,-0.5},
+    ln2hi   = 6.9314575195e-1f,  /* 0x3f317200 */
+    ln2lo   = 1.4286067653e-6f,  /* 0x35bfbe8e */
+    invln2  = 1.4426950216e+0f,  /* 0x3fb8aa3b */
+    /*
+ * Domain [-0.34568, 0.34568], range ~[-4.278e-9, 4.447e-9]:
+ * |x*(exp(x)+1)/(exp(x)-1) - p(x)| < 2**-27.74
+ */
+    P1 =  1.6666625440e-1f, /*  0xaaaa8f.0p-26 */
+    P2 = -2.7667332906e-3f; /* -0xb55215.0p-32 */
+
+float expf(float x)
+{
+    float_t hi, lo, c, xx, y;
+    int k, sign;
+    uint32_t hx;
+
+    GET_FLOAT_WORD(hx, x);
+    sign = hx >> 31;   /* sign bit of x */
+    hx &= 0x7fffffff;  /* high word of |x| */
+
+    /* special cases */
+    if (hx >= 0x42aeac50) {  /* if |x| >= -87.33655f or NaN */
+        if (hx >= 0x42b17218 && !sign) {  /* x >= 88.722839f */
+            /* overflow */
+            x *= 0x1p127f;
+            return x;
+        }
+        if (sign) {
+            /* underflow */
+            FORCE_EVAL(-0x1p-149f/x);
+            if (hx >= 0x42cff1b5)  /* x <= -103.972084f */
+                return 0;
+        }
+    }
+
+    /* argument reduction */
+    if (hx > 0x3eb17218) {  /* if |x| > 0.5 ln2 */
+        if (hx > 0x3f851592)  /* if |x| > 1.5 ln2 */
+            k = invln2*x + half[sign];
+        else
+            k = 1 - sign - sign;
+        hi = x - k*ln2hi;  /* k*ln2hi is exact here */
+        lo = k*ln2lo;
+        x = hi - lo;
+    } else if (hx > 0x39000000) {  /* |x| > 2**-14 */
+        k = 0;
+        hi = x;
+        lo = 0;
+    } else {
+        /* raise inexact */
+        FORCE_EVAL(0x1p127f + x);
+        return 1 + x;
+    }
+
+    /* x is now in primary range */
+    xx = x*x;
+    c = x - xx*(P1+xx*P2);
+    y = 1 + (x*c/(2-c) - lo + hi);
+    if (k == 0)
+        return y;
+    return scalbnf(y, k);
+}
\ No newline at end of file
diff --git a/base/glibc-compatibility/musl/scalbnf.c b/base/glibc-compatibility/musl/scalbnf.c
new file mode 100644
index 00000000000..cf56cacfb5f
--- /dev/null
+++ b/base/glibc-compatibility/musl/scalbnf.c
@@ -0,0 +1,31 @@
+#include <math.h>
+#include <stdint.h>
+
+float scalbnf(float x, int n)
+{
+    union {float f; uint32_t i;} u;
+    float_t y = x;
+
+    if (n > 127) {
+        y *= 0x1p127f;
+        n -= 127;
+        if (n > 127) {
+            y *= 0x1p127f;
+            n -= 127;
+            if (n > 127)
+                n = 127;
+        }
+    } else if (n < -126) {
+        y *= 0x1p-126f;
+        n += 126;
+        if (n < -126) {
+            y *= 0x1p-126f;
+            n += 126;
+            if (n < -126)
+                n = -126;
+        }
+    }
+    u.i = (uint32_t)(0x7f+n)<<23;
+    x = y * u.f;
+    return x;
+}

From 7ee6724ea5ae53bb9a9302d8201837818376f9ff Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Mon, 3 Apr 2023 19:23:29 +0000
Subject: [PATCH 53/80] Fix tests with explain and analyzer where names
 changed.

---
 ...02149_read_in_order_fixed_prefix.reference | 39 +++++++++++++++++++
 .../02149_read_in_order_fixed_prefix.sql      |  9 +++--
 .../02481_aggregation_in_order_plan.reference |  4 ++
 .../02481_aggregation_in_order_plan.sql       |  3 +-
 ...n_merge_tree_prewhere_row_policy.reference | 30 ++++++++++++++
 ...explain_merge_tree_prewhere_row_policy.sql |  3 +-
 6 files changed, 83 insertions(+), 5 deletions(-)

diff --git a/tests/queries/0_stateless/02149_read_in_order_fixed_prefix.reference b/tests/queries/0_stateless/02149_read_in_order_fixed_prefix.reference
index 71ca326f952..d1662cdeb81 100644
--- a/tests/queries/0_stateless/02149_read_in_order_fixed_prefix.reference
+++ b/tests/queries/0_stateless/02149_read_in_order_fixed_prefix.reference
@@ -66,6 +66,18 @@ ExpressionTransform
       ExpressionTransform
         (ReadFromMergeTree)
         MergeTreeInOrder 0 → 1
+(Expression)
+ExpressionTransform
+  (Limit)
+  Limit
+    (Sorting)
+      (Expression)
+      ExpressionTransform
+        (Expression)
+        ExpressionTransform
+          (ReadFromMergeTree)
+          ExpressionTransform
+            MergeTreeInOrder 0 → 1
 2020-10-11	0	0
 2020-10-11	0	10
 2020-10-11	0	20
@@ -82,6 +94,20 @@ ExpressionTransform
         ExpressionTransform
           (ReadFromMergeTree)
           MergeTreeInOrder 0 → 1
+(Expression)
+ExpressionTransform
+  (Limit)
+  Limit
+    (Sorting)
+    FinishSortingTransform
+      PartialSortingTransform
+        (Expression)
+        ExpressionTransform
+          (Expression)
+          ExpressionTransform
+            (ReadFromMergeTree)
+            ExpressionTransform
+              MergeTreeInOrder 0 → 1
 2020-10-12	0
 2020-10-12	1
 2020-10-12	2
@@ -104,6 +130,19 @@ ExpressionTransform
         (ReadFromMergeTree)
         ReverseTransform
           MergeTreeReverse 0 → 1
+(Expression)
+ExpressionTransform
+  (Limit)
+  Limit
+    (Sorting)
+      (Expression)
+      ExpressionTransform
+        (Expression)
+        ExpressionTransform
+          (ReadFromMergeTree)
+          ExpressionTransform
+            ReverseTransform
+              MergeTreeReverse 0 → 1
 2020-10-12	99999
 2020-10-12	99998
 2020-10-12	99997
diff --git a/tests/queries/0_stateless/02149_read_in_order_fixed_prefix.sql b/tests/queries/0_stateless/02149_read_in_order_fixed_prefix.sql
index f50aab67d77..5e662bd7842 100644
--- a/tests/queries/0_stateless/02149_read_in_order_fixed_prefix.sql
+++ b/tests/queries/0_stateless/02149_read_in_order_fixed_prefix.sql
@@ -21,17 +21,20 @@ SELECT toStartOfMonth(date) as d, i FROM t_read_in_order ORDER BY d, -i LIMIT 5;
 EXPLAIN PIPELINE SELECT toStartOfMonth(date) as d, i FROM t_read_in_order ORDER BY d, -i LIMIT 5;
 
 SELECT date, i FROM t_read_in_order WHERE date = '2020-10-11' ORDER BY i LIMIT 5;
-EXPLAIN PIPELINE SELECT date, i FROM t_read_in_order WHERE date = '2020-10-11' ORDER BY i LIMIT 5;
+EXPLAIN PIPELINE SELECT date, i FROM t_read_in_order WHERE date = '2020-10-11' ORDER BY i LIMIT 5 settings allow_experimental_analyzer=0;
+EXPLAIN PIPELINE SELECT date, i FROM t_read_in_order WHERE date = '2020-10-11' ORDER BY i LIMIT 5 settings allow_experimental_analyzer=1;
 
 SELECT * FROM t_read_in_order WHERE date = '2020-10-11' ORDER BY i, v LIMIT 5;
-EXPLAIN PIPELINE SELECT * FROM t_read_in_order WHERE date = '2020-10-11' ORDER BY i, v LIMIT 5;
+EXPLAIN PIPELINE SELECT * FROM t_read_in_order WHERE date = '2020-10-11' ORDER BY i, v LIMIT 5 settings allow_experimental_analyzer=0;
+EXPLAIN PIPELINE SELECT * FROM t_read_in_order WHERE date = '2020-10-11' ORDER BY i, v LIMIT 5 settings allow_experimental_analyzer=1;
 
 INSERT INTO t_read_in_order SELECT '2020-10-12', number, number FROM numbers(100000);
 
 SELECT date, i FROM t_read_in_order WHERE date = '2020-10-12' ORDER BY i LIMIT 5;
 
 EXPLAIN SYNTAX SELECT date, i FROM t_read_in_order WHERE date = '2020-10-12' ORDER BY i DESC LIMIT 5;
-EXPLAIN PIPELINE SELECT date, i FROM t_read_in_order WHERE date = '2020-10-12' ORDER BY i DESC LIMIT 5;
+EXPLAIN PIPELINE SELECT date, i FROM t_read_in_order WHERE date = '2020-10-12' ORDER BY i DESC LIMIT 5 settings allow_experimental_analyzer=0;
+EXPLAIN PIPELINE SELECT date, i FROM t_read_in_order WHERE date = '2020-10-12' ORDER BY i DESC LIMIT 5 settings allow_experimental_analyzer=1;
 SELECT date, i FROM t_read_in_order WHERE date = '2020-10-12' ORDER BY i DESC LIMIT 5;
 
 DROP TABLE IF EXISTS t_read_in_order;
diff --git a/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference b/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference
index d8b62435bfa..176b371478f 100644
--- a/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference
+++ b/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference
@@ -7,3 +7,7 @@
     Sorting (Stream): a ASC, b ASC, c ASC
       ReadFromMergeTree (default.tab)
       Sorting (Stream): a ASC, b ASC, c ASC
+  Aggregating
+  Order: default.tab.a_0 ASC, default.tab.c_2 ASC
+    Sorting (Stream): a ASC, b ASC, c ASC
+        ReadFromMergeTree (default.tab)
diff --git a/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql b/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql
index 9c99609ca46..40942954e0a 100644
--- a/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql
+++ b/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql
@@ -5,4 +5,5 @@ insert into tab select 0, number % 3, 2 - intDiv(number, 3), (number % 3 + 1) *
 insert into tab select 0, number % 3, 2 - intDiv(number, 3), (number % 3 + 1) * 100 from numbers(6);
 
 select a, any(b), c, d from tab where b = 1 group by a, c, d order by c, d settings optimize_aggregation_in_order=1, query_plan_aggregation_in_order=1;
-select * from (explain actions = 1, sorting=1 select a, any(b), c, d from tab where b = 1 group by a, c, d settings optimize_aggregation_in_order=1, query_plan_aggregation_in_order=1) where explain like '%Sorting (Stream)%' or explain like '%ReadFromMergeTree%' or explain like '%Aggregating%' or explain like '%Order:%';
+select * from (explain actions = 1, sorting=1 select a, any(b), c, d from tab where b = 1 group by a, c, d settings optimize_aggregation_in_order=1, query_plan_aggregation_in_order=1) where explain like '%Sorting (Stream)%' or explain like '%ReadFromMergeTree%' or explain like '%Aggregating%' or explain like '%Order:%' settings allow_experimental_analyzer=0;
+select * from (explain actions = 1, sorting=1 select a, any(b), c, d from tab where b = 1 group by a, c, d settings optimize_aggregation_in_order=1, query_plan_aggregation_in_order=1) where explain like '%Sorting (Stream)%' or explain like '%ReadFromMergeTree%' or explain like '%Aggregating%' or explain like '%Order:%' settings allow_experimental_analyzer=1;
diff --git a/tests/queries/0_stateless/02679_explain_merge_tree_prewhere_row_policy.reference b/tests/queries/0_stateless/02679_explain_merge_tree_prewhere_row_policy.reference
index 2f3b59e5530..2fe98ea1682 100644
--- a/tests/queries/0_stateless/02679_explain_merge_tree_prewhere_row_policy.reference
+++ b/tests/queries/0_stateless/02679_explain_merge_tree_prewhere_row_policy.reference
@@ -24,3 +24,33 @@ Positions: 0 1
              COLUMN Const(UInt8) -> 5 UInt8 : 1
              FUNCTION greaterOrEquals(id : 0, 5 :: 1) -> greaterOrEquals(id, 5) UInt8 : 2
     Positions: 2 0
+Expression ((Project names + (Projection + Change column names to column identifiers)))
+Header: id UInt64
+        value String
+Actions: INPUT : 0 -> id UInt64 : 0
+         INPUT : 1 -> value String : 1
+         ALIAS id :: 0 -> default.test_table.id_0 UInt64 : 2
+         ALIAS value :: 1 -> default.test_table.value_1 String : 0
+         ALIAS default.test_table.id_0 :: 2 -> id UInt64 : 1
+         ALIAS default.test_table.value_1 :: 0 -> value String : 2
+Positions: 1 2
+  ReadFromMergeTree (default.test_table)
+  Header: id UInt64
+          value String
+  ReadType: Default
+  Parts: 0
+  Granules: 0
+  Prewhere info
+  Need filter: 1
+    Prewhere filter
+    Prewhere filter column: equals(id, 5_UInt8) (removed)
+    Actions: INPUT : 0 -> id UInt64 : 0
+             COLUMN Const(UInt8) -> 5_UInt8 UInt8 : 1
+             FUNCTION equals(id : 0, 5_UInt8 :: 1) -> equals(id, 5_UInt8) UInt8 : 2
+    Positions: 2 0
+    Row level filter
+    Row level filter column: greaterOrEquals(id, 5_UInt8)
+    Actions: INPUT : 0 -> id UInt64 : 0
+             COLUMN Const(UInt8) -> 5_UInt8 UInt8 : 1
+             FUNCTION greaterOrEquals(id : 0, 5_UInt8 :: 1) -> greaterOrEquals(id, 5_UInt8) UInt8 : 2
+    Positions: 2 0
diff --git a/tests/queries/0_stateless/02679_explain_merge_tree_prewhere_row_policy.sql b/tests/queries/0_stateless/02679_explain_merge_tree_prewhere_row_policy.sql
index 8099ccc0b0d..4bc7be13490 100644
--- a/tests/queries/0_stateless/02679_explain_merge_tree_prewhere_row_policy.sql
+++ b/tests/queries/0_stateless/02679_explain_merge_tree_prewhere_row_policy.sql
@@ -10,7 +10,8 @@ INSERT INTO test_table VALUES (0, 'Value');
 DROP ROW POLICY IF EXISTS test_row_policy ON test_table;
 CREATE ROW POLICY test_row_policy ON test_table USING id >= 5 TO ALL;
 
-EXPLAIN header = 1, actions = 1 SELECT id, value FROM test_table PREWHERE id = 5;
+EXPLAIN header = 1, actions = 1 SELECT id, value FROM test_table PREWHERE id = 5 settings allow_experimental_analyzer=0;
+EXPLAIN header = 1, actions = 1 SELECT id, value FROM test_table PREWHERE id = 5 settings allow_experimental_analyzer=1;
 
 DROP ROW POLICY test_row_policy ON test_table;
 DROP TABLE test_table;

From 7df9b2d563bc65c950bb2c2ee579615046df3278 Mon Sep 17 00:00:00 2001
From: Robert Schulze <robert@clickhouse.com>
Date: Tue, 4 Apr 2023 07:39:19 +0000
Subject: [PATCH 54/80] Small follow-up to #45912

- clear query cache at the end of the tests to minimize interaction with
  other query cache tests

- generate data more elegantly
---
 .../02494_query_cache_compression.reference   | 1728 -----------------
 .../02494_query_cache_compression.sql         |  411 +---
 ...494_query_cache_squash_partial_results.sql |    2 +-
 3 files changed, 3 insertions(+), 2138 deletions(-)

diff --git a/tests/queries/0_stateless/02494_query_cache_compression.reference b/tests/queries/0_stateless/02494_query_cache_compression.reference
index 1d206bbc4d2..922ab65540a 100644
--- a/tests/queries/0_stateless/02494_query_cache_compression.reference
+++ b/tests/queries/0_stateless/02494_query_cache_compression.reference
@@ -599,222 +599,6 @@ abc
 abc
 abc
 abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
 def
 def
 def
@@ -1115,222 +899,6 @@ def
 def
 def
 def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
 jkl
 jkl
 jkl
@@ -2232,222 +1800,6 @@ abc
 abc
 abc
 abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
 def
 def
 def
@@ -2748,222 +2100,6 @@ def
 def
 def
 def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
 jkl
 jkl
 jkl
@@ -3865,222 +3001,6 @@ abc
 abc
 abc
 abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
 def
 def
 def
@@ -4381,222 +3301,6 @@ def
 def
 def
 def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
 jkl
 jkl
 jkl
@@ -5498,222 +4202,6 @@ abc
 abc
 abc
 abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
-abc
 def
 def
 def
@@ -6014,222 +4502,6 @@ def
 def
 def
 def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-def
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
-jkl
 jkl
 jkl
 jkl
diff --git a/tests/queries/0_stateless/02494_query_cache_compression.sql b/tests/queries/0_stateless/02494_query_cache_compression.sql
index 0f527dfde5e..619ae7d5cd8 100644
--- a/tests/queries/0_stateless/02494_query_cache_compression.sql
+++ b/tests/queries/0_stateless/02494_query_cache_compression.sql
@@ -4,419 +4,11 @@
 SET allow_experimental_query_cache = true;
 
 SYSTEM DROP QUERY CACHE;
-
 DROP TABLE IF EXISTS t;
 
 -- Create test table with lot's of rows
 CREATE TABLE t(c String) ENGINE=MergeTree ORDER BY c;
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
-INSERT INTO t values ('abc') ('def') ('abc') ('jkl');
+INSERT INTO t SELECT multiIf(n = 0, 'abc', n = 1, 'def', n = 2, 'abc', n = 3, 'jkl', '<unused>') FROM (SELECT number % 4 AS n FROM numbers(1200));
 OPTIMIZE TABLE t FINAL;
 
 -- Run query which, store *compressed* result in query cache
@@ -442,3 +34,4 @@ SELECT * FROM t ORDER BY c
 SETTINGS use_query_cache = true;
 
 DROP TABLE t;
+SYSTEM DROP QUERY CACHE;
diff --git a/tests/queries/0_stateless/02494_query_cache_squash_partial_results.sql b/tests/queries/0_stateless/02494_query_cache_squash_partial_results.sql
index d57773b51f8..d18f6d57ff0 100644
--- a/tests/queries/0_stateless/02494_query_cache_squash_partial_results.sql
+++ b/tests/queries/0_stateless/02494_query_cache_squash_partial_results.sql
@@ -4,7 +4,6 @@
 SET allow_experimental_query_cache = true;
 
 SYSTEM DROP QUERY CACHE;
-
 DROP TABLE IF EXISTS t;
 
 -- Create test table with "many" rows
@@ -51,3 +50,4 @@ SELECT * FROM t ORDER BY c
 SETTINGS max_block_size = 2, use_query_cache = true;
 
 DROP TABLE t;
+SYSTEM DROP QUERY CACHE;

From 779bd3bf4dab092e083e0add155f2cf8e3355fa8 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 11:27:02 +0100
Subject: [PATCH 55/80] move hilite comparator tests as well

---
 .../Parsers/HiliteComparator}/gtest_hilite_comparator.cpp       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename {utils/hilite_comparator => src/Parsers/HiliteComparator}/gtest_hilite_comparator.cpp (97%)

diff --git a/utils/hilite_comparator/gtest_hilite_comparator.cpp b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
similarity index 97%
rename from utils/hilite_comparator/gtest_hilite_comparator.cpp
rename to src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
index 51ea92344e1..9a0bc01943f 100644
--- a/utils/hilite_comparator/gtest_hilite_comparator.cpp
+++ b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <Parsers/IAST.h>
-#include <utils/hilite_comparator/HiliteComparator.h>
+#include <Parsers/HiliteComparator/HiliteComparator.h>
 
 
 TEST(FormatHiliting, MetaTestConsumeHilites)

From 141feffa3b760bea6ed1b303c68ff2cb605a0db1 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Tue, 4 Apr 2023 10:33:06 +0000
Subject: [PATCH 56/80] Fixing test.

---
 .../0_stateless/02481_aggregation_in_order_plan.reference     | 3 ---
 tests/queries/0_stateless/02481_aggregation_in_order_plan.sql | 4 ++--
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference b/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference
index 176b371478f..bb4eb4ddd75 100644
--- a/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference
+++ b/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference
@@ -4,10 +4,7 @@
 0	1	2	200
   Aggregating
   Order: a ASC, c ASC
-    Sorting (Stream): a ASC, b ASC, c ASC
       ReadFromMergeTree (default.tab)
-      Sorting (Stream): a ASC, b ASC, c ASC
   Aggregating
   Order: default.tab.a_0 ASC, default.tab.c_2 ASC
-    Sorting (Stream): a ASC, b ASC, c ASC
         ReadFromMergeTree (default.tab)
diff --git a/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql b/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql
index 40942954e0a..490060dee6f 100644
--- a/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql
+++ b/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql
@@ -5,5 +5,5 @@ insert into tab select 0, number % 3, 2 - intDiv(number, 3), (number % 3 + 1) *
 insert into tab select 0, number % 3, 2 - intDiv(number, 3), (number % 3 + 1) * 100 from numbers(6);
 
 select a, any(b), c, d from tab where b = 1 group by a, c, d order by c, d settings optimize_aggregation_in_order=1, query_plan_aggregation_in_order=1;
-select * from (explain actions = 1, sorting=1 select a, any(b), c, d from tab where b = 1 group by a, c, d settings optimize_aggregation_in_order=1, query_plan_aggregation_in_order=1) where explain like '%Sorting (Stream)%' or explain like '%ReadFromMergeTree%' or explain like '%Aggregating%' or explain like '%Order:%' settings allow_experimental_analyzer=0;
-select * from (explain actions = 1, sorting=1 select a, any(b), c, d from tab where b = 1 group by a, c, d settings optimize_aggregation_in_order=1, query_plan_aggregation_in_order=1) where explain like '%Sorting (Stream)%' or explain like '%ReadFromMergeTree%' or explain like '%Aggregating%' or explain like '%Order:%' settings allow_experimental_analyzer=1;
+select * from (explain actions = 1, sorting=1 select a, any(b), c, d from tab where b = 1 group by a, c, d settings optimize_aggregation_in_order=1, query_plan_aggregation_in_order=1) where explain like '%ReadFromMergeTree%' or explain like '%Aggregating%' or explain like '%Order:%' settings allow_experimental_analyzer=0;
+select * from (explain actions = 1, sorting=1 select a, any(b), c, d from tab where b = 1 group by a, c, d settings optimize_aggregation_in_order=1, query_plan_aggregation_in_order=1) where explain like '%ReadFromMergeTree%' or explain like '%Aggregating%' or explain like '%Order:%' settings allow_experimental_analyzer=1;

From 880e44132f4c62c51a61fb8d7b2a7cc717afb22d Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 12:36:22 +0100
Subject: [PATCH 57/80] fix hilite comparator tests

---
 src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
index 9a0bc01943f..72829596091 100644
--- a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
+++ b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
@@ -2,6 +2,7 @@
 #include <Parsers/IAST.h>
 #include <Parsers/HiliteComparator/HiliteComparator.h>
 
+using namespace HiliteComparator;
 
 TEST(FormatHiliting, MetaTestConsumeHilites)
 {
@@ -86,4 +87,4 @@ TEST(FormatHiliting, MetaTestAreEqualWithHilites)
         right += "long";
         ASSERT_PRED2(are_equal_with_hilites, left, right);
     }
-}
\ No newline at end of file
+}

From 3452e1927e652edc04dcebf67cfaa0b6907c2880 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 12:36:41 +0100
Subject: [PATCH 58/80] move const var definition in HiliteComparator

---
 src/Parsers/HiliteComparator/HiliteComparator.cpp | 11 -----------
 src/Parsers/HiliteComparator/HiliteComparator.h   | 11 +++++++++++
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/Parsers/HiliteComparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.cpp
index 38788d76bb9..03e60b4bc53 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -2,17 +2,6 @@
 
 namespace HiliteComparator {
 
-std::vector<const char *> HILITES =
-    {
-        DB::IAST::hilite_keyword,
-        DB::IAST::hilite_identifier,
-        DB::IAST::hilite_function,
-        DB::IAST::hilite_operator,
-        DB::IAST::hilite_alias,
-        DB::IAST::hilite_substitution,
-        DB::IAST::hilite_none
-};
-
 [[maybe_unused]] const char * consume_hilites(const char ** ptr_ptr)
 {
     const char * last_hilite = nullptr;
diff --git a/src/Parsers/HiliteComparator/HiliteComparator.h b/src/Parsers/HiliteComparator/HiliteComparator.h
index 78d2edacc59..1ced56364dd 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.h
+++ b/src/Parsers/HiliteComparator/HiliteComparator.h
@@ -5,6 +5,17 @@
 
 namespace HiliteComparator {
 
+const std::vector<const char *> HILITES =
+    {
+        DB::IAST::hilite_keyword,
+        DB::IAST::hilite_identifier,
+        DB::IAST::hilite_function,
+        DB::IAST::hilite_operator,
+        DB::IAST::hilite_alias,
+        DB::IAST::hilite_substitution,
+        DB::IAST::hilite_none
+};
+
 [[maybe_unused]] const char * consume_hilites(const char ** ptr_ptr);
 
 String remove_hilites(std::string_view string);

From 3e11c06976cf8e73dfa4ec201c455fb4fc646e2f Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 12:41:08 +0100
Subject: [PATCH 59/80] extract HiliteComparator tests into an own test suit

---
 src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
index 72829596091..b9bc9cafaf3 100644
--- a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
+++ b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
@@ -4,7 +4,7 @@
 
 using namespace HiliteComparator;
 
-TEST(FormatHiliting, MetaTestConsumeHilites)
+TEST(HiliteComparator, ConsumeHilites)
 {
     using namespace DB;
     // The order is different from the order in HILITES on purpose.
@@ -26,7 +26,7 @@ TEST(FormatHiliting, MetaTestConsumeHilites)
     ASSERT_EQ(IAST::hilite_function, last_hilite);
 }
 
-TEST(FormatHiliting, MetaTestRemoveHilites)
+TEST(HiliteComparator, RemoveHilites)
 {
     using namespace DB;
     String s;
@@ -43,7 +43,7 @@ TEST(FormatHiliting, MetaTestRemoveHilites)
     ASSERT_EQ("test", remove_hilites(s));
 }
 
-TEST(FormatHiliting, MetaTestAreEqualWithHilites)
+TEST(HiliteComparator, AreEqualWithHilites)
 {
     using namespace DB;
     ASSERT_PRED2(are_equal_with_hilites, "", "");

From 7aef9bb65ed777cc4a3c9281a000d7f8a652f2ee Mon Sep 17 00:00:00 2001
From: Dan Roscigno <dan@roscigno.com>
Date: Tue, 4 Apr 2023 08:41:58 -0400
Subject: [PATCH 60/80] Clarify SYSTEM RELOAD CONFIG and USERS

closes #48201
---
 docs/en/sql-reference/statements/system.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/en/sql-reference/statements/system.md b/docs/en/sql-reference/statements/system.md
index fbd7c31a098..8c4b07333be 100644
--- a/docs/en/sql-reference/statements/system.md
+++ b/docs/en/sql-reference/statements/system.md
@@ -114,11 +114,11 @@ This will also create system tables even if message queue is empty.
 
 ## RELOAD CONFIG
 
-Reloads ClickHouse configuration. Used when configuration is stored in ZooKeeper.
+Reloads ClickHouse configuration. Used when configuration is stored in ZooKeeper. Note that `SYSTEM RELOAD CONFIG` does not reload `USER` configuration stored in ZooKeeper, it only reloads `USER` configuration that is stored in `users.xml`.  To reload all `USER` config use `SYSTEM RELOAD USERS`
 
 ## RELOAD USERS
 
-Reloads all access storages, including: users.xml, local disk access storage, replicated (in ZooKeeper) access storage. Note that `SYSTEM RELOAD CONFIG` will only reload users.xml access storage.
+Reloads all access storages, including: users.xml, local disk access storage, replicated (in ZooKeeper) access storage. 
 
 ## SHUTDOWN
 

From a164adc0b4eb32b88b05f6089f74e9f993a19636 Mon Sep 17 00:00:00 2001
From: Antonio Andelic <antonio@clickhouse.com>
Date: Tue, 4 Apr 2023 12:56:39 +0000
Subject: [PATCH 61/80] less flaky test_keeper_mntr_data_size

---
 .../configs/enable_keeper.xml                 |  1 +
 .../test_keeper_mntr_data_size/test.py        | 31 +++++++++++++------
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/tests/integration/test_keeper_mntr_data_size/configs/enable_keeper.xml b/tests/integration/test_keeper_mntr_data_size/configs/enable_keeper.xml
index a3217b34501..519154e835b 100644
--- a/tests/integration/test_keeper_mntr_data_size/configs/enable_keeper.xml
+++ b/tests/integration/test_keeper_mntr_data_size/configs/enable_keeper.xml
@@ -1,5 +1,6 @@
 <clickhouse>
     <keeper_server>
+        <use_cluster>false</use_cluster>
         <tcp_port>9181</tcp_port>
         <server_id>1</server_id>
         <log_storage_path>/var/lib/clickhouse/coordination/log</log_storage_path>
diff --git a/tests/integration/test_keeper_mntr_data_size/test.py b/tests/integration/test_keeper_mntr_data_size/test.py
index ad6e5f02af7..68fb25f0cbe 100644
--- a/tests/integration/test_keeper_mntr_data_size/test.py
+++ b/tests/integration/test_keeper_mntr_data_size/test.py
@@ -61,28 +61,39 @@ def test_mntr_data_size_after_restart(started_cluster):
         node_zk.close()
         node_zk = None
 
-        def get_line_from_mntr(key):
+        def get_line_from_mntr(mntr_str, key):
             return next(
                 filter(
                     lambda line: key in line,
-                    keeper_utils.send_4lw_cmd(started_cluster, node, "mntr").split(
-                        "\n"
-                    ),
+                    mntr_str.split("\n"),
                 ),
                 None,
             )
 
-        line_size_before = get_line_from_mntr("zk_approximate_data_size")
-        node_count_before = get_line_from_mntr("zk_znode_count")
-        assert get_line_from_mntr("zk_ephemerals_count") == "zk_ephemerals_count\t0"
+        mntr_result = keeper_utils.send_4lw_cmd(started_cluster, node, "mntr")
+        line_size_before = get_line_from_mntr(mntr_result, "zk_approximate_data_size")
+        node_count_before = get_line_from_mntr(mntr_result, "zk_znode_count")
+        assert (
+            get_line_from_mntr(mntr_result, "zk_ephemerals_count")
+            == "zk_ephemerals_count\t0"
+        )
         assert line_size_before != None
 
         restart_clickhouse()
 
         def assert_mntr_stats():
-            assert get_line_from_mntr("zk_ephemerals_count") == "zk_ephemerals_count\t0"
-            assert get_line_from_mntr("zk_znode_count") == node_count_before
-            assert get_line_from_mntr("zk_approximate_data_size") == line_size_before
+            mntr_result = keeper_utils.send_4lw_cmd(started_cluster, node, "mntr")
+            assert (
+                get_line_from_mntr(mntr_result, "zk_ephemerals_count")
+                == "zk_ephemerals_count\t0"
+            )
+            assert (
+                get_line_from_mntr(mntr_result, "zk_znode_count") == node_count_before
+            )
+            assert (
+                get_line_from_mntr(mntr_result, "zk_approximate_data_size")
+                == line_size_before
+            )
 
         assert_mntr_stats()
         keeper_utils.send_4lw_cmd(started_cluster, node, "rclc")

From ebb8899a3dbd06262839fb4e44dcfb07d931b443 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 14:19:06 +0100
Subject: [PATCH 62/80] restructure format hiliting tests to avoid code
 duplication

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 125 +++++++++-----------
 1 file changed, 56 insertions(+), 69 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 2f2ea4f40a8..5194e1b6049 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -59,90 +59,77 @@ void compare(const String & query, const String & expected)
     ASSERT_PRED2(HiliteComparator::are_equal_with_hilites, expected, write_buffer.str());
 }
 
-TEST(FormatHiliting, SimpleSelect)
-{
-    String query = "select * from table";
+const std::vector<std::pair<std::string, std::string>> expected_and_query_pairs = {
+    // Simple select
+    {
+        keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table"),
+     "select * from table"
+    },
 
-    String expected = keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table");
+    // ASTWithElement
+    {
+        keyword("WITH ") + alias("alias ") + keyword("AS ")
+            + "(" + keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table") + ") "
+            + keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table"),
+        "with alias as (select * from table) select * from table"
+    },
 
-    compare(query, expected);
-}
+    // ASTWithAlias
+    {
+        keyword("SELECT ") + identifier("a ") + op("+ ") + "1 " + keyword("AS ") + alias("b") + ", " + identifier("b"),
+        "select a + 1 as b, b"
+    },
 
-TEST(FormatHiliting, ASTWithElement)
-{
-    String query = "with alias as (select * from table) select * from table";
+    // ASTFunction
+    {
+        keyword("SELECT ") + "* " + keyword("FROM ")
+            + function("view(") + keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table") + function(")"),
+        "select * from view(select * from table)"
+    },
 
-    String expected = keyword("WITH ") + alias("alias ") + keyword("AS ")
-             + "(" + keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table") + ") "
-             + keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table");
-
-    compare(query, expected);
-}
-
-TEST(FormatHiliting, ASTWithAlias)
-{
-    String query = "select a + 1 as b, b";
-
-    String expected = keyword("SELECT ") + identifier("a ") + op("+ ") + "1 " + keyword("AS ") + alias("b") + ", " + identifier("b");
-
-    compare(query, expected);
-}
-
-TEST(FormatHiliting, ASTFunction)
-{
-    String query = "select * from view(select * from table)";
-
-    String expected = keyword("SELECT ") + "* " + keyword("FROM ")
-            + function("view(") + keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table") + function(")");
-
-    compare(query, expected);
-}
-
-TEST(FormatHiliting, ASTDictionaryAttributeDeclaration)
-{
-    String query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID)";
-
-    String expected = keyword("CREATE DICTIONARY ") + "name "
+    // ASTDictionaryAttributeDeclaration
+    {
+        keyword("CREATE DICTIONARY ") + "name "
             + "(`Name` " + function("ClickHouseDataType ")
             + keyword("DEFAULT ") + "'' "
             + keyword("EXPRESSION ") + function("rand64() ")
-            + keyword("IS_OBJECT_ID") + ")";
+            + keyword("IS_OBJECT_ID") + ")",
+        "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID)"
+    },
 
-    compare(query, expected);
-}
-
-TEST(FormatHiliting, ASTDictionaryClassSourceKeyword)
-{
-    String query = "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID) "
-                        "SOURCE(FILE(PATH 'path'))";
-
-    String expected = keyword("CREATE DICTIONARY ") + "name "
+    // ASTDictionary, SOURCE keyword
+    {
+        keyword("CREATE DICTIONARY ") + "name "
             + "(`Name` " + function("ClickHouseDataType ")
             + keyword("DEFAULT ") + "'' "
             + keyword("EXPRESSION ") + function("rand64() ")
             + keyword("IS_OBJECT_ID") + ") "
-            + keyword("SOURCE") + "(" + keyword("FILE") + "(" + keyword("PATH ") + "'path'))";
+            + keyword("SOURCE") + "(" + keyword("FILE") + "(" + keyword("PATH ") + "'path'))",
+        "CREATE DICTIONARY name (`Name` ClickHouseDataType DEFAULT '' EXPRESSION rand64() IS_OBJECT_ID) "
+        "SOURCE(FILE(PATH 'path'))"
+    },
 
-    compare(query, expected);
-}
-
-TEST(FormatHiliting, ASTKillQueryQuery)
-{
-    String query = "KILL QUERY ON CLUSTER clustername WHERE user = 'username' SYNC";
-
-    String expected = keyword("KILL QUERY ON CLUSTER ") + "clustername "
+    // ASTKillQueryQuery
+    {
+        keyword("KILL QUERY ON CLUSTER ") + "clustername "
             + keyword("WHERE ") + identifier("user ") + op("= ") + "'username' "
-            + keyword("SYNC");
+            + keyword("SYNC"),
+        "KILL QUERY ON CLUSTER clustername WHERE user = 'username' SYNC"
+    },
 
-    compare(query, expected);
-}
+    // ASTCreateQuery
+    {
+        keyword("CREATE TABLE ") + "name " + keyword("AS (SELECT ") + "*" + keyword(") ")
+            + keyword("COMMENT ") + "'hello'",
+        "CREATE TABLE name AS (SELECT *) COMMENT 'hello'"
+    },
+};
 
-TEST(FormatHiliting, ASTCreateQuery)
+
+TEST(FormatHiliting, Queries)
 {
-    String query = "CREATE TABLE name AS (SELECT *) COMMENT 'hello'";
-
-    String expected = keyword("CREATE TABLE ") + "name " + keyword("AS (SELECT ") + "*" + keyword(") ")
-            + keyword("COMMENT ") + "'hello'";
-
-    compare(query, expected);
+    for (const auto & [expected, query] : expected_and_query_pairs)
+    {
+        compare(query, expected);
+    }
 }

From 2ff5d60509eb3ec277a153b4314078582c3c5f22 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 14:20:13 +0100
Subject: [PATCH 63/80] change compare argument order to be expected, query
 (=actual)

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 5194e1b6049..77849072131 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -44,7 +44,7 @@ String substitution(const String & s)
 }
 
 
-void compare(const String & query, const String & expected)
+void compare(const String & expected, const String & query)
 {
     using namespace DB;
     ParserQuery parser(query.data() + query.size());
@@ -130,6 +130,6 @@ TEST(FormatHiliting, Queries)
 {
     for (const auto & [expected, query] : expected_and_query_pairs)
     {
-        compare(query, expected);
+        compare(expected, query);
     }
 }

From 86edd4809658c0fd057760c2e935df8849a7da0c Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 14:29:02 +0100
Subject: [PATCH 64/80] HiliteComparator: add Hilite alias for const char *
 representing hilites

---
 src/Parsers/HiliteComparator/HiliteComparator.cpp | 12 +++++++-----
 src/Parsers/HiliteComparator/HiliteComparator.h   |  6 ++++--
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/Parsers/HiliteComparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.cpp
index 03e60b4bc53..43abb3e4441 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -2,13 +2,13 @@
 
 namespace HiliteComparator {
 
-[[maybe_unused]] const char * consume_hilites(const char ** ptr_ptr)
+[[maybe_unused]] Hilite consume_hilites(const char ** ptr_ptr)
 {
     const char * last_hilite = nullptr;
     while (true)
     {
         bool changed_hilite = false;
-        for (const char * hilite : HILITES)
+        for (Hilite hilite : HILITES)
         {
             if (std::string_view(*ptr_ptr).starts_with(hilite))
             {
@@ -55,13 +55,15 @@ bool are_equal_with_hilites(std::string_view left, std::string_view right)
 
     const char * left_it = left.begin();
     const char * right_it = right.begin();
-    const char * left_hilite = DB::IAST::hilite_none;
-    const char * right_hilite = DB::IAST::hilite_none;
+    Hilite left_hilite = DB::IAST::hilite_none;
+    Hilite right_hilite = DB::IAST::hilite_none;
 
     while (true)
     {
         // Consume all prefix hilites, update the current hilite to be the last one.
-        const char * last_hilite = consume_hilites(&left_it);
+        Hilite last_hilite;
+
+        last_hilite = consume_hilites(&left_it);
         if (last_hilite != nullptr)
             left_hilite = last_hilite;
 
diff --git a/src/Parsers/HiliteComparator/HiliteComparator.h b/src/Parsers/HiliteComparator/HiliteComparator.h
index 1ced56364dd..e9e2aa0fe0d 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.h
+++ b/src/Parsers/HiliteComparator/HiliteComparator.h
@@ -5,7 +5,9 @@
 
 namespace HiliteComparator {
 
-const std::vector<const char *> HILITES =
+using Hilite = const char *;
+
+const std::vector<Hilite> HILITES =
     {
         DB::IAST::hilite_keyword,
         DB::IAST::hilite_identifier,
@@ -16,7 +18,7 @@ const std::vector<const char *> HILITES =
         DB::IAST::hilite_none
 };
 
-[[maybe_unused]] const char * consume_hilites(const char ** ptr_ptr);
+[[maybe_unused]] Hilite consume_hilites(const char ** ptr_ptr);
 
 String remove_hilites(std::string_view string);
 

From 2e9607f9c1c5ea2f50ebb636b69bb4c1de16e8bd Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 14:33:50 +0100
Subject: [PATCH 65/80] Fix style

---
 src/Parsers/HiliteComparator/HiliteComparator.cpp | 3 ++-
 src/Parsers/HiliteComparator/HiliteComparator.h   | 8 ++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/Parsers/HiliteComparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.cpp
index 43abb3e4441..93afef8aa82 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -1,6 +1,7 @@
 #include "HiliteComparator.h"
 
-namespace HiliteComparator {
+namespace HiliteComparator
+{
 
 [[maybe_unused]] Hilite consume_hilites(const char ** ptr_ptr)
 {
diff --git a/src/Parsers/HiliteComparator/HiliteComparator.h b/src/Parsers/HiliteComparator/HiliteComparator.h
index e9e2aa0fe0d..27e651d193a 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.h
+++ b/src/Parsers/HiliteComparator/HiliteComparator.h
@@ -3,12 +3,12 @@
 #include <Parsers/IAST.h>
 
 
-namespace HiliteComparator {
+namespace HiliteComparator
+{
 
 using Hilite = const char *;
 
-const std::vector<Hilite> HILITES =
-    {
+const std::vector<Hilite> HILITES = {
         DB::IAST::hilite_keyword,
         DB::IAST::hilite_identifier,
         DB::IAST::hilite_function,
@@ -16,7 +16,7 @@ const std::vector<Hilite> HILITES =
         DB::IAST::hilite_alias,
         DB::IAST::hilite_substitution,
         DB::IAST::hilite_none
-};
+    };
 
 [[maybe_unused]] Hilite consume_hilites(const char ** ptr_ptr);
 

From 4894f47d95f87a4628165eb5f9e810e3ab3256e9 Mon Sep 17 00:00:00 2001
From: avogar <avogar@clickhouse.com>
Date: Tue, 4 Apr 2023 13:34:02 +0000
Subject: [PATCH 66/80] Fix tests

---
 src/Formats/CapnProtoUtils.cpp                          | 6 +++---
 src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp | 5 ++++-
 tests/queries/0_stateless/02030_capnp_format.reference  | 1 -
 tests/queries/0_stateless/02030_capnp_format.sh         | 2 --
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/Formats/CapnProtoUtils.cpp b/src/Formats/CapnProtoUtils.cpp
index 78bc90e001e..d6c032408bb 100644
--- a/src/Formats/CapnProtoUtils.cpp
+++ b/src/Formats/CapnProtoUtils.cpp
@@ -265,7 +265,7 @@ static bool checkTupleType(const capnp::Type & capnp_type, const DataTypePtr & d
         return false;
     }
 
-    bool have_explicit_names = false;
+    bool have_explicit_names = tuple_data_type->haveExplicitNames();
     const auto & nested_names = tuple_data_type->getElementNames();
     for (uint32_t i = 0; i != nested_names.size(); ++i)
     {
@@ -414,10 +414,10 @@ static bool checkCapnProtoType(const capnp::Type & capnp_type, const DataTypePtr
             return capnp_type.isUInt32();
         case TypeIndex::Date32: [[fallthrough]];
         case TypeIndex::Decimal32:
-            return capnp_type.isInt32();
+            return capnp_type.isInt32() || capnp_type.isUInt32();
         case TypeIndex::DateTime64: [[fallthrough]];
         case TypeIndex::Decimal64:
-            return capnp_type.isUInt64();
+            return capnp_type.isInt64() || capnp_type.isUInt64();
         case TypeIndex::Float32:[[fallthrough]];
         case TypeIndex::Float64:
             /// Allow converting between Float32 and isFloat64
diff --git a/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp b/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
index 84ea27618d0..2f84e9bde3c 100644
--- a/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
+++ b/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
@@ -106,6 +106,9 @@ static void insertInteger(IColumn & column, const DataTypePtr & column_type, UIn
         case TypeIndex::UInt32:
             assert_cast<ColumnUInt32 &>(column).insertValue(static_cast<UInt32>(value));
             break;
+        case TypeIndex::IPv4:
+            assert_cast<ColumnIPv4 &>(column).insertValue(IPv4(static_cast<UInt32>(value)));
+            break;
         case TypeIndex::Int64:
             assert_cast<ColumnInt64 &>(column).insertValue(value);
             break;
@@ -122,7 +125,7 @@ static void insertInteger(IColumn & column, const DataTypePtr & column_type, UIn
             assert_cast<ColumnDecimal<Decimal64> &>(column).insertValue(value);
             break;
         default:
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Column type is not a signed integer.");
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Column type {} cannot be parsed from integer", column_type->getName());
     }
 }
 
diff --git a/tests/queries/0_stateless/02030_capnp_format.reference b/tests/queries/0_stateless/02030_capnp_format.reference
index 8c3c81b5bc3..2b2307bfc6a 100644
--- a/tests/queries/0_stateless/02030_capnp_format.reference
+++ b/tests/queries/0_stateless/02030_capnp_format.reference
@@ -50,4 +50,3 @@ OK
 OK
 OK
 OK
-OK
diff --git a/tests/queries/0_stateless/02030_capnp_format.sh b/tests/queries/0_stateless/02030_capnp_format.sh
index cdc1587bccd..c15d6fe442e 100755
--- a/tests/queries/0_stateless/02030_capnp_format.sh
+++ b/tests/queries/0_stateless/02030_capnp_format.sh
@@ -109,8 +109,6 @@ $CLICKHOUSE_CLIENT --query="SELECT * FROM file('data.capnp', 'CapnProto', 'uint6
 $CLICKHOUSE_CLIENT --query="SELECT * FROM file('data.capnp', 'CapnProto', 'uint64 Enum(\'one\' = 1)') SETTINGS format_schema='$SERVER_SCHEMADIR/02030_capnp_simple_types:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
 $CLICKHOUSE_CLIENT --query="SELECT * FROM file('data.capnp', 'CapnProto', 'uint64 Tuple(UInt64)') SETTINGS format_schema='$SERVER_SCHEMADIR/02030_capnp_simple_types:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
 $CLICKHOUSE_CLIENT --query="SELECT * FROM file('data.capnp', 'CapnProto', 'uint64 Nullable(UInt64)') SETTINGS format_schema='$SERVER_SCHEMADIR/02030_capnp_simple_types:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
-$CLICKHOUSE_CLIENT --query="SELECT * FROM file('data.capnp', 'CapnProto', 'uint64 Int32') SETTINGS format_schema='$SERVER_SCHEMADIR/02030_capnp_simple_types:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
-
 
 $CLICKHOUSE_CLIENT --query="SELECT number AS a, toString(number) as b FROM numbers(5) FORMAT CapnProto SETTINGS format_schema='$CLIENT_SCHEMADIR/02030_capnp_unnamed_union:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
 $CLICKHOUSE_CLIENT --query="SELECT toNullable(toString(number)) as nullable1 FROM numbers(5) FORMAT CapnProto SETTINGS format_schema='$CLIENT_SCHEMADIR/02030_capnp_fake_nullable:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';

From f3560a295dd044f52f43a908956cc4a439468060 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 14:39:03 +0100
Subject: [PATCH 67/80] accept the pointer by & in consume_hilites, rather than
 by a pointer to the pointer

---
 src/Parsers/HiliteComparator/HiliteComparator.cpp    | 12 ++++++------
 src/Parsers/HiliteComparator/HiliteComparator.h      |  2 +-
 .../HiliteComparator/gtest_hilite_comparator.cpp     |  2 +-
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/Parsers/HiliteComparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.cpp
index 93afef8aa82..b256a625a22 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -3,7 +3,7 @@
 namespace HiliteComparator
 {
 
-[[maybe_unused]] Hilite consume_hilites(const char ** ptr_ptr)
+[[maybe_unused]] Hilite consume_hilites(const char * & ptr)
 {
     const char * last_hilite = nullptr;
     while (true)
@@ -11,9 +11,9 @@ namespace HiliteComparator
         bool changed_hilite = false;
         for (Hilite hilite : HILITES)
         {
-            if (std::string_view(*ptr_ptr).starts_with(hilite))
+            if (std::string_view(ptr).starts_with(hilite))
             {
-                *ptr_ptr += strlen(hilite);
+                ptr += strlen(hilite);
                 changed_hilite = true;
                 last_hilite = hilite;
             }
@@ -35,7 +35,7 @@ String remove_hilites(std::string_view string)
     String string_without_hilites;
     while (true)
     {
-        consume_hilites(&ptr);
+        consume_hilites(ptr);
         if (ptr == string.end())
             return string_without_hilites;
         string_without_hilites += *(ptr++);
@@ -64,11 +64,11 @@ bool are_equal_with_hilites(std::string_view left, std::string_view right)
         // Consume all prefix hilites, update the current hilite to be the last one.
         Hilite last_hilite;
 
-        last_hilite = consume_hilites(&left_it);
+        last_hilite = consume_hilites(left_it);
         if (last_hilite != nullptr)
             left_hilite = last_hilite;
 
-        last_hilite = consume_hilites(&right_it);
+        last_hilite = consume_hilites(right_it);
         if (last_hilite != nullptr)
             right_hilite = last_hilite;
 
diff --git a/src/Parsers/HiliteComparator/HiliteComparator.h b/src/Parsers/HiliteComparator/HiliteComparator.h
index 27e651d193a..9b47acc3cd4 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.h
+++ b/src/Parsers/HiliteComparator/HiliteComparator.h
@@ -18,7 +18,7 @@ const std::vector<Hilite> HILITES = {
         DB::IAST::hilite_none
     };
 
-[[maybe_unused]] Hilite consume_hilites(const char ** ptr_ptr);
+[[maybe_unused]] Hilite consume_hilites(const char * & ptr);
 
 String remove_hilites(std::string_view string);
 
diff --git a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
index b9bc9cafaf3..f4ee3b271d8 100644
--- a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
+++ b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
@@ -20,7 +20,7 @@ TEST(HiliteComparator, ConsumeHilites)
     s += IAST::hilite_keyword;
     const char * ptr = s.c_str();
     const char * expected_ptr = strchr(ptr, 't');
-    const char * last_hilite = consume_hilites(&ptr);
+    const char * last_hilite = consume_hilites(ptr);
     ASSERT_EQ(expected_ptr, ptr);
     ASSERT_TRUE(last_hilite != nullptr);
     ASSERT_EQ(IAST::hilite_function, last_hilite);

From 0a021d33780e63510cdc0abc3ff6907ab3c6729e Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 14:58:39 +0100
Subject: [PATCH 68/80] refactor consume_hilites to assign last_hilite to an
 argument, rather than return it, to avoid code duplication in
 are_equal_with_hilites

---
 .../HiliteComparator/HiliteComparator.cpp     | 26 ++++++-------------
 .../HiliteComparator/HiliteComparator.h       |  2 +-
 .../gtest_hilite_comparator.cpp               |  3 ++-
 3 files changed, 11 insertions(+), 20 deletions(-)

diff --git a/src/Parsers/HiliteComparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.cpp
index b256a625a22..88790a0d9ba 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -3,25 +3,22 @@
 namespace HiliteComparator
 {
 
-[[maybe_unused]] Hilite consume_hilites(const char * & ptr)
+void consume_hilites(const char * & ptr, Hilite * last_hilite)
 {
-    const char * last_hilite = nullptr;
-    while (true)
+    bool changed_hilite = false;
+    do
     {
-        bool changed_hilite = false;
         for (Hilite hilite : HILITES)
         {
             if (std::string_view(ptr).starts_with(hilite))
             {
                 ptr += strlen(hilite);
                 changed_hilite = true;
-                last_hilite = hilite;
+                if (last_hilite != nullptr)
+                    *last_hilite = hilite;
             }
         }
-        if (!changed_hilite)
-            break;
-    }
-    return last_hilite;
+    } while (changed_hilite);
 }
 
 bool are_equal_with_hilites_removed(std::string_view left, std::string_view right)
@@ -62,15 +59,8 @@ bool are_equal_with_hilites(std::string_view left, std::string_view right)
     while (true)
     {
         // Consume all prefix hilites, update the current hilite to be the last one.
-        Hilite last_hilite;
-
-        last_hilite = consume_hilites(left_it);
-        if (last_hilite != nullptr)
-            left_hilite = last_hilite;
-
-        last_hilite = consume_hilites(right_it);
-        if (last_hilite != nullptr)
-            right_hilite = last_hilite;
+        consume_hilites(left_it, &left_hilite);
+        consume_hilites(right_it, &right_hilite);
 
         if (left_it == left.end() && right_it == right.end())
             return true;
diff --git a/src/Parsers/HiliteComparator/HiliteComparator.h b/src/Parsers/HiliteComparator/HiliteComparator.h
index 9b47acc3cd4..dad50982928 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.h
+++ b/src/Parsers/HiliteComparator/HiliteComparator.h
@@ -18,7 +18,7 @@ const std::vector<Hilite> HILITES = {
         DB::IAST::hilite_none
     };
 
-[[maybe_unused]] Hilite consume_hilites(const char * & ptr);
+void consume_hilites(const char * & ptr, Hilite * last_hilite = nullptr);
 
 String remove_hilites(std::string_view string);
 
diff --git a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
index f4ee3b271d8..674d68e3c35 100644
--- a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
+++ b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
@@ -20,7 +20,8 @@ TEST(HiliteComparator, ConsumeHilites)
     s += IAST::hilite_keyword;
     const char * ptr = s.c_str();
     const char * expected_ptr = strchr(ptr, 't');
-    const char * last_hilite = consume_hilites(ptr);
+    const char * last_hilite = nullptr;
+    consume_hilites(ptr, &last_hilite);
     ASSERT_EQ(expected_ptr, ptr);
     ASSERT_TRUE(last_hilite != nullptr);
     ASSERT_EQ(IAST::hilite_function, last_hilite);

From f6db4fa466a921d64d3e5c7f2ac289b20765af36 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 15:00:14 +0100
Subject: [PATCH 69/80] avoid explicit check if strings
 are_equal_without_hilites in are_equal_with_hilites if anyone needs it, they
 can call it themselves

---
 src/Parsers/HiliteComparator/HiliteComparator.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/Parsers/HiliteComparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.cpp
index 88790a0d9ba..77621c45553 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -48,9 +48,6 @@ String remove_hilites(std::string_view string)
  */
 bool are_equal_with_hilites(std::string_view left, std::string_view right)
 {
-    if (!are_equal_with_hilites_removed(left, right))
-        return false;
-
     const char * left_it = left.begin();
     const char * right_it = right.begin();
     Hilite left_hilite = DB::IAST::hilite_none;
@@ -70,7 +67,6 @@ bool are_equal_with_hilites(std::string_view left, std::string_view right)
 
         // Lookup one character.
         // Check characters match.
-        // Redundant check, given the hilite-ignorant comparison at the beginning, but let's keep it just in case.
         if (*left_it != *right_it)
             return false;
 

From cba124f99cd11a93deb14dbb56bfb90f57eab808 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 15:04:50 +0100
Subject: [PATCH 70/80] fix while in consume_hilites

---
 src/Parsers/HiliteComparator/HiliteComparator.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/Parsers/HiliteComparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.cpp
index 77621c45553..0d9d06a0ad2 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -5,9 +5,9 @@ namespace HiliteComparator
 
 void consume_hilites(const char * & ptr, Hilite * last_hilite)
 {
-    bool changed_hilite = false;
-    do
+    while (true)
     {
+        bool changed_hilite = false;
         for (Hilite hilite : HILITES)
         {
             if (std::string_view(ptr).starts_with(hilite))
@@ -18,7 +18,9 @@ void consume_hilites(const char * & ptr, Hilite * last_hilite)
                     *last_hilite = hilite;
             }
         }
-    } while (changed_hilite);
+        if (!changed_hilite)
+            break;
+    }
 }
 
 bool are_equal_with_hilites_removed(std::string_view left, std::string_view right)

From a1d718c60127256e405639e664c8a5e99d776761 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 15:12:52 +0100
Subject: [PATCH 71/80] update docstring for consume_hilites

---
 src/Parsers/HiliteComparator/HiliteComparator.cpp | 2 +-
 src/Parsers/HiliteComparator/HiliteComparator.h   | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/Parsers/HiliteComparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.cpp
index 0d9d06a0ad2..61178be43a7 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -57,7 +57,7 @@ bool are_equal_with_hilites(std::string_view left, std::string_view right)
 
     while (true)
     {
-        // Consume all prefix hilites, update the current hilite to be the last one.
+        // For each argument, consume all prefix hilites, and update the current hilite to be the last one.
         consume_hilites(left_it, &left_hilite);
         consume_hilites(right_it, &right_hilite);
 
diff --git a/src/Parsers/HiliteComparator/HiliteComparator.h b/src/Parsers/HiliteComparator/HiliteComparator.h
index dad50982928..76ba1ece07a 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.h
+++ b/src/Parsers/HiliteComparator/HiliteComparator.h
@@ -18,6 +18,10 @@ const std::vector<Hilite> HILITES = {
         DB::IAST::hilite_none
     };
 
+/*
+ * Consume all prefix hilites, by moving `ptr` to
+ * If `last_hilite` is not `nullptr`, update the last hilite to be the last hilite of the prefix hilites.
+ */
 void consume_hilites(const char * & ptr, Hilite * last_hilite = nullptr);
 
 String remove_hilites(std::string_view string);

From 46691ef705c7171c0ad829f4ac1103086e8270cb Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 15:51:12 +0100
Subject: [PATCH 72/80] add check that all strings end without any hilite

---
 .../HiliteComparator/HiliteComparator.cpp     | 14 ++++++++++-
 .../HiliteComparator/HiliteComparator.h       |  5 +++-
 .../gtest_hilite_comparator.cpp               | 25 ++++++++++++-------
 src/Parsers/tests/gtest_format_hiliting.cpp   |  2 +-
 4 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/src/Parsers/HiliteComparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.cpp
index 61178be43a7..cf20f492d1c 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -48,7 +48,7 @@ String remove_hilites(std::string_view string)
  *      a. hilite_keyword foo hilite_none hilite_operator +
  *      b. hilite_keyword foo hilite_operator +
  */
-bool are_equal_with_hilites(std::string_view left, std::string_view right)
+bool are_equal_with_hilites(std::string_view left, std::string_view right, bool check_end_without_hilite)
 {
     const char * left_it = left.begin();
     const char * right_it = right.begin();
@@ -62,7 +62,14 @@ bool are_equal_with_hilites(std::string_view left, std::string_view right)
         consume_hilites(right_it, &right_hilite);
 
         if (left_it == left.end() && right_it == right.end())
+        {
+            if (left_hilite != right_hilite)
+                return false;
+            if (check_end_without_hilite)
+                if (left_hilite != DB::IAST::hilite_none)
+                    throw std::logic_error("Expected string ends with a hilite");
             return true;
+        }
 
         if (left_it == left.end() || right_it == right.end())
             return false;
@@ -82,5 +89,10 @@ bool are_equal_with_hilites(std::string_view left, std::string_view right)
     }
 }
 
+bool are_equal_with_hilites_and_end_without_hilite(std::string_view left, std::string_view right)
+{
+    return are_equal_with_hilites(left, right, true);
+}
+
 
 }
diff --git a/src/Parsers/HiliteComparator/HiliteComparator.h b/src/Parsers/HiliteComparator/HiliteComparator.h
index 76ba1ece07a..f8346454858 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.h
+++ b/src/Parsers/HiliteComparator/HiliteComparator.h
@@ -35,6 +35,9 @@ bool are_equal_with_hilites_removed(std::string_view left, std::string_view righ
  *      a. hilite_keyword foo hilite_none hilite_operator +
  *      b. hilite_keyword foo hilite_operator +
  */
-bool are_equal_with_hilites(std::string_view left, std::string_view right);
+bool are_equal_with_hilites(std::string_view left, std::string_view right, bool check_end_without_hilite);
+
+// Google tests's ASSERT_PRED_2 doesn't see overloads with default parameter values.
+bool are_equal_with_hilites_and_end_without_hilite(std::string_view left, std::string_view right);
 
 }
diff --git a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
index 674d68e3c35..785e83d09cc 100644
--- a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
+++ b/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
@@ -47,20 +47,26 @@ TEST(HiliteComparator, RemoveHilites)
 TEST(HiliteComparator, AreEqualWithHilites)
 {
     using namespace DB;
-    ASSERT_PRED2(are_equal_with_hilites, "", "");
+    String s = IAST::hilite_keyword;
+    ASSERT_THROW(are_equal_with_hilites(s, s, true), std::logic_error);
+    ASSERT_TRUE(are_equal_with_hilites(s, s, false));
+}
 
-    for (const char * hilite : HILITES)
-    {
-        ASSERT_PRED2(are_equal_with_hilites, "", std::string_view(hilite));
-        ASSERT_PRED2(are_equal_with_hilites, std::string_view(hilite), "");
-    }
+TEST(HiliteComparator, AreEqualWithHilitesAndEndWithoutHilite)
+{
+    using namespace DB;
+
+    ASSERT_PRED2(are_equal_with_hilites_and_end_without_hilite, "", "");
+    ASSERT_PRED2(are_equal_with_hilites_and_end_without_hilite, "", IAST::hilite_none);
+    ASSERT_PRED2(are_equal_with_hilites_and_end_without_hilite, IAST::hilite_none, "");
+    ASSERT_PRED2(are_equal_with_hilites_and_end_without_hilite, IAST::hilite_none, IAST::hilite_none);
 
     {
         String s;
         s += IAST::hilite_none;
         s += "select";
         s += IAST::hilite_none;
-        ASSERT_PRED2(are_equal_with_hilites, s, "select");
+        ASSERT_PRED2(are_equal_with_hilites_and_end_without_hilite, s, "select");
     }
 
     {
@@ -70,7 +76,7 @@ TEST(HiliteComparator, AreEqualWithHilites)
         s += DB::IAST::hilite_none;
         s += "ect";
         s += DB::IAST::hilite_none;
-        ASSERT_PRED2(are_equal_with_hilites, s, "\n select");
+        ASSERT_PRED2(are_equal_with_hilites_and_end_without_hilite, s, "\n select");
     }
 
     {
@@ -86,6 +92,7 @@ TEST(HiliteComparator, AreEqualWithHilites)
         right += " ";
         right += DB::IAST::hilite_keyword;
         right += "long";
-        ASSERT_PRED2(are_equal_with_hilites, left, right);
+        right += DB::IAST::hilite_none;
+        ASSERT_PRED2(are_equal_with_hilites_and_end_without_hilite, left, right);
     }
 }
diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 77849072131..46b933de789 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -56,7 +56,7 @@ void compare(const String & expected, const String & query)
     ast->format(settings);
 
     ASSERT_PRED2(HiliteComparator::are_equal_with_hilites_removed, expected, write_buffer.str());
-    ASSERT_PRED2(HiliteComparator::are_equal_with_hilites, expected, write_buffer.str());
+    ASSERT_PRED2(HiliteComparator::are_equal_with_hilites_and_end_without_hilite, expected, write_buffer.str());
 }
 
 const std::vector<std::pair<std::string, std::string>> expected_and_query_pairs = {

From 95d77193afb42519940eb9556c24d4e8c08ff8a0 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 15:54:42 +0100
Subject: [PATCH 73/80] add comment re excessive copying in
 are_equal_with_hilites_removed

---
 src/Parsers/HiliteComparator/HiliteComparator.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Parsers/HiliteComparator/HiliteComparator.h b/src/Parsers/HiliteComparator/HiliteComparator.h
index f8346454858..6aedc616d66 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.h
+++ b/src/Parsers/HiliteComparator/HiliteComparator.h
@@ -26,6 +26,9 @@ void consume_hilites(const char * & ptr, Hilite * last_hilite = nullptr);
 
 String remove_hilites(std::string_view string);
 
+/*
+ * Copies both strings, for the simplicity of the implementation.
+ */
 bool are_equal_with_hilites_removed(std::string_view left, std::string_view right);
 
 /*

From 647fb63b83e8e59b6802da2e7cd9bbb7dc28ee1c Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 16:01:15 +0100
Subject: [PATCH 74/80] rm unneeded parentheses

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index 46b933de789..ffa8a1cfab3 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -129,7 +129,5 @@ const std::vector<std::pair<std::string, std::string>> expected_and_query_pairs
 TEST(FormatHiliting, Queries)
 {
     for (const auto & [expected, query] : expected_and_query_pairs)
-    {
         compare(expected, query);
-    }
 }

From c3acaecce6a1d89d609b96f11207990b0e4a06f2 Mon Sep 17 00:00:00 2001
From: natasha <murfel@users.noreply.github.com>
Date: Tue, 4 Apr 2023 16:04:33 +0100
Subject: [PATCH 75/80] fix style - missed tab

---
 src/Parsers/tests/gtest_format_hiliting.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Parsers/tests/gtest_format_hiliting.cpp b/src/Parsers/tests/gtest_format_hiliting.cpp
index ffa8a1cfab3..d0ce8f2c897 100644
--- a/src/Parsers/tests/gtest_format_hiliting.cpp
+++ b/src/Parsers/tests/gtest_format_hiliting.cpp
@@ -63,7 +63,7 @@ const std::vector<std::pair<std::string, std::string>> expected_and_query_pairs
     // Simple select
     {
         keyword("SELECT ") + "* " + keyword("FROM ") + identifier("table"),
-     "select * from table"
+        "select * from table"
     },
 
     // ASTWithElement

From e031783ae575908b60f725fbd965b389a0b4592f Mon Sep 17 00:00:00 2001
From: Robert Schulze <robert@clickhouse.com>
Date: Tue, 4 Apr 2023 15:39:16 +0000
Subject: [PATCH 76/80] More CMake fixes

---
 src/Parsers/HiliteComparator/CMakeLists.txt              | 9 +++++----
 src/Parsers/HiliteComparator/HiliteComparator.cpp        | 2 +-
 src/Parsers/HiliteComparator/HiliteComparator.h          | 4 +++-
 .../{ => tests}/gtest_hilite_comparator.cpp              | 0
 4 files changed, 9 insertions(+), 6 deletions(-)
 rename src/Parsers/HiliteComparator/{ => tests}/gtest_hilite_comparator.cpp (100%)

diff --git a/src/Parsers/HiliteComparator/CMakeLists.txt b/src/Parsers/HiliteComparator/CMakeLists.txt
index 5bc738b3586..0e68b19be08 100644
--- a/src/Parsers/HiliteComparator/CMakeLists.txt
+++ b/src/Parsers/HiliteComparator/CMakeLists.txt
@@ -1,6 +1,7 @@
-add_library(hilite_comparator
-    HiliteComparator.h
-    HiliteComparator.cpp
-)
+include("${ClickHouse_SOURCE_DIR}/cmake/dbms_glob_sources.cmake")
+
+add_headers_and_sources(hilite_comparator .)
+
+add_library(hilite_comparator ${hilite_comparator_sources})
 
 target_link_libraries(hilite_comparator PRIVATE dbms)
diff --git a/src/Parsers/HiliteComparator/HiliteComparator.cpp b/src/Parsers/HiliteComparator/HiliteComparator.cpp
index cf20f492d1c..0c12c6e821c 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.cpp
+++ b/src/Parsers/HiliteComparator/HiliteComparator.cpp
@@ -8,7 +8,7 @@ void consume_hilites(const char * & ptr, Hilite * last_hilite)
     while (true)
     {
         bool changed_hilite = false;
-        for (Hilite hilite : HILITES)
+        for (Hilite hilite : hilites)
         {
             if (std::string_view(ptr).starts_with(hilite))
             {
diff --git a/src/Parsers/HiliteComparator/HiliteComparator.h b/src/Parsers/HiliteComparator/HiliteComparator.h
index 6aedc616d66..137c5892b3a 100644
--- a/src/Parsers/HiliteComparator/HiliteComparator.h
+++ b/src/Parsers/HiliteComparator/HiliteComparator.h
@@ -1,6 +1,8 @@
 #pragma once
 
 #include <Parsers/IAST.h>
+#include <string>
+#include <string_view>
 
 
 namespace HiliteComparator
@@ -8,7 +10,7 @@ namespace HiliteComparator
 
 using Hilite = const char *;
 
-const std::vector<Hilite> HILITES = {
+static const std::vector<Hilite> hilites = {
         DB::IAST::hilite_keyword,
         DB::IAST::hilite_identifier,
         DB::IAST::hilite_function,
diff --git a/src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp b/src/Parsers/HiliteComparator/tests/gtest_hilite_comparator.cpp
similarity index 100%
rename from src/Parsers/HiliteComparator/gtest_hilite_comparator.cpp
rename to src/Parsers/HiliteComparator/tests/gtest_hilite_comparator.cpp

From fa5b2bd4a5b02336bca8837c473a7124f8ecedf2 Mon Sep 17 00:00:00 2001
From: Nikita Mikhaylov <mikhaylovnikitka@gmail.com>
Date: Tue, 4 Apr 2023 18:12:08 +0200
Subject: [PATCH 77/80] Added Keeper retries for backups operations (#47224)

---
 src/Backups/BackupCoordinationLocal.cpp       |  10 +-
 src/Backups/BackupCoordinationRemote.cpp      | 518 +++++++++++-------
 src/Backups/BackupCoordinationRemote.h        |  16 +-
 .../BackupCoordinationReplicatedAccess.cpp    |   7 +-
 .../BackupCoordinationReplicatedAccess.h      |  10 +-
 ...BackupCoordinationReplicatedSQLObjects.cpp |   7 +-
 .../BackupCoordinationReplicatedSQLObjects.h  |  10 +-
 .../BackupCoordinationReplicatedTables.cpp    |  27 +-
 .../BackupCoordinationReplicatedTables.h      |  36 +-
 src/Backups/BackupCoordinationStageSync.cpp   | 163 ++++--
 src/Backups/BackupCoordinationStageSync.h     |  13 +-
 src/Backups/BackupEntriesCollector.cpp        |  13 +-
 src/Backups/BackupEntriesCollector.h          |   4 +
 src/Backups/BackupsWorker.cpp                 |  34 +-
 src/Backups/RestoreCoordinationRemote.cpp     | 274 +++++----
 src/Backups/RestoreCoordinationRemote.h       |  10 +-
 src/Backups/WithRetries.cpp                   |  61 +++
 src/Backups/WithRetries.h                     |  79 +++
 src/Common/ZooKeeper/Common.h                 |   5 +-
 src/Common/ZooKeeper/TestKeeper.h             |   1 -
 .../ZooKeeper/ZooKeeperWithFaultInjection.h   |  75 ++-
 src/Core/Settings.h                           |  12 +-
 src/Storages/MergeTree/ZooKeeperRetries.h     |   6 +
 .../configs/zookeeper_retries.xml             |  11 +
 .../test_backup_restore_new/test.py           |   1 +
 .../configs/zookeeper_retries.xml             |  11 +
 .../test_backup_restore_on_cluster/test.py    |   5 +-
 .../test_concurrency.py                       |   1 +
 .../test_disallow_concurrency.py              |   1 +
 .../configs/zookeeper_retries.xml             |  11 +
 .../test_backup_restore_s3/test.py            |   3 +
 31 files changed, 1017 insertions(+), 418 deletions(-)
 create mode 100644 src/Backups/WithRetries.cpp
 create mode 100644 src/Backups/WithRetries.h
 create mode 100644 tests/integration/test_backup_restore_new/configs/zookeeper_retries.xml
 create mode 100644 tests/integration/test_backup_restore_on_cluster/configs/zookeeper_retries.xml
 create mode 100644 tests/integration/test_backup_restore_s3/configs/zookeeper_retries.xml

diff --git a/src/Backups/BackupCoordinationLocal.cpp b/src/Backups/BackupCoordinationLocal.cpp
index f3a6c02d228..27e0f173cf3 100644
--- a/src/Backups/BackupCoordinationLocal.cpp
+++ b/src/Backups/BackupCoordinationLocal.cpp
@@ -36,7 +36,7 @@ Strings BackupCoordinationLocal::waitForStage(const String &, std::chrono::milli
 void BackupCoordinationLocal::addReplicatedPartNames(const String & table_shared_id, const String & table_name_for_logs, const String & replica_name, const std::vector<PartNameAndChecksum> & part_names_and_checksums)
 {
     std::lock_guard lock{replicated_tables_mutex};
-    replicated_tables.addPartNames(table_shared_id, table_name_for_logs, replica_name, part_names_and_checksums);
+    replicated_tables.addPartNames({table_shared_id, table_name_for_logs, replica_name, part_names_and_checksums});
 }
 
 Strings BackupCoordinationLocal::getReplicatedPartNames(const String & table_shared_id, const String & replica_name) const
@@ -49,7 +49,7 @@ Strings BackupCoordinationLocal::getReplicatedPartNames(const String & table_sha
 void BackupCoordinationLocal::addReplicatedMutations(const String & table_shared_id, const String & table_name_for_logs, const String & replica_name, const std::vector<MutationInfo> & mutations)
 {
     std::lock_guard lock{replicated_tables_mutex};
-    replicated_tables.addMutations(table_shared_id, table_name_for_logs, replica_name, mutations);
+    replicated_tables.addMutations({table_shared_id, table_name_for_logs, replica_name, mutations});
 }
 
 std::vector<IBackupCoordination::MutationInfo> BackupCoordinationLocal::getReplicatedMutations(const String & table_shared_id, const String & replica_name) const
@@ -62,7 +62,7 @@ std::vector<IBackupCoordination::MutationInfo> BackupCoordinationLocal::getRepli
 void BackupCoordinationLocal::addReplicatedDataPath(const String & table_shared_id, const String & data_path)
 {
     std::lock_guard lock{replicated_tables_mutex};
-    replicated_tables.addDataPath(table_shared_id, data_path);
+    replicated_tables.addDataPath({table_shared_id, data_path});
 }
 
 Strings BackupCoordinationLocal::getReplicatedDataPaths(const String & table_shared_id) const
@@ -75,7 +75,7 @@ Strings BackupCoordinationLocal::getReplicatedDataPaths(const String & table_sha
 void BackupCoordinationLocal::addReplicatedAccessFilePath(const String & access_zk_path, AccessEntityType access_entity_type, const String & file_path)
 {
     std::lock_guard lock{replicated_access_mutex};
-    replicated_access.addFilePath(access_zk_path, access_entity_type, "", file_path);
+    replicated_access.addFilePath({access_zk_path, access_entity_type, "", file_path});
 }
 
 Strings BackupCoordinationLocal::getReplicatedAccessFilePaths(const String & access_zk_path, AccessEntityType access_entity_type) const
@@ -88,7 +88,7 @@ Strings BackupCoordinationLocal::getReplicatedAccessFilePaths(const String & acc
 void BackupCoordinationLocal::addReplicatedSQLObjectsDir(const String & loader_zk_path, UserDefinedSQLObjectType object_type, const String & dir_path)
 {
     std::lock_guard lock{replicated_sql_objects_mutex};
-    replicated_sql_objects.addDirectory(loader_zk_path, object_type, "", dir_path);
+    replicated_sql_objects.addDirectory({loader_zk_path, object_type, "", dir_path});
 }
 
 Strings BackupCoordinationLocal::getReplicatedSQLObjectsDirs(const String & loader_zk_path, UserDefinedSQLObjectType object_type) const
diff --git a/src/Backups/BackupCoordinationRemote.cpp b/src/Backups/BackupCoordinationRemote.cpp
index d6463d08909..f885cd0e6b4 100644
--- a/src/Backups/BackupCoordinationRemote.cpp
+++ b/src/Backups/BackupCoordinationRemote.cpp
@@ -1,13 +1,18 @@
 #include <Backups/BackupCoordinationRemote.h>
+
+#include <base/hex.h>
+
 #include <Access/Common/AccessEntityType.h>
+#include <Backups/BackupCoordinationReplicatedAccess.h>
+#include <Backups/BackupCoordinationStage.h>
+#include <Common/escapeForFileName.h>
+#include <Common/ZooKeeper/Common.h>
+#include <Common/ZooKeeper/KeeperException.h>
 #include <Functions/UserDefined/UserDefinedSQLObjectType.h>
 #include <IO/ReadBufferFromString.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteBufferFromString.h>
 #include <IO/WriteHelpers.h>
-#include <Common/ZooKeeper/KeeperException.h>
-#include <Common/escapeForFileName.h>
-#include <Backups/BackupCoordinationStage.h>
 
 
 namespace DB
@@ -154,8 +159,7 @@ BackupCoordinationRemote::BackupCoordinationRemote(
     const String & current_host_,
     bool plain_backup_,
     bool is_internal_)
-    : get_zookeeper(get_zookeeper_)
-    , root_zookeeper_path(root_zookeeper_path_)
+    : root_zookeeper_path(root_zookeeper_path_)
     , zookeeper_path(root_zookeeper_path_ + "/backup-" + backup_uuid_)
     , keeper_settings(keeper_settings_)
     , backup_uuid(backup_uuid_)
@@ -165,17 +169,32 @@ BackupCoordinationRemote::BackupCoordinationRemote(
     , plain_backup(plain_backup_)
     , is_internal(is_internal_)
     , log(&Poco::Logger::get("BackupCoordinationRemote"))
-{
-    zookeeper_retries_info = ZooKeeperRetriesInfo(
-        "BackupCoordinationRemote",
+    , with_retries(
         log,
-        keeper_settings.keeper_max_retries,
-        keeper_settings.keeper_retry_initial_backoff_ms,
-        keeper_settings.keeper_retry_max_backoff_ms);
+        get_zookeeper_,
+        keeper_settings,
+        [zookeeper_path = zookeeper_path, current_host = current_host, is_internal = is_internal]
+        (WithRetries::FaultyKeeper & zk)
+        {
+            /// Recreate this ephemeral node to signal that we are alive.
+            if (is_internal)
+            {
+                String alive_node_path = zookeeper_path + "/stage/alive|" + current_host;
+                auto code = zk->tryCreate(alive_node_path, "", zkutil::CreateMode::Ephemeral);
 
+                if (code == Coordination::Error::ZNODEEXISTS)
+                    zk->handleEphemeralNodeExistenceNoFailureInjection(alive_node_path, "");
+                else if (code != Coordination::Error::ZOK)
+                    throw zkutil::KeeperException(code, alive_node_path);
+            }
+        })
+{
     createRootNodes();
+
     stage_sync.emplace(
-        zookeeper_path + "/stage", [this] { return getZooKeeper(); }, log);
+        zookeeper_path,
+        with_retries,
+        log);
 }
 
 BackupCoordinationRemote::~BackupCoordinationRemote()
@@ -191,44 +210,45 @@ BackupCoordinationRemote::~BackupCoordinationRemote()
     }
 }
 
-zkutil::ZooKeeperPtr BackupCoordinationRemote::getZooKeeper() const
-{
-    std::lock_guard lock{zookeeper_mutex};
-    if (!zookeeper || zookeeper->expired())
-    {
-        zookeeper = get_zookeeper();
-
-        /// It's possible that we connected to different [Zoo]Keeper instance
-        /// so we may read a bit stale state.
-        zookeeper->sync(zookeeper_path);
-    }
-    return zookeeper;
-}
-
 void BackupCoordinationRemote::createRootNodes()
 {
-    auto zk = getZooKeeper();
-    zk->createAncestors(zookeeper_path);
-    zk->createIfNotExists(zookeeper_path, "");
-    zk->createIfNotExists(zookeeper_path + "/repl_part_names", "");
-    zk->createIfNotExists(zookeeper_path + "/repl_mutations", "");
-    zk->createIfNotExists(zookeeper_path + "/repl_data_paths", "");
-    zk->createIfNotExists(zookeeper_path + "/repl_access", "");
-    zk->createIfNotExists(zookeeper_path + "/repl_sql_objects", "");
-    zk->createIfNotExists(zookeeper_path + "/file_infos", "");
-    zk->createIfNotExists(zookeeper_path + "/writing_files", "");
+    auto holder = with_retries.createRetriesControlHolder("createRootNodes");
+    holder.retries_ctl.retryLoop(
+    [&, &zk = holder.faulty_zookeeper]()
+    {
+        with_retries.renewZooKeeper(zk);
+
+        zk->createAncestors(zookeeper_path);
+
+        Coordination::Requests ops;
+        Coordination::Responses responses;
+        ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path, "", zkutil::CreateMode::Persistent));
+        ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/repl_part_names", "", zkutil::CreateMode::Persistent));
+        ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/repl_mutations", "", zkutil::CreateMode::Persistent));
+        ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/repl_data_paths", "", zkutil::CreateMode::Persistent));
+        ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/repl_access", "", zkutil::CreateMode::Persistent));
+        ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/repl_sql_objects", "", zkutil::CreateMode::Persistent));
+        ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/file_infos", "", zkutil::CreateMode::Persistent));
+        ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/writing_files", "", zkutil::CreateMode::Persistent));
+        zk->tryMulti(ops, responses);
+    });
 }
 
 void BackupCoordinationRemote::removeAllNodes()
 {
-    /// Usually this function is called by the initiator when a backup is complete so we don't need the coordination anymore.
-    ///
-    /// However there can be a rare situation when this function is called after an error occurs on the initiator of a query
-    /// while some hosts are still making the backup. Removing all the nodes will remove the parent node of the backup coordination
-    /// at `zookeeper_path` which might cause such hosts to stop with exception "ZNONODE". Or such hosts might still do some useless part
-    /// of their backup work before that. Anyway in this case backup won't be finalized (because only an initiator can do that).
-    auto zk = getZooKeeper();
-    zk->removeRecursive(zookeeper_path);
+    auto holder = with_retries.createRetriesControlHolder("removeAllNodes");
+    holder.retries_ctl.retryLoop(
+    [&, &zk = holder.faulty_zookeeper]()
+    {
+        /// Usually this function is called by the initiator when a backup is complete so we don't need the coordination anymore.
+        ///
+        /// However there can be a rare situation when this function is called after an error occurs on the initiator of a query
+        /// while some hosts are still making the backup. Removing all the nodes will remove the parent node of the backup coordination
+        /// at `zookeeper_path` which might cause such hosts to stop with exception "ZNONODE". Or such hosts might still do some useless part
+        /// of their backup work before that. Anyway in this case backup won't be finalized (because only an initiator can do that).
+        with_retries.renewZooKeeper(zk);
+        zk->removeRecursive(zookeeper_path);
+    });
 }
 
 
@@ -256,10 +276,11 @@ Strings BackupCoordinationRemote::waitForStage(const String & stage_to_wait, std
 void BackupCoordinationRemote::serializeToMultipleZooKeeperNodes(const String & path, const String & value, const String & logging_name)
 {
     {
-        ZooKeeperRetriesControl retries_ctl(logging_name + "::create", zookeeper_retries_info);
-        retries_ctl.retryLoop([&]
+        auto holder = with_retries.createRetriesControlHolder(logging_name + "::create");
+        holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
         {
-            auto zk = getZooKeeper();
+            with_retries.renewZooKeeper(zk);
             zk->createIfNotExists(path, "");
         });
     }
@@ -280,10 +301,11 @@ void BackupCoordinationRemote::serializeToMultipleZooKeeperNodes(const String &
         String part = value.substr(begin, end - begin);
         String part_path = fmt::format("{}/{:06}", path, i);
 
-        ZooKeeperRetriesControl retries_ctl(logging_name + "::createPart", zookeeper_retries_info);
-        retries_ctl.retryLoop([&]
+        auto holder = with_retries.createRetriesControlHolder(logging_name + "::createPart");
+        holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
         {
-            auto zk = getZooKeeper();
+            with_retries.renewZooKeeper(zk);
             zk->createIfNotExists(part_path, part);
         });
     }
@@ -294,9 +316,11 @@ String BackupCoordinationRemote::deserializeFromMultipleZooKeeperNodes(const Str
     Strings part_names;
 
     {
-        ZooKeeperRetriesControl retries_ctl(logging_name + "::getChildren", zookeeper_retries_info);
-        retries_ctl.retryLoop([&]{
-            auto zk = getZooKeeper();
+        auto holder = with_retries.createRetriesControlHolder(logging_name + "::getChildren");
+        holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
+        {
+            with_retries.renewZooKeeper(zk);
             part_names = zk->getChildren(path);
             std::sort(part_names.begin(), part_names.end());
         });
@@ -307,10 +331,11 @@ String BackupCoordinationRemote::deserializeFromMultipleZooKeeperNodes(const Str
     {
         String part;
         String part_path = path + "/" + part_name;
-        ZooKeeperRetriesControl retries_ctl(logging_name + "::get", zookeeper_retries_info);
-        retries_ctl.retryLoop([&]
+        auto holder = with_retries.createRetriesControlHolder(logging_name + "::get");
+        holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
         {
-            auto zk = getZooKeeper();
+            with_retries.renewZooKeeper(zk);
             part = zk->get(part_path);
         });
         res += part;
@@ -331,11 +356,16 @@ void BackupCoordinationRemote::addReplicatedPartNames(
             throw Exception(ErrorCodes::LOGICAL_ERROR, "addReplicatedPartNames() must not be called after preparing");
     }
 
-    auto zk = getZooKeeper();
-    String path = zookeeper_path + "/repl_part_names/" + escapeForFileName(table_shared_id);
-    zk->createIfNotExists(path, "");
-    path += "/" + escapeForFileName(replica_name);
-    zk->create(path, ReplicatedPartNames::serialize(part_names_and_checksums, table_name_for_logs), zkutil::CreateMode::Persistent);
+    auto holder = with_retries.createRetriesControlHolder("addReplicatedPartNames");
+    holder.retries_ctl.retryLoop(
+    [&, &zk = holder.faulty_zookeeper]()
+    {
+        with_retries.renewZooKeeper(zk);
+        String path = zookeeper_path + "/repl_part_names/" + escapeForFileName(table_shared_id);
+        zk->createIfNotExists(path, "");
+        path += "/" + escapeForFileName(replica_name);
+        zk->createIfNotExists(path, ReplicatedPartNames::serialize(part_names_and_checksums, table_name_for_logs));
+    });
 }
 
 Strings BackupCoordinationRemote::getReplicatedPartNames(const String & table_shared_id, const String & replica_name) const
@@ -357,11 +387,16 @@ void BackupCoordinationRemote::addReplicatedMutations(
             throw Exception(ErrorCodes::LOGICAL_ERROR, "addReplicatedMutations() must not be called after preparing");
     }
 
-    auto zk = getZooKeeper();
-    String path = zookeeper_path + "/repl_mutations/" + escapeForFileName(table_shared_id);
-    zk->createIfNotExists(path, "");
-    path += "/" + escapeForFileName(replica_name);
-    zk->create(path, ReplicatedMutations::serialize(mutations, table_name_for_logs), zkutil::CreateMode::Persistent);
+    auto holder = with_retries.createRetriesControlHolder("addReplicatedMutations");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
+        {
+            with_retries.renewZooKeeper(zk);
+            String path = zookeeper_path + "/repl_mutations/" + escapeForFileName(table_shared_id);
+            zk->createIfNotExists(path, "");
+            path += "/" + escapeForFileName(replica_name);
+            zk->createIfNotExists(path, ReplicatedMutations::serialize(mutations, table_name_for_logs));
+        });
 }
 
 std::vector<IBackupCoordination::MutationInfo> BackupCoordinationRemote::getReplicatedMutations(const String & table_shared_id, const String & replica_name) const
@@ -381,11 +416,16 @@ void BackupCoordinationRemote::addReplicatedDataPath(
             throw Exception(ErrorCodes::LOGICAL_ERROR, "addReplicatedDataPath() must not be called after preparing");
     }
 
-    auto zk = getZooKeeper();
-    String path = zookeeper_path + "/repl_data_paths/" + escapeForFileName(table_shared_id);
-    zk->createIfNotExists(path, "");
-    path += "/" + escapeForFileName(data_path);
-    zk->createIfNotExists(path, "");
+    auto holder = with_retries.createRetriesControlHolder("addReplicatedDataPath");
+    holder.retries_ctl.retryLoop(
+    [&, &zk = holder.faulty_zookeeper]()
+    {
+        with_retries.renewZooKeeper(zk);
+        String path = zookeeper_path + "/repl_data_paths/" + escapeForFileName(table_shared_id);
+        zk->createIfNotExists(path, "");
+        path += "/" + escapeForFileName(data_path);
+        zk->createIfNotExists(path, "");
+    });
 }
 
 Strings BackupCoordinationRemote::getReplicatedDataPaths(const String & table_shared_id) const
@@ -401,55 +441,88 @@ void BackupCoordinationRemote::prepareReplicatedTables() const
     if (replicated_tables)
         return;
 
+    std::vector<BackupCoordinationReplicatedTables::PartNamesForTableReplica> part_names_for_replicated_tables;
+    {
+        auto holder = with_retries.createRetriesControlHolder("prepareReplicatedTables::repl_part_names");
+        holder.retries_ctl.retryLoop(
+            [&, &zk = holder.faulty_zookeeper]()
+        {
+            part_names_for_replicated_tables.clear();
+            with_retries.renewZooKeeper(zk);
+
+            String path = zookeeper_path + "/repl_part_names";
+            for (const String & escaped_table_shared_id : zk->getChildren(path))
+            {
+                String table_shared_id = unescapeForFileName(escaped_table_shared_id);
+                String path2 = path + "/" + escaped_table_shared_id;
+                for (const String & escaped_replica_name : zk->getChildren(path2))
+                {
+                    String replica_name = unescapeForFileName(escaped_replica_name);
+                    auto part_names = ReplicatedPartNames::deserialize(zk->get(path2 + "/" + escaped_replica_name));
+                    part_names_for_replicated_tables.push_back(
+                        {table_shared_id, part_names.table_name_for_logs, replica_name, part_names.part_names_and_checksums});
+                }
+            }
+        });
+    }
+
+    std::vector<BackupCoordinationReplicatedTables::MutationsForTableReplica> mutations_for_replicated_tables;
+    {
+        auto holder = with_retries.createRetriesControlHolder("prepareReplicatedTables::repl_mutations");
+        holder.retries_ctl.retryLoop(
+            [&, &zk = holder.faulty_zookeeper]()
+        {
+            mutations_for_replicated_tables.clear();
+            with_retries.renewZooKeeper(zk);
+
+            String path = zookeeper_path + "/repl_mutations";
+            for (const String & escaped_table_shared_id : zk->getChildren(path))
+            {
+                String table_shared_id = unescapeForFileName(escaped_table_shared_id);
+                String path2 = path + "/" + escaped_table_shared_id;
+                for (const String & escaped_replica_name : zk->getChildren(path2))
+                {
+                    String replica_name = unescapeForFileName(escaped_replica_name);
+                    auto mutations = ReplicatedMutations::deserialize(zk->get(path2 + "/" + escaped_replica_name));
+                    mutations_for_replicated_tables.push_back(
+                        {table_shared_id, mutations.table_name_for_logs, replica_name, mutations.mutations});
+                }
+            }
+        });
+    }
+
+    std::vector<BackupCoordinationReplicatedTables::DataPathForTableReplica> data_paths_for_replicated_tables;
+    {
+        auto holder = with_retries.createRetriesControlHolder("prepareReplicatedTables::repl_data_paths");
+        holder.retries_ctl.retryLoop(
+            [&, &zk = holder.faulty_zookeeper]()
+        {
+            data_paths_for_replicated_tables.clear();
+            with_retries.renewZooKeeper(zk);
+
+            String path = zookeeper_path + "/repl_data_paths";
+            for (const String & escaped_table_shared_id : zk->getChildren(path))
+            {
+                String table_shared_id = unescapeForFileName(escaped_table_shared_id);
+                String path2 = path + "/" + escaped_table_shared_id;
+                for (const String & escaped_data_path : zk->getChildren(path2))
+                {
+                    String data_path = unescapeForFileName(escaped_data_path);
+                    data_paths_for_replicated_tables.push_back({table_shared_id, data_path});
+                }
+            }
+        });
+    }
+
     replicated_tables.emplace();
-    auto zk = getZooKeeper();
-
-    {
-        String path = zookeeper_path + "/repl_part_names";
-        for (const String & escaped_table_shared_id : zk->getChildren(path))
-        {
-            String table_shared_id = unescapeForFileName(escaped_table_shared_id);
-            String path2 = path + "/" + escaped_table_shared_id;
-            for (const String & escaped_replica_name : zk->getChildren(path2))
-            {
-                String replica_name = unescapeForFileName(escaped_replica_name);
-                auto part_names = ReplicatedPartNames::deserialize(zk->get(path2 + "/" + escaped_replica_name));
-                replicated_tables->addPartNames(table_shared_id, part_names.table_name_for_logs, replica_name, part_names.part_names_and_checksums);
-            }
-        }
-    }
-
-    {
-        String path = zookeeper_path + "/repl_mutations";
-        for (const String & escaped_table_shared_id : zk->getChildren(path))
-        {
-            String table_shared_id = unescapeForFileName(escaped_table_shared_id);
-            String path2 = path + "/" + escaped_table_shared_id;
-            for (const String & escaped_replica_name : zk->getChildren(path2))
-            {
-                String replica_name = unescapeForFileName(escaped_replica_name);
-                auto mutations = ReplicatedMutations::deserialize(zk->get(path2 + "/" + escaped_replica_name));
-                replicated_tables->addMutations(table_shared_id, mutations.table_name_for_logs, replica_name, mutations.mutations);
-            }
-        }
-    }
-
-    {
-        String path = zookeeper_path + "/repl_data_paths";
-        for (const String & escaped_table_shared_id : zk->getChildren(path))
-        {
-            String table_shared_id = unescapeForFileName(escaped_table_shared_id);
-            String path2 = path + "/" + escaped_table_shared_id;
-            for (const String & escaped_data_path : zk->getChildren(path2))
-            {
-                String data_path = unescapeForFileName(escaped_data_path);
-                replicated_tables->addDataPath(table_shared_id, data_path);
-            }
-        }
-    }
+    for (auto & part_names : part_names_for_replicated_tables)
+        replicated_tables->addPartNames(std::move(part_names));
+    for (auto & mutations : mutations_for_replicated_tables)
+        replicated_tables->addMutations(std::move(mutations));
+    for (auto & data_paths : data_paths_for_replicated_tables)
+        replicated_tables->addDataPath(std::move(data_paths));
 }
 
-
 void BackupCoordinationRemote::addReplicatedAccessFilePath(const String & access_zk_path, AccessEntityType access_entity_type, const String & file_path)
 {
     {
@@ -458,13 +531,18 @@ void BackupCoordinationRemote::addReplicatedAccessFilePath(const String & access
             throw Exception(ErrorCodes::LOGICAL_ERROR, "addReplicatedAccessFilePath() must not be called after preparing");
     }
 
-    auto zk = getZooKeeper();
-    String path = zookeeper_path + "/repl_access/" + escapeForFileName(access_zk_path);
-    zk->createIfNotExists(path, "");
-    path += "/" + AccessEntityTypeInfo::get(access_entity_type).name;
-    zk->createIfNotExists(path, "");
-    path += "/" + current_host;
-    zk->createIfNotExists(path, file_path);
+    auto holder = with_retries.createRetriesControlHolder("addReplicatedAccessFilePath");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
+    {
+        with_retries.renewZooKeeper(zk);
+        String path = zookeeper_path + "/repl_access/" + escapeForFileName(access_zk_path);
+        zk->createIfNotExists(path, "");
+        path += "/" + AccessEntityTypeInfo::get(access_entity_type).name;
+        zk->createIfNotExists(path, "");
+        path += "/" + current_host;
+        zk->createIfNotExists(path, file_path);
+    });
 }
 
 Strings BackupCoordinationRemote::getReplicatedAccessFilePaths(const String & access_zk_path, AccessEntityType access_entity_type) const
@@ -479,25 +557,35 @@ void BackupCoordinationRemote::prepareReplicatedAccess() const
     if (replicated_access)
         return;
 
-    replicated_access.emplace();
-    auto zk = getZooKeeper();
-
-    String path = zookeeper_path + "/repl_access";
-    for (const String & escaped_access_zk_path : zk->getChildren(path))
+    std::vector<BackupCoordinationReplicatedAccess::FilePathForAccessEntitry> file_path_for_access_entities;
+    auto holder = with_retries.createRetriesControlHolder("prepareReplicatedAccess");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
     {
-        String access_zk_path = unescapeForFileName(escaped_access_zk_path);
-        String path2 = path + "/" + escaped_access_zk_path;
-        for (const String & type_str : zk->getChildren(path2))
+        file_path_for_access_entities.clear();
+        with_retries.renewZooKeeper(zk);
+
+        String path = zookeeper_path + "/repl_access";
+        for (const String & escaped_access_zk_path : zk->getChildren(path))
         {
-            AccessEntityType type = AccessEntityTypeInfo::parseType(type_str);
-            String path3 = path2 + "/" + type_str;
-            for (const String & host_id : zk->getChildren(path3))
+            String access_zk_path = unescapeForFileName(escaped_access_zk_path);
+            String path2 = path + "/" + escaped_access_zk_path;
+            for (const String & type_str : zk->getChildren(path2))
             {
-                String file_path = zk->get(path3 + "/" + host_id);
-                replicated_access->addFilePath(access_zk_path, type, host_id, file_path);
+                AccessEntityType type = AccessEntityTypeInfo::parseType(type_str);
+                String path3 = path2 + "/" + type_str;
+                for (const String & host_id : zk->getChildren(path3))
+                {
+                    String file_path = zk->get(path3 + "/" + host_id);
+                    file_path_for_access_entities.push_back({access_zk_path, type, host_id, file_path});
+                }
             }
         }
-    }
+    });
+
+    replicated_access.emplace();
+    for (auto & file_path : file_path_for_access_entities)
+        replicated_access->addFilePath(std::move(file_path));
 }
 
 void BackupCoordinationRemote::addReplicatedSQLObjectsDir(const String & loader_zk_path, UserDefinedSQLObjectType object_type, const String & dir_path)
@@ -508,21 +596,26 @@ void BackupCoordinationRemote::addReplicatedSQLObjectsDir(const String & loader_
             throw Exception(ErrorCodes::LOGICAL_ERROR, "addReplicatedSQLObjectsDir() must not be called after preparing");
     }
 
-    auto zk = getZooKeeper();
-    String path = zookeeper_path + "/repl_sql_objects/" + escapeForFileName(loader_zk_path);
-    zk->createIfNotExists(path, "");
-
-    path += "/";
-    switch (object_type)
+    auto holder = with_retries.createRetriesControlHolder("addReplicatedSQLObjectsDir");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
     {
-        case UserDefinedSQLObjectType::Function:
-            path += "functions";
-            break;
-    }
+        with_retries.renewZooKeeper(zk);
+        String path = zookeeper_path + "/repl_sql_objects/" + escapeForFileName(loader_zk_path);
+        zk->createIfNotExists(path, "");
 
-    zk->createIfNotExists(path, "");
-    path += "/" + current_host;
-    zk->createIfNotExists(path, dir_path);
+        path += "/";
+        switch (object_type)
+        {
+            case UserDefinedSQLObjectType::Function:
+                path += "functions";
+                break;
+        }
+
+        zk->createIfNotExists(path, "");
+        path += "/" + current_host;
+        zk->createIfNotExists(path, dir_path);
+    });
 }
 
 Strings BackupCoordinationRemote::getReplicatedSQLObjectsDirs(const String & loader_zk_path, UserDefinedSQLObjectType object_type) const
@@ -537,27 +630,36 @@ void BackupCoordinationRemote::prepareReplicatedSQLObjects() const
     if (replicated_sql_objects)
         return;
 
-    replicated_sql_objects.emplace();
-    auto zk = getZooKeeper();
-
-    String path = zookeeper_path + "/repl_sql_objects";
-    for (const String & escaped_loader_zk_path : zk->getChildren(path))
+    std::vector<BackupCoordinationReplicatedSQLObjects::DirectoryPathForSQLObject> directories_for_sql_objects;
+    auto holder = with_retries.createRetriesControlHolder("prepareReplicatedSQLObjects");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
     {
-        String loader_zk_path = unescapeForFileName(escaped_loader_zk_path);
-        String objects_path = path + "/" + escaped_loader_zk_path;
+        directories_for_sql_objects.clear();
+        with_retries.renewZooKeeper(zk);
 
-        if (String functions_path = objects_path + "/functions"; zk->exists(functions_path))
+        String path = zookeeper_path + "/repl_sql_objects";
+        for (const String & escaped_loader_zk_path : zk->getChildren(path))
         {
-            UserDefinedSQLObjectType object_type = UserDefinedSQLObjectType::Function;
-            for (const String & host_id : zk->getChildren(functions_path))
+            String loader_zk_path = unescapeForFileName(escaped_loader_zk_path);
+            String objects_path = path + "/" + escaped_loader_zk_path;
+
+            if (String functions_path = objects_path + "/functions"; zk->exists(functions_path))
             {
-                String dir = zk->get(functions_path + "/" + host_id);
-                replicated_sql_objects->addDirectory(loader_zk_path, object_type, host_id, dir);
+                UserDefinedSQLObjectType object_type = UserDefinedSQLObjectType::Function;
+                for (const String & host_id : zk->getChildren(functions_path))
+                {
+                    String dir = zk->get(functions_path + "/" + host_id);
+                    directories_for_sql_objects.push_back({loader_zk_path, object_type, host_id, dir});
+                }
             }
         }
-    }
-}
+    });
 
+    replicated_sql_objects.emplace();
+    for (auto & directory : directories_for_sql_objects)
+        replicated_sql_objects->addDirectory(std::move(directory));
+}
 
 void BackupCoordinationRemote::addFileInfos(BackupFileInfos && file_infos_)
 {
@@ -595,9 +697,11 @@ void BackupCoordinationRemote::prepareFileInfos() const
 
     Strings hosts_with_file_infos;
     {
-        ZooKeeperRetriesControl retries_ctl("prepareFileInfos::get_hosts", zookeeper_retries_info);
-        retries_ctl.retryLoop([&]{
-            auto zk = getZooKeeper();
+        auto holder = with_retries.createRetriesControlHolder("prepareFileInfos::get_hosts");
+        holder.retries_ctl.retryLoop(
+            [&, &zk = holder.faulty_zookeeper]()
+        {
+            with_retries.renewZooKeeper(zk);
             hosts_with_file_infos = zk->getChildren(zookeeper_path + "/file_infos");
         });
     }
@@ -616,10 +720,11 @@ bool BackupCoordinationRemote::startWritingFile(size_t data_file_index)
     String full_path = zookeeper_path + "/writing_files/" + std::to_string(data_file_index);
     String host_index_str = std::to_string(current_host_index);
 
-    ZooKeeperRetriesControl retries_ctl("startWritingFile", zookeeper_retries_info);
-    retries_ctl.retryLoop([&]
+    auto holder = with_retries.createRetriesControlHolder("startWritingFile");
+    holder.retries_ctl.retryLoop(
+            [&, &zk = holder.faulty_zookeeper]()
     {
-        auto zk = getZooKeeper();
+        with_retries.renewZooKeeper(zk);
         auto code = zk->tryCreate(full_path, host_index_str, zkutil::CreateMode::Persistent);
 
         if (code == Coordination::Error::ZOK)
@@ -633,54 +738,63 @@ bool BackupCoordinationRemote::startWritingFile(size_t data_file_index)
     return acquired_writing;
 }
 
-
 bool BackupCoordinationRemote::hasConcurrentBackups(const std::atomic<size_t> &) const
 {
     /// If its internal concurrency will be checked for the base backup
     if (is_internal)
         return false;
 
-    auto zk = getZooKeeper();
     std::string backup_stage_path = zookeeper_path + "/stage";
 
-    if (!zk->exists(root_zookeeper_path))
-        zk->createAncestors(root_zookeeper_path);
+    bool result = false;
 
-    for (size_t attempt = 0; attempt < MAX_ZOOKEEPER_ATTEMPTS; ++attempt)
+    auto holder = with_retries.createRetriesControlHolder("getAllArchiveSuffixes");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
     {
-        Coordination::Stat stat;
-        zk->get(root_zookeeper_path, &stat);
-        Strings existing_backup_paths = zk->getChildren(root_zookeeper_path);
+        with_retries.renewZooKeeper(zk);
 
-        for (const auto & existing_backup_path : existing_backup_paths)
+        if (!zk->exists(root_zookeeper_path))
+            zk->createAncestors(root_zookeeper_path);
+
+        for (size_t attempt = 0; attempt < MAX_ZOOKEEPER_ATTEMPTS; ++attempt)
         {
-            if (startsWith(existing_backup_path, "restore-"))
-                continue;
+            Coordination::Stat stat;
+            zk->get(root_zookeeper_path, &stat);
+            Strings existing_backup_paths = zk->getChildren(root_zookeeper_path);
 
-            String existing_backup_uuid = existing_backup_path;
-            existing_backup_uuid.erase(0, String("backup-").size());
-
-            if (existing_backup_uuid == toString(backup_uuid))
-                continue;
-
-            const auto status = zk->get(root_zookeeper_path + "/" + existing_backup_path + "/stage");
-            if (status != Stage::COMPLETED)
+            for (const auto & existing_backup_path : existing_backup_paths)
             {
-                LOG_WARNING(log, "Found a concurrent backup: {}, current backup: {}", existing_backup_uuid, toString(backup_uuid));
-                return true;
+                if (startsWith(existing_backup_path, "restore-"))
+                    continue;
+
+                String existing_backup_uuid = existing_backup_path;
+                existing_backup_uuid.erase(0, String("backup-").size());
+
+
+                if (existing_backup_uuid == toString(backup_uuid))
+                    continue;
+
+                const auto status = zk->get(root_zookeeper_path + "/" + existing_backup_path + "/stage");
+                if (status != Stage::COMPLETED)
+                {
+                    LOG_WARNING(log, "Found a concurrent backup: {}, current backup: {}", existing_backup_uuid, toString(backup_uuid));
+                    result = true;
+                    return;
+                }
             }
+
+            zk->createIfNotExists(backup_stage_path, "");
+            auto code = zk->trySet(backup_stage_path, Stage::SCHEDULED_TO_START, stat.version);
+            if (code == Coordination::Error::ZOK)
+                break;
+            bool is_last_attempt = (attempt == MAX_ZOOKEEPER_ATTEMPTS - 1);
+            if ((code != Coordination::Error::ZBADVERSION) || is_last_attempt)
+                throw zkutil::KeeperException(code, backup_stage_path);
         }
+    });
 
-        zk->createIfNotExists(backup_stage_path, "");
-        auto code = zk->trySet(backup_stage_path, Stage::SCHEDULED_TO_START, stat.version);
-        if (code == Coordination::Error::ZOK)
-            break;
-        bool is_last_attempt = (attempt == MAX_ZOOKEEPER_ATTEMPTS - 1);
-        if ((code != Coordination::Error::ZBADVERSION) || is_last_attempt)
-            throw zkutil::KeeperException(code, backup_stage_path);
-    }
-
-    return false;
+    return result;
 }
 
 }
diff --git a/src/Backups/BackupCoordinationRemote.h b/src/Backups/BackupCoordinationRemote.h
index 5155f21c27a..949dd9c9bf0 100644
--- a/src/Backups/BackupCoordinationRemote.h
+++ b/src/Backups/BackupCoordinationRemote.h
@@ -6,7 +6,7 @@
 #include <Backups/BackupCoordinationReplicatedSQLObjects.h>
 #include <Backups/BackupCoordinationReplicatedTables.h>
 #include <Backups/BackupCoordinationStageSync.h>
-#include <Storages/MergeTree/ZooKeeperRetries.h>
+#include <Backups/WithRetries.h>
 
 
 namespace DB
@@ -19,13 +19,7 @@ constexpr size_t MAX_ZOOKEEPER_ATTEMPTS = 10;
 class BackupCoordinationRemote : public IBackupCoordination
 {
 public:
-    struct BackupKeeperSettings
-    {
-        UInt64 keeper_max_retries;
-        UInt64 keeper_retry_initial_backoff_ms;
-        UInt64 keeper_retry_max_backoff_ms;
-        UInt64 keeper_value_max_size;
-    };
+    using BackupKeeperSettings = WithRetries::KeeperSettings;
 
     BackupCoordinationRemote(
         zkutil::GetZooKeeper get_zookeeper_,
@@ -79,7 +73,6 @@ public:
     static size_t findCurrentHostIndex(const Strings & all_hosts, const String & current_host);
 
 private:
-    zkutil::ZooKeeperPtr getZooKeeper() const;
     void createRootNodes();
     void removeAllNodes();
 
@@ -94,7 +87,6 @@ private:
     void prepareReplicatedSQLObjects() const TSA_REQUIRES(replicated_sql_objects_mutex);
     void prepareFileInfos() const TSA_REQUIRES(file_infos_mutex);
 
-    const zkutil::GetZooKeeper get_zookeeper;
     const String root_zookeeper_path;
     const String zookeeper_path;
     const BackupKeeperSettings keeper_settings;
@@ -106,10 +98,10 @@ private:
     const bool is_internal;
     Poco::Logger * const log;
 
-    mutable ZooKeeperRetriesInfo zookeeper_retries_info;
+    /// The order of these two fields matters, because stage_sync holds a reference to with_retries object
+    mutable WithRetries with_retries;
     std::optional<BackupCoordinationStageSync> stage_sync;
 
-    mutable zkutil::ZooKeeperPtr TSA_GUARDED_BY(zookeeper_mutex) zookeeper;
     mutable std::optional<BackupCoordinationReplicatedTables> TSA_GUARDED_BY(replicated_tables_mutex) replicated_tables;
     mutable std::optional<BackupCoordinationReplicatedAccess> TSA_GUARDED_BY(replicated_access_mutex) replicated_access;
     mutable std::optional<BackupCoordinationReplicatedSQLObjects> TSA_GUARDED_BY(replicated_sql_objects_mutex) replicated_sql_objects;
diff --git a/src/Backups/BackupCoordinationReplicatedAccess.cpp b/src/Backups/BackupCoordinationReplicatedAccess.cpp
index 23d35d0ecc4..5a7d049920c 100644
--- a/src/Backups/BackupCoordinationReplicatedAccess.cpp
+++ b/src/Backups/BackupCoordinationReplicatedAccess.cpp
@@ -7,8 +7,13 @@ namespace DB
 BackupCoordinationReplicatedAccess::BackupCoordinationReplicatedAccess() = default;
 BackupCoordinationReplicatedAccess::~BackupCoordinationReplicatedAccess() = default;
 
-void BackupCoordinationReplicatedAccess::addFilePath(const String & access_zk_path, AccessEntityType access_entity_type, const String & host_id, const String & file_path)
+void BackupCoordinationReplicatedAccess::addFilePath(FilePathForAccessEntitry && file_path_for_access_entity)
 {
+    const auto & access_zk_path = file_path_for_access_entity.access_zk_path;
+    const auto & access_entity_type = file_path_for_access_entity.access_entity_type;
+    const auto & host_id = file_path_for_access_entity.host_id;
+    const auto & file_path = file_path_for_access_entity.file_path;
+
     auto & ref = file_paths_by_zk_path[std::make_pair(access_zk_path, access_entity_type)];
     ref.file_paths.emplace(file_path);
 
diff --git a/src/Backups/BackupCoordinationReplicatedAccess.h b/src/Backups/BackupCoordinationReplicatedAccess.h
index 93ae0203be9..9ed9e62c21a 100644
--- a/src/Backups/BackupCoordinationReplicatedAccess.h
+++ b/src/Backups/BackupCoordinationReplicatedAccess.h
@@ -28,8 +28,16 @@ public:
     BackupCoordinationReplicatedAccess();
     ~BackupCoordinationReplicatedAccess();
 
+    struct FilePathForAccessEntitry
+    {
+        String access_zk_path;
+        AccessEntityType access_entity_type;
+        String host_id;
+        String file_path;
+    };
+
     /// Adds a path to access*.txt file keeping access entities of a ReplicatedAccessStorage.
-    void addFilePath(const String & access_zk_path, AccessEntityType access_entity_type, const String & host_id, const String & file_path);
+    void addFilePath(FilePathForAccessEntitry && file_path_for_access_entity);
 
     /// Returns all paths added by addFilePath() if `host_id` is a host chosen to store access.
     Strings getFilePaths(const String & access_zk_path, AccessEntityType access_entity_type, const String & host_id) const;
diff --git a/src/Backups/BackupCoordinationReplicatedSQLObjects.cpp b/src/Backups/BackupCoordinationReplicatedSQLObjects.cpp
index 87b9390e48d..cb326e17411 100644
--- a/src/Backups/BackupCoordinationReplicatedSQLObjects.cpp
+++ b/src/Backups/BackupCoordinationReplicatedSQLObjects.cpp
@@ -7,8 +7,13 @@ namespace DB
 BackupCoordinationReplicatedSQLObjects::BackupCoordinationReplicatedSQLObjects() = default;
 BackupCoordinationReplicatedSQLObjects::~BackupCoordinationReplicatedSQLObjects() = default;
 
-void BackupCoordinationReplicatedSQLObjects::addDirectory(const String & loader_zk_path, UserDefinedSQLObjectType object_type, const String & host_id, const String & dir_path)
+void BackupCoordinationReplicatedSQLObjects::addDirectory(DirectoryPathForSQLObject && directory_path_for_sql_object)
 {
+    const auto & loader_zk_path = directory_path_for_sql_object.loader_zk_path;
+    const auto & object_type = directory_path_for_sql_object.object_type;
+    const auto & host_id = directory_path_for_sql_object.host_id;
+    const auto & dir_path = directory_path_for_sql_object.dir_path;
+
     auto & ref = dir_paths_by_zk_path[std::make_pair(loader_zk_path, object_type)];
     ref.dir_paths.emplace(dir_path);
 
diff --git a/src/Backups/BackupCoordinationReplicatedSQLObjects.h b/src/Backups/BackupCoordinationReplicatedSQLObjects.h
index b70c48edc54..27aa08ee755 100644
--- a/src/Backups/BackupCoordinationReplicatedSQLObjects.h
+++ b/src/Backups/BackupCoordinationReplicatedSQLObjects.h
@@ -28,8 +28,16 @@ public:
     BackupCoordinationReplicatedSQLObjects();
     ~BackupCoordinationReplicatedSQLObjects();
 
+    struct DirectoryPathForSQLObject
+    {
+        String loader_zk_path;
+        UserDefinedSQLObjectType object_type;
+        String host_id;
+        String dir_path;
+    };
+
     /// Adds a path to directory keeping user defined SQL objects.
-    void addDirectory(const String & loader_zk_path, UserDefinedSQLObjectType object_type, const String & host_id, const String & dir_path);
+    void addDirectory(DirectoryPathForSQLObject && directory_path_for_sql_object);
 
     /// Returns all added paths to directories if `host_id` is a host chosen to store user-defined SQL objects.
     Strings getDirectories(const String & loader_zk_path, UserDefinedSQLObjectType object_type, const String & host_id) const;
diff --git a/src/Backups/BackupCoordinationReplicatedTables.cpp b/src/Backups/BackupCoordinationReplicatedTables.cpp
index 27977445641..87de1c7ec75 100644
--- a/src/Backups/BackupCoordinationReplicatedTables.cpp
+++ b/src/Backups/BackupCoordinationReplicatedTables.cpp
@@ -149,12 +149,13 @@ private:
 BackupCoordinationReplicatedTables::BackupCoordinationReplicatedTables() = default;
 BackupCoordinationReplicatedTables::~BackupCoordinationReplicatedTables() = default;
 
-void BackupCoordinationReplicatedTables::addPartNames(
-    const String & table_shared_id,
-    const String & table_name_for_logs,
-    const String & replica_name,
-    const std::vector<PartNameAndChecksum> & part_names_and_checksums)
+void BackupCoordinationReplicatedTables::addPartNames(PartNamesForTableReplica && part_names)
 {
+    const auto & table_shared_id = part_names.table_shared_id;
+    const auto & table_name_for_logs = part_names.table_name_for_logs;
+    const auto & replica_name = part_names.replica_name;
+    const auto & part_names_and_checksums = part_names.part_names_and_checksums;
+
     if (prepared)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "addPartNames() must not be called after preparing");
 
@@ -216,12 +217,13 @@ Strings BackupCoordinationReplicatedTables::getPartNames(const String & table_sh
     return it2->second;
 }
 
-void BackupCoordinationReplicatedTables::addMutations(
-    const String & table_shared_id,
-    const String & table_name_for_logs,
-    const String & replica_name,
-    const std::vector<MutationInfo> & mutations)
+void BackupCoordinationReplicatedTables::addMutations(MutationsForTableReplica && mutations_for_table_replica)
 {
+    const auto & table_shared_id = mutations_for_table_replica.table_shared_id;
+    const auto & table_name_for_logs = mutations_for_table_replica.table_name_for_logs;
+    const auto & replica_name = mutations_for_table_replica.replica_name;
+    const auto & mutations = mutations_for_table_replica.mutations;
+
     if (prepared)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "addMutations() must not be called after preparing");
 
@@ -254,8 +256,11 @@ BackupCoordinationReplicatedTables::getMutations(const String & table_shared_id,
     return res;
 }
 
-void BackupCoordinationReplicatedTables::addDataPath(const String & table_shared_id, const String & data_path)
+void BackupCoordinationReplicatedTables::addDataPath(DataPathForTableReplica && data_path_for_table_replica)
 {
+    const auto & table_shared_id = data_path_for_table_replica.table_shared_id;
+    const auto & data_path = data_path_for_table_replica.data_path;
+
     auto & table_info = table_infos[table_shared_id];
     table_info.data_paths.emplace(data_path);
 }
diff --git a/src/Backups/BackupCoordinationReplicatedTables.h b/src/Backups/BackupCoordinationReplicatedTables.h
index 7b9f608d28b..74f21eb9c7c 100644
--- a/src/Backups/BackupCoordinationReplicatedTables.h
+++ b/src/Backups/BackupCoordinationReplicatedTables.h
@@ -38,15 +38,19 @@ public:
 
     using PartNameAndChecksum = IBackupCoordination::PartNameAndChecksum;
 
+    struct PartNamesForTableReplica
+    {
+        String table_shared_id;
+        String table_name_for_logs;
+        String replica_name;
+        std::vector<PartNameAndChecksum> part_names_and_checksums;
+    };
+
     /// Adds part names which a specified replica of a replicated table is going to put to the backup.
     /// Multiple replicas of the replicated table call this function and then the added part names can be returned by call of the function
     /// getPartNames().
     /// Checksums are used only to control that parts under the same names on different replicas are the same.
-    void addPartNames(
-        const String & table_shared_id,
-        const String & table_name_for_logs,
-        const String & replica_name,
-        const std::vector<PartNameAndChecksum> & part_names_and_checksums);
+    void addPartNames(PartNamesForTableReplica && part_names);
 
     /// Returns the names of the parts which a specified replica of a replicated table should put to the backup.
     /// This is the same list as it was added by call of the function addPartNames() but without duplications and without
@@ -55,20 +59,30 @@ public:
 
     using MutationInfo = IBackupCoordination::MutationInfo;
 
+    struct MutationsForTableReplica
+    {
+        String table_shared_id;
+        String table_name_for_logs;
+        String replica_name;
+        std::vector<MutationInfo> mutations;
+    };
+
     /// Adds information about mutations of a replicated table.
-    void addMutations(
-        const String & table_shared_id,
-        const String & table_name_for_logs,
-        const String & replica_name,
-        const std::vector<MutationInfo> & mutations);
+    void addMutations(MutationsForTableReplica && mutations_for_table_replica);
 
     /// Returns all mutations of a replicated table which are not finished for some data parts added by addReplicatedPartNames().
     std::vector<MutationInfo> getMutations(const String & table_shared_id, const String & replica_name) const;
 
+    struct DataPathForTableReplica
+    {
+        String table_shared_id;
+        String data_path;
+    };
+
     /// Adds a data path in backup for a replicated table.
     /// Multiple replicas of the replicated table call this function and then all the added paths can be returned by call of the function
     /// getDataPaths().
-    void addDataPath(const String & table_shared_id, const String & data_path);
+    void addDataPath(DataPathForTableReplica && data_path_for_table_replica);
 
     /// Returns all the data paths in backup added for a replicated table (see also addReplicatedDataPath()).
     Strings getDataPaths(const String & table_shared_id) const;
diff --git a/src/Backups/BackupCoordinationStageSync.cpp b/src/Backups/BackupCoordinationStageSync.cpp
index e4773223075..effb00085c3 100644
--- a/src/Backups/BackupCoordinationStageSync.cpp
+++ b/src/Backups/BackupCoordinationStageSync.cpp
@@ -1,11 +1,13 @@
 #include <Backups/BackupCoordinationStageSync.h>
+
+#include <base/chrono_io.h>
+#include <Common/ZooKeeper/Common.h>
 #include <Common/Exception.h>
 #include <Common/ZooKeeper/KeeperException.h>
 #include <IO/ReadBufferFromString.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteBufferFromString.h>
 #include <IO/WriteHelpers.h>
-#include <base/chrono_io.h>
 
 
 namespace DB
@@ -17,9 +19,12 @@ namespace ErrorCodes
 }
 
 
-BackupCoordinationStageSync::BackupCoordinationStageSync(const String & zookeeper_path_, zkutil::GetZooKeeper get_zookeeper_, Poco::Logger * log_)
-    : zookeeper_path(zookeeper_path_)
-    , get_zookeeper(get_zookeeper_)
+BackupCoordinationStageSync::BackupCoordinationStageSync(
+    const String & root_zookeeper_path_,
+    WithRetries & with_retries_,
+    Poco::Logger * log_)
+    : zookeeper_path(root_zookeeper_path_ + "/stage")
+    , with_retries(with_retries_)
     , log(log_)
 {
     createRootNodes();
@@ -27,32 +32,48 @@ BackupCoordinationStageSync::BackupCoordinationStageSync(const String & zookeepe
 
 void BackupCoordinationStageSync::createRootNodes()
 {
-    auto zookeeper = get_zookeeper();
-    zookeeper->createAncestors(zookeeper_path);
-    zookeeper->createIfNotExists(zookeeper_path, "");
+    auto holder = with_retries.createRetriesControlHolder("createRootNodes");
+    holder.retries_ctl.retryLoop(
+        [&, &zookeeper = holder.faulty_zookeeper]()
+    {
+        with_retries.renewZooKeeper(zookeeper);
+        zookeeper->createAncestors(zookeeper_path);
+        zookeeper->createIfNotExists(zookeeper_path, "");
+    });
 }
 
 void BackupCoordinationStageSync::set(const String & current_host, const String & new_stage, const String & message)
 {
-    auto zookeeper = get_zookeeper();
+    auto holder = with_retries.createRetriesControlHolder("set");
+    holder.retries_ctl.retryLoop(
+        [&, &zookeeper = holder.faulty_zookeeper]()
+    {
+        with_retries.renewZooKeeper(zookeeper);
 
-    /// Make an ephemeral node so the initiator can track if the current host is still working.
-    String alive_node_path = zookeeper_path + "/alive|" + current_host;
-    auto code = zookeeper->tryCreate(alive_node_path, "", zkutil::CreateMode::Ephemeral);
-    if (code != Coordination::Error::ZOK && code != Coordination::Error::ZNODEEXISTS)
-        throw zkutil::KeeperException(code, alive_node_path);
+        /// Make an ephemeral node so the initiator can track if the current host is still working.
+        String alive_node_path = zookeeper_path + "/alive|" + current_host;
+        auto code = zookeeper->tryCreate(alive_node_path, "", zkutil::CreateMode::Ephemeral);
+        if (code != Coordination::Error::ZOK && code != Coordination::Error::ZNODEEXISTS)
+            throw zkutil::KeeperException(code, alive_node_path);
 
-    zookeeper->createIfNotExists(zookeeper_path + "/started|" + current_host, "");
-    zookeeper->create(zookeeper_path + "/current|" + current_host + "|" + new_stage, message, zkutil::CreateMode::Persistent);
+        zookeeper->createIfNotExists(zookeeper_path + "/started|" + current_host, "");
+        zookeeper->createIfNotExists(zookeeper_path + "/current|" + current_host + "|" + new_stage, message);
+    });
 }
 
 void BackupCoordinationStageSync::setError(const String & current_host, const Exception & exception)
 {
-    auto zookeeper = get_zookeeper();
-    WriteBufferFromOwnString buf;
-    writeStringBinary(current_host, buf);
-    writeException(exception, buf, true);
-    zookeeper->createIfNotExists(zookeeper_path + "/error", buf.str());
+    auto holder = with_retries.createRetriesControlHolder("setError");
+    holder.retries_ctl.retryLoop(
+        [&, &zookeeper = holder.faulty_zookeeper]()
+    {
+        with_retries.renewZooKeeper(zookeeper);
+
+        WriteBufferFromOwnString buf;
+        writeStringBinary(current_host, buf);
+        writeException(exception, buf, true);
+        zookeeper->createIfNotExists(zookeeper_path + "/error", buf.str());
+    });
 }
 
 Strings BackupCoordinationStageSync::wait(const Strings & all_hosts, const String & stage_to_wait)
@@ -83,14 +104,24 @@ struct BackupCoordinationStageSync::State
 };
 
 BackupCoordinationStageSync::State BackupCoordinationStageSync::readCurrentState(
-    zkutil::ZooKeeperPtr zookeeper, const Strings & zk_nodes, const Strings & all_hosts, const String & stage_to_wait) const
+    const Strings & zk_nodes, const Strings & all_hosts, const String & stage_to_wait) const
 {
     std::unordered_set<std::string_view> zk_nodes_set{zk_nodes.begin(), zk_nodes.end()};
 
     State state;
     if (zk_nodes_set.contains("error"))
     {
-        ReadBufferFromOwnString buf{zookeeper->get(zookeeper_path + "/error")};
+        String errors;
+        {
+            auto holder = with_retries.createRetriesControlHolder("readCurrentState");
+            holder.retries_ctl.retryLoop(
+                [&, &zookeeper = holder.faulty_zookeeper]()
+                {
+                    with_retries.renewZooKeeper(zookeeper);
+                    errors = zookeeper->get(zookeeper_path + "/error");
+                });
+        }
+        ReadBufferFromOwnString buf{errors};
         String host;
         readStringBinary(host, buf);
         state.error = std::make_pair(host, readException(buf, fmt::format("Got error from {}", host)));
@@ -102,8 +133,38 @@ BackupCoordinationStageSync::State BackupCoordinationStageSync::readCurrentState
         if (!zk_nodes_set.contains("current|" + host + "|" + stage_to_wait))
         {
             UnreadyHostState unready_host_state;
-            unready_host_state.started = zk_nodes_set.contains("started|" + host);
-            unready_host_state.alive = zk_nodes_set.contains("alive|" + host);
+            const String started_node_name = "started|" + host;
+            const String alive_node_name = "alive|" + host;
+            const String alive_node_path = zookeeper_path + "/" + alive_node_name;
+            unready_host_state.started = zk_nodes_set.contains(started_node_name);
+
+            /// Because we do retries everywhere we can't fully rely on ephemeral nodes anymore.
+            /// Though we recreate "alive" node when reconnecting it might be not enough and race condition is possible.
+            /// And everything we can do here - just retry.
+            /// In worst case when we won't manage to see the alive node for a long time we will just abort the backup.
+            unready_host_state.alive = zk_nodes_set.contains(alive_node_name);
+            if (!unready_host_state.alive)
+            {
+                LOG_TRACE(log, "Seems like host ({}) is dead. Will retry the check to confirm", host);
+                auto holder = with_retries.createRetriesControlHolder("readCurrentState::checkAliveNode");
+                holder.retries_ctl.retryLoop(
+                    [&, &zookeeper = holder.faulty_zookeeper]()
+                {
+                    with_retries.renewZooKeeper(zookeeper);
+
+                    if (zookeeper->existsNoFailureInjection(alive_node_path))
+                    {
+                        unready_host_state.alive = true;
+                        return;
+                    }
+
+                    // Retry with backoff. We also check whether it is last retry or no, because we won't to rethrow an exception.
+                    if (!holder.retries_ctl.isLastRetry())
+                        holder.retries_ctl.setKeeperError(Coordination::Error::ZNONODE, "There is no alive node for host {}. Will retry", host);
+                });
+            }
+            LOG_TRACE(log, "Host ({}) appeared to be {}", host, unready_host_state.alive ? "alive" : "dead");
+
             state.unready_hosts.emplace(host, unready_host_state);
             if (!unready_host_state.alive && unready_host_state.started && !state.host_terminated)
                 state.host_terminated = host;
@@ -113,51 +174,62 @@ BackupCoordinationStageSync::State BackupCoordinationStageSync::readCurrentState
     if (state.host_terminated || !state.unready_hosts.empty())
         return state;
 
-    state.results.reserve(all_hosts.size());
-    for (const auto & host : all_hosts)
-        state.results.emplace_back(zookeeper->get(zookeeper_path + "/current|" + host + "|" + stage_to_wait));
+    auto holder = with_retries.createRetriesControlHolder("waitImpl::collectStagesToWait");
+    holder.retries_ctl.retryLoop(
+        [&, &zookeeper = holder.faulty_zookeeper]()
+    {
+        with_retries.renewZooKeeper(zookeeper);
+        Strings results;
+
+        for (const auto & host : all_hosts)
+            results.emplace_back(zookeeper->get(zookeeper_path + "/current|" + host + "|" + stage_to_wait));
+
+        state.results = std::move(results);
+    });
 
     return state;
 }
 
-Strings BackupCoordinationStageSync::waitImpl(const Strings & all_hosts, const String & stage_to_wait, std::optional<std::chrono::milliseconds> timeout) const
+Strings BackupCoordinationStageSync::waitImpl(
+    const Strings & all_hosts, const String & stage_to_wait, std::optional<std::chrono::milliseconds> timeout) const
 {
     if (all_hosts.empty())
         return {};
 
     /// Wait until all hosts are ready or an error happens or time is out.
 
-    auto zookeeper = get_zookeeper();
-
-    /// Set by ZooKepper when list of zk nodes have changed.
-    auto watch = std::make_shared<Poco::Event>();
-
     bool use_timeout = timeout.has_value();
     std::chrono::steady_clock::time_point end_of_timeout;
     if (use_timeout)
         end_of_timeout = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(*timeout);
 
     State state;
-
-    String previous_unready_host; /// Used for logging: we don't want to log the same unready host again.
-
     for (;;)
     {
-        /// Get zk nodes and subscribe on their changes.
-        Strings zk_nodes = zookeeper->getChildren(zookeeper_path, nullptr, watch);
+        LOG_INFO(log, "Waiting for the stage {}", stage_to_wait);
+        /// Set by ZooKepper when list of zk nodes have changed.
+        auto watch = std::make_shared<Poco::Event>();
+        Strings zk_nodes;
+        {
+            auto holder = with_retries.createRetriesControlHolder("waitImpl::getChildren");
+            holder.retries_ctl.retryLoop(
+                [&, &zookeeper = holder.faulty_zookeeper]()
+            {
+                with_retries.renewZooKeeper(zookeeper);
+                watch->reset();
+                /// Get zk nodes and subscribe on their changes.
+                zk_nodes = zookeeper->getChildren(zookeeper_path, nullptr, watch);
+            });
+        }
 
         /// Read and analyze the current state of zk nodes.
-        state = readCurrentState(zookeeper, zk_nodes, all_hosts, stage_to_wait);
+        state = readCurrentState(zk_nodes, all_hosts, stage_to_wait);
         if (state.error || state.host_terminated || state.unready_hosts.empty())
             break; /// Error happened or everything is ready.
 
-        /// Log that we will wait for another host.
+        /// Log that we will wait
         const auto & unready_host = state.unready_hosts.begin()->first;
-        if (unready_host != previous_unready_host)
-        {
-            LOG_TRACE(log, "Waiting for host {}", unready_host);
-            previous_unready_host = unready_host;
-        }
+        LOG_INFO(log, "Waiting on ZooKeeper watch for any node to be changed (currently waiting for host {})", unready_host);
 
         /// Wait until `watch_callback` is called by ZooKeeper meaning that zk nodes have changed.
         {
@@ -195,6 +267,7 @@ Strings BackupCoordinationStageSync::waitImpl(const Strings & all_hosts, const S
             unready_host_state.started ? "" : ": Operation didn't start");
     }
 
+    LOG_TRACE(log, "Everything is Ok. All hosts achieved stage {}", stage_to_wait);
     return state.results;
 }
 
diff --git a/src/Backups/BackupCoordinationStageSync.h b/src/Backups/BackupCoordinationStageSync.h
index 623b58fd9fa..56081f8779c 100644
--- a/src/Backups/BackupCoordinationStageSync.h
+++ b/src/Backups/BackupCoordinationStageSync.h
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <Common/ZooKeeper/Common.h>
-
+#include <Backups/WithRetries.h>
 
 namespace DB
 {
@@ -10,7 +9,10 @@ namespace DB
 class BackupCoordinationStageSync
 {
 public:
-    BackupCoordinationStageSync(const String & zookeeper_path_, zkutil::GetZooKeeper get_zookeeper_, Poco::Logger * log_);
+    BackupCoordinationStageSync(
+        const String & root_zookeeper_path_,
+        WithRetries & with_retries_,
+        Poco::Logger * log_);
 
     /// Sets the stage of the current host and signal other hosts if there were other hosts waiting for that.
     void set(const String & current_host, const String & new_stage, const String & message);
@@ -27,12 +29,13 @@ private:
     void createRootNodes();
 
     struct State;
-    State readCurrentState(zkutil::ZooKeeperPtr zookeeper, const Strings & zk_nodes, const Strings & all_hosts, const String & stage_to_wait) const;
+    State readCurrentState(const Strings & zk_nodes, const Strings & all_hosts, const String & stage_to_wait) const;
 
     Strings waitImpl(const Strings & all_hosts, const String & stage_to_wait, std::optional<std::chrono::milliseconds> timeout) const;
 
     String zookeeper_path;
-    zkutil::GetZooKeeper get_zookeeper;
+    /// A reference to the field of parent object - BackupCoordinationRemote or RestoreCoordinationRemote
+    WithRetries & with_retries;
     Poco::Logger * log;
 };
 
diff --git a/src/Backups/BackupEntriesCollector.cpp b/src/Backups/BackupEntriesCollector.cpp
index 4d117f54342..1adc4d41fee 100644
--- a/src/Backups/BackupEntriesCollector.cpp
+++ b/src/Backups/BackupEntriesCollector.cpp
@@ -84,6 +84,12 @@ BackupEntriesCollector::BackupEntriesCollector(
     , on_cluster_first_sync_timeout(context->getConfigRef().getUInt64("backups.on_cluster_first_sync_timeout", 180000))
     , consistent_metadata_snapshot_timeout(context->getConfigRef().getUInt64("backups.consistent_metadata_snapshot_timeout", 600000))
     , log(&Poco::Logger::get("BackupEntriesCollector"))
+    , global_zookeeper_retries_info(
+        "BackupEntriesCollector",
+        log,
+        context->getSettingsRef().backup_restore_keeper_max_retries,
+        context->getSettingsRef().backup_restore_keeper_retry_initial_backoff_ms,
+        context->getSettingsRef().backup_restore_keeper_retry_max_backoff_ms)
 {
 }
 
@@ -482,7 +488,10 @@ std::vector<std::pair<ASTPtr, StoragePtr>> BackupEntriesCollector::findTablesInD
 
     try
     {
-        db_tables = database->getTablesForBackup(filter_by_table_name, context);
+        /// Database or table could be replicated - so may use ZooKeeper. We need to retry.
+        auto zookeeper_retries_info = global_zookeeper_retries_info;
+        ZooKeeperRetriesControl retries_ctl("getTablesForBackup", zookeeper_retries_info);
+        retries_ctl.retryLoop([&](){ db_tables = database->getTablesForBackup(filter_by_table_name, context); });
     }
     catch (Exception & e)
     {
@@ -745,6 +754,7 @@ void BackupEntriesCollector::addPostTask(std::function<void()> task)
 /// Runs all the tasks added with addPostCollectingTask().
 void BackupEntriesCollector::runPostTasks()
 {
+    LOG_TRACE(log, "Will run {} post tasks", post_tasks.size());
     /// Post collecting tasks can add other post collecting tasks, our code is fine with that.
     while (!post_tasks.empty())
     {
@@ -752,6 +762,7 @@ void BackupEntriesCollector::runPostTasks()
         post_tasks.pop();
         std::move(task)();
     }
+    LOG_TRACE(log, "All post tasks successfully executed");
 }
 
 size_t BackupEntriesCollector::getAccessCounter(AccessEntityType type)
diff --git a/src/Backups/BackupEntriesCollector.h b/src/Backups/BackupEntriesCollector.h
index eca0dd8e078..be6ca8d1ebe 100644
--- a/src/Backups/BackupEntriesCollector.h
+++ b/src/Backups/BackupEntriesCollector.h
@@ -6,6 +6,7 @@
 #include <Parsers/ASTBackupQuery.h>
 #include <Storages/IStorage_fwd.h>
 #include <Storages/TableLockHolder.h>
+#include <Storages/MergeTree/ZooKeeperRetries.h>
 #include <filesystem>
 #include <queue>
 
@@ -96,6 +97,9 @@ private:
     std::chrono::milliseconds on_cluster_first_sync_timeout;
     std::chrono::milliseconds consistent_metadata_snapshot_timeout;
     Poco::Logger * log;
+    /// Unfortunately we can use ZooKeeper for collecting information for backup
+    /// and we need to retry...
+    ZooKeeperRetriesInfo global_zookeeper_retries_info;
 
     Strings all_hosts;
     DDLRenamingMap renaming_map;
diff --git a/src/Backups/BackupsWorker.cpp b/src/Backups/BackupsWorker.cpp
index 4572e481829..58f0b3effc5 100644
--- a/src/Backups/BackupsWorker.cpp
+++ b/src/Backups/BackupsWorker.cpp
@@ -58,10 +58,13 @@ namespace
 
             BackupCoordinationRemote::BackupKeeperSettings keeper_settings
             {
-                .keeper_max_retries = context->getSettingsRef().backup_keeper_max_retries,
-                .keeper_retry_initial_backoff_ms = context->getSettingsRef().backup_keeper_retry_initial_backoff_ms,
-                .keeper_retry_max_backoff_ms = context->getSettingsRef().backup_keeper_retry_max_backoff_ms,
-                .keeper_value_max_size = context->getSettingsRef().backup_keeper_value_max_size,
+                .keeper_max_retries = context->getSettingsRef().backup_restore_keeper_max_retries,
+                .keeper_retry_initial_backoff_ms = context->getSettingsRef().backup_restore_keeper_retry_initial_backoff_ms,
+                .keeper_retry_max_backoff_ms = context->getSettingsRef().backup_restore_keeper_retry_max_backoff_ms,
+                .batch_size_for_keeper_multiread = context->getSettingsRef().backup_restore_batch_size_for_keeper_multiread,
+                .keeper_fault_injection_probability = context->getSettingsRef().backup_restore_keeper_fault_injection_probability,
+                .keeper_fault_injection_seed = context->getSettingsRef().backup_restore_keeper_fault_injection_seed,
+                .keeper_value_max_size = context->getSettingsRef().backup_restore_keeper_value_max_size,
             };
 
             auto all_hosts = BackupSettings::Util::filterHostIDs(
@@ -92,10 +95,27 @@ namespace
 
             auto get_zookeeper = [global_context = context->getGlobalContext()] { return global_context->getZooKeeper(); };
 
+            RestoreCoordinationRemote::RestoreKeeperSettings keeper_settings
+            {
+                .keeper_max_retries = context->getSettingsRef().backup_restore_keeper_max_retries,
+                .keeper_retry_initial_backoff_ms = context->getSettingsRef().backup_restore_keeper_retry_initial_backoff_ms,
+                .keeper_retry_max_backoff_ms = context->getSettingsRef().backup_restore_keeper_retry_max_backoff_ms,
+                .batch_size_for_keeper_multiread = context->getSettingsRef().backup_restore_batch_size_for_keeper_multiread,
+                .keeper_fault_injection_probability = context->getSettingsRef().backup_restore_keeper_fault_injection_probability,
+                .keeper_fault_injection_seed = context->getSettingsRef().backup_restore_keeper_fault_injection_seed
+            };
+
             auto all_hosts = BackupSettings::Util::filterHostIDs(
                 restore_settings.cluster_host_ids, restore_settings.shard_num, restore_settings.replica_num);
 
-            return std::make_shared<RestoreCoordinationRemote>(get_zookeeper, root_zk_path, toString(*restore_settings.restore_uuid), all_hosts, restore_settings.host_id, restore_settings.internal);
+            return std::make_shared<RestoreCoordinationRemote>(
+                get_zookeeper,
+                root_zk_path,
+                keeper_settings,
+                toString(*restore_settings.restore_uuid),
+                all_hosts,
+                restore_settings.host_id,
+                restore_settings.internal);
         }
         else
         {
@@ -660,7 +680,9 @@ void BackupsWorker::doRestore(
             restore_coordination = makeRestoreCoordination(context, restore_settings, /* remote= */ on_cluster);
 
         if (!allow_concurrent_restores && restore_coordination->hasConcurrentRestores(std::ref(num_active_restores)))
-            throw Exception(ErrorCodes::CONCURRENT_ACCESS_NOT_SUPPORTED, "Concurrent restores not supported, turn on setting 'allow_concurrent_restores'");
+            throw Exception(
+                ErrorCodes::CONCURRENT_ACCESS_NOT_SUPPORTED,
+                "Concurrent restores not supported, turn on setting 'allow_concurrent_restores'");
 
         /// Do RESTORE.
         if (on_cluster)
diff --git a/src/Backups/RestoreCoordinationRemote.cpp b/src/Backups/RestoreCoordinationRemote.cpp
index d93f99a3f2a..0187ad0e7e2 100644
--- a/src/Backups/RestoreCoordinationRemote.cpp
+++ b/src/Backups/RestoreCoordinationRemote.cpp
@@ -1,9 +1,10 @@
+#include <Backups/BackupCoordinationRemote.h>
+#include <Backups/BackupCoordinationStage.h>
 #include <Backups/RestoreCoordinationRemote.h>
 #include <Functions/UserDefined/UserDefinedSQLObjectType.h>
 #include <Common/ZooKeeper/KeeperException.h>
 #include <Common/escapeForFileName.h>
-#include <Backups/BackupCoordinationStage.h>
-#include <Backups/BackupCoordinationRemote.h>
+#include "Backups/BackupCoordinationStageSync.h"
 
 namespace DB
 {
@@ -13,12 +14,14 @@ namespace Stage = BackupCoordinationStage;
 RestoreCoordinationRemote::RestoreCoordinationRemote(
     zkutil::GetZooKeeper get_zookeeper_,
     const String & root_zookeeper_path_,
+    const RestoreKeeperSettings & keeper_settings_,
     const String & restore_uuid_,
     const Strings & all_hosts_,
     const String & current_host_,
     bool is_internal_)
     : get_zookeeper(get_zookeeper_)
     , root_zookeeper_path(root_zookeeper_path_)
+    , keeper_settings(keeper_settings_)
     , restore_uuid(restore_uuid_)
     , zookeeper_path(root_zookeeper_path_ + "/restore-" + restore_uuid_)
     , all_hosts(all_hosts_)
@@ -26,11 +29,32 @@ RestoreCoordinationRemote::RestoreCoordinationRemote(
     , current_host_index(BackupCoordinationRemote::findCurrentHostIndex(all_hosts, current_host))
     , is_internal(is_internal_)
     , log(&Poco::Logger::get("RestoreCoordinationRemote"))
+    , with_retries(
+        log,
+        get_zookeeper_,
+        keeper_settings,
+        [zookeeper_path = zookeeper_path, current_host = current_host, is_internal = is_internal]
+        (WithRetries::FaultyKeeper & zk)
+        {
+            /// Recreate this ephemeral node to signal that we are alive.
+            if (is_internal)
+            {
+                String alive_node_path = zookeeper_path + "/stage/alive|" + current_host;
+                auto code = zk->tryCreate(alive_node_path, "", zkutil::CreateMode::Ephemeral);
+
+                if (code == Coordination::Error::ZNODEEXISTS)
+                    zk->handleEphemeralNodeExistenceNoFailureInjection(alive_node_path, "");
+                else if (code != Coordination::Error::ZOK)
+                    throw zkutil::KeeperException(code, alive_node_path);
+            }
+        })
 {
     createRootNodes();
 
     stage_sync.emplace(
-        zookeeper_path + "/stage", [this] { return getZooKeeper(); }, log);
+        zookeeper_path,
+        with_retries,
+        log);
 }
 
 RestoreCoordinationRemote::~RestoreCoordinationRemote()
@@ -46,31 +70,25 @@ RestoreCoordinationRemote::~RestoreCoordinationRemote()
     }
 }
 
-zkutil::ZooKeeperPtr RestoreCoordinationRemote::getZooKeeper() const
-{
-    std::lock_guard lock{mutex};
-    if (!zookeeper || zookeeper->expired())
-    {
-        zookeeper = get_zookeeper();
-
-        /// It's possible that we connected to different [Zoo]Keeper instance
-        /// so we may read a bit stale state.
-        zookeeper->sync(zookeeper_path);
-    }
-    return zookeeper;
-}
-
 void RestoreCoordinationRemote::createRootNodes()
 {
-    auto zk = getZooKeeper();
-    zk->createAncestors(zookeeper_path);
-    zk->createIfNotExists(zookeeper_path, "");
-    zk->createIfNotExists(zookeeper_path + "/repl_databases_tables_acquired", "");
-    zk->createIfNotExists(zookeeper_path + "/repl_tables_data_acquired", "");
-    zk->createIfNotExists(zookeeper_path + "/repl_access_storages_acquired", "");
-    zk->createIfNotExists(zookeeper_path + "/repl_sql_objects_acquired", "");
-}
+    auto holder = with_retries.createRetriesControlHolder("createRootNodes");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
+        {
+            with_retries.renewZooKeeper(zk);
+            zk->createAncestors(zookeeper_path);
 
+            Coordination::Requests ops;
+            Coordination::Responses responses;
+            ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path, "", zkutil::CreateMode::Persistent));
+            ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/repl_databases_tables_acquired", "", zkutil::CreateMode::Persistent));
+            ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/repl_tables_data_acquired", "", zkutil::CreateMode::Persistent));
+            ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/repl_access_storages_acquired", "", zkutil::CreateMode::Persistent));
+            ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/repl_sql_objects_acquired", "", zkutil::CreateMode::Persistent));
+            zk->tryMulti(ops, responses);
+        });
+}
 
 void RestoreCoordinationRemote::setStage(const String & new_stage, const String & message)
 {
@@ -92,66 +110,121 @@ Strings RestoreCoordinationRemote::waitForStage(const String & stage_to_wait, st
     return stage_sync->waitFor(all_hosts, stage_to_wait, timeout);
 }
 
-
 bool RestoreCoordinationRemote::acquireCreatingTableInReplicatedDatabase(const String & database_zk_path, const String & table_name)
 {
-    auto zk = getZooKeeper();
+    bool result = false;
+    auto holder = with_retries.createRetriesControlHolder("acquireCreatingTableInReplicatedDatabase");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
+        {
+            with_retries.renewZooKeeper(zk);
 
-    String path = zookeeper_path + "/repl_databases_tables_acquired/" + escapeForFileName(database_zk_path);
-    zk->createIfNotExists(path, "");
+            String path = zookeeper_path + "/repl_databases_tables_acquired/" + escapeForFileName(database_zk_path);
+            zk->createIfNotExists(path, "");
 
-    path += "/" + escapeForFileName(table_name);
-    auto code = zk->tryCreate(path, "", zkutil::CreateMode::Persistent);
-    if ((code != Coordination::Error::ZOK) && (code != Coordination::Error::ZNODEEXISTS))
-        throw zkutil::KeeperException(code, path);
+            path += "/" + escapeForFileName(table_name);
+            auto code = zk->tryCreate(path, toString(current_host_index), zkutil::CreateMode::Persistent);
+            if ((code != Coordination::Error::ZOK) && (code != Coordination::Error::ZNODEEXISTS))
+                throw zkutil::KeeperException(code, path);
 
-    return (code == Coordination::Error::ZOK);
+            if (code == Coordination::Error::ZOK)
+            {
+                result = true;
+                return;
+            }
+
+            /// We need to check who created that node
+            result = zk->get(path) == toString(current_host_index);
+        });
+    return result;
 }
 
 bool RestoreCoordinationRemote::acquireInsertingDataIntoReplicatedTable(const String & table_zk_path)
 {
-    auto zk = getZooKeeper();
+    bool result = false;
+    auto holder = with_retries.createRetriesControlHolder("acquireInsertingDataIntoReplicatedTable");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
+        {
+            with_retries.renewZooKeeper(zk);
 
-    String path = zookeeper_path + "/repl_tables_data_acquired/" + escapeForFileName(table_zk_path);
-    auto code = zk->tryCreate(path, "", zkutil::CreateMode::Persistent);
-    if ((code != Coordination::Error::ZOK) && (code != Coordination::Error::ZNODEEXISTS))
-        throw zkutil::KeeperException(code, path);
+            String path = zookeeper_path + "/repl_tables_data_acquired/" + escapeForFileName(table_zk_path);
+            auto code = zk->tryCreate(path, toString(current_host_index), zkutil::CreateMode::Persistent);
+            if ((code != Coordination::Error::ZOK) && (code != Coordination::Error::ZNODEEXISTS))
+                throw zkutil::KeeperException(code, path);
 
-    return (code == Coordination::Error::ZOK);
+            if (code == Coordination::Error::ZOK)
+            {
+                result = true;
+                return;
+            }
+
+            /// We need to check who created that node
+            result = zk->get(path) == toString(current_host_index);
+        });
+    return result;
 }
 
 bool RestoreCoordinationRemote::acquireReplicatedAccessStorage(const String & access_storage_zk_path)
 {
-    auto zk = getZooKeeper();
+    bool result = false;
+    auto holder = with_retries.createRetriesControlHolder("acquireReplicatedAccessStorage");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
+        {
+            with_retries.renewZooKeeper(zk);
 
-    String path = zookeeper_path + "/repl_access_storages_acquired/" + escapeForFileName(access_storage_zk_path);
-    auto code = zk->tryCreate(path, "", zkutil::CreateMode::Persistent);
-    if ((code != Coordination::Error::ZOK) && (code != Coordination::Error::ZNODEEXISTS))
-        throw zkutil::KeeperException(code, path);
+            String path = zookeeper_path + "/repl_access_storages_acquired/" + escapeForFileName(access_storage_zk_path);
+            auto code = zk->tryCreate(path, toString(current_host_index), zkutil::CreateMode::Persistent);
+            if ((code != Coordination::Error::ZOK) && (code != Coordination::Error::ZNODEEXISTS))
+                throw zkutil::KeeperException(code, path);
 
-    return (code == Coordination::Error::ZOK);
+            if (code == Coordination::Error::ZOK)
+            {
+                result = true;
+                return;
+            }
+
+            /// We need to check who created that node
+            result = zk->get(path) == toString(current_host_index);
+        });
+    return result;
 }
 
 bool RestoreCoordinationRemote::acquireReplicatedSQLObjects(const String & loader_zk_path, UserDefinedSQLObjectType object_type)
 {
-    auto zk = getZooKeeper();
+    bool result = false;
+    auto holder = with_retries.createRetriesControlHolder("acquireReplicatedSQLObjects");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
+        {
+            with_retries.renewZooKeeper(zk);
 
-    String path = zookeeper_path + "/repl_sql_objects_acquired/" + escapeForFileName(loader_zk_path);
-    zk->createIfNotExists(path, "");
+            String path = zookeeper_path + "/repl_sql_objects_acquired/" + escapeForFileName(loader_zk_path);
+            zk->createIfNotExists(path, "");
 
-    path += "/";
-    switch (object_type)
-    {
-        case UserDefinedSQLObjectType::Function:
-            path += "functions";
-            break;
-    }
+            path += "/";
+            switch (object_type)
+            {
+                case UserDefinedSQLObjectType::Function:
+                    path += "functions";
+                    break;
+            }
 
-    auto code = zk->tryCreate(path, "", zkutil::CreateMode::Persistent);
-    if ((code != Coordination::Error::ZOK) && (code != Coordination::Error::ZNODEEXISTS))
-        throw zkutil::KeeperException(code, path);
+            auto code = zk->tryCreate(path, "", zkutil::CreateMode::Persistent);
+            if ((code != Coordination::Error::ZOK) && (code != Coordination::Error::ZNODEEXISTS))
+                throw zkutil::KeeperException(code, path);
 
-    return (code == Coordination::Error::ZOK);
+            if (code == Coordination::Error::ZOK)
+            {
+                result = true;
+                return;
+            }
+
+            /// We need to check who created that node
+            result =  zk->get(path) == toString(current_host_index);
+        });
+    return result;
 }
 
 void RestoreCoordinationRemote::removeAllNodes()
@@ -163,8 +236,13 @@ void RestoreCoordinationRemote::removeAllNodes()
     /// at `zookeeper_path` which might cause such hosts to stop with exception "ZNONODE". Or such hosts might still do some part
     /// of their restore work before that.
 
-    auto zk = getZooKeeper();
-    zk->removeRecursive(zookeeper_path);
+    auto holder = with_retries.createRetriesControlHolder("removeAllNodes");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
+        {
+            with_retries.renewZooKeeper(zk);
+            zk->removeRecursive(zookeeper_path);
+        });
 }
 
 bool RestoreCoordinationRemote::hasConcurrentRestores(const std::atomic<size_t> &) const
@@ -173,46 +251,54 @@ bool RestoreCoordinationRemote::hasConcurrentRestores(const std::atomic<size_t>
     if (is_internal)
         return false;
 
-    auto zk = getZooKeeper();
+    bool result = false;
     std::string path = zookeeper_path +"/stage";
 
-    if (! zk->exists(root_zookeeper_path))
-        zk->createAncestors(root_zookeeper_path);
-
-    for (size_t attempt = 0; attempt < MAX_ZOOKEEPER_ATTEMPTS; ++attempt)
-    {
-        Coordination::Stat stat;
-        zk->get(root_zookeeper_path, &stat);
-        Strings existing_restore_paths = zk->getChildren(root_zookeeper_path);
-        for (const auto & existing_restore_path : existing_restore_paths)
+    auto holder = with_retries.createRetriesControlHolder("createRootNodes");
+    holder.retries_ctl.retryLoop(
+        [&, &zk = holder.faulty_zookeeper]()
         {
-            if (startsWith(existing_restore_path, "backup-"))
-                continue;
+            with_retries.renewZooKeeper(zk);
 
-            String existing_restore_uuid = existing_restore_path;
-            existing_restore_uuid.erase(0, String("restore-").size());
+            if (! zk->exists(root_zookeeper_path))
+                zk->createAncestors(root_zookeeper_path);
 
-            if (existing_restore_uuid == toString(restore_uuid))
-                continue;
-
-
-            const auto status = zk->get(root_zookeeper_path + "/" + existing_restore_path + "/stage");
-            if (status != Stage::COMPLETED)
+            for (size_t attempt = 0; attempt < MAX_ZOOKEEPER_ATTEMPTS; ++attempt)
             {
-                LOG_WARNING(log, "Found a concurrent restore: {}, current restore: {}", existing_restore_uuid, toString(restore_uuid));
-                return true;
+                Coordination::Stat stat;
+                zk->get(root_zookeeper_path, &stat);
+                Strings existing_restore_paths = zk->getChildren(root_zookeeper_path);
+                for (const auto & existing_restore_path : existing_restore_paths)
+                {
+                    if (startsWith(existing_restore_path, "backup-"))
+                        continue;
+
+                    String existing_restore_uuid = existing_restore_path;
+                    existing_restore_uuid.erase(0, String("restore-").size());
+
+                    if (existing_restore_uuid == toString(restore_uuid))
+                        continue;
+
+                    const auto status = zk->get(root_zookeeper_path + "/" + existing_restore_path + "/stage");
+                    if (status != Stage::COMPLETED)
+                    {
+                        LOG_WARNING(log, "Found a concurrent restore: {}, current restore: {}", existing_restore_uuid, toString(restore_uuid));
+                        result = true;
+                        return;
+                    }
+                }
+
+                zk->createIfNotExists(path, "");
+                auto code = zk->trySet(path, Stage::SCHEDULED_TO_START, stat.version);
+                if (code == Coordination::Error::ZOK)
+                    break;
+                bool is_last_attempt = (attempt == MAX_ZOOKEEPER_ATTEMPTS - 1);
+                if ((code != Coordination::Error::ZBADVERSION) || is_last_attempt)
+                    throw zkutil::KeeperException(code, path);
             }
-        }
+        });
 
-        zk->createIfNotExists(path, "");
-        auto code = zk->trySet(path, Stage::SCHEDULED_TO_START, stat.version);
-        if (code == Coordination::Error::ZOK)
-            break;
-        bool is_last_attempt = (attempt == MAX_ZOOKEEPER_ATTEMPTS - 1);
-        if ((code != Coordination::Error::ZBADVERSION) || is_last_attempt)
-            throw zkutil::KeeperException(code, path);
-    }
-    return false;
+    return result;
 }
 
 }
diff --git a/src/Backups/RestoreCoordinationRemote.h b/src/Backups/RestoreCoordinationRemote.h
index e524e42c440..eb0fcff9c2d 100644
--- a/src/Backups/RestoreCoordinationRemote.h
+++ b/src/Backups/RestoreCoordinationRemote.h
@@ -2,6 +2,7 @@
 
 #include <Backups/IRestoreCoordination.h>
 #include <Backups/BackupCoordinationStageSync.h>
+#include <Backups/WithRetries.h>
 
 
 namespace DB
@@ -11,9 +12,12 @@ namespace DB
 class RestoreCoordinationRemote : public IRestoreCoordination
 {
 public:
+    using RestoreKeeperSettings = WithRetries::KeeperSettings;
+
     RestoreCoordinationRemote(
         zkutil::GetZooKeeper get_zookeeper_,
         const String & root_zookeeper_path_,
+        const RestoreKeeperSettings & keeper_settings_,
         const String & restore_uuid_,
         const Strings & all_hosts_,
         const String & current_host_,
@@ -45,14 +49,15 @@ public:
     bool hasConcurrentRestores(const std::atomic<size_t> & num_active_restores) const override;
 
 private:
-    zkutil::ZooKeeperPtr getZooKeeper() const;
     void createRootNodes();
     void removeAllNodes();
 
     class ReplicatedDatabasesMetadataSync;
 
+    /// get_zookeeper will provide a zookeeper client without any fault injection
     const zkutil::GetZooKeeper get_zookeeper;
     const String root_zookeeper_path;
+    const RestoreKeeperSettings keeper_settings;
     const String restore_uuid;
     const String zookeeper_path;
     const Strings all_hosts;
@@ -61,10 +66,9 @@ private:
     const bool is_internal;
     Poco::Logger * const log;
 
+    mutable WithRetries with_retries;
     std::optional<BackupCoordinationStageSync> stage_sync;
-
     mutable std::mutex mutex;
-    mutable zkutil::ZooKeeperPtr zookeeper;
 };
 
 }
diff --git a/src/Backups/WithRetries.cpp b/src/Backups/WithRetries.cpp
new file mode 100644
index 00000000000..35d4d7f5f32
--- /dev/null
+++ b/src/Backups/WithRetries.cpp
@@ -0,0 +1,61 @@
+#include <mutex>
+#include <Backups/WithRetries.h>
+
+namespace DB
+{
+
+
+WithRetries::WithRetries(Poco::Logger * log_, zkutil::GetZooKeeper get_zookeeper_, const KeeperSettings & settings_, RenewerCallback callback_)
+    : log(log_)
+    , get_zookeeper(get_zookeeper_)
+    , settings(settings_)
+    , callback(callback_)
+    , global_zookeeper_retries_info(
+        log->name(),
+        log,
+        settings.keeper_max_retries,
+        settings.keeper_retry_initial_backoff_ms,
+        settings.keeper_retry_max_backoff_ms)
+{}
+
+WithRetries::RetriesControlHolder::RetriesControlHolder(const WithRetries * parent, const String & name)
+    : info(parent->global_zookeeper_retries_info)
+    , retries_ctl(name, info)
+    , faulty_zookeeper(parent->getFaultyZooKeeper())
+{}
+
+WithRetries::RetriesControlHolder WithRetries::createRetriesControlHolder(const String & name)
+{
+    return RetriesControlHolder(this, name);
+}
+
+void WithRetries::renewZooKeeper(FaultyKeeper my_faulty_zookeeper) const
+{
+    std::lock_guard lock(zookeeper_mutex);
+
+    if (!zookeeper || zookeeper->expired())
+    {
+        zookeeper = get_zookeeper();
+        my_faulty_zookeeper->setKeeper(zookeeper);
+
+        callback(my_faulty_zookeeper);
+    }
+}
+
+WithRetries::FaultyKeeper WithRetries::getFaultyZooKeeper() const
+{
+    /// We need to create new instance of ZooKeeperWithFaultInjection each time a copy a pointer to ZooKeeper client there
+    /// The reason is that ZooKeeperWithFaultInjection may reset the underlying pointer and there could be a race condition
+    /// when the same object is used from multiple threads.
+    auto faulty_zookeeper = ZooKeeperWithFaultInjection::createInstance(
+        settings.keeper_fault_injection_probability,
+        settings.keeper_fault_injection_seed,
+        zookeeper,
+        log->name(),
+        log);
+
+    return faulty_zookeeper;
+}
+
+
+}
diff --git a/src/Backups/WithRetries.h b/src/Backups/WithRetries.h
new file mode 100644
index 00000000000..3955682be94
--- /dev/null
+++ b/src/Backups/WithRetries.h
@@ -0,0 +1,79 @@
+#pragma once
+
+#include <Storages/MergeTree/ZooKeeperRetries.h>
+#include <Common/ZooKeeper/Common.h>
+#include <Common/ZooKeeper/ZooKeeperWithFaultInjection.h>
+
+namespace DB
+{
+
+/// In backups every request to [Zoo]Keeper should be retryable
+/// and this tiny class encapsulates all the machinery for make it possible -
+/// a [Zoo]Keeper client which injects faults with configurable probability
+/// and a retries controller which performs retries with growing backoff.
+class WithRetries
+{
+public:
+    using FaultyKeeper = Coordination::ZooKeeperWithFaultInjection::Ptr;
+    using RenewerCallback = std::function<void(FaultyKeeper &)>;
+
+    struct KeeperSettings
+    {
+        UInt64 keeper_max_retries{0};
+        UInt64 keeper_retry_initial_backoff_ms{0};
+        UInt64 keeper_retry_max_backoff_ms{0};
+        UInt64 batch_size_for_keeper_multiread{10000};
+        Float64 keeper_fault_injection_probability{0};
+        UInt64 keeper_fault_injection_seed{42};
+        UInt64 keeper_value_max_size{1048576};
+    };
+
+    /// For simplicity a separate ZooKeeperRetriesInfo and a faulty [Zoo]Keeper client
+    /// are stored in one place.
+    /// This helps to avoid writing too much boilerplate each time we need to
+    /// execute some operation (a set of requests) over [Zoo]Keeper with retries.
+    /// Why ZooKeeperRetriesInfo is separate for each operation?
+    /// The reason is that backup usually takes long time to finish and it makes no sense
+    /// to limit the overall number of retries (for example 1000) for the whole backup
+    /// and have a continuously growing backoff.
+    class RetriesControlHolder
+    {
+    public:
+        ZooKeeperRetriesInfo info;
+        ZooKeeperRetriesControl retries_ctl;
+        FaultyKeeper faulty_zookeeper;
+
+    private:
+        friend class WithRetries;
+        RetriesControlHolder(const WithRetries * parent, const String & name);
+    };
+
+    RetriesControlHolder createRetriesControlHolder(const String & name);
+    WithRetries(Poco::Logger * log, zkutil::GetZooKeeper get_zookeeper_, const KeeperSettings & settings, RenewerCallback callback);
+
+    /// Used to re-establish new connection inside a retry loop.
+    void renewZooKeeper(FaultyKeeper my_faulty_zookeeper) const;
+private:
+    /// This will provide a special wrapper which is useful for testing
+    FaultyKeeper getFaultyZooKeeper() const;
+
+    Poco::Logger * log;
+    zkutil::GetZooKeeper get_zookeeper;
+    KeeperSettings settings;
+    /// This callback is called each time when a new [Zoo]Keeper session is created.
+    /// In backups it is primarily used to re-create an ephemeral node to signal the coordinator
+    /// that the host is alive and able to continue writing the backup.
+    /// Coordinator (or an initiator) of the backup also retries when it doesn't find an ephemeral node
+    /// for a particular host.
+    /// Again, this schema is not ideal. False-positives are still possible, but in worst case scenario
+    /// it could lead just to a failed backup which could possibly be successful
+    /// if there were a little bit more retries.
+    RenewerCallback callback;
+    ZooKeeperRetriesInfo global_zookeeper_retries_info;
+
+    /// This is needed only to protect zookeeper object
+    mutable std::mutex zookeeper_mutex;
+    mutable zkutil::ZooKeeperPtr zookeeper;
+};
+
+}
diff --git a/src/Common/ZooKeeper/Common.h b/src/Common/ZooKeeper/Common.h
index e81b2770cf9..a2956706c8f 100644
--- a/src/Common/ZooKeeper/Common.h
+++ b/src/Common/ZooKeeper/Common.h
@@ -1,11 +1,14 @@
 #pragma once
 
-#include "ZooKeeper.h"
 #include <functional>
 
+#include <Common/ZooKeeper/ZooKeeper.h>
+#include <Common/ZooKeeper/ZooKeeperWithFaultInjection.h>
+
 namespace zkutil
 {
 
 using GetZooKeeper = std::function<ZooKeeperPtr()>;
+using GetZooKeeperWithFaultInjection = std::function<Coordination::ZooKeeperWithFaultInjection::Ptr()>;
 
 }
diff --git a/src/Common/ZooKeeper/TestKeeper.h b/src/Common/ZooKeeper/TestKeeper.h
index 62615afb4f7..fb4e527e50e 100644
--- a/src/Common/ZooKeeper/TestKeeper.h
+++ b/src/Common/ZooKeeper/TestKeeper.h
@@ -146,4 +146,3 @@ private:
 };
 
 }
-
diff --git a/src/Common/ZooKeeper/ZooKeeperWithFaultInjection.h b/src/Common/ZooKeeper/ZooKeeperWithFaultInjection.h
index 491f97b52bd..a39a083cf33 100644
--- a/src/Common/ZooKeeper/ZooKeeperWithFaultInjection.h
+++ b/src/Common/ZooKeeper/ZooKeeperWithFaultInjection.h
@@ -114,6 +114,7 @@ public:
 
     void setKeeper(zk::Ptr const & keeper_) { keeper = keeper_; }
     bool isNull() const { return keeper.get() == nullptr; }
+    bool expired() { return keeper->expired(); }
 
     ///
     /// mirror ZooKeeper interface
@@ -232,6 +233,11 @@ public:
         return access("exists", path, [&]() { return keeper->exists(path, stat, watch); });
     }
 
+    bool existsNoFailureInjection(const std::string & path, Coordination::Stat * stat = nullptr, const zkutil::EventPtr & watch = nullptr)
+    {
+        return access<false, false, false>("exists", path, [&]() { return keeper->exists(path, stat, watch); });
+    }
+
     zkutil::ZooKeeper::MultiExistsResponse exists(const std::vector<std::string> & paths)
     {
         return access("exists", !paths.empty() ? paths.front() : "", [&]() { return keeper->exists(paths); });
@@ -239,19 +245,30 @@ public:
 
     std::string create(const std::string & path, const std::string & data, int32_t mode)
     {
-        auto path_created = access(
-            "create",
+        std::string path_created;
+        auto code = tryCreate(path, data, mode, path_created);
+
+        if (code != Coordination::Error::ZOK)
+            throw zkutil::KeeperException(code, path);
+
+        return path_created;
+    }
+
+    Coordination::Error tryCreate(const std::string & path, const std::string & data, int32_t mode, std::string & path_created)
+    {
+        auto error = access(
+            "tryCreate",
             path,
-            [&]() { return keeper->create(path, data, mode); },
-            [&](std::string const & result_path)
+            [&]() { return keeper->tryCreate(path, data, mode, path_created); },
+            [&](Coordination::Error &)
             {
                 try
                 {
                     if (mode == zkutil::CreateMode::EphemeralSequential || mode == zkutil::CreateMode::Ephemeral)
                     {
-                        keeper->remove(result_path);
+                        keeper->remove(path);
                         if (unlikely(logger))
-                            LOG_TRACE(logger, "ZooKeeperWithFaultInjection cleanup: seed={} func={} path={}", seed, "create", result_path);
+                            LOG_TRACE(logger, "ZooKeeperWithFaultInjection cleanup: seed={} func={} path={}", seed, "tryCreate", path);
                     }
                 }
                 catch (const zkutil::KeeperException & e)
@@ -261,8 +278,8 @@ public:
                             logger,
                             "ZooKeeperWithFaultInjection cleanup FAILED: seed={} func={} path={} code={} message={} ",
                             seed,
-                            "create",
-                            result_path,
+                            "tryCreate",
+                            path,
                             e.code,
                             e.message());
                 }
@@ -272,10 +289,27 @@ public:
         if (unlikely(fault_policy))
         {
             if (mode == zkutil::CreateMode::EphemeralSequential || mode == zkutil::CreateMode::Ephemeral)
-                ephemeral_nodes.push_back(path_created);
+                ephemeral_nodes.push_back(path);
         }
 
-        return path_created;
+        return error;
+    }
+
+    Coordination::Error tryCreate(const std::string & path, const std::string & data, int32_t mode)
+    {
+        String path_created;
+        return tryCreate(path, data, mode, path_created);
+    }
+
+    void createIfNotExists(const std::string & path, const std::string & data)
+    {
+        std::string path_created;
+        auto code = tryCreate(path, data, zkutil::CreateMode::Persistent, path_created);
+
+        if (code == Coordination::Error::ZOK || code == Coordination::Error::ZNODEEXISTS)
+            return;
+
+        throw zkutil::KeeperException(code, path);
     }
 
     Coordination::Responses multi(const Coordination::Requests & requests)
@@ -306,6 +340,27 @@ public:
         return access("tryRemove", path, [&]() { return keeper->tryRemove(path, version); });
     }
 
+    void removeRecursive(const std::string & path)
+    {
+        return access("removeRecursive", path, [&]() { return keeper->removeRecursive(path); });
+    }
+
+    std::string sync(const std::string & path)
+    {
+        return access("sync", path, [&]() { return keeper->sync(path); });
+    }
+
+    Coordination::Error trySet(const std::string & path, const std::string & data, int32_t version = -1, Coordination::Stat * stat = nullptr)
+    {
+        return access("trySet", path, [&]() { return keeper->trySet(path, data, version, stat); });
+    }
+
+
+    void handleEphemeralNodeExistenceNoFailureInjection(const std::string & path, const std::string & fast_delete_if_equal_value)
+    {
+        return access<false, false, false>("handleEphemeralNodeExistence", path, [&]() { return keeper->handleEphemeralNodeExistence(path, fast_delete_if_equal_value); });
+    }
+
     void cleanupEphemeralNodes()
     {
         for (const auto & path : ephemeral_nodes)
diff --git a/src/Core/Settings.h b/src/Core/Settings.h
index 12dc1d0f256..44b68f459bd 100644
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@@ -415,11 +415,13 @@ class IColumn;
     M(UInt64, max_temporary_data_on_disk_size_for_user, 0, "The maximum amount of data consumed by temporary files on disk in bytes for all concurrently running user queries. Zero means unlimited.", 0)\
     M(UInt64, max_temporary_data_on_disk_size_for_query, 0, "The maximum amount of data consumed by temporary files on disk in bytes for all concurrently running queries. Zero means unlimited.", 0)\
     \
-    M(UInt64, backup_keeper_max_retries, 20, "Max retries for keeper operations during backup", 0) \
-    M(UInt64, backup_keeper_retry_initial_backoff_ms, 100, "Initial backoff timeout for [Zoo]Keeper operations during backup", 0) \
-    M(UInt64, backup_keeper_retry_max_backoff_ms, 5000, "Max backoff timeout for [Zoo]Keeper operations during backup", 0) \
-    M(UInt64, backup_keeper_value_max_size, 1048576, "Maximum size of data of a [Zoo]Keeper's node during backup", 0) \
-    M(UInt64, backup_batch_size_for_keeper_multiread, 10000, "Maximum size of batch for multiread request to [Zoo]Keeper during backup", 0) \
+    M(UInt64, backup_restore_keeper_max_retries, 20, "Max retries for keeper operations during backup or restore", 0) \
+    M(UInt64, backup_restore_keeper_retry_initial_backoff_ms, 100, "Initial backoff timeout for [Zoo]Keeper operations during backup or restore", 0) \
+    M(UInt64, backup_restore_keeper_retry_max_backoff_ms, 5000, "Max backoff timeout for [Zoo]Keeper operations during backup or restore", 0) \
+    M(Float,  backup_restore_keeper_fault_injection_probability, 0.0f, "Approximate probability of failure for a keeper request during backup or restore. Valid value is in interval [0.0f, 1.0f]", 0) \
+    M(UInt64, backup_restore_keeper_fault_injection_seed, 0, "0 - random seed, otherwise the setting value", 0) \
+    M(UInt64, backup_restore_keeper_value_max_size, 1048576, "Maximum size of data of a [Zoo]Keeper's node during backup", 0) \
+    M(UInt64, backup_restore_batch_size_for_keeper_multiread, 10000, "Maximum size of batch for multiread request to [Zoo]Keeper during backup or restore", 0) \
     \
     M(Bool, log_profile_events, true, "Log query performance statistics into the query_log, query_thread_log and query_views_log.", 0) \
     M(Bool, log_query_settings, true, "Log query settings into the query_log.", 0) \
diff --git a/src/Storages/MergeTree/ZooKeeperRetries.h b/src/Storages/MergeTree/ZooKeeperRetries.h
index 1a4d394857f..dfc83bbc3f5 100644
--- a/src/Storages/MergeTree/ZooKeeperRetries.h
+++ b/src/Storages/MergeTree/ZooKeeperRetries.h
@@ -126,6 +126,12 @@ public:
         user_error = UserError{};
     }
 
+    template <typename... Args>
+    void setKeeperError(Coordination::Error code, fmt::format_string<Args...> fmt, Args &&... args)
+    {
+        setKeeperError(code, fmt::format(fmt, std::forward<Args>(args)...));
+    }
+
     void stopRetries() { stop_retries = true; }
 
     void requestUnconditionalRetry() { unconditional_retry = true; }
diff --git a/tests/integration/test_backup_restore_new/configs/zookeeper_retries.xml b/tests/integration/test_backup_restore_new/configs/zookeeper_retries.xml
new file mode 100644
index 00000000000..1283f28a8cb
--- /dev/null
+++ b/tests/integration/test_backup_restore_new/configs/zookeeper_retries.xml
@@ -0,0 +1,11 @@
+<clickhouse>
+    <profiles>
+        <default>
+            <backup_restore_keeper_max_retries>1000</backup_restore_keeper_max_retries>
+            <backup_restore_keeper_retry_initial_backoff_ms>1</backup_restore_keeper_retry_initial_backoff_ms>
+            <backup_restore_keeper_retry_max_backoff_ms>1</backup_restore_keeper_retry_max_backoff_ms>
+            <backup_restore_keeper_fault_injection_seed>42</backup_restore_keeper_fault_injection_seed>
+            <backup_restore_keeper_fault_injection_probability>0.002</backup_restore_keeper_fault_injection_probability>
+        </default>
+    </profiles>
+</clickhouse>
diff --git a/tests/integration/test_backup_restore_new/test.py b/tests/integration/test_backup_restore_new/test.py
index 424799e2402..ed9747f940b 100644
--- a/tests/integration/test_backup_restore_new/test.py
+++ b/tests/integration/test_backup_restore_new/test.py
@@ -13,6 +13,7 @@ cluster = ClickHouseCluster(__file__)
 instance = cluster.add_instance(
     "instance",
     main_configs=["configs/backups_disk.xml"],
+    user_configs=["configs/zookeeper_retries.xml"],
     external_dirs=["/backups/"],
 )
 
diff --git a/tests/integration/test_backup_restore_on_cluster/configs/zookeeper_retries.xml b/tests/integration/test_backup_restore_on_cluster/configs/zookeeper_retries.xml
new file mode 100644
index 00000000000..1283f28a8cb
--- /dev/null
+++ b/tests/integration/test_backup_restore_on_cluster/configs/zookeeper_retries.xml
@@ -0,0 +1,11 @@
+<clickhouse>
+    <profiles>
+        <default>
+            <backup_restore_keeper_max_retries>1000</backup_restore_keeper_max_retries>
+            <backup_restore_keeper_retry_initial_backoff_ms>1</backup_restore_keeper_retry_initial_backoff_ms>
+            <backup_restore_keeper_retry_max_backoff_ms>1</backup_restore_keeper_retry_max_backoff_ms>
+            <backup_restore_keeper_fault_injection_seed>42</backup_restore_keeper_fault_injection_seed>
+            <backup_restore_keeper_fault_injection_probability>0.002</backup_restore_keeper_fault_injection_probability>
+        </default>
+    </profiles>
+</clickhouse>
diff --git a/tests/integration/test_backup_restore_on_cluster/test.py b/tests/integration/test_backup_restore_on_cluster/test.py
index b95d49a2e7c..9ed39627d82 100644
--- a/tests/integration/test_backup_restore_on_cluster/test.py
+++ b/tests/integration/test_backup_restore_on_cluster/test.py
@@ -18,6 +18,7 @@ main_configs = [
 
 user_configs = [
     "configs/allow_database_types.xml",
+    "configs/zookeeper_retries.xml",
 ]
 
 node1 = cluster.add_instance(
@@ -429,7 +430,7 @@ def test_replicated_database_async():
     assert node2.query("SELECT * FROM mydb.tbl2 ORDER BY y") == TSV(["a", "bb"])
 
 
-# By default `backup_keeper_value_max_size` is 1 MB, but in this test we'll set it to 50 bytes just to check it works.
+# By default `backup_restore_keeper_value_max_size` is 1 MB, but in this test we'll set it to 50 bytes just to check it works.
 def test_keeper_value_max_size():
     node1.query(
         "CREATE TABLE tbl ON CLUSTER 'cluster' ("
@@ -450,7 +451,7 @@ def test_keeper_value_max_size():
     backup_name = new_backup_name()
     node1.query(
         f"BACKUP TABLE tbl ON CLUSTER 'cluster' TO {backup_name}",
-        settings={"backup_keeper_value_max_size": 50},
+        settings={"backup_restore_keeper_value_max_size": 50},
     )
 
     node1.query(f"DROP TABLE tbl ON CLUSTER 'cluster' NO DELAY")
diff --git a/tests/integration/test_backup_restore_on_cluster/test_concurrency.py b/tests/integration/test_backup_restore_on_cluster/test_concurrency.py
index 570a3c01ec0..a28a1fa142b 100644
--- a/tests/integration/test_backup_restore_on_cluster/test_concurrency.py
+++ b/tests/integration/test_backup_restore_on_cluster/test_concurrency.py
@@ -29,6 +29,7 @@ def generate_cluster_def():
 
 
 main_configs = ["configs/backups_disk.xml", generate_cluster_def()]
+# No [Zoo]Keeper retries for tests with concurrency
 user_configs = ["configs/allow_database_types.xml"]
 
 nodes = []
diff --git a/tests/integration/test_backup_restore_on_cluster/test_disallow_concurrency.py b/tests/integration/test_backup_restore_on_cluster/test_disallow_concurrency.py
index 1fb1f807245..0d8fad96438 100644
--- a/tests/integration/test_backup_restore_on_cluster/test_disallow_concurrency.py
+++ b/tests/integration/test_backup_restore_on_cluster/test_disallow_concurrency.py
@@ -50,6 +50,7 @@ def generate_cluster_def():
 
 
 main_configs = ["configs/disallow_concurrency.xml", generate_cluster_def()]
+# No [Zoo]Keeper retries for tests with concurrency
 user_configs = ["configs/allow_database_types.xml"]
 
 nodes = []
diff --git a/tests/integration/test_backup_restore_s3/configs/zookeeper_retries.xml b/tests/integration/test_backup_restore_s3/configs/zookeeper_retries.xml
new file mode 100644
index 00000000000..1283f28a8cb
--- /dev/null
+++ b/tests/integration/test_backup_restore_s3/configs/zookeeper_retries.xml
@@ -0,0 +1,11 @@
+<clickhouse>
+    <profiles>
+        <default>
+            <backup_restore_keeper_max_retries>1000</backup_restore_keeper_max_retries>
+            <backup_restore_keeper_retry_initial_backoff_ms>1</backup_restore_keeper_retry_initial_backoff_ms>
+            <backup_restore_keeper_retry_max_backoff_ms>1</backup_restore_keeper_retry_max_backoff_ms>
+            <backup_restore_keeper_fault_injection_seed>42</backup_restore_keeper_fault_injection_seed>
+            <backup_restore_keeper_fault_injection_probability>0.002</backup_restore_keeper_fault_injection_probability>
+        </default>
+    </profiles>
+</clickhouse>
diff --git a/tests/integration/test_backup_restore_s3/test.py b/tests/integration/test_backup_restore_s3/test.py
index d046c97f8d1..0696d51136a 100644
--- a/tests/integration/test_backup_restore_s3/test.py
+++ b/tests/integration/test_backup_restore_s3/test.py
@@ -9,6 +9,9 @@ node = cluster.add_instance(
         "configs/named_collection_s3_backups.xml",
         "configs/s3_settings.xml",
     ],
+    user_configs=[
+        "configs/zookeeper_retries.xml",
+    ],
     with_minio=True,
 )
 

From 6e8f77ee9cba381c5175b7b22ce0c6f6bb95d6b9 Mon Sep 17 00:00:00 2001
From: FFFFFFFHHHHHHH <75292180+FFFFFFFHHHHHHH@users.noreply.github.com>
Date: Wed, 5 Apr 2023 07:18:54 +0800
Subject: [PATCH 78/80] Add statistical aggregate function
 kolmogorovSmirnovTest (#48325)

---
 ...AggregateFunctionKolmogorovSmirnovTest.cpp |  36 ++
 .../AggregateFunctionKolmogorovSmirnovTest.h  | 323 ++++++++++++++++++
 .../registerAggregateFunctions.cpp            |   2 +
 .../02706_kolmogorov_smirnov_test.reference   |   3 +
 .../02706_kolmogorov_smirnov_test.sql         | 107 ++++++
 ...02706_kolmogorov_smirnov_test_scipy.python |  84 +++++
 ...06_kolmogorov_smirnov_test_scipy.reference |   1 +
 .../02706_kolmogorov_smirnov_test_scipy.sh    |   9 +
 8 files changed, 565 insertions(+)
 create mode 100644 src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.cpp
 create mode 100644 src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.h
 create mode 100644 tests/queries/0_stateless/02706_kolmogorov_smirnov_test.reference
 create mode 100644 tests/queries/0_stateless/02706_kolmogorov_smirnov_test.sql
 create mode 100644 tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.python
 create mode 100644 tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.reference
 create mode 100755 tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.sh

diff --git a/src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.cpp b/src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.cpp
new file mode 100644
index 00000000000..9bd06c3ef4d
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.cpp
@@ -0,0 +1,36 @@
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.h>
+#include <AggregateFunctions/FactoryHelpers.h>
+
+namespace ErrorCodes
+{
+    extern const int NOT_IMPLEMENTED;
+}
+
+namespace DB
+{
+struct Settings;
+
+namespace
+{
+
+AggregateFunctionPtr createAggregateFunctionKolmogorovSmirnovTest(
+    const std::string & name, const DataTypes & argument_types, const Array & parameters, const Settings *)
+{
+    assertBinary(name, argument_types);
+
+    if (!isNumber(argument_types[0]) || !isNumber(argument_types[1]))
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Aggregate function {} only supports numerical types", name);
+
+    return std::make_shared<AggregateFunctionKolmogorovSmirnov>(argument_types, parameters);
+}
+
+
+}
+
+void registerAggregateFunctionKolmogorovSmirnovTest(AggregateFunctionFactory & factory)
+{
+    factory.registerFunction("kolmogorovSmirnovTest", createAggregateFunctionKolmogorovSmirnovTest, AggregateFunctionFactory::CaseInsensitive);
+}
+
+}
diff --git a/src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.h b/src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.h
new file mode 100644
index 00000000000..51e0950f782
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.h
@@ -0,0 +1,323 @@
+#pragma once
+#include <AggregateFunctions/IAggregateFunction.h>
+#include <AggregateFunctions/StatCommon.h>
+#include <Columns/ColumnVector.h>
+#include <Columns/ColumnTuple.h>
+#include <Common/Exception.h>
+#include <Common/assert_cast.h>
+#include <Common/ArenaAllocator.h>
+#include <Common/PODArray_fwd.h>
+#include <base/types.h>
+#include <DataTypes/DataTypeNullable.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/DataTypeTuple.h>
+#include <IO/ReadHelpers.h>
+#include <IO/WriteHelpers.h>
+
+namespace DB
+{
+struct Settings;
+
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int BAD_ARGUMENTS;
+}
+
+struct KolmogorovSmirnov : public StatisticalSample<Float64, Float64>
+{
+    enum class Alternative
+    {
+        TwoSided,
+        Less,
+        Greater
+    };
+
+    std::pair<Float64, Float64> getResult(Alternative alternative, String method)
+    {
+        ::sort(x.begin(), x.end());
+        ::sort(y.begin(), y.end());
+
+        Float64 max_s = std::numeric_limits<Float64>::min();
+        Float64 min_s = std::numeric_limits<Float64>::max();
+        Float64 now_s = 0;
+        UInt64 pos_x = 0;
+        UInt64 pos_y = 0;
+        UInt64 n1 = x.size();
+        UInt64 n2 = y.size();
+
+        const Float64 n1_d = 1. / n1;
+        const Float64 n2_d = 1. / n2;
+        const Float64 tol = 1e-7;
+
+        // reference: https://en.wikipedia.org/wiki/Kolmogorov%E2%80%93Smirnov_test
+        while (pos_x < x.size() && pos_y < y.size())
+        {
+            if (likely(fabs(x[pos_x] - y[pos_y]) >= tol))
+            {
+                if (x[pos_x] < y[pos_y])
+                {
+                    now_s += n1_d;
+                    ++pos_x;
+                }
+                else
+                {
+                    now_s -= n2_d;
+                    ++pos_y;
+                }
+                max_s = std::max(max_s, now_s);
+                min_s = std::min(min_s, now_s);
+            }
+            else
+            {
+                now_s += n1_d;
+                ++pos_x;
+            }
+        }
+        now_s += n1_d * (x.size() - pos_x) - n2_d * (y.size() - pos_y);
+        min_s = std::min(min_s, now_s);
+        max_s = std::max(max_s, now_s);
+
+        Float64 d = 0;
+        if (alternative == Alternative::TwoSided)
+            d = std::max(std::abs(max_s), std::abs(min_s));
+        else if (alternative == Alternative::Less)
+            d = -min_s;
+        else if (alternative == Alternative::Greater)
+            d = max_s;
+
+        UInt64 g = std::__gcd(n1, n2);
+        UInt64 nx_g = n1 / g;
+        UInt64 ny_g = n2 / g;
+
+        if (method == "auto")
+            method = std::max(n1, n2) <= 10000 ? "exact" : "asymp";
+        else if (method == "exact" && nx_g >= std::numeric_limits<Int32>::max() / ny_g)
+            method = "asymp";
+
+        Float64 p_value = std::numeric_limits<Float64>::infinity();
+
+        if (method == "exact")
+        {
+            /* reference:
+             * Gunar Schröer and Dietrich Trenkler
+             * Exact and Randomization Distributions of Kolmogorov-Smirnov, Tests for Two or Three Samples
+             *
+             * and
+             *
+             * Thomas Viehmann
+             * Numerically more stable computation of the p-values for the two-sample Kolmogorov-Smirnov test
+             */
+            if (n2 > n1)
+                std::swap(n1, n2);
+
+            const Float64 f_n1 = static_cast<Float64>(n1);
+            const Float64 f_n2 = static_cast<Float64>(n2);
+            const Float64 k_d = (0.5 + floor(d * f_n2 * f_n1 - tol)) / (f_n2 * f_n1);
+            PaddedPODArray<Float64> c(n1 + 1);
+
+            auto check = alternative == Alternative::TwoSided ?
+                         [](const Float64 & q, const Float64 & r, const Float64 & s) { return fabs(r - s) >= q; }
+                       : [](const Float64 & q, const Float64 & r, const Float64 & s) { return r - s >= q; };
+
+            c[0] = 0;
+            for (UInt64 j = 1; j <= n1; j++)
+                if (check(k_d, 0., j / f_n1))
+                    c[j] = 1.;
+                else
+                    c[j] = c[j - 1];
+
+            for (UInt64 i = 1; i <= n2; i++)
+            {
+                if (check(k_d, i / f_n2, 0.))
+                    c[0] = 1.;
+                for (UInt64 j = 1; j <= n1; j++)
+                    if (check(k_d, i / f_n2, j / f_n1))
+                        c[j] = 1.;
+                    else
+                    {
+                        Float64 v = i / static_cast<Float64>(i + j);
+                        Float64 w = j / static_cast<Float64>(i + j);
+                        c[j] = v * c[j] + w * c[j - 1];
+                    }
+            }
+            p_value = c[n1];
+        }
+        else if (method == "asymp")
+        {
+            Float64 n = std::min(n1, n2);
+            Float64 m = std::max(n1, n2);
+            Float64 p = sqrt((n * m) / (n + m)) * d;
+
+            if (alternative == Alternative::TwoSided)
+            {
+                /* reference:
+                 * J.DURBIN
+                 * Distribution theory for tests based on the sample distribution function
+                 */
+                Float64 new_val, old_val, s, w, z;
+                UInt64 k_max = static_cast<UInt64>(sqrt(2 - log(tol)));
+
+                if (p < 1)
+                {
+                    z = - (M_PI_2 * M_PI_4) / (p * p);
+                    w = log(p);
+                    s = 0;
+                    for (UInt64 k = 1; k < k_max; k += 2)
+                        s += exp(k * k * z - w);
+                    p = s / 0.398942280401432677939946059934;
+                }
+                else
+                {
+                    z = -2 * p * p;
+                    s = -1;
+                    UInt64 k = 1;
+                    old_val = 0;
+                    new_val = 1;
+                    while (fabs(old_val - new_val) > tol)
+                    {
+                        old_val = new_val;
+                        new_val += 2 * s * exp(z * k * k);
+                        s *= -1;
+                        k++;
+                    }
+                    p = new_val;
+                }
+                p_value = 1 - p;
+            }
+            else
+            {
+                /* reference:
+                 * J. L. HODGES, Jr
+                 * The significance probability of the Smirnov two-sample test
+                 */
+
+                // Use Hodges' suggested approximation Eqn 5.3
+                // Requires m to be the larger of (n1, n2)
+                Float64 expt = -2 * p * p - 2 * p * (m + 2 * n) / sqrt(m * n * (m + n)) / 3.0;
+                p_value = exp(expt);
+            }
+        }
+        return {d, p_value};
+    }
+
+};
+
+class AggregateFunctionKolmogorovSmirnov final:
+    public IAggregateFunctionDataHelper<KolmogorovSmirnov, AggregateFunctionKolmogorovSmirnov>
+{
+private:
+    using Alternative = typename KolmogorovSmirnov::Alternative;
+    Alternative alternative = Alternative::TwoSided;
+    String method = "auto";
+
+public:
+    explicit AggregateFunctionKolmogorovSmirnov(const DataTypes & arguments, const Array & params)
+        : IAggregateFunctionDataHelper<KolmogorovSmirnov, AggregateFunctionKolmogorovSmirnov> ({arguments}, {}, createResultType())
+    {
+        if (params.size() > 2)
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} require two parameter or less", getName());
+
+        if (params.empty())
+            return;
+
+        if (params[0].getType() != Field::Types::String)
+            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Aggregate function {} require first parameter to be a String", getName());
+
+        const auto & param = params[0].get<String>();
+        if (param == "two-sided")
+            alternative = Alternative::TwoSided;
+        else if (param == "less")
+            alternative = Alternative::Less;
+        else if (param == "greater")
+            alternative = Alternative::Greater;
+        else
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unknown parameter in aggregate function {}. "
+                    "It must be one of: 'two-sided', 'less', 'greater'", getName());
+
+        if (params.size() != 2)
+            return;
+
+        if (params[1].getType() != Field::Types::String)
+                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Aggregate function {} require second parameter to be a String", getName());
+
+        method = params[1].get<String>();
+        if (method != "auto" && method != "exact" && method != "asymp")
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unknown method in aggregate function {}. "
+                    "It must be one of: 'auto', 'exact', 'asymp'", getName());
+    }
+
+    String getName() const override
+    {
+        return "kolmogorovSmirnovTest";
+    }
+
+    bool allocatesMemoryInArena() const override { return true; }
+
+    static DataTypePtr createResultType()
+    {
+        DataTypes types
+        {
+            std::make_shared<DataTypeNumber<Float64>>(),
+            std::make_shared<DataTypeNumber<Float64>>(),
+        };
+
+        Strings names
+        {
+            "d_statistic",
+            "p_value"
+        };
+
+        return std::make_shared<DataTypeTuple>(
+            std::move(types),
+            std::move(names)
+        );
+    }
+
+    void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena * arena) const override
+    {
+        Float64 value = columns[0]->getFloat64(row_num);
+        UInt8 is_second = columns[1]->getUInt(row_num);
+        if (is_second)
+            this->data(place).addY(value, arena);
+        else
+            this->data(place).addX(value, arena);
+    }
+
+    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena * arena) const override
+    {
+        this->data(place).merge(this->data(rhs), arena);
+    }
+
+    void serialize(ConstAggregateDataPtr __restrict place, WriteBuffer & buf, std::optional<size_t> /* version */) const override
+    {
+        this->data(place).write(buf);
+    }
+
+    void deserialize(AggregateDataPtr __restrict place, ReadBuffer & buf, std::optional<size_t> /* version */, Arena * arena) const override
+    {
+        this->data(place).read(buf, arena);
+    }
+
+    void insertResultInto(AggregateDataPtr __restrict place, IColumn & to, Arena *) const override
+    {
+        if (!this->data(place).size_x || !this->data(place).size_y)
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Aggregate function {} require both samples to be non empty", getName());
+
+        auto [d_statistic, p_value] = this->data(place).getResult(alternative, method);
+
+        /// Because p-value is a probability.
+        p_value = std::min(1.0, std::max(0.0, p_value));
+
+        auto & column_tuple = assert_cast<ColumnTuple &>(to);
+        auto & column_stat = assert_cast<ColumnVector<Float64> &>(column_tuple.getColumn(0));
+        auto & column_value = assert_cast<ColumnVector<Float64> &>(column_tuple.getColumn(1));
+
+        column_stat.getData().push_back(d_statistic);
+        column_value.getData().push_back(p_value);
+    }
+
+};
+
+}
diff --git a/src/AggregateFunctions/registerAggregateFunctions.cpp b/src/AggregateFunctions/registerAggregateFunctions.cpp
index 679449681a0..2781d0662b0 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.cpp
+++ b/src/AggregateFunctions/registerAggregateFunctions.cpp
@@ -79,6 +79,7 @@ void registerAggregateFunctionExponentialMovingAverage(AggregateFunctionFactory
 void registerAggregateFunctionSparkbar(AggregateFunctionFactory &);
 void registerAggregateFunctionIntervalLengthSum(AggregateFunctionFactory &);
 void registerAggregateFunctionAnalysisOfVariance(AggregateFunctionFactory &);
+void registerAggregateFunctionKolmogorovSmirnovTest(AggregateFunctionFactory & factory);
 
 class AggregateFunctionCombinatorFactory;
 void registerAggregateFunctionCombinatorIf(AggregateFunctionCombinatorFactory &);
@@ -170,6 +171,7 @@ void registerAggregateFunctions()
         registerAggregateFunctionExponentialMovingAverage(factory);
         registerAggregateFunctionSparkbar(factory);
         registerAggregateFunctionAnalysisOfVariance(factory);
+        registerAggregateFunctionKolmogorovSmirnovTest(factory);
 
         registerWindowFunctions(factory);
     }
diff --git a/tests/queries/0_stateless/02706_kolmogorov_smirnov_test.reference b/tests/queries/0_stateless/02706_kolmogorov_smirnov_test.reference
new file mode 100644
index 00000000000..d2e9e7de5d4
--- /dev/null
+++ b/tests/queries/0_stateless/02706_kolmogorov_smirnov_test.reference
@@ -0,0 +1,3 @@
+0.1	0.1	1	0.05	0.1	1	0.05	0.1	1	0.05	0.099562	1	0.018316	1	1	-0	1	1	-0	1	1	-0	1	1	-0	1
+0.000007	0.000007	0.000004	0.000023	0.000007	0.000004	0.000023	0.000007	0.000004	0.000023	0.000008	0.000003	0.00002	0.158	0.158	0.158	0.146	0.158	0.158	0.146	0.158	0.158	0.146	0.158	0.158	0.146
+0	0	0	0.523357	0	0	0.523357	0	0	0.523357	0	0	0.504595	0.486	0.486	0.486	0.036	0.486	0.486	0.036	0.486	0.486	0.036	0.486	0.486	0.036
diff --git a/tests/queries/0_stateless/02706_kolmogorov_smirnov_test.sql b/tests/queries/0_stateless/02706_kolmogorov_smirnov_test.sql
new file mode 100644
index 00000000000..3199b6968c0
--- /dev/null
+++ b/tests/queries/0_stateless/02706_kolmogorov_smirnov_test.sql
@@ -0,0 +1,107 @@
+DROP TABLE IF EXISTS kstest;
+
+CREATE TABLE kstest (left Float64, right Float64) ENGINE = Memory;
+
+INSERT INTO kstest VALUES (0.010268, 0), (0.000167, 0), (0.000167, 0), (0.159258, 1), (0.136278, 1), (0.122389, 1);
+
+SELECT 
+roundBankers(kolmogorovSmirnovTest(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','auto')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less','auto')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater','auto')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','exact')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less','exact')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater','exact')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','asymp')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less','asymp')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater','asymp')(left, right).2, 6) ,
+roundBankers(kolmogorovSmirnovTest(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','auto')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less','auto')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater','auto')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','exact')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less','exact')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater','exact')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','asymp')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less','asymp')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater','asymp')(left, right).1, 6) 
+from kstest;
+
+DROP TABLE IF EXISTS kstest;
+
+CREATE TABLE kstest (left Float64, right Float64) ENGINE = Memory;
+
+INSERT INTO kstest VALUES (14.72789, 0), (9.61661, 0), (13.57615, 0), (3.98392, 0), (11.98889, 0), (10.99422, 0), (5.44792, 0), (20.29346, 0), (7.05926, 0), (9.22732, 0), (12.06847, 0), (13.52612, 0), (8.24597, 0), (9.35245, 0), (10.12297, 0), (15.80624, 0), (13.68613, 0), (10.72729, 0), (5.62078, 0), (6.12229, 0), (6.03801, 0), (8.95585, 0), (24.04613, 0), (9.04757, 0), (2.68263, 0), (15.43935, 0), (2.89423, 0), (4.01423, 0), (4.30568, 0), (11.99948, 0), (8.40574, 0), (10.86642, 0), (9.4266, 0), (-8.12752, 0), (7.91634, 0), (7.3967, 0), (2.26431, 0), (14.20118, 0), (6.68233, 0), (15.46221, 0), (7.88467, 0), (11.20011, 0), (8.92027, 0), (10.27926, 0), (5.14395, 0), (5.62178, 0), (12.84383, 0), (9.98009, 0), (-0.69789, 0), (11.41386, 0), (7.76863, 0), (7.21743, 0), (1.81176, 0), (9.43762, 0), (19.22117, 0), (2.97128, 0), (14.32851, 0), (7.54959, 0), (3.81545, 0), (10.1281, 0), (2.48596, 0), (10.0461, 0), (3.59714, 0), (9.73522, 0), (18.8077, 0), (3.15148, 0), (12.26062, 0), (5.66707, 0), (6.58623, 0), (17.30902, 0), (9.91391, 0), (5.36946, 0), (15.73637, 0), (16.96281, 0), (11.54063, 0), (18.37358, 0), (11.38255, 0), (10.53256, 0), (8.08833, 0), (16.27556, 0), (2.42969, 0), (9.56127, 0), (7.32998, 0), (9.19511, 0), (9.66903, 0), (4.15029, 0), (8.83511, 0), (14.60617, 0), (14.06143, 0), (5.39556, 0), (10.11871, 0), (10.56619, 0), (14.4462, 0), (10.42106, 0), (7.75551, 0), (11.00418, 0), (4.47226, 0), (16.35461, 0), (18.55174, 0), (11.82044, 0), (7.39454, 0), (11.27767, 0), (6.83827, 0), (7.76858, 0), (15.97614, 0), (14.53781, 0), (12.99546, 0), (16.91151, 0), (9.65012, 0), (14.25487, 0), (14.03618, 0), (2.57382, 0), (2.50779, 0), (14.24787, 0), (13.34666, 0), (7.31102, 0), (10.22981, 0), (17.4435, 0), (21.2074, 0), (6.64191, 0), (18.7086, 0), (14.78686, 0), (9.85287, 0), (4.48263, 0), (14.17469, 0), (14.4342, 0), (19.2481, 0), (3.47165, 0), (8.28712, 0), (8.81657, 0), (0.92319, 0), (20.41106, 0), (6.76127, 0), (22.00242, 0), (8.66129, 0), (10.9929, 0), (17.95494, 0), (17.20996, 0), (12.18888, 0), (12.14257, 0), (15.81243, 0), (4.43362, 0), (1.17567, 0), (15.60881, 0), (9.34833, 0), (6.33513, 0), (-0.83095, 0), (12.43268, 0), (6.63207, 0), (11.96877, 0), (14.81029, 0), (21.84876, 0), (3.75896, 0), (6.91307, 0), (13.73015, 0), (8.63753, 0), (15.71679, 0), (1.74565, 0), (9.16895, 0), (5.70685, 0), (5.00117, 0), (13.06888, 0), (7.51204, 0), (15.34885, 0), (5.20264, 0), (8.59043, 0), (6.45619, 0), (14.61979, 0), (11.7075, 0), (14.04901, 0), (4.20525, 0), (15.1733, 0), (3.12934, 0), (8.08049, 0), (15.41273, 0), (16.90751, 0), (5.86893, 0), (7.1086, 0), (4.418, 0), (12.0614, 0), (7.07887, 0), (3.61585, 0), (11.73001, 0), (10.80449, 0), (8.40311, 0), (9.91276, 0), (16.4164, 0), (5.25034, 0), (15.20283, 0), (10.42909, 0), (9.53888, 0), (14.68939, 0), (6.60007, 0), (18.31058, 0), (7.01885, 0), (18.71631, 0), (10.50002, 0), (10.7517, 0), (4.23224, 0), (2.28924, 0), (8.56059, 0), (8.25095, 0), (9.15673, 0), (13.28409, 0), (8.4513, 0), (2.83911, 0), (2.79676, 0), (9.11055, 0), (7.18529, 0), (-4.1258, 0), (5.28306, 0), (6.82757, 0), (10.89035, 0), (5.24822, 0), (11.935, 0), (6.45675, 0), (10.18088, 0), (4.9932, 0), (18.09939, 0), (8.11738, 0), (5.37883, 0), (10.50339, 0), (16.64093, 0), (14.77263, 0), (13.71385, 0), (6.98746, 0), (10.74635, 0), (5.49432, 0), (13.46078, 0), (10.67565, 0), (9.0291, 0), (11.51417, 0), (13.07118, 0), (9.5049, 0), (8.50611, 0), (6.47606, 0), (13.06526, 0), (19.08658, 0), (9.49741, 0), (10.60865, 0), (2.28996, 0), (8.12846, 0), (5.62241, 0), (4.07712, 0), (17.98526, 0), (9.466, 0), (11.38904, 0), (5.91826, 0), (1.52059, 0), (18.79161, 0), (18.20669, 0), (-1.67829, 0), (18.01586, 0), (16.31577, 0), (7.88281, 0), (8.46179, 0), (10.31113, 0), (14.88377, 0), (1.31835, 0), (2.53176, 0), (9.48625, 0), (3.97936, 0), (11.52319, 0), (13.24178, 0), (7.58739, 0), (10.00959, 0), (9.73361, 0), (8.35716, 0), (1.65491, 0), (11.11521, 0), (6.08355, 0), (10.04582, 0), (11.58237, 0), (16.40249, 0), (1.9691, 0), (13.22776, 0), (2.67059, 0), (9.83651, 0), (2.12539, 0), (9.27114, 0), (9.0699, 0), (2.78179, 0), (12.49311, 0), (12.97662, 0), (15.06359, 0), (16.91565, 0), (5.92011, 0), (5.81304, 0), (8.46425, 0), (9.48705, 0), (4.68191, 0), (5.70028, 0), (-0.78798, 0), (10.03442, 0), (15.45433, 0), (9.43845, 0), (3.05825, 0), (6.92126, 0), (14.05905, 0), (19.71579, 0), (15.0131, 0), (4.50386, 0), (1.31061, 0), (10.81197, 0), (14.32942, 0), (9.26469, 0), (7.27679, 0), (22.69295, 0), (12.03763, 0), (7.34876, 0), (16.60689, 0), (7.48786, 0), (15.78602, 0), (17.21048, 0), (13.93482, 0), (9.69911, 0), (12.24315, 0), (10.58131, 0), (19.57006, 0), (9.8856, 0), (11.70302, 0), (7.89864, 0), (12.24831, 0), (16.93707, 0), (9.65467, 0), (4.221, 0), (15.45229, 0), (12.83088, 0), (7.58313, 0), (12.895, 0), (10.02471, 0), (13.36059, 0), (5.07864, 0), (9.72017, 0), (11.05809, 0), (15.28528, 0), (13.99834, 0), (19.26989, 0), (9.41846, 0), (11.65425, 0), (8.49638, 0), (6.38592, 0), (-4.69837, 0), (12.22061, 0), (9.41331, 0), (13.2075, 0), (12.97005, 0), (11.44352, 0), (9.79805, 0), (6.93116, 0), (10.07691, 0), (22.05892, 0), (7.80353, 0), (-2.17276, 0), (0.61509, 0), (8.35842, 0), (17.77108, 0), (14.70841, 0), (1.27992, 0), (15.62699, 0), (9.32914, 0), (15.41866, 0), (10.82009, 0), (3.29902, 0), (9.21998, 0), (7.93845, 0), (10.33344, 0), (12.06399, 0), (5.5308, 0), (8.38727, 0), (18.11104, 0), (8.86565, 0), (19.41825, 0), (9.52376, 0), (3.94552, 0), (9.37587, 0), (15.44954, 0), (15.90527, 0), (13.18927, 0), (7.01646, 0), (9.06005, 0), (9.06431, 0), (5.76006, 0), (9.18705, 0), (-3.48446, 0), (15.89817, 0), (12.94719, 0), (23.69426, 0), (17.47755, 0), (15.61528, 0), (0.54832, 0), (14.32916, 0), (9.55305, 0), (13.79891, 0), (0.82544, 0), (13.34875, 0), (9.07614, 0), (5.19621, 0), (2.1451, 0), (9.87726, 0), (8.45439, 0), (-1.41842, 0), (7.93598, 0), (11.23151, 0), (17.84458, 0), (7.02237, 0), (10.7842, 0), (4.42832, 0), (4.45044, 0), (1.50938, 0), (21.21651, 0), (6.2097, 0), (6.84354, 0), (18.53804, 0), (12.01072, 0), (4.8345, 0), (20.41587, 0), (14.48353, 0), (8.71116, 0), (12.42818, 0), (14.89244, 0), (8.03033, 0), (5.25917, 0), (2.30092, 0), (10.22504, 0), (15.37573, 0), (7.13666, 0), (4.45018, 0), (10.18405, 0), (3.91025, 0), (14.52304, 0), (13.14771, 0), (11.99219, 0), (9.21345, 0), (8.85106, 0), (12.91887, 0), (15.62308, 0), (11.88034, 0), (15.12097, 0), (11.58168, 0), (16.83051, 0), (5.25405, 0), (2.19976, 0), (4.56716, 0), (16.46053, 0), (5.61995, 0), (8.67704, 0), (5.62789, 0), (9.84815, 0), (13.05834, 0), (11.74205, 0), (3.88393, 0), (16.15321, 0), (4.83925, 0), (13.00334, 0), (4.4028, 0), (4.35794, 0), (4.47478, 0), (2.38713, 0), (4.25235, 0), (10.87509, 0), (9.82411, 0), (13.61518, 0), (10.25507, 0), (4.0335, 0), (10.69881, 0), (5.70321, 0), (6.96244, 0), (9.35874, 0), (6.28076, 0), (8.29015, 0), (6.88653, 0), (7.70687, 0), (8.2001, 0), (6.73415, 0), (3.82052, 0), (3.94469, 0), (15.82384, 0), (2.54004, 0), (10.74876, 0), (12.60517, 0), (17.7024, 0), (4.6722, 0), (13.67341, 0), (6.4565, 0), (12.95699, 0), (4.56912, 0), (5.58464, 0), (4.0638, 0), (13.05559, 0), (5.38269, 0), (0.16354, 0), (7.23962, 0), (7.38577, 0), (8.50951, 0), (13.72574, 0), (17.80421, 0), (3.01135, 0), (8.02608, 0), (14.23847, 0), (-8.65656, 1), (22.98234, 1), (23.80821, 1), (13.33939, 1), (-4.05537, 1), (23.5155, 1), (-6.45272, 1), (17.7903, 1), (11.463, 1), (5.28021, 1), (8.39157, 1), (6.02464, 1), (14.43732, 1), (15.76584, 1), (1.54391, 1), (1.24897, 1), (27.1507, 1), (7.71091, 1), (15.71846, 1), (32.97808, 1), (-1.79334, 1), (-9.23439, 1), (11.27838, 1), (0.72703, 1), (18.51557, 1), (9.16619, 1), (17.29624, 1), (-1.30208, 1), (-3.48018, 1), (10.12082, 1), (-8.01318, 1), (-14.22264, 1), (16.58174, 1), (-0.55975, 1), (5.61449, 1), (1.44626, 1), (7.89158, 1), (1.13369, 1), (-0.82609, 1), (12.23365, 1), (12.45443, 1), (14.46915, 1), (13.72627, 1), (18.41459, 1), (29.66702, 1), (1.51619, 1), (10.40078, 1), (3.33266, 1), (6.12036, 1), (11.86553, 1), (6.59422, 1), (22.0948, 1), (1.79623, 1), (14.29513, 1), (19.69162, 1), (-7.98033, 1), (5.48433, 1), (-2.28474, 1), (9.91876, 1), (10.64097, 1), (0.22523, 1), (17.01773, 1), (22.37388, 1), (14.04215, 1), (23.1244, 1), (18.96958, 1), (8.42663, 1), (3.7165, 1), (14.29366, 1), (23.50886, 1), (26.33722, 1), (26.72396, 1), (13.26287, 1), (12.97607, 1), (17.41838, 1), (8.63875, 1), (17.08943, 1), (23.15356, 1), (-4.4965, 1), (7.58895, 1), (26.04074, 1), (6.84245, 1), (20.56287, 1), (3.84735, 1), (-2.76304, 1), (13.1615, 1), (8.21954, 1), (-3.49943, 1), (22.12419, 1), (7.08323, 1), (16.12937, 1), (-0.32672, 1), (16.5942, 1), (7.68977, 1), (11.39484, 1), (-5.11987, 1), (20.87404, 1), (8.01007, 1), (3.26497, 1), (5.61253, 1), (20.69182, 1), (0.0296, 1), (21.904, 1), (22.46572, 1), (3.63685, 1), (-5.10846, 1), (14.86389, 1), (5.47188, 1), (18.44095, 1), (16.71368, 1), (6.36704, 1), (8.82663, 1), (14.6727, 1), (7.98383, 1), (2.65568, 1), (21.45827, 1), (11.77948, 1), (4.71979, 1), (3.17951, 1), (13.90226, 1), (15.50578, 1), (10.8026, 1), (16.91369, 1), (9.90552, 1), (13.87322, 1), (4.12366, 1), (-3.78985, 1), (1.7599, 1), (3.43715, 1), (-3.45246, 1), (23.64571, 1), (-4.96877, 1), (3.93514, 1), (1.49914, 1), (12.71519, 1), (5.11521, 1), (4.79872, 1), (20.89391, 1), (5.363, 1), (8.02765, 1), (14.30804, 1), (11.49002, 1), (14.25281, 1), (7.6573, 1), (15.49686, 1), (3.29327, 1), (2.27236, 1), (12.58104, 1), (19.19128, 1), (15.25901, 1), (6.5221, 1), (10.10965, 1), (12.75249, 1), (16.50977, 1), (-8.6697, 1), (8.28553, 1), (1.44315, 1), (4.65869, 1), (0.98149, 1), (0.16623, 1), (17.66332, 1), (4.35346, 1), (6.52742, 1), (-1.06631, 1), (-5.28454, 1), (14.25583, 1), (8.74058, 1), (1.89553, 1), (-0.92959, 1), (10.30289, 1), (-6.3744, 1), (-8.1706, 1), (10.95369, 1), (4.94384, 1), (28.40568, 1), (3.7004, 1), (2.52363, 1), (4.07997, 1), (7.8849, 1), (17.95409, 1), (16.67021, 1), (11.34377, 1), (-0.07446, 1), (22.00223, 1), (3.31778, 1), (18.50719, 1), (-3.58655, 1), (6.5394, 1), (12.40459, 1), (16.59866, 1), (7.54176, 1), (-1.51044, 1), (12.69758, 1), (2.9842, 1), (2.49187, 1), (2.04113, 1), (-2.46544, 1), (15.18368, 1), (-0.04058, 1), (-0.4127, 1), (10.5526, 1), (12.03982, 1), (12.10923, 1), (11.54954, 1), (-1.18613, 1), (11.30984, 1), (23.54105, 1), (10.67321, 1), (24.09196, 1), (7.5008, 1), (12.52233, 1), (4.30673, 1), (9.35793, 1), (4.44472, 1), (-7.00679, 1), (8.56241, 1), (23.73891, 1), (15.62708, 1), (16.09205, 1), (12.52074, 1), (14.58927, 1), (-4.80187, 1), (8.47964, 1), (7.75477, 1), (12.6893, 1), (7.14147, 1), (12.12654, 1), (12.32334, 1), (7.98909, 1), (3.26652, 1), (20.53684, 1), (32.3369, 1), (19.74911, 1), (-4.62897, 1), (8.26483, 1), (20.88451, 1), (-2.12982, 1), (25.61459, 1), (5.32091, 1), (-4.1196, 1), (7.57937, 1), (21.15847, 1), (6.46355, 1), (7.74846, 1), (19.62636, 1), (28.34629, 1), (26.73919, 1), (20.40427, 1), (3.03378, 1), (10.2537, 1), (7.47745, 1), (10.79184, 1), (3.91962, 1), (19.97973, 1), (18.87711, 1), (12.56157, 1), (11.46033, 1), (3.78661, 1), (-9.45748, 1), (12.06033, 1), (-0.74615, 1), (13.2815, 1), (24.78052, 1), (5.83337, 1), (17.4111, 1), (19.70331, 1), (11.78446, 1), (-1.366, 1), (1.37458, 1), (16.31483, 1), (32.63464, 1), (-3.79736, 1), (19.17984, 1), (-0.27705, 1), (-3.69456, 1), (28.38058, 1), (-1.36876, 1), (-25.63301, 1), (3.58644, 1), (-6.85667, 1), (13.42225, 1), (12.04671, 1), (28.99468, 1), (7.87662, 1), (2.61119, 1), (-3.56022, 1), (1.50022, 1), (14.55836, 1), (9.35831, 1), (16.9366, 1), (29.23126, 1), (15.31386, 1), (13.46112, 1), (7.39667, 1), (11.15599, 1), (9.80499, 1), (22.64923, 1), (8.67693, 1), (18.67335, 1), (-3.19127, 1), (22.94716, 1), (17.86834, 1), (16.98267, 1), (15.91653, 1), (11.79718, 1), (18.50208, 1), (8.90755, 1), (10.44843, 1), (4.67433, 1), (6.82287, 1), (10.82228, 1), (-4.18631, 1), (20.3872, 1), (11.84735, 1), (21.25376, 1), (10.55032, 1), (12.19023, 1), (0.63369, 1), (7.92381, 1), (17.90933, 1), (15.30781, 1), (10.01877, 1), (0.88744, 1), (22.20967, 1), (-4.23117, 1), (21.50819, 1), (11.27421, 1), (-16.23179, 1), (33.43085, 1), (5.15093, 1), (1.34505, 1), (6.027, 1), (-10.43035, 1), (27.45998, 1), (19.24886, 1), (-4.44761, 1), (5.453, 1), (12.73758, 1), (11.2897, 1), (31.032, 1), (7.39168, 1), (11.95245, 1), (26.279, 1), (-1.0255, 1), (10.36675, 1), (11.58439, 1), (27.8405, 1), (13.1707, 1), (31.39133, 1), (27.08301, 1), (-2.14368, 1), (4.08476, 1), (21.5573, 1), (16.69822, 1), (7.69955, 1), (8.32793, 1), (6.49235, 1), (-7.3284, 1), (10.58264, 1), (-6.17006, 1), (34.55782, 1), (10.93221, 1), (44.24299, 1), (14.6224, 1), (-7.42798, 1), (15.52351, 1), (11.33982, 1), (10.46716, 1), (13.0986, 1), (-4.25988, 1), (9.55316, 1), (0.75489, 1), (25.99212, 1), (-0.81401, 1), (3.49551, 1), (22.99402, 1), (10.99628, 1), (23.70223, 1), (2.71482, 1), (22.82309, 1), (31.25686, 1), (4.86318, 1), (-1.06476, 1), (15.10298, 1), (-0.61015, 1), (17.81246, 1), (-1.55788, 1), (18.09709, 1), (9.11271, 1), (9.94682, 1), (-7.33194, 1), (-4.67293, 1), (21.81717, 1), (7.16318, 1), (13.25649, 1), (13.88776, 1), (4.95793, 1), (17.65303, 1), (14.47382, 1), (13.19373, 1), (31.86093, 1), (5.73161, 1), (10.96492, 1), (6.97951, 1), (1.75136, 1), (10.96144, 1), (15.08137, 1), (9.95311, 1), (7.07729, 1), (3.08148, 1), (22.37954, 1), (8.51951, 1), (2.88746, 1), (26.73509, 1), (-2.88939, 1), (-2.82367, 1), (-0.35783, 1), (14.22076, 1), (11.50295, 1), (7.10171, 1), (8.28488, 1), (0.54178, 1), (13.8022, 1), (15.62157, 1), (10.79173, 1), (28.18946, 1), (30.43524, 1), (2.54914, 1), (9.89421, 1), (13.08631, 1), (4.68761, 1), (5.61516, 1), (22.88072, 1), (7.4735, 1), (11.27382, 1), (2.39559, 1), (-3.31889, 1), (9.61957, 1), (23.01381, 1), (-1.23467, 1), (9.07691, 1), (15.78056, 1), (12.28421, 1), (9.44888, 1), (13.16928, 1), (4.33357, 1), (2.21737, 1), (33.17833, 1), (13.25407, 1), (-2.47961, 1), (6.41401, 1), (18.8439, 1), (-4.63375, 1), (-8.2909, 1), (12.18221, 1), (-2.95356, 1), (19.61659, 1), (12.45056, 1), (-4.17198, 1), (21.9641, 1), (11.96416, 1), (12.74573, 1), (10.47873, 1), (12.73295, 1), (11.31373, 1), (9.9827, 1), (5.87138, 1), (4.24372, 1), (-23.72256, 1), (28.41337, 1), (4.88103, 1), (3.61902, 1), (8.93586, 1), (16.40759, 1), (27.84494, 1), (5.6001, 1), (14.51379, 1), (13.5576, 1), (12.92213, 1), (3.90686, 1), (17.07104, 1), (15.84268, 1), (17.38777, 1), (16.54766, 1), (5.94487, 1), (17.02804, 1), (7.66386, 1), (10.43088, 1), (6.16059, 1), (20.46178, 1), (20.02888, 1), (20.95949, 1), (6.50808, 1), (7.22366, 1), (8.06659, 1), (16.08241, 1), (13.83514, 1), (-0.33454, 1), (12.98848, 1), (12.99024, 1);
+
+SELECT 
+roundBankers(kolmogorovSmirnovTest(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','auto')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less','auto')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater','auto')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','exact')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less','exact')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater','exact')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','asymp')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less','asymp')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater','asymp')(left, right).2, 6) ,
+roundBankers(kolmogorovSmirnovTest(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','auto')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less','auto')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater','auto')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','exact')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less','exact')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater','exact')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','asymp')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less','asymp')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater','asymp')(left, right).1, 6) 
+from kstest;
+
+DROP TABLE IF EXISTS kstest;
+
+
+CREATE TABLE kstest (left Float64, right Float64) ENGINE = Memory;
+
+INSERT INTO kstest VALUES (4.82025, 0), (6.13896, 0), (15.20277, 0), (14.15351, 0), (7.21338, 0), (8.55506, 0), (13.80816, 0), (11.28411, 0), (7.4612, 0), (7.43759, 0), (12.9832, 0), (-5.74783, 0), (12.47114, 0), (15.14223, 0), (3.40603, 0), (9.27323, 0), (7.88547, 0), (8.56456, 0), (4.59731, 0), (7.91213, 0), (7.33894, 0), (21.74811, 0), (11.92111, 0), (0.18828, 0), (10.47314, 0), (20.37396, 0), (11.04991, 0), (13.30083, 0), (14.28065, 0), (2.86942, 0), (24.96072, 0), (14.20164, 0), (18.28769, 0), (10.50949, 0), (9.22273, 0), (11.77608, 0), (8.56872, 0), (13.74535, 0), (11.65209, 0), (12.51894, 0), (17.76256, 0), (13.52122, 0), (8.70796, 0), (6.04749, 0), (16.33064, 0), (8.35636, 0), (14.03496, 0), (11.05834, 0), (14.49261, 0), (2.59383, 0), (8.01022, 0), (4.05458, 0), (13.26384, 0), (14.62058, 0), (10.52489, 0), (8.46357, 0), (6.4147, 0), (9.70071, 0), (12.47581, 0), (4.38333, 0), (17.54172, 0), (10.12109, 0), (7.73186, 0), (14.0279, 0), (11.6621, 0), (17.47045, 0), (15.50223, 0), (15.46034, 0), (13.39964, 0), (14.98025, 0), (15.87912, 0), (17.67374, 0), (9.64073, 0), (12.84904, 0), (7.70278, 0), (13.03156, 0), (9.04512, 0), (15.97014, 0), (8.96389, 0), (11.48009, 0), (9.71153, 0), (13.00084, 0), (12.39803, 0), (13.08188, 0), (5.82244, 0), (10.81871, 0), (8.2539, 0), (7.52114, 0), (9.11488, 0), (8.37482, 0), (14.48652, 0), (11.42152, 0), (16.03111, 0), (13.14057, 0), (-2.26351, 0), (15.50394, 0), (14.88603, 0), (13.37257, 0), (11.84026, 0), (7.66558, 0), (6.24584, 0), (3.6312, 0), (2.7018, 0), (5.63656, 0), (5.82643, 0), (10.06745, 0), (-0.5831, 0), (14.84202, 0), (9.5524, 0), (19.71713, 0), (14.23109, 0), (8.69105, 0), (5.33742, 0), (7.30372, 0), (7.93342, 0), (15.20884, 0), (7.53839, 0), (13.45311, 0), (11.04473, 0), (10.76673, 0), (15.44145, 0), (14.06596, 0), (9.14873, 0), (12.88372, 0), (8.74994, 0), (10.53263, 0), (16.16694, 0), (8.37197, 0), (3.43739, 0), (4.72799, 0), (9.08802, 0), (11.2531, 0), (5.16115, 0), (10.20895, 0), (18.70884, 0), (15.88924, 0), (3.38758, 0), (6.46449, 0), (10.21088, 0), (14.08458, 0), (15.74508, 0), (19.31896, 0), (13.19641, 0), (11.95409, 0), (10.70718, 0), (1.05245, 0), (10.04772, 0), (17.01369, 0), (10.2286, 0), (19.58323, 0), (7.02892, 0), (4.16866, 0), (8.94326, 0), (4.99854, 0), (8.88352, 0), (18.65422, 0), (17.32328, 0), (9.33492, 0), (14.94788, 0), (8.05863, 0), (14.6737, 0), (10.93801, 0), (0.54036, 0), (-0.34242, 0), (5.89076, 0), (3.15189, 0), (1.94421, 0), (6.38698, 0), (10.50654, 0), (8.95362, 0), (6.23711, 0), (11.75359, 0), (12.42155, 0), (-1.55472, 0), (4.6688, 0), (10.48087, 0), (11.74615, 0), (9.26822, 0), (7.55517, 0), (12.76005, 0), (16.47102, 0), (11.31297, 0), (14.37437, 0), (2.38799, 0), (6.44577, 0), (5.07471, 0), (11.55123, 0), (7.76795, 0), (10.60116, 0), (14.40885, 0), (11.58158, 0), (8.81648, 0), (12.92299, 0), (11.26939, 0), (17.95014, 0), (2.95002, 0), (17.41959, 0), (11.12455, 0), (8.78541, 0), (14.36413, 0), (12.98554, 0), (12.58505, 0), (15.49789, 0), (11.70999, 0), (0.65596, 0), (11.08202, 0), (14.75752, 0), (6.84385, 0), (9.27245, 0), (13.78243, 0), (17.4863, 0), (4.01777, 0), (11.82861, 0), (13.86551, 0), (6.16591, 0), (8.71589, 0), (16.77195, 0), (17.23243, 0), (-2.12941, 0), (5.66629, 0), (12.45153, 0), (1.63971, 0), (13.84031, 0), (4.6144, 0), (5.26169, 0), (9.27769, 0), (9.14288, 0), (9.71953, 0), (9.38446, 0), (1.64788, 0), (11.72922, 0), (13.68926, 0), (9.42952, 0), (12.05574, 0), (9.09148, 0), (5.32273, 0), (20.25258, 0), (10.14599, 0), (10.82156, 0), (5.75736, 0), (7.13567, 0), (9.29746, 0), (5.1618, 0), (10.076, 0), (21.65669, 0), (13.35486, 0), (6.79957, 0), (8.76243, 0), (14.59294, 0), (16.90609, 0), (10.50337, 0), (-0.07923, 0), (13.51648, 0), (12.0676, 0), (0.86482, 0), (9.03563, 0), (5.38751, 0), (17.16866, 0), (2.78702, 0), (11.15548, 0), (12.30843, 0), (8.04897, 0), (9.95814, 0), (11.29308, 0), (14.13032, 0), (21.05877, 0), (3.57386, 0), (7.96631, 0), (3.30484, 0), (18.61856, 0), (16.35184, 0), (7.65236, 0), (18.02895, 0), (9.79458, 0), (16.7274, 0), (8.84453, 0), (13.05709, 0), (10.91447, 0), (8.40171, 0), (16.95211, 0), (11.82194, 0), (19.87978, 0), (12.88455, 0), (-0.00947, 0), (12.28109, 0), (6.96462, 0), (13.75282, 0), (14.39141, 0), (11.07193, 0), (12.88039, 0), (11.38253, 0), (21.02707, 0), (7.51955, 0), (6.31984, 0), (15.6543, 0), (14.80315, 0), (8.38024, 0), (21.7516, 0), (14.31336, 0), (15.04703, 0), (5.73787, 0), (13.16911, 0), (12.40695, 0), (9.88968, 0), (8.46703, 0), (8.70637, 0), (8.03551, 0), (5.9757, 0), (12.22951, 0), (3.14736, 0), (10.51266, 0), (18.593, 0), (10.82213, 0), (7.14216, 0), (6.81154, 0), (-0.6486, 0), (20.56136, 0), (11.35367, 0), (11.38205, 0), (17.14, 0), (14.91215, 0), (15.50207, 0), (5.93162, 0), (3.74869, 0), (14.11532, 0), (7.38954, 0), (5.45764, 0), (18.33733, 0), (9.91923, 0), (2.38991, 0), (14.16756, 0), (2.39791, 0), (6.92586, 0), (5.32474, 0), (2.28812, 0), (5.71718, 0), (5.84197, 0), (2.76206, 0), (19.05928, 0), (11.51788, 0), (6.56648, 0), (3.35735, 0), (7.55948, 0), (19.99908, 0), (13.00634, 0), (18.36886, 0), (11.14675, 0), (16.72931, 0), (12.50106, 0), (6.00605, 0), (23.06653, 0), (5.39694, 0), (9.53167, 0), (12.76944, 0), (7.20604, 0), (13.25391, 0), (13.7341, 0), (10.85292, 0), (-7.75835, 0), (10.29728, 0), (13.70099, 0), (10.17959, 0), (9.98399, 0), (12.69389, 0), (-0.28848, 0), (-2.18319, 0), (13.36378, 0), (10.09232, 0), (5.49489, 0), (5.46156, 0), (0.94225, 0), (12.79205, 0), (10.09593, 0), (6.06218, 0), (0.89463, 0), (11.88986, 0), (10.79733, 0), (1.51371, 0), (2.20967, 0), (15.45732, 0), (16.5262, 0), (5.99724, 0), (8.3613, 0), (15.68183, 0), (15.32117, 0), (14.15674, 0), (6.64553, 0), (4.20777, 0), (-0.10521, 0), (-0.88169, 0), (1.85913, 0), (9.73673, 0), (0.30926, 0), (6.17559, 0), (11.76602, 0), (5.68385, 0), (14.57088, 0), (12.81509, 0), (9.85682, 0), (12.06376, 0), (6.08874, 0), (11.63921, 0), (14.86722, 0), (10.41035, 0), (2.93794, 0), (12.21841, 0), (0.23804, 0), (3.14845, 0), (7.29748, 0), (3.06134, 0), (13.77684, 0), (16.21992, 0), (5.33511, 0), (9.68959, 0), (9.44169, 0), (18.08012, 0), (4.04224, 0), (8.77918, 0), (10.18324, 0), (9.38914, 0), (11.76995, 0), (14.19963, 0), (6.88817, 0), (16.56123, 0), (15.39885, 0), (5.21241, 0), (4.44408, 0), (17.87587, 0), (12.53337, 0), (13.60916, 0), (6.60104, 0), (7.35453, 0), (18.61572, 0), (6.10437, 0), (13.08682, 0), (12.15404, 0), (4.90789, 0), (2.13353, 0), (12.49593, 0), (11.93056, 0), (13.29408, 0), (5.70038, 0), (8.40271, 0), (5.19456, 0), (-5.51028, 0), (14.0329, 0), (10.38365, 0), (6.56812, 0), (4.21129, 0), (9.7157, 0), (9.88553, 0), (13.45346, 0), (4.97752, 0), (12.77595, 0), (8.56465, 0), (4.27703, 0), (18.12502, 0), (12.45735, 0), (12.42912, 0), (12.08125, 0), (10.85779, 0), (4.36013, 0), (11.85062, 0), (8.47776, 0), (9.60822, 0), (11.3069, 0), (14.25525, 0), (1.55168, 0), (14.57782, 0), (7.84786, 0), (9.87774, 0), (14.75575, 0), (3.68774, 0), (9.37667, 0), (20.28676, 0), (12.10027, 0), (8.01819, 0), (18.78158, 0), (20.85402, 0), (18.98069, 0), (16.1429, 0), (9.24047, 0), (14.12487, 0), (10.18841, 0), (-3.04478, 0), (5.7552, 0), (9.30376, 0), (11.42837, 0), (6.02364, 0), (8.86984, 0), (10.91177, 0), (10.04418, 0), (18.10774, 0), (7.49384, 0), (9.11556, 0), (9.7051, 0), (5.23268, 0), (9.04647, 0), (8.81547, 0), (2.65098, 0), (-2.69857, 1), (15.80943, 1), (7.31555, 1), (3.96517, 1), (4.77809, 1), (9.6472, 1), (-26.41717, 1), (-10.85635, 1), (-1.4376, 1), (-0.96308, 1), (2.84315, 1), (5.79467, 1), (-3.06091, 1), (-14.62902, 1), (22.08022, 1), (-2.11982, 1), (-4.84824, 1), (-10.50447, 1), (2.4891, 1), (9.90324, 1), (-22.66866, 1), (-0.97103, 1), (-16.57608, 1), (-3.78749, 1), (25.84511, 1), (5.30797, 1), (-18.19466, 1), (11.72708, 1), (0.2891, 1), (-9.83474, 1), (6.69942, 1), (18.09604, 1), (18.52651, 1), (1.38201, 1), (7.64615, 1), (17.66598, 1), (-2.44141, 1), (-9.01598, 1), (27.69142, 1), (4.06946, 1), (-15.0077, 1), (-10.49648, 1), (-4.88322, 1), (-25.09805, 1), (-4.64024, 1), (20.94434, 1), (24.12126, 1), (-14.10962, 1), (10.6512, 1), (14.50687, 1), (-19.88081, 1), (-11.55271, 1), (13.16921, 1), (16.63864, 1), (-24.08114, 1), (-9.09949, 1), (-10.54702, 1), (0.20813, 1), (8.19066, 1), (-2.70523, 1), (-0.23954, 1), (7.19398, 1), (-7.1618, 1), (-7.44322, 1), (-17.92031, 1), (-1.58146, 1), (9.18338, 1), (3.25838, 1), (-14.30234, 1), (1.84695, 1), (31.13794, 1), (-0.85067, 1), (19.02787, 1), (-3.09594, 1), (13.45584, 1), (-5.48104, 1), (-22.74928, 1), (-8.03697, 1), (17.31143, 1), (-16.65231, 1), (-18.58713, 1), (-16.52641, 1), (14.95261, 1), (12.56762, 1), (15.00188, 1), (1.85858, 1), (2.1926, 1), (-2.4095, 1), (21.56873, 1), (3.35509, 1), (-4.98672, 1), (35.08603, 1), (-10.01602, 1), (-3.85153, 1), (-6.81974, 1), (19.56525, 1), (-9.35488, 1), (0.24268, 1), (-3.51488, 1), (-0.37066, 1), (24.20888, 1), (-11.73537, 1), (0.01282, 1), (0.03963, 1), (-9.65589, 1), (-0.37429, 1), (5.61255, 1), (0.49984, 1), (-10.15066, 1), (-14.54314, 1), (16.56889, 1), (-7.73873, 1), (-3.76422, 1), (1.40722, 1), (2.28818, 1), (-13.12643, 1), (5.17082, 1), (4.79089, 1), (-17.42643, 1), (8.72548, 1), (-3.70285, 1), (16.77893, 1), (13.382, 1), (19.98418, 1), (0.00483, 1), (-4.75951, 1), (2.35391, 1), (21.65809, 1), (-9.2714, 1), (-18.38253, 1), (7.23097, 1), (14.97927, 1), (-4.02197, 1), (-29.8189, 1), (-12.8554, 1), (-7.60124, 1), (-14.90158, 1), (-3.31486, 1), (31.38144, 1), (-8.61288, 1), (15.31895, 1), (-10.19488, 1), (13.796, 1), (-0.32912, 1), (-0.0684, 1), (-30.06834, 1), (24.93912, 1), (-3.26506, 1), (-8.29751, 1), (-5.39189, 1), (-25.08603, 1), (-1.45318, 1), (16.72724, 1), (-3.38467, 1), (-26.00478, 1), (7.28369, 1), (16.96226, 1), (16.5858, 1), (10.46583, 1), (3.84345, 1), (-2.99382, 1), (1.42078, 1), (-11.0123, 1), (2.09909, 1), (1.21064, 1), (15.36079, 1), (-21.61349, 1), (22.7726, 1), (10.50512, 1), (-6.95825, 1), (9.20036, 1), (15.66902, 1), (3.28098, 1), (-9.05692, 1), (0.32882, 1), (-1.64934, 1), (-4.81406, 1), (-5.06006, 1), (19.97493, 1), (2.88646, 1), (-0.34552, 1), (7.55186, 1), (-22.96115, 1), (31.29166, 1), (6.18798, 1), (-2.52715, 1), (-11.58799, 1), (14.13596, 1), (13.45069, 1), (12.15179, 1), (3.44491, 1), (-8.78006, 1), (18.32087, 1), (11.91757, 1), (-2.00179, 1), (10.88411, 1), (9.09327, 1), (6.62484, 1), (8.87178, 1), (11.52254, 1), (-14.15988, 1), (-17.19515, 1), (14.03089, 1), (-2.4095, 1), (-16.83575, 1), (2.71469, 1), (4.84351, 1), (-1.17651, 1), (-3.37529, 1), (-19.92137, 1), (4.48952, 1), (-12.4906, 1), (-5.65277, 1), (8.50819, 1), (-19.61261, 1), (12.54156, 1), (11.06784, 1), (-12.59285, 1), (3.43683, 1), (-3.00325, 1), (12.49082, 1), (7.20955, 1), (17.6547, 1), (15.8619, 1), (24.3048, 1), (-8.05434, 1), (-6.06901, 1), (-15.69515, 1), (-11.13917, 1), (-3.90757, 1), (-2.57038, 1), (5.14065, 1), (17.8497, 1), (-8.64665, 1), (-18.68331, 1), (5.8567, 1), (-20.93884, 1), (4.40583, 1), (14.35985, 1), (4.18134, 1), (4.3635, 1), (9.35428, 1), (2.8908, 1), (16.01017, 1), (-1.48499, 1), (-9.97949, 1), (1.03055, 1), (-2.79697, 1), (6.85977, 1), (4.73213, 1), (2.7815, 1), (-2.46866, 1), (18.39425, 1), (-0.80378, 1), (-0.22982, 1), (-16.11608, 1), (3.0862, 1), (3.20779, 1), (10.50146, 1), (-0.21305, 1), (11.21012, 1), (-0.99825, 1), (18.39633, 1), (-3.39003, 1), (-0.64411, 1), (-1.39932, 1), (15.45319, 1), (-0.66044, 1), (-15.2223, 1), (-34.39907, 1), (-3.57836, 1), (16.82828, 1), (1.66624, 1), (15.43475, 1), (8.17776, 1), (5.50486, 1), (10.43082, 1), (-6.63332, 1), (2.28008, 1), (16.37203, 1), (5.16313, 1), (-8.85281, 1), (13.26692, 1), (-7.46842, 1), (8.43091, 1), (-13.18172, 1), (-0.72401, 1), (22.3881, 1), (10.65448, 1), (2.81289, 1), (10.92405, 1), (-8.95358, 1), (19.80653, 1), (-12.86527, 1), (5.38826, 1), (-6.83501, 1), (-15.7647, 1), (-27.67412, 1), (8.6499, 1), (-4.89542, 1), (16.76167, 1), (12.84284, 1), (-17.27324, 1), (-4.18726, 1), (-14.62366, 1), (-5.49863, 1), (-16.22846, 1), (10.60329, 1), (6.46781, 1), (1.70458, 1), (10.77448, 1), (0.8463, 1), (13.0482, 1), (-4.36264, 1), (3.22647, 1), (2.38828, 1), (6.7946, 1), (-0.25254, 1), (1.2497, 1), (1.6544, 1), (4.1019, 1), (11.27839, 1), (-5.04127, 1), (18.11674, 1), (0.51231, 1), (-0.51029, 1), (13.52556, 1), (16.10171, 1), (5.68197, 1), (-2.85904, 1), (-8.89167, 1), (6.24489, 1), (10.85319, 1), (-0.39816, 1), (3.87079, 1), (-3.1867, 1), (1.55322, 1), (16.86779, 1), (-14.60321, 1), (-1.81952, 1), (-3.11624, 1), (1.24193, 1), (10.18179, 1), (4.69796, 1), (0.69032, 1), (11.7723, 1), (7.62896, 1), (9.89741, 1), (9.11484, 1), (-3.84676, 1), (-0.4777, 1), (0.95958, 1), (-7.95056, 1), (-10.97474, 1), (-6.54861, 1), (34.74933, 1), (27.39463, 1), (4.18299, 1), (6.02476, 1), (-1.99397, 1), (1.26478, 1), (23.37106, 1), (10.49682, 1), (-11.04354, 1), (-12.22284, 1), (-9.87635, 1), (28.90511, 1), (6.77613, 1), (0.55352, 1), (0.37031, 1), (7.1418, 1), (3.24897, 1), (-1.60918, 1), (3.1675, 1), (-17.97072, 1), (-5.61743, 1), (14.1422, 1), (14.87695, 1), (-4.65961, 1), (-0.99174, 1), (-2.96623, 1), (-9.02263, 1), (-17.2088, 1), (2.78608, 1), (6.74239, 1), (4.8524, 1), (7.46731, 1), (1.04894, 1), (-12.8023, 1), (-17.18188, 1), (-5.08801, 1), (22.13942, 1), (-0.36384, 1), (17.80564, 1), (7.67504, 1), (1.59779, 1), (4.10942, 1), (0.61074, 1), (-14.40767, 1), (10.59906, 1), (16.57017, 1), (-15.17526, 1), (-6.98549, 1), (-0.64548, 1), (3.23756, 1), (14.65504, 1), (4.583, 1), (12.72378, 1), (5.26547, 1), (0.81781, 1), (9.38273, 1), (10.37636, 1), (10.70325, 1), (-0.83043, 1), (-7.53149, 1), (-9.09147, 1), (-19.51381, 1), (-28.44508, 1), (6.44392, 1), (11.10201, 1), (-2.86184, 1), (8.30673, 1), (8.8797, 1), (10.68053, 1), (15.62919, 1), (8.00579, 1), (6.4651, 1), (-4.50029, 1), (18.04514, 1), (11.12996, 1), (-5.14007, 1), (9.43857, 1), (3.13476, 1), (4.9772, 1), (-17.45782, 1), (0.05552, 1), (-1.90283, 1), (2.67908, 1), (-2.62243, 1), (-3.22767, 1), (-8.70222, 1), (-23.11605, 1), (21.6757, 1), (12.70076, 1), (4.4322, 1), (11.69344, 1), (9.18052, 1), (-2.2549, 1), (-2.15615, 1), (20.29765, 1), (-0.29536, 1), (15.50109, 1), (8.79187, 1), (5.11533, 1), (-20.44436, 1), (-3.00909, 1), (-4.48291, 1), (21.84462, 1), (1.94225, 1), (-2.81908, 1), (17.19418, 1), (-9.33528, 1), (-0.17346, 1), (0.03958, 1), (-35.17786, 1), (8.36887, 1), (-9.02292, 1), (-10.98804, 1), (0.29335, 1), (4.29634, 1), (3.87718, 1), (-9.08532, 1), (7.13922, 1), (-7.62463, 1), (-10.5666, 1), (4.68165, 1), (-3.30172, 1), (13.04852, 1), (13.45616, 1), (2.41043, 1), (-0.36501, 1), (-15.67383, 1), (17.92217, 1), (8.42106, 1), (3.22063, 1), (-7.31753, 1), (21.99596, 1), (-36.8273, 1), (-20.46391, 1), (5.74179, 1), (-15.83178, 1), (14.90454, 1), (-8.84645, 1), (3.72036, 1), (4.6877, 1), (16.35418, 1), (3.15441, 1), (2.39907, 1), (-17.58664, 1), (-13.18269, 1);
+
+SELECT 
+roundBankers(kolmogorovSmirnovTest(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','auto')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less','auto')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater','auto')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','exact')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less','exact')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater','exact')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','asymp')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('less','asymp')(left, right).2, 6),
+roundBankers(kolmogorovSmirnovTest('greater','asymp')(left, right).2, 6) ,
+roundBankers(kolmogorovSmirnovTest(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','auto')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less','auto')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater','auto')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','exact')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less','exact')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater','exact')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('two-sided','asymp')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('less','asymp')(left, right).1, 6),
+roundBankers(kolmogorovSmirnovTest('greater','asymp')(left, right).1, 6) 
+from kstest;
+
+DROP TABLE IF EXISTS kstest;
diff --git a/tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.python b/tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.python
new file mode 100644
index 00000000000..a2a34b57c90
--- /dev/null
+++ b/tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.python
@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+import os
+import sys
+from scipy import stats
+import pandas as pd
+import numpy as np
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, "helpers"))
+
+from pure_http_client import ClickHouseClient
+
+
+def test_and_check(name, a, b, t_stat, p_value, precision=1e-2):
+    client = ClickHouseClient()
+    client.query("DROP TABLE IF EXISTS ks_test;")
+    client.query("CREATE TABLE ks_test (left Float64, right UInt8) ENGINE = Memory;")
+    client.query(
+        "INSERT INTO ks_test VALUES {};".format(
+            ", ".join(["({},{})".format(i, 0) for i in a])
+        )
+    )
+    client.query(
+        "INSERT INTO ks_test VALUES {};".format(
+            ", ".join(["({},{})".format(j, 1) for j in b])
+        )
+    )
+    real = client.query_return_df(
+        "SELECT roundBankers({}(left, right).1, 16) as t_stat, ".format(name)
+        + "roundBankers({}(left, right).2, 16) as p_value ".format(name)
+        + "FROM ks_test FORMAT TabSeparatedWithNames;"
+    )
+    real_t_stat = real["t_stat"][0]
+    real_p_value = real["p_value"][0]
+    assert (
+        abs(real_t_stat - np.float64(t_stat)) < precision
+    ), "clickhouse_t_stat {}, scipy_t_stat {}".format(real_t_stat, t_stat)
+    assert (
+        abs(real_p_value - np.float64(p_value)) < precision
+    ), "clickhouse_p_value {}, scipy_p_value {}".format(real_p_value, p_value)
+    client.query("DROP TABLE IF EXISTS ks_test;")
+
+
+def test_ks_all_alternatives(rvs1, rvs2):
+    s, p = stats.ks_2samp(rvs1, rvs2)
+    test_and_check("kolmogorovSmirnovTest", rvs1, rvs2, s, p)
+
+    s, p = stats.ks_2samp(rvs1, rvs2, alternative="two-sided")
+    test_and_check("kolmogorovSmirnovTest('two-sided')", rvs1, rvs2, s, p)
+
+    s, p = stats.ks_2samp(rvs1, rvs2, alternative="greater", method="auto")
+    test_and_check("kolmogorovSmirnovTest('greater', 'auto')", rvs1, rvs2, s, p)
+
+    s, p = stats.ks_2samp(rvs1, rvs2, alternative="less", method="exact")
+    test_and_check("kolmogorovSmirnovTest('less', 'exact')", rvs1, rvs2, s, p)
+
+    if max(len(rvs1), len(rvs2)) > 10000:
+        s, p = stats.ks_2samp(rvs1, rvs2, alternative="two-sided", method="asymp")
+        test_and_check("kolmogorovSmirnovTest('two-sided', 'asymp')", rvs1, rvs2, s, p)
+        s, p = stats.ks_2samp(rvs1, rvs2, alternative="greater", method="asymp")
+        test_and_check("kolmogorovSmirnovTest('greater', 'asymp')", rvs1, rvs2, s, p)
+
+
+def test_kolmogorov_smirnov():
+    rvs1 = np.round(stats.norm.rvs(loc=1, scale=5, size=10), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=1.5, scale=5, size=20), 2)
+    test_ks_all_alternatives(rvs1, rvs2)
+
+    rvs1 = np.round(stats.norm.rvs(loc=13, scale=1, size=100), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=1.52, scale=9, size=100), 2)
+    test_ks_all_alternatives(rvs1, rvs2)
+
+    rvs1 = np.round(stats.norm.rvs(loc=1, scale=5, size=100), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=11.5, scale=50, size=1000), 2)
+    test_ks_all_alternatives(rvs1, rvs2)
+
+    rvs1 = np.round(stats.norm.rvs(loc=1, scale=5, size=11000), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=3.5, scale=5.5, size=11000), 2)
+    test_ks_all_alternatives(rvs1, rvs2)
+
+
+if __name__ == "__main__":
+    test_kolmogorov_smirnov()
+    print("Ok.")
diff --git a/tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.reference b/tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.reference
new file mode 100644
index 00000000000..587579af915
--- /dev/null
+++ b/tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.reference
@@ -0,0 +1 @@
+Ok.
diff --git a/tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.sh b/tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.sh
new file mode 100755
index 00000000000..674495bbefa
--- /dev/null
+++ b/tests/queries/0_stateless/02706_kolmogorov_smirnov_test_scipy.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+# We should have correct env vars from shell_config.sh to run this test
+
+python3 "$CURDIR"/02706_kolmogorov_smirnov_test_scipy.python

From 1bea16ea6321e21972abb8d8fd53b1915021abb7 Mon Sep 17 00:00:00 2001
From: Sergei Trifonov <sergei@clickhouse.com>
Date: Wed, 5 Apr 2023 01:34:25 +0200
Subject: [PATCH 79/80] doc entry for SYSTEM WAIT LOADING PARTS

---
 docs/en/sql-reference/statements/system.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/docs/en/sql-reference/statements/system.md b/docs/en/sql-reference/statements/system.md
index 8c4b07333be..5a5a771f239 100644
--- a/docs/en/sql-reference/statements/system.md
+++ b/docs/en/sql-reference/statements/system.md
@@ -224,6 +224,14 @@ Clears freezed backup with the specified name from all the disks. See more about
 SYSTEM UNFREEZE WITH NAME <backup_name>
 ```
 
+### WAIT LOADING PARTS
+
+Wait until all asynchronously loading data parts of a table (outdated data parts) will became loaded.
+
+``` sql
+SYSTEM WAIT LOADING PARTS [db.]merge_tree_family_table_name
+```
+
 ## Managing ReplicatedMergeTree Tables
 
 ClickHouse can manage background replication related processes in [ReplicatedMergeTree](../../engines/table-engines/mergetree-family/replication.md#table_engines-replication) tables.

From e2679ccb532a00ac5f557310456204193cb8be09 Mon Sep 17 00:00:00 2001
From: Alexander Tokmakov <tavplubix@clickhouse.com>
Date: Wed, 5 Apr 2023 01:57:26 +0200
Subject: [PATCH 80/80] make CI slack bot less noisy

---
 utils/ci-slack-bot/ci-slack-bot.py | 108 +++++++++++++++++++++++++----
 1 file changed, 96 insertions(+), 12 deletions(-)

diff --git a/utils/ci-slack-bot/ci-slack-bot.py b/utils/ci-slack-bot/ci-slack-bot.py
index 83b6d8aad6b..76f60a80c04 100755
--- a/utils/ci-slack-bot/ci-slack-bot.py
+++ b/utils/ci-slack-bot/ci-slack-bot.py
@@ -15,6 +15,7 @@
 import os
 import json
 import base64
+import random
 
 if os.environ.get("AWS_LAMBDA_ENV", "0") == "1":
     # For AWS labmda (python 3.7)
@@ -28,25 +29,34 @@ DRY_RUN_MARK = "<no url, dry run>"
 MAX_FAILURES_DEFAULT = 50
 SLACK_URL_DEFAULT = DRY_RUN_MARK
 
-# Find tests that failed in master during the last check_period hours,
+EXTENDED_CHECK_PERIOD_MUL = 3
+FLAKY_ALERT_PROBABILITY = 0.20
+
+# Find tests that failed in master during the last check_period * 12 hours,
 # but did not fail during the last 2 weeks. Assuming these tests were broken recently.
-# NOTE: It may report flaky tests that fail too rarely.
+# Counts number of failures in check_period and check_period * 12 time windows
+# to distinguish rare flaky tests from completely broken tests
 NEW_BROKEN_TESTS_QUERY = """
 WITH
     1 AS check_period,
+    check_period * 12 AS extended_check_period,
     now() as now
-SELECT test_name, any(report_url)
+SELECT
+    test_name,
+    any(report_url),
+    countIf((check_start_time + check_duration_ms / 1000) < now - INTERVAL check_period HOUR) AS count_prev_periods,
+    countIf((check_start_time + check_duration_ms / 1000) >= now - INTERVAL check_period HOUR) AS count
 FROM checks
 WHERE 1
-    AND check_start_time >= now - INTERVAL 1 WEEK
-    AND (check_start_time + check_duration_ms / 1000) >= now - INTERVAL check_period HOUR
+    AND check_start_time BETWEEN now - INTERVAL 1 WEEK AND now
+    AND (check_start_time + check_duration_ms / 1000) >= now - INTERVAL extended_check_period HOUR
     AND pull_request_number = 0
     AND test_status LIKE 'F%'
     AND check_status != 'success'
     AND test_name NOT IN (
         SELECT test_name FROM checks WHERE 1
         AND check_start_time >= now - INTERVAL 1 MONTH
-        AND (check_start_time + check_duration_ms / 1000) BETWEEN now - INTERVAL 2 WEEK AND now - INTERVAL check_period HOUR 
+        AND (check_start_time + check_duration_ms / 1000) BETWEEN now - INTERVAL 2 WEEK AND now - INTERVAL extended_check_period HOUR 
         AND pull_request_number = 0
         AND check_status != 'success'
         AND test_status LIKE 'F%')
@@ -74,6 +84,27 @@ WHERE 1
     AND check_name ILIKE check_name_pattern
 """
 
+# It shows all recent failures of the specified test (helps to find when it started)
+ALL_RECENT_FAILURES_QUERY = """
+WITH
+    '{}' AS name_substr,
+    90 AS interval_days,
+    ('Stateless tests (asan)', 'Stateless tests (address)', 'Stateless tests (address, actions)') AS backport_and_release_specific_checks
+SELECT
+    toStartOfDay(check_start_time) AS d,
+    count(),
+    groupUniqArray(pull_request_number) AS prs,
+    any(report_url)
+FROM checks
+WHERE ((now() - toIntervalDay(interval_days)) <= check_start_time) AND (pull_request_number NOT IN (
+    SELECT pull_request_number AS prn
+    FROM checks
+    WHERE (prn != 0) AND ((now() - toIntervalDay(interval_days)) <= check_start_time) AND (check_name IN (backport_and_release_specific_checks))
+)) AND (position(test_name, name_substr) > 0) AND (test_status IN ('FAIL', 'ERROR', 'FLAKY'))
+GROUP BY d
+ORDER BY d DESC
+"""
+
 SLACK_MESSAGE_JSON = {"type": "mrkdwn", "text": None}
 
 
@@ -97,16 +128,62 @@ def run_clickhouse_query(query):
     return [x.split("\t") for x in lines]
 
 
-def get_new_broken_tests_message(broken_tests):
-    if not broken_tests:
+def split_broken_and_flaky_tests(failed_tests):
+    if not failed_tests:
         return None
-    msg = "There are {} new broken tests in master:\n".format(len(broken_tests))
-    for name, report in broken_tests:
-        msg += " - *{}*  -  <{}|Report>\n".format(name, report)
+
+    broken_tests = []
+    flaky_tests = []
+    for name, report, count_prev_str, count_str in failed_tests:
+        count_prev, count = int(count_prev_str), int(count_str)
+        if (2 <= count and count_prev < 2) or (count_prev == 1 and count == 1):
+            # It failed 2 times or more within extended time window, it's definitely broken.
+            # 2 <= count_prev means that it was not reported as broken on previous runs
+            broken_tests.append([name, report])
+        elif 0 < count and count_prev == 0:
+            # It failed only once, can be a rare flaky test
+            flaky_tests.append([name, report])
+
+    return broken_tests, flaky_tests
+
+
+def format_failed_tests_list(failed_tests, failure_type):
+    if len(failed_tests) == 1:
+        res = "There is a new {} test:\n".format(failure_type)
+    else:
+        res = "There are {} new {} tests:\n".format(len(failed_tests), failure_type)
+
+    for name, report in failed_tests:
+        cidb_url = get_play_url(ALL_RECENT_FAILURES_QUERY.format(name))
+        res += " - *{}*  -  <{}|Report>  -  <{}|CI DB> \n".format(
+            name, report, cidb_url
+        )
+    return res
+
+
+def get_new_broken_tests_message(failed_tests):
+    if not failed_tests:
+        return None
+
+    broken_tests, flaky_tests = split_broken_and_flaky_tests(failed_tests)
+    if len(broken_tests) == 0 and len(flaky_tests) == 0:
+        return None
+
+    msg = ""
+    if len(broken_tests) > 0:
+        msg += format_failed_tests_list(broken_tests, "*BROKEN*")
+    elif random.random() > FLAKY_ALERT_PROBABILITY:
+        # Should we report fuzzers unconditionally?
+        print("Will not report flaky tests to avoid noise: ", flaky_tests)
+        return None
+
+    if len(flaky_tests) > 0:
+        msg += format_failed_tests_list(flaky_tests, "flaky")
+
     return msg
 
 
-def get_too_many_failures_message(failures_count):
+def get_too_many_failures_message_impl(failures_count):
     MAX_FAILURES = int(os.environ.get("MAX_FAILURES", MAX_FAILURES_DEFAULT))
     curr_failures = int(failures_count[0][0])
     prev_failures = int(failures_count[0][1])
@@ -129,6 +206,13 @@ def get_too_many_failures_message(failures_count):
     )
 
 
+def get_too_many_failures_message(failures_count):
+    msg = get_too_many_failures_message_impl(failures_count)
+    if msg:
+        msg += "\nSee https://aretestsgreenyet.com/"
+    return msg
+
+
 def send_to_slack(message):
     SLACK_URL = os.environ.get("SLACK_URL", SLACK_URL_DEFAULT)
     if SLACK_URL == DRY_RUN_MARK: