Merge branch 'master' into #31363_format_template_configure_in_settings

2024-09-20 00:30:49 +00:00 · 2024-02-13 17:24:54 +01:00 · 2024-02-13 17:24:54 +01:00 · 42628fdd38
commit 42628fdd38
parent 913c23fa88 39f091bffb
434 changed files with 7402 additions and 4800 deletions
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@ -97,6 +97,14 @@ jobs:
      build_name: package_release
      checkout_depth: 0
      data: ${{ needs.RunConfig.outputs.data }}
+  BuilderDebReleaseCoverage:
+    needs: [RunConfig, BuildDockers]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_build.yml
+    with:
+      build_name: package_release_coverage
+      checkout_depth: 0
+      data: ${{ needs.RunConfig.outputs.data }}
  BuilderDebAarch64:
    needs: [RunConfig, BuildDockers]
    if: ${{ !failure() && !cancelled() }}
@ -277,6 +285,7 @@ jobs:
      - BuilderDebDebug
      - BuilderDebMsan
      - BuilderDebRelease
+      - BuilderDebReleaseCoverage
      - BuilderDebTsan
      - BuilderDebUBsan
    uses: ./.github/workflows/reusable_test.yml
@ -318,15 +327,19 @@ jobs:
      run_command: |
        python3 build_report_check.py "$CHECK_NAME"
  MarkReleaseReady:
-    needs: [RunConfig, BuilderBinDarwin, BuilderBinDarwinAarch64, BuilderDebRelease, BuilderDebAarch64]
-    if: ${{ !failure() && !cancelled() }}
-    uses: ./.github/workflows/reusable_test.yml
-    with:
-      test_name: Mark Commit Release Ready
-      runner_type: style-checker
-      data: ${{ needs.RunConfig.outputs.data }}
-      run_command: |
-        python3 mark_release_ready.py
+    needs:
+      - BuilderBinDarwin
+      - BuilderBinDarwinAarch64
+      - BuilderDebRelease
+      - BuilderDebAarch64
+    runs-on: [self-hosted, style-checker]
+    steps:
+      - name: Check out repository code
+        uses: ClickHouse/checkout@v1
+      - name: Mark Commit Release Ready
+        run: |
+          cd "$GITHUB_WORKSPACE/tests/ci"
+          python3 mark_release_ready.py
 ############################################################################################
 #################################### INSTALL PACKAGES ######################################
 ############################################################################################
@ -361,6 +374,14 @@ jobs:
      test_name: Stateless tests (release)
      runner_type: func-tester
      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatelessTestCoverage:
+    needs: [RunConfig, BuilderDebReleaseCoverage]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateless tests (coverage)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
  FunctionalStatelessTestReleaseDatabaseReplicated:
    needs: [RunConfig, BuilderDebRelease]
    if: ${{ !failure() && !cancelled() }}
@ -385,6 +406,22 @@ jobs:
      test_name: Stateless tests (release, s3 storage)
      runner_type: func-tester
      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatelessTestS3Debug:
+    needs: [RunConfig, BuilderDebDebug]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateless tests (debug, s3 storage)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatelessTestS3Tsan:
+    needs: [RunConfig, BuilderDebTsan]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateless tests (tsan, s3 storage)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
  FunctionalStatelessTestAarch64:
    needs: [RunConfig, BuilderDebAarch64]
    if: ${{ !failure() && !cancelled() }}
@ -445,6 +482,14 @@ jobs:
      test_name: Stateful tests (release)
      runner_type: func-tester
      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatefulTestCoverage:
+    needs: [RunConfig, BuilderDebReleaseCoverage]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateful tests (coverage)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
  FunctionalStatefulTestAarch64:
    needs: [RunConfig, BuilderDebAarch64]
    if: ${{ !failure() && !cancelled() }}
@ -493,6 +538,55 @@ jobs:
      test_name: Stateful tests (debug)
      runner_type: func-tester
      data: ${{ needs.RunConfig.outputs.data }}
+  # Parallel replicas
+  FunctionalStatefulTestDebugParallelReplicas:
+    needs: [RunConfig, BuilderDebDebug]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateful tests (debug, ParallelReplicas)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatefulTestUBsanParallelReplicas:
+    needs: [RunConfig, BuilderDebUBsan]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateful tests (ubsan, ParallelReplicas)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatefulTestMsanParallelReplicas:
+    needs: [RunConfig, BuilderDebMsan]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateful tests (msan, ParallelReplicas)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatefulTestTsanParallelReplicas:
+    needs: [RunConfig, BuilderDebTsan]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateful tests (tsan, ParallelReplicas)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatefulTestAsanParallelReplicas:
+    needs: [RunConfig, BuilderDebAsan]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateful tests (asan, ParallelReplicas)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatefulTestReleaseParallelReplicas:
+    needs: [RunConfig, BuilderDebRelease]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateful tests (release, ParallelReplicas)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
 ##############################################################################################
 ########################### ClickBench #######################################################
 ##############################################################################################
@ -700,6 +794,28 @@ jobs:
      runner_type: func-tester-aarch64
      data: ${{ needs.RunConfig.outputs.data }}
 ##############################################################################################
+############################ SQLLOGIC TEST ###################################################
+##############################################################################################
+  SQLLogicTestRelease:
+    needs: [RunConfig, BuilderDebRelease]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Sqllogic test (release)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
+##############################################################################################
+##################################### SQL TEST ###############################################
+##############################################################################################
+  SQLTest:
+    needs: [RunConfig, BuilderDebRelease]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: SQLTest
+      runner_type: fuzzer-unit-tester
+      data: ${{ needs.RunConfig.outputs.data }}
+##############################################################################################
 ###################################### SQLANCER FUZZERS ######################################
 ##############################################################################################
  SQLancerTestRelease:
@ -732,6 +848,8 @@ jobs:
      - FunctionalStatelessTestTsan
      - FunctionalStatelessTestMsan
      - FunctionalStatelessTestUBsan
+      - FunctionalStatelessTestS3Debug
+      - FunctionalStatelessTestS3Tsan
      - FunctionalStatefulTestDebug
      - FunctionalStatefulTestRelease
      - FunctionalStatefulTestAarch64
@ -739,6 +857,12 @@ jobs:
      - FunctionalStatefulTestTsan
      - FunctionalStatefulTestMsan
      - FunctionalStatefulTestUBsan
+      - FunctionalStatefulTestDebugParallelReplicas
+      - FunctionalStatefulTestUBsanParallelReplicas
+      - FunctionalStatefulTestMsanParallelReplicas
+      - FunctionalStatefulTestTsanParallelReplicas
+      - FunctionalStatefulTestAsanParallelReplicas
+      - FunctionalStatefulTestReleaseParallelReplicas
      - StressTestDebug
      - StressTestAsan
      - StressTestTsan
@ -764,6 +888,8 @@ jobs:
      - UnitTestsReleaseClang
      - SQLancerTestRelease
      - SQLancerTestDebug
+      - SQLLogicTestRelease
+      - SQLTest
    runs-on: [self-hosted, style-checker]
    steps:
      - name: Check out repository code
--- a/.github/workflows/pull_request.yml
+++ b/.github/workflows/pull_request.yml
@ -147,6 +147,14 @@ jobs:
      build_name: package_release
      checkout_depth: 0
      data: ${{ needs.RunConfig.outputs.data }}
+  BuilderDebReleaseCoverage:
+    needs: [RunConfig, FastTest]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_build.yml
+    with:
+      build_name: package_release_coverage
+      checkout_depth: 0
+      data: ${{ needs.RunConfig.outputs.data }}
  BuilderDebAarch64:
    needs: [RunConfig, FastTest]
    if: ${{ !failure() && !cancelled() }}
@ -309,6 +317,7 @@ jobs:
      - BuilderDebDebug
      - BuilderDebMsan
      - BuilderDebRelease
+      - BuilderDebReleaseCoverage
      - BuilderDebTsan
      - BuilderDebUBsan
    uses: ./.github/workflows/reusable_test.yml
@ -382,6 +391,14 @@ jobs:
      test_name: Stateless tests (release)
      runner_type: func-tester
      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatelessTestCoverage:
+    needs: [RunConfig, BuilderDebReleaseCoverage]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateless tests (coverage)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
  FunctionalStatelessTestReleaseDatabaseReplicated:
    needs: [RunConfig, BuilderDebRelease]
    if: ${{ !failure() && !cancelled() }}
@ -509,6 +526,14 @@ jobs:
      test_name: Stateful tests (release)
      runner_type: func-tester
      data: ${{ needs.RunConfig.outputs.data }}
+  FunctionalStatefulTestCoverage:
+    needs: [RunConfig, BuilderDebReleaseCoverage]
+    if: ${{ !failure() && !cancelled() }}
+    uses: ./.github/workflows/reusable_test.yml
+    with:
+      test_name: Stateful tests (coverage)
+      runner_type: func-tester
+      data: ${{ needs.RunConfig.outputs.data }}
  FunctionalStatefulTestAarch64:
    needs: [RunConfig, BuilderDebAarch64]
    if: ${{ !failure() && !cancelled() }}
@ -1002,7 +1027,7 @@ jobs:
 ####################################### libFuzzer ###########################################
 #############################################################################################
  libFuzzer:
-    if: ${{ !failure() && !cancelled() && contains(github.event.pull_request.labels.*.name, 'libFuzzer') }}
+    if: ${{ !failure() && !cancelled() }}
    needs: [RunConfig, StyleCheck]
    uses: ./.github/workflows/libfuzzer.yml
    with:
--- a/.github/workflows/release_branches.yml
+++ b/.github/workflows/release_branches.yml
@ -91,6 +91,8 @@ jobs:
      build_name: package_release
      checkout_depth: 0
      data: ${{ needs.RunConfig.outputs.data }}
+      # always rebuild on release branches to be able to publish from any commit
+      force: true
  BuilderDebAarch64:
    needs: [RunConfig, BuildDockers]
    if: ${{ !failure() && !cancelled() }}
@ -99,6 +101,8 @@ jobs:
      build_name: package_aarch64
      checkout_depth: 0
      data: ${{ needs.RunConfig.outputs.data }}
+      # always rebuild on release branches to be able to publish from any commit
+      force: true
  BuilderDebAsan:
    needs: [RunConfig, BuildDockers]
    if: ${{ !failure() && !cancelled() }}
@ -142,6 +146,8 @@ jobs:
      build_name: binary_darwin
      checkout_depth: 0
      data: ${{ needs.RunConfig.outputs.data }}
+      # always rebuild on release branches to be able to publish from any commit
+      force: true
  BuilderBinDarwinAarch64:
    needs: [RunConfig, BuildDockers]
    if: ${{ !failure() && !cancelled() }}
@ -150,6 +156,8 @@ jobs:
      build_name: binary_darwin_aarch64
      checkout_depth: 0
      data: ${{ needs.RunConfig.outputs.data }}
+      # always rebuild on release branches to be able to publish from any commit
+      force: true
 ############################################################################################
 ##################################### Docker images  #######################################
 ############################################################################################
@ -206,13 +214,8 @@ jobs:
    if: ${{ !cancelled() }}
    needs:
      - RunConfig
-      - BuilderDebRelease
-      - BuilderDebAarch64
-      - BuilderDebAsan
-      - BuilderDebTsan
-      - BuilderDebUBsan
-      - BuilderDebMsan
-      - BuilderDebDebug
+      - BuilderBinDarwin
+      - BuilderBinDarwinAarch64
    uses: ./.github/workflows/reusable_test.yml
    with:
      test_name: ClickHouse special build check
@ -225,7 +228,6 @@ jobs:
      run_command: |
        python3 build_report_check.py "$CHECK_NAME"
  MarkReleaseReady:
-    if: ${{ !failure() && !cancelled() }}
    needs:
      - BuilderBinDarwin
      - BuilderBinDarwinAarch64
@ -235,8 +237,6 @@ jobs:
    steps:
      - name: Check out repository code
        uses: ClickHouse/checkout@v1
-        with:
-          clear-repository: true
      - name: Mark Commit Release Ready
        run: |
          cd "$GITHUB_WORKSPACE/tests/ci"
--- a/.github/workflows/reusable_build.yml
+++ b/.github/workflows/reusable_build.yml
@ -26,6 +26,10 @@ name: Build ClickHouse
        description: json ci data
        type: string
        required: true
+      force:
+        description: disallow job skipping
+        type: boolean
+        default: false
      additional_envs:
        description: additional ENV variables to setup the job
        type: string
@ -33,7 +37,7 @@ name: Build ClickHouse
 jobs:
  Build:
    name: Build-${{inputs.build_name}}
-    if: contains(fromJson(inputs.data).jobs_data.jobs_to_do, inputs.build_name)
+    if: ${{ contains(fromJson(inputs.data).jobs_data.jobs_to_do, inputs.build_name) || inputs.force }}
    env:
      GITHUB_JOB_OVERRIDDEN: Build-${{inputs.build_name}}
    runs-on: [self-hosted, '${{inputs.runner_type}}']
@ -78,13 +82,15 @@ jobs:
          python3 "$GITHUB_WORKSPACE/tests/ci/ci.py" \
            --infile ${{ toJson(inputs.data) }} \
            --job-name "$BUILD_NAME" \
-            --run
+            --run \
+            ${{ inputs.force && '--force' || '' }}
      - name: Post
        # it still be build report to upload for failed build job
        if: ${{ !cancelled() }}
        run: |
          python3 "$GITHUB_WORKSPACE/tests/ci/ci.py" --infile ${{ toJson(inputs.data) }} --post --job-name '${{inputs.build_name}}'
      - name: Mark as done
+        if: ${{ !cancelled() }}
        run: |
          python3 "$GITHUB_WORKSPACE/tests/ci/ci.py" --infile ${{ toJson(inputs.data) }} --mark-success --job-name '${{inputs.build_name}}'
      - name: Clean
--- a/.github/workflows/reusable_docker.yml
+++ b/.github/workflows/reusable_docker.yml
@ -63,4 +63,4 @@ jobs:
          python3 docker_manifests_merge.py --suffix amd64 --suffix aarch64 \
            --image-tags '${{ toJson(fromJson(inputs.data).docker_data.images) }}' \
            --missing-images '${{ toJson(fromJson(inputs.data).docker_data.missing_multi) }}' \
-            "$FLAG_LATEST"
+            $FLAG_LATEST
--- a/.github/workflows/reusable_test.yml
+++ b/.github/workflows/reusable_test.yml
@ -107,6 +107,7 @@ jobs:
        run: |
          python3 "$GITHUB_WORKSPACE/tests/ci/ci.py" --infile ${{ toJson(inputs.data) }} --post --job-name '${{inputs.test_name}}'
      - name: Mark as done
+        if: ${{ !cancelled() }}
        run: |
          python3 "$GITHUB_WORKSPACE/tests/ci/ci.py" --infile ${{ toJson(inputs.data) }} --mark-success --job-name '${{inputs.test_name}}' --batch ${{matrix.batch}}
      - name: Clean
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -22,7 +22,6 @@
 * Add `quantileDD` aggregate function as well as the corresponding `quantilesDD` and `medianDD`. It is based on the DDSketch https://www.vldb.org/pvldb/vol12/p2195-masson.pdf. ### Documentation entry for user-facing changes. [#56342](https://github.com/ClickHouse/ClickHouse/pull/56342) ([Srikanth Chekuri](https://github.com/srikanthccv)).
 * Allow to configure any kind of object storage with any kind of metadata type. [#58357](https://github.com/ClickHouse/ClickHouse/pull/58357) ([Kseniia Sumarokova](https://github.com/kssenii)).
 * Added `null_status_on_timeout_only_active` and `throw_only_active` modes for `distributed_ddl_output_mode` that allow to avoid waiting for inactive replicas. [#58350](https://github.com/ClickHouse/ClickHouse/pull/58350) ([Alexander Tokmakov](https://github.com/tavplubix)).
-* Allow partitions from tables with different partition expressions to be attached when the destination table partition expression doesn't re-partition/split the part. [#39507](https://github.com/ClickHouse/ClickHouse/pull/39507) ([Arthur Passos](https://github.com/arthurpassos)).
 * Add function `arrayShingles` to compute subarrays, e.g. `arrayShingles([1, 2, 3, 4, 5], 3)` returns `[[1,2,3],[2,3,4],[3,4,5]]`. [#58396](https://github.com/ClickHouse/ClickHouse/pull/58396) ([Zheng Miao](https://github.com/zenmiao7)).
 * Added functions `punycodeEncode`, `punycodeDecode`, `idnaEncode` and `idnaDecode` which are useful for translating international domain names to an ASCII representation according to the IDNA standard. [#58454](https://github.com/ClickHouse/ClickHouse/pull/58454) ([Robert Schulze](https://github.com/rschu1ze)).
 * Added string similarity functions `dramerauLevenshteinDistance`, `jaroSimilarity` and `jaroWinklerSimilarity`. [#58531](https://github.com/ClickHouse/ClickHouse/pull/58531) ([Robert Schulze](https://github.com/rschu1ze)).
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -254,10 +254,17 @@ endif()

 include(cmake/cpu_features.cmake)

-# Asynchronous unwind tables are needed for Query Profiler.
-# They are already by default on some platforms but possibly not on all platforms.
-# Enable it explicitly.
-set (COMPILER_FLAGS "${COMPILER_FLAGS} -fasynchronous-unwind-tables")
+
+# Query Profiler doesn't work on MacOS for several reasons
+# - PHDR cache is not available
+# - We use native functionality to get stacktraces which is not async signal safe
+# and thus we don't need to generate asynchronous unwind tables
+if (NOT OS_DARWIN)
+    # Asynchronous unwind tables are needed for Query Profiler.
+    # They are already by default on some platforms but possibly not on all platforms.
+    # Enable it explicitly.
+    set (COMPILER_FLAGS "${COMPILER_FLAGS} -fasynchronous-unwind-tables")
+endif()

 # Reproducible builds.
 if (CMAKE_BUILD_TYPE_UC STREQUAL "DEBUG")
@ -348,7 +355,7 @@ if (COMPILER_CLANG)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-absolute-paths")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fdiagnostics-absolute-paths")

-    if (NOT ENABLE_TESTS AND NOT SANITIZE AND OS_LINUX)
+    if (NOT ENABLE_TESTS AND NOT SANITIZE AND NOT SANITIZE_COVERAGE AND OS_LINUX)
        # https://clang.llvm.org/docs/ThinLTO.html
        # Applies to clang and linux only.
        # Disabled when building with tests or sanitizers.
@ -546,7 +553,7 @@ if (ENABLE_RUST)
    endif()
 endif()

-if (CMAKE_BUILD_TYPE_UC STREQUAL "RELWITHDEBINFO" AND NOT SANITIZE AND OS_LINUX AND (ARCH_AMD64 OR ARCH_AARCH64))
+if (CMAKE_BUILD_TYPE_UC STREQUAL "RELWITHDEBINFO" AND NOT SANITIZE AND NOT SANITIZE_COVERAGE AND OS_LINUX AND (ARCH_AMD64 OR ARCH_AARCH64))
    set(CHECK_LARGE_OBJECT_SIZES_DEFAULT ON)
 else ()
    set(CHECK_LARGE_OBJECT_SIZES_DEFAULT OFF)
--- a/base/base/CMakeLists.txt
+++ b/base/base/CMakeLists.txt
@ -17,6 +17,7 @@ set (SRCS
    getMemoryAmount.cpp
    getPageSize.cpp
    getThreadId.cpp
+    int8_to_string.cpp
    JSON.cpp
    mremap.cpp
    phdr_cache.cpp
--- a/base/base/coverage.cpp
+++ b/base/base/coverage.cpp
@ -1,4 +1,5 @@
 #include "coverage.h"
+#include <sys/mman.h>

 #pragma GCC diagnostic ignored "-Wreserved-identifier"

@ -52,11 +53,21 @@ namespace
    uint32_t * guards_start = nullptr;
    uint32_t * guards_end = nullptr;

-    uintptr_t * coverage_array = nullptr;
+    uintptr_t * current_coverage_array = nullptr;
+    uintptr_t * cumulative_coverage_array = nullptr;
    size_t coverage_array_size = 0;

    uintptr_t * all_addresses_array = nullptr;
    size_t all_addresses_array_size = 0;
+
+    uintptr_t * allocate(size_t size)
+    {
+        /// Note: mmap return zero-initialized memory, and we count on that.
+        void * map = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+        if (MAP_FAILED == map)
+            return nullptr;
+        return static_cast<uintptr_t*>(map);
+    }
 }

 extern "C"
@ -79,7 +90,8 @@ void __sanitizer_cov_trace_pc_guard_init(uint32_t * start, uint32_t * stop)
    coverage_array_size = stop - start;

    /// Note: we will leak this.
-    coverage_array = static_cast<uintptr_t*>(malloc(sizeof(uintptr_t) * coverage_array_size));
+    current_coverage_array = allocate(sizeof(uintptr_t) * coverage_array_size);
+    cumulative_coverage_array = allocate(sizeof(uintptr_t) * coverage_array_size);

    resetCoverage();
 }
@ -92,8 +104,8 @@ void __sanitizer_cov_pcs_init(const uintptr_t * pcs_begin, const uintptr_t * pcs
        return;
    pc_table_initialized = true;

-    all_addresses_array = static_cast<uintptr_t*>(malloc(sizeof(uintptr_t) * coverage_array_size));
    all_addresses_array_size = pcs_end - pcs_begin;
+    all_addresses_array = allocate(sizeof(uintptr_t) * all_addresses_array_size);

    /// They are not a real pointers, but also contain a flag in the most significant bit,
    /// in which we are not interested for now. Reset it.
@ -115,17 +127,24 @@ void __sanitizer_cov_trace_pc_guard(uint32_t * guard)
    /// The values of `*guard` are as you set them in
    /// __sanitizer_cov_trace_pc_guard_init and so you can make them consecutive
    /// and use them to dereference an array or a bit vector.
-    void * pc = __builtin_return_address(0);
+    intptr_t pc = reinterpret_cast<uintptr_t>(__builtin_return_address(0));

-    coverage_array[guard - guards_start] = reinterpret_cast<uintptr_t>(pc);
+    current_coverage_array[guard - guards_start] = pc;
+    cumulative_coverage_array[guard - guards_start] = pc;
 }

 }

 __attribute__((no_sanitize("coverage")))
-std::span<const uintptr_t> getCoverage()
+std::span<const uintptr_t> getCurrentCoverage()
 {
-    return {coverage_array, coverage_array_size};
+    return {current_coverage_array, coverage_array_size};
+}
+
+__attribute__((no_sanitize("coverage")))
+std::span<const uintptr_t> getCumulativeCoverage()
+{
+    return {cumulative_coverage_array, coverage_array_size};
 }

 __attribute__((no_sanitize("coverage")))
@ -137,7 +156,7 @@ std::span<const uintptr_t> getAllInstrumentedAddresses()
 __attribute__((no_sanitize("coverage")))
 void resetCoverage()
 {
-    memset(coverage_array, 0, coverage_array_size * sizeof(*coverage_array));
+    memset(current_coverage_array, 0, coverage_array_size * sizeof(*current_coverage_array));

    /// The guard defines whether the __sanitizer_cov_trace_pc_guard should be called.
    /// For example, you can unset it after first invocation to prevent excessive work.
--- a/base/base/coverage.h
+++ b/base/base/coverage.h
@ -15,7 +15,10 @@ void dumpCoverageReportIfPossible();
 /// Get accumulated unique program addresses of the instrumented parts of the code,
 /// seen so far after program startup or after previous reset.
 /// The returned span will be represented as a sparse map, containing mostly zeros, which you should filter away.
-std::span<const uintptr_t> getCoverage();
+std::span<const uintptr_t> getCurrentCoverage();
+
+/// Similar but not being reset.
+std::span<const uintptr_t> getCumulativeCoverage();

 /// Get all instrumented addresses that could be in the coverage.
 std::span<const uintptr_t> getAllInstrumentedAddresses();
--- a/base/base/getMemoryAmount.cpp
+++ b/base/base/getMemoryAmount.cpp
@ -1,8 +1,11 @@
-#include <stdexcept>
-#include <fstream>
 #include <base/getMemoryAmount.h>
+
 #include <base/getPageSize.h>

+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/param.h>
@ -11,6 +14,80 @@
 #endif


+namespace
+{
+
+std::optional<uint64_t> getCgroupsV2MemoryLimit()
+{
+#if defined(OS_LINUX)
+    const std::filesystem::path default_cgroups_mount = "/sys/fs/cgroup";
+
+    /// This file exists iff the host has cgroups v2 enabled.
+    std::ifstream controllers_file(default_cgroups_mount / "cgroup.controllers");
+    if (!controllers_file.is_open())
+        return {};
+
+    /// Make sure that the memory controller is enabled.
+    /// - cgroup.controllers defines which controllers *can* be enabled.
+    /// - cgroup.subtree_control defines which controllers *are* enabled.
+    /// (see https://docs.kernel.org/admin-guide/cgroup-v2.html)
+    /// Caveat: nested groups may disable controllers. For simplicity, check only the top-level group.
+    /// ReadBufferFromFile subtree_control_file(default_cgroups_mount / "cgroup.subtree_control");
+    /// std::string subtree_control;
+    /// readString(subtree_control, subtree_control_file);
+    /// if (subtree_control.find("memory") == std::string::npos)
+    ///     return {};
+    std::ifstream subtree_control_file(default_cgroups_mount / "cgroup.subtree_control");
+    std::stringstream subtree_control_buf;
+    subtree_control_buf << subtree_control_file.rdbuf();
+    std::string subtree_control = subtree_control_buf.str();
+    if (subtree_control.find("memory") == std::string::npos)
+        return {};
+
+    /// Identify the cgroup the process belongs to
+    /// All PIDs assigned to a cgroup are in /sys/fs/cgroups/{cgroup_name}/cgroup.procs
+    /// A simpler way to get the membership is:
+    std::ifstream cgroup_name_file("/proc/self/cgroup");
+    if (!cgroup_name_file.is_open())
+        return {};
+
+    std::stringstream cgroup_name_buf;
+    cgroup_name_buf << cgroup_name_file.rdbuf();
+    std::string cgroup_name = cgroup_name_buf.str();
+    if (!cgroup_name.empty() && cgroup_name.back() == '\n')
+        cgroup_name.pop_back(); /// remove trailing newline, if any
+    /// With cgroups v2, there will be a *single* line with prefix "0::/"
+    const std::string v2_prefix = "0::/";
+    if (!cgroup_name.starts_with(v2_prefix))
+        return {};
+    cgroup_name = cgroup_name.substr(v2_prefix.length());
+
+    std::filesystem::path current_cgroup = cgroup_name.empty() ? default_cgroups_mount : (default_cgroups_mount / cgroup_name);
+
+    /// Open the bottom-most nested memory limit setting file. If there is no such file at the current
+    /// level, try again at the parent level as memory settings are inherited.
+    while (current_cgroup != default_cgroups_mount.parent_path())
+    {
+        std::ifstream setting_file(current_cgroup / "memory.max");
+        if (setting_file.is_open())
+        {
+            uint64_t value;
+            if (setting_file >> value)
+                return {value};
+            else
+                return {}; /// e.g. the cgroups default "max"
+        }
+        current_cgroup = current_cgroup.parent_path();
+    }
+
+    return {};
+#else
+    return {};
+#endif
+}
+
+}
+
 /** Returns the size of physical memory (RAM) in bytes.
  * Returns 0 on unsupported platform
  */
@ -26,34 +103,27 @@ uint64_t getMemoryAmountOrZero()

    uint64_t memory_amount = num_pages * page_size;

-#if defined(OS_LINUX)
-    // Try to lookup at the Cgroup limit
-
-    // CGroups v2
-    std::ifstream cgroupv2_limit("/sys/fs/cgroup/memory.max");
-    if (cgroupv2_limit.is_open())
-    {
-        uint64_t memory_limit = 0;
-        cgroupv2_limit >> memory_limit;
-        if (memory_limit > 0 && memory_limit < memory_amount)
-            memory_amount = memory_limit;
-    }
+    /// Respect the memory limit set by cgroups v2.
+    auto limit_v2 = getCgroupsV2MemoryLimit();
+    if (limit_v2.has_value() && *limit_v2 < memory_amount)
+         memory_amount = *limit_v2;
    else
    {
-        // CGroups v1
-        std::ifstream cgroup_limit("/sys/fs/cgroup/memory/memory.limit_in_bytes");
-        if (cgroup_limit.is_open())
+        /// Cgroups v1 were replaced by v2 in 2015. The only reason we keep supporting v1 is that the transition to v2
+        /// has been slow. Caveat : Hierarchical groups as in v2 are not supported for v1, the location of the memory
+        /// limit (virtual) file is hard-coded.
+        /// TODO: check at the end of 2024 if we can get rid of v1.
+        std::ifstream limit_file_v1("/sys/fs/cgroup/memory/memory.limit_in_bytes");
+        if (limit_file_v1.is_open())
        {
-            uint64_t memory_limit = 0; // in case of read error
-            cgroup_limit >> memory_limit;
-            if (memory_limit > 0 && memory_limit < memory_amount)
-                memory_amount = memory_limit;
+            uint64_t limit_v1;
+            if (limit_file_v1 >> limit_v1)
+                if (limit_v1 < memory_amount)
+                    memory_amount = limit_v1;
        }
    }
-#endif

    return memory_amount;
-
 }


--- a/base/base/int8_to_string.cpp
+++ b/base/base/int8_to_string.cpp
@ -0,0 +1,9 @@
+#include <base/int8_to_string.h>
+
+namespace std
+{
+std::string to_string(Int8 v) /// NOLINT (cert-dcl58-cpp)
+{
+    return to_string(int8_t{v});
+}
+}
--- a/base/base/int8_to_string.h
+++ b/base/base/int8_to_string.h
@ -0,0 +1,17 @@
+#pragma once
+
+#include <base/defines.h>
+#include <base/types.h>
+
+#include <fmt/format.h>
+
+template <>
+struct fmt::formatter<Int8> : fmt::formatter<int8_t>
+{
+};
+
+
+namespace std
+{
+std::string to_string(Int8 v); /// NOLINT (cert-dcl58-cpp)
+}
--- a/base/base/types.h
+++ b/base/base/types.h
@ -3,14 +3,29 @@
 #include <cstdint>
 #include <string>

-/// This is needed for more strict aliasing. https://godbolt.org/z/xpJBSb https://stackoverflow.com/a/57453713
+/// Using char8_t more strict aliasing (https://stackoverflow.com/a/57453713)
 using UInt8 = char8_t;

+/// Same for using signed _BitInt(8) (there isn't a signed char8_t, which would be more convenient)
+/// See https://godbolt.org/z/fafnWEnnf
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wbit-int-extension"
+using Int8 = signed _BitInt(8);
+#pragma clang diagnostic pop
+
+namespace std
+{
+template <>
+struct hash<Int8> /// NOLINT (cert-dcl58-cpp)
+{
+    size_t operator()(const Int8 x) const { return std::hash<int8_t>()(int8_t{x}); }
+};
+}
+
 using UInt16 = uint16_t;
 using UInt32 = uint32_t;
 using UInt64 = uint64_t;

-using Int8 = int8_t;
 using Int16 = int16_t;
 using Int32 = int32_t;
 using Int64 = int64_t;
--- a/base/poco/Foundation/include/Poco/Logger.h
+++ b/base/poco/Foundation/include/Poco/Logger.h
@ -22,6 +22,7 @@
 #include <cstddef>
 #include <map>
 #include <vector>
+
 #include "Poco/Channel.h"
 #include "Poco/Format.h"
 #include "Poco/Foundation.h"
@ -871,21 +872,11 @@ public:
    /// If the Logger does not yet exist, it is created, based
    /// on its parent logger.

-    static LoggerPtr getShared(const std::string & name);
+    static LoggerPtr getShared(const std::string & name, bool should_be_owned_by_shared_ptr_if_created = true);
    /// Returns a shared pointer to the Logger with the given name.
    /// If the Logger does not yet exist, it is created, based
    /// on its parent logger.

-    static Logger & unsafeGet(const std::string & name);
-    /// Returns a reference to the Logger with the given name.
-    /// If the Logger does not yet exist, it is created, based
-    /// on its parent logger.
-    ///
-    /// WARNING: This method is not thread safe. You should
-    /// probably use get() instead.
-    /// The only time this method should be used is during
-    /// program initialization, when only one thread is running.
-
    static Logger & create(const std::string & name, Channel * pChannel, int level = Message::PRIO_INFORMATION);
    /// Creates and returns a reference to a Logger with the
    /// given name. The Logger's Channel and log level as set as
@ -932,6 +923,16 @@ public:

    static const std::string ROOT; /// The name of the root logger ("").

+public:
+    struct LoggerEntry
+    {
+        Poco::Logger * logger;
+        bool owned_by_shared_ptr = false;
+    };
+
+    using LoggerMap = std::unordered_map<std::string, LoggerEntry>;
+    using LoggerMapIterator = LoggerMap::iterator;
+
 protected:
    Logger(const std::string & name, Channel * pChannel, int level);
    ~Logger();
@ -940,12 +941,16 @@ protected:
    void log(const std::string & text, Message::Priority prio, const char * file, int line);

    static std::string format(const std::string & fmt, int argc, std::string argv[]);
-    static Logger & unsafeCreate(const std::string & name, Channel * pChannel, int level = Message::PRIO_INFORMATION);
-    static Logger & parent(const std::string & name);
-    static void add(Logger * pLogger);
-    static Logger * find(const std::string & name);

 private:
+    static std::pair<Logger::LoggerMapIterator, bool> unsafeGet(const std::string & name, bool get_shared);
+    static Logger * unsafeGetRawPtr(const std::string & name);
+    static std::pair<LoggerMapIterator, bool> unsafeCreate(const std::string & name, Channel * pChannel, int level = Message::PRIO_INFORMATION);
+    static Logger & parent(const std::string & name);
+    static std::pair<LoggerMapIterator, bool> add(Logger * pLogger);
+    static std::optional<LoggerMapIterator> find(const std::string & name);
+    static Logger * findRawPtr(const std::string & name);
+
    Logger();
    Logger(const Logger &);
    Logger & operator=(const Logger &);
--- a/base/poco/Foundation/src/Logger.cpp
+++ b/base/poco/Foundation/src/Logger.cpp
@ -38,14 +38,7 @@ std::mutex & getLoggerMutex()
 	return *logger_mutex;
 }

-struct LoggerEntry
-{
-	Poco::Logger * logger;
-	bool owned_by_shared_ptr = false;
-};
-
-using LoggerMap = std::unordered_map<std::string, LoggerEntry>;
-LoggerMap * _pLoggerMap = nullptr;
+Poco::Logger::LoggerMap * _pLoggerMap = nullptr;

 }

@ -337,10 +330,12 @@ struct LoggerDeleter
 	}
 };

-
-inline LoggerPtr makeLoggerPtr(Logger & logger)
+inline LoggerPtr makeLoggerPtr(Logger & logger, bool owned_by_shared_ptr)
 {
-	return std::shared_ptr<Logger>(&logger, LoggerDeleter());
+	if (owned_by_shared_ptr)
+		return LoggerPtr(&logger, LoggerDeleter());
+
+	return LoggerPtr(std::shared_ptr<void>{}, &logger);
 }

 }
@ -350,64 +345,67 @@ Logger& Logger::get(const std::string& name)
 {
 	std::lock_guard<std::mutex> lock(getLoggerMutex());

-	Logger & logger = unsafeGet(name);
-
-	/** If there are already shared pointer created for this logger
-	  * we need to increment Logger reference count and now logger
-	  * is owned by logger infrastructure.
-	  */
-	auto it = _pLoggerMap->find(name);
-	if (it->second.owned_by_shared_ptr)
-	{
-		it->second.logger->duplicate();
-		it->second.owned_by_shared_ptr = false;
-	}
-
-	return logger;
+	auto [it, inserted] = unsafeGet(name, false /*get_shared*/);
+	return *it->second.logger;
 }


-LoggerPtr Logger::getShared(const std::string & name)
+LoggerPtr Logger::getShared(const std::string & name, bool should_be_owned_by_shared_ptr_if_created)
 {
 	std::lock_guard<std::mutex> lock(getLoggerMutex());
-	bool logger_exists = _pLoggerMap && _pLoggerMap->contains(name);
+	auto [it, inserted] = unsafeGet(name, true /*get_shared*/);

-	Logger & logger = unsafeGet(name);
-
-	/** If logger already exists, then this shared pointer does not own it.
-	  * If logger does not exists, logger infrastructure could be already destroyed
-	  * or logger was created.
+	/** If during `unsafeGet` logger was created, then this shared pointer owns it.
+	  * If logger was already created, then this shared pointer does not own it.
 	  */
-	if (logger_exists)
-	{
-		logger.duplicate();
-	}
-	else if (_pLoggerMap)
-	{
-		_pLoggerMap->find(name)->second.owned_by_shared_ptr = true;
-	}
+	if (inserted && should_be_owned_by_shared_ptr_if_created)
+		it->second.owned_by_shared_ptr = true;

-	return makeLoggerPtr(logger);
+	return makeLoggerPtr(*it->second.logger, it->second.owned_by_shared_ptr);
 }


-Logger& Logger::unsafeGet(const std::string& name)
+std::pair<Logger::LoggerMapIterator, bool> Logger::unsafeGet(const std::string& name, bool get_shared)
 {
-	Logger* pLogger = find(name);
-	if (!pLogger)
+	std::optional<Logger::LoggerMapIterator> optional_logger_it = find(name);
+
+	if (optional_logger_it)
 	{
+		auto & logger_it = *optional_logger_it;
+
+		if (logger_it->second.owned_by_shared_ptr)
+		{
+			logger_it->second.logger->duplicate();
+
+			if (!get_shared)
+				logger_it->second.owned_by_shared_ptr = false;
+		}
+	}
+
+	if (!optional_logger_it)
+	{
+		Logger * logger = nullptr;
+
 		if (name == ROOT)
 		{
-			pLogger = new Logger(name, 0, Message::PRIO_INFORMATION);
+			logger = new Logger(name, nullptr, Message::PRIO_INFORMATION);
 		}
 		else
 		{
 			Logger& par = parent(name);
-			pLogger = new Logger(name, par.getChannel(), par.getLevel());
+			logger = new Logger(name, par.getChannel(), par.getLevel());
 		}
-		add(pLogger);
+
+		return add(logger);
 	}
-	return *pLogger;
+
+	return std::make_pair(*optional_logger_it, false);
+}
+
+
+Logger * Logger::unsafeGetRawPtr(const std::string & name)
+{
+	return unsafeGet(name, false /*get_shared*/).first->second.logger;
 }


@ -415,24 +413,24 @@ Logger& Logger::create(const std::string& name, Channel* pChannel, int level)
 {
 	std::lock_guard<std::mutex> lock(getLoggerMutex());

-	return unsafeCreate(name, pChannel, level);
+	return *unsafeCreate(name, pChannel, level).first->second.logger;
 }

 LoggerPtr Logger::createShared(const std::string & name, Channel * pChannel, int level)
 {
 	std::lock_guard<std::mutex> lock(getLoggerMutex());

-	Logger & logger = unsafeCreate(name, pChannel, level);
-	_pLoggerMap->find(name)->second.owned_by_shared_ptr = true;
+	auto [it, inserted] = unsafeCreate(name, pChannel, level);
+	it->second.owned_by_shared_ptr = true;

-	return makeLoggerPtr(logger);
+	return makeLoggerPtr(*it->second.logger, it->second.owned_by_shared_ptr);
 }

 Logger& Logger::root()
 {
 	std::lock_guard<std::mutex> lock(getLoggerMutex());

-	return unsafeGet(ROOT);
+	return *unsafeGetRawPtr(ROOT);
 }


@ -440,7 +438,11 @@ Logger* Logger::has(const std::string& name)
 {
 	std::lock_guard<std::mutex> lock(getLoggerMutex());

-	return find(name);
+	auto optional_it = find(name);
+	if (!optional_it)
+		return nullptr;
+
+	return (*optional_it)->second.logger;
 }


@ -459,20 +461,32 @@ void Logger::shutdown()
 		}

 		delete _pLoggerMap;
-		_pLoggerMap = 0;
+		_pLoggerMap = nullptr;
 	}
 }


-Logger* Logger::find(const std::string& name)
+std::optional<Logger::LoggerMapIterator> Logger::find(const std::string& name)
 {
 	if (_pLoggerMap)
 	{
 		LoggerMap::iterator it = _pLoggerMap->find(name);
 		if (it != _pLoggerMap->end())
-			return it->second.logger;
+			return it;
+
+		return {};
 	}
-	return 0;
+
+	return {};
+}
+
+Logger * Logger::findRawPtr(const std::string & name)
+{
+	auto optional_it = find(name);
+	if (!optional_it)
+		return nullptr;
+
+	return (*optional_it)->second.logger;
 }


@ -490,28 +504,28 @@ void Logger::names(std::vector<std::string>& names)
 	}
 }

-Logger& Logger::unsafeCreate(const std::string & name, Channel * pChannel, int level)
+
+std::pair<Logger::LoggerMapIterator, bool> Logger::unsafeCreate(const std::string & name, Channel * pChannel, int level)
 {
 	if (find(name)) throw ExistsException();
 	Logger* pLogger = new Logger(name, pChannel, level);
-	add(pLogger);
-
-	return *pLogger;
+	return add(pLogger);
 }

+
 Logger& Logger::parent(const std::string& name)
 {
 	std::string::size_type pos = name.rfind('.');
 	if (pos != std::string::npos)
 	{
 		std::string pname = name.substr(0, pos);
-		Logger* pParent = find(pname);
+		Logger* pParent = findRawPtr(pname);
 		if (pParent)
 			return *pParent;
 		else
 			return parent(pname);
 	}
-	else return unsafeGet(ROOT);
+	else return *unsafeGetRawPtr(ROOT);
 }


@ -579,12 +593,14 @@ namespace
 }


-void Logger::add(Logger* pLogger)
+std::pair<Logger::LoggerMapIterator, bool> Logger::add(Logger* pLogger)
 {
 	if (!_pLoggerMap)
-		_pLoggerMap = new LoggerMap;
+		_pLoggerMap = new Logger::LoggerMap;

-	_pLoggerMap->emplace(pLogger->name(), LoggerEntry{pLogger, false /*owned_by_shared_ptr*/});
+	auto result = _pLoggerMap->emplace(pLogger->name(), LoggerEntry{pLogger, false /*owned_by_shared_ptr*/});
+	assert(result.second);
+	return result;
 }


--- a/cmake/sanitize.cmake
+++ b/cmake/sanitize.cmake
@ -63,14 +63,14 @@ endif()
 option(WITH_COVERAGE "Instrumentation for code coverage with default implementation" OFF)

 if (WITH_COVERAGE)
-    message (INFORMATION "Enabled instrumentation for code coverage")
+    message (STATUS "Enabled instrumentation for code coverage")
    set(COVERAGE_FLAGS "-fprofile-instr-generate -fcoverage-mapping")
 endif()

 option (SANITIZE_COVERAGE "Instrumentation for code coverage with custom callbacks" OFF)

 if (SANITIZE_COVERAGE)
-    message (INFORMATION "Enabled instrumentation for code coverage")
+    message (STATUS "Enabled instrumentation for code coverage")

    # We set this define for whole build to indicate that at least some parts are compiled with coverage.
    # And to expose it in system.build_options.
--- a/contrib/libunwind-cmake/unwind-override.c
+++ b/contrib/libunwind-cmake/unwind-override.c
@ -1,6 +1,10 @@
 #include <libunwind.h>

+/// On MacOS this function will be replaced with a dynamic symbol
+/// from the system library.
+#if !defined(OS_DARWIN)
 int backtrace(void ** buffer, int size)
 {
    return unw_backtrace(buffer, size);
 }
+#endif
--- a/contrib/libuv
+++ b/contrib/libuv
@ -1 +1 @@
-Subproject commit 3a85b2eb3d83f369b8a8cafd329d7e9dc28f60cf
+Subproject commit 4482964660c77eec1166cd7d14fb915e3dbd774a
--- a/contrib/llvm-project
+++ b/contrib/llvm-project
@ -1 +1 @@
-Subproject commit 2568a7cd1297c7c3044b0f3cc0c23a6f6444d856
+Subproject commit d2142eed98046a47ff7112e3cc1e197c8a5cd80f
--- a/docker/keeper/Dockerfile
+++ b/docker/keeper/Dockerfile
@ -34,7 +34,7 @@ RUN arch=${TARGETARCH:-amd64} \
 # lts / testing / prestable / etc
 ARG REPO_CHANNEL="stable"
 ARG REPOSITORY="https://packages.clickhouse.com/tgz/${REPO_CHANNEL}"
-ARG VERSION="24.1.2.5"
+ARG VERSION="24.1.3.31"
 ARG PACKAGES="clickhouse-keeper"
 ARG DIRECT_DOWNLOAD_URLS=""

--- a/docker/packager/packager
+++ b/docker/packager/packager
@ -115,12 +115,17 @@ def run_docker_image_with_env(
    subprocess.check_call(cmd, shell=True)


-def is_release_build(debug_build: bool, package_type: str, sanitizer: str) -> bool:
-    return not debug_build and package_type == "deb" and sanitizer == ""
+def is_release_build(
+    debug_build: bool, package_type: str, sanitizer: str, coverage: bool
+) -> bool:
+    return (
+        not debug_build and package_type == "deb" and sanitizer == "" and not coverage
+    )


 def parse_env_variables(
    debug_build: bool,
+    coverage: bool,
    compiler: str,
    sanitizer: str,
    package_type: str,
@ -261,7 +266,7 @@ def parse_env_variables(
        build_target = (
            f"{build_target} clickhouse-odbc-bridge clickhouse-library-bridge"
        )
-        if is_release_build(debug_build, package_type, sanitizer):
+        if is_release_build(debug_build, package_type, sanitizer, coverage):
            cmake_flags.append("-DSPLIT_DEBUG_SYMBOLS=ON")
            result.append("WITH_PERFORMANCE=1")
            if is_cross_arm:
@ -287,6 +292,9 @@ def parse_env_variables(
    else:
        result.append("BUILD_TYPE=None")

+    if coverage:
+        cmake_flags.append("-DSANITIZE_COVERAGE=1 -DBUILD_STANDALONE_KEEPER=0")
+
    if not cache:
        cmake_flags.append("-DCOMPILER_CACHE=disabled")

@ -415,6 +423,11 @@ def parse_args() -> argparse.Namespace:
        choices=("address", "thread", "memory", "undefined", ""),
        default="",
    )
+    parser.add_argument(
+        "--coverage",
+        action="store_true",
+        help="enable granular coverage with introspection",
+    )

    parser.add_argument("--clang-tidy", action="store_true")
    parser.add_argument(
@ -507,6 +520,7 @@ def main() -> None:

    env_prepared = parse_env_variables(
        args.debug_build,
+        args.coverage,
        args.compiler,
        args.sanitizer,
        args.package_type,
--- a/docker/server/Dockerfile.alpine
+++ b/docker/server/Dockerfile.alpine
@ -32,7 +32,7 @@ RUN arch=${TARGETARCH:-amd64} \
 # lts / testing / prestable / etc
 ARG REPO_CHANNEL="stable"
 ARG REPOSITORY="https://packages.clickhouse.com/tgz/${REPO_CHANNEL}"
-ARG VERSION="24.1.2.5"
+ARG VERSION="24.1.3.31"
 ARG PACKAGES="clickhouse-client clickhouse-server clickhouse-common-static"
 ARG DIRECT_DOWNLOAD_URLS=""

--- a/docker/server/Dockerfile.ubuntu
+++ b/docker/server/Dockerfile.ubuntu
@ -27,7 +27,7 @@ RUN sed -i "s|http://archive.ubuntu.com|${apt_archive}|g" /etc/apt/sources.list

 ARG REPO_CHANNEL="stable"
 ARG REPOSITORY="deb [signed-by=/usr/share/keyrings/clickhouse-keyring.gpg] https://packages.clickhouse.com/deb ${REPO_CHANNEL} main"
-ARG VERSION="24.1.2.5"
+ARG VERSION="24.1.3.31"
 ARG PACKAGES="clickhouse-client clickhouse-server clickhouse-common-static"

 # set non-empty deb_location_url url to create a docker image
--- a/docker/server/entrypoint.sh
+++ b/docker/server/entrypoint.sh
@ -118,13 +118,19 @@ if [ -n "$CLICKHOUSE_USER" ] && [ "$CLICKHOUSE_USER" != "default" ] || [ -n "$CL
 EOT
 fi

+CLICKHOUSE_ALWAYS_RUN_INITDB_SCRIPTS="${CLICKHOUSE_ALWAYS_RUN_INITDB_SCRIPTS:-}"
+
 # checking $DATA_DIR for initialization
 if [ -d "${DATA_DIR%/}/data" ]; then
    DATABASE_ALREADY_EXISTS='true'
 fi

-# only run initialization on an empty data directory
-if [ -z "${DATABASE_ALREADY_EXISTS}" ]; then
+# run initialization if flag CLICKHOUSE_ALWAYS_RUN_INITDB_SCRIPTS is not empty or data directory is empty
+if [[ -n "${CLICKHOUSE_ALWAYS_RUN_INITDB_SCRIPTS}" || -z "${DATABASE_ALREADY_EXISTS}" ]]; then
+  RUN_INITDB_SCRIPTS='true'
+fi
+
+if [ -z "${RUN_INITDB_SCRIPTS}" ]; then
    if [ -n "$(ls /docker-entrypoint-initdb.d/)" ] || [ -n "$CLICKHOUSE_DB" ]; then
        # port is needed to check if clickhouse-server is ready for connections
        HTTP_PORT="$(clickhouse extract-from-config --config-file "$CLICKHOUSE_CONFIG" --key=http_port --try)"
--- a/docker/test/base/setup_export_logs.sh
+++ b/docker/test/base/setup_export_logs.sh
@ -17,16 +17,20 @@ CLICKHOUSE_CI_LOGS_CLUSTER=${CLICKHOUSE_CI_LOGS_CLUSTER:-system_logs_export}

 EXTRA_COLUMNS=${EXTRA_COLUMNS:-"pull_request_number UInt32, commit_sha String, check_start_time DateTime('UTC'), check_name LowCardinality(String), instance_type LowCardinality(String), instance_id String, INDEX ix_pr (pull_request_number) TYPE set(100), INDEX ix_commit (commit_sha) TYPE set(100), INDEX ix_check_time (check_start_time) TYPE minmax, "}
 EXTRA_COLUMNS_EXPRESSION=${EXTRA_COLUMNS_EXPRESSION:-"CAST(0 AS UInt32) AS pull_request_number, '' AS commit_sha, now() AS check_start_time, toLowCardinality('') AS check_name, toLowCardinality('') AS instance_type, '' AS instance_id"}
-EXTRA_ORDER_BY_COLUMNS=${EXTRA_ORDER_BY_COLUMNS:-"check_name, "}
+EXTRA_ORDER_BY_COLUMNS=${EXTRA_ORDER_BY_COLUMNS:-"check_name"}

 # trace_log needs more columns for symbolization
 EXTRA_COLUMNS_TRACE_LOG="${EXTRA_COLUMNS} symbols Array(LowCardinality(String)), lines Array(LowCardinality(String)), "
 EXTRA_COLUMNS_EXPRESSION_TRACE_LOG="${EXTRA_COLUMNS_EXPRESSION}, arrayMap(x -> demangle(addressToSymbol(x)), trace)::Array(LowCardinality(String)) AS symbols, arrayMap(x -> addressToLine(x), trace)::Array(LowCardinality(String)) AS lines"

+# coverage_log needs more columns for symbolization, but only symbol names (the line numbers are too heavy to calculate)
+EXTRA_COLUMNS_COVERAGE_LOG="${EXTRA_COLUMNS} symbols Array(LowCardinality(String)), "
+EXTRA_COLUMNS_EXPRESSION_COVERAGE_LOG="${EXTRA_COLUMNS_EXPRESSION}, arrayMap(x -> demangle(addressToSymbol(x)), coverage)::Array(LowCardinality(String)) AS symbols"
+

 function __set_connection_args
 {
-    # It's impossible to use generous $CONNECTION_ARGS string, it's unsafe from word splitting perspective.
+    # It's impossible to use a generic $CONNECTION_ARGS string, it's unsafe from word splitting perspective.
    # That's why we must stick to the generated option
    CONNECTION_ARGS=(
        --receive_timeout=45 --send_timeout=45 --secure
@ -129,6 +133,19 @@ function setup_logs_replication
    debug_or_sanitizer_build=$(clickhouse-client -q "WITH ((SELECT value FROM system.build_options WHERE name='BUILD_TYPE') AS build, (SELECT value FROM system.build_options WHERE name='CXX_FLAGS') as flags) SELECT build='Debug' OR flags LIKE '%fsanitize%'")
    echo "Build is debug or sanitizer: $debug_or_sanitizer_build"

+    # We will pre-create a table system.coverage_log.
+    # It is normally created by clickhouse-test rather than the server,
+    # so we will create it in advance to make it be picked up by the next commands:
+
+    clickhouse-client --query "
+        CREATE TABLE IF NOT EXISTS system.coverage_log
+        (
+            time DateTime COMMENT 'The time of test run',
+            test_name String COMMENT 'The name of the test',
+            coverage Array(UInt64) COMMENT 'An array of addresses of the code (a subset of addresses instrumented for coverage) that were encountered during the test run'
+        ) ENGINE = Null COMMENT 'Contains information about per-test coverage from the CI, but used only for exporting to the CI cluster'
+    "
+
    # For each system log table:
    echo 'Create %_log tables'
    clickhouse-client --query "SHOW TABLES FROM system LIKE '%\\_log'" | while read -r table
@ -139,11 +156,16 @@ function setup_logs_replication
            # Do not try to resolve stack traces in case of debug/sanitizers
            # build, since it is too slow (flushing of trace_log can take ~1min
            # with such MV attached)
-            if [[ "$debug_or_sanitizer_build" = 1 ]]; then
+            if [[ "$debug_or_sanitizer_build" = 1 ]]
+            then
                EXTRA_COLUMNS_EXPRESSION_FOR_TABLE="${EXTRA_COLUMNS_EXPRESSION}"
            else
                EXTRA_COLUMNS_EXPRESSION_FOR_TABLE="${EXTRA_COLUMNS_EXPRESSION_TRACE_LOG}"
            fi
+        elif [[ "$table" = "coverage_log" ]]
+        then
+            EXTRA_COLUMNS_FOR_TABLE="${EXTRA_COLUMNS_COVERAGE_LOG}"
+            EXTRA_COLUMNS_EXPRESSION_FOR_TABLE="${EXTRA_COLUMNS_EXPRESSION_COVERAGE_LOG}"
        else
            EXTRA_COLUMNS_FOR_TABLE="${EXTRA_COLUMNS}"
            EXTRA_COLUMNS_EXPRESSION_FOR_TABLE="${EXTRA_COLUMNS_EXPRESSION}"
@ -160,7 +182,7 @@ function setup_logs_replication
        # Create the destination table with adapted name and structure:
        statement=$(clickhouse-client --format TSVRaw --query "SHOW CREATE TABLE system.${table}" | sed -r -e '
            s/^\($/('"$EXTRA_COLUMNS_FOR_TABLE"'/;
-            s/ORDER BY \(/ORDER BY ('"$EXTRA_ORDER_BY_COLUMNS"'/;
+            s/^ORDER BY (([^\(].+?)|\((.+?)\))$/ORDER BY ('"$EXTRA_ORDER_BY_COLUMNS"', \2\3)/;
            s/^CREATE TABLE system\.\w+_log$/CREATE TABLE IF NOT EXISTS '"$table"'_'"$hash"'/;
            /^TTL /d
            ')
--- a/docker/test/stateless/Dockerfile
+++ b/docker/test/stateless/Dockerfile
@ -47,7 +47,7 @@ RUN apt-get update -y \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/* /var/cache/debconf /tmp/*

-RUN pip3 install numpy scipy pandas Jinja2 pyarrow
+RUN pip3 install numpy==1.26.3 scipy==1.12.0 pandas==1.5.3 Jinja2==3.1.3 pyarrow==15.0.0

 RUN mkdir -p /tmp/clickhouse-odbc-tmp \
   && wget -nv -O - ${odbc_driver_url} | tar --strip-components=1 -xz -C /tmp/clickhouse-odbc-tmp \
@ -74,7 +74,6 @@ RUN arch=${TARGETARCH:-amd64} \
    && wget "https://dl.min.io/client/mc/release/linux-${arch}/archive/mc.RELEASE.${MINIO_CLIENT_VERSION}" -O ./mc \
    && chmod +x ./mc ./minio

-
 RUN wget --no-verbose 'https://archive.apache.org/dist/hadoop/common/hadoop-3.3.1/hadoop-3.3.1.tar.gz' \
    && tar -xvf hadoop-3.3.1.tar.gz \
    && rm -rf hadoop-3.3.1.tar.gz
--- a/docker/test/stateless/run.sh
+++ b/docker/test/stateless/run.sh
@ -185,11 +185,15 @@ function run_tests()

    if [[ -n "$USE_DATABASE_REPLICATED" ]] && [[ "$USE_DATABASE_REPLICATED" -eq 1 ]]; then
        ADDITIONAL_OPTIONS+=('--replicated-database')
+        # Too many tests fail for DatabaseReplicated in parallel.
        ADDITIONAL_OPTIONS+=('--jobs')
        ADDITIONAL_OPTIONS+=('2')
+    elif [[ 1 == $(clickhouse-client --query "SELECT value LIKE '%SANITIZE_COVERAGE%' FROM system.build_options WHERE name = 'CXX_FLAGS'") ]]; then
+        # Coverage on a per-test basis could only be collected sequentially.
+        # Do not set the --jobs parameter.
+        echo "Running tests with coverage collection."
    else
-        # Too many tests fail for DatabaseReplicated in parallel. All other
-        # configurations are OK.
+        # All other configurations are OK.
        ADDITIONAL_OPTIONS+=('--jobs')
        ADDITIONAL_OPTIONS+=('8')
    fi
--- a/docker/test/util/Dockerfile
+++ b/docker/test/util/Dockerfile
@ -5,7 +5,6 @@ FROM ubuntu:22.04
 ARG apt_archive="http://archive.ubuntu.com"
 RUN sed -i "s|http://archive.ubuntu.com|$apt_archive|g" /etc/apt/sources.list

-# 15.0.2
 ENV DEBIAN_FRONTEND=noninteractive LLVM_VERSION=17

 RUN apt-get update \
@ -30,8 +29,7 @@ RUN apt-get update \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/* /var/cache/debconf /tmp/*

-
-# Install cmake 3.20+ for rust support
+# Install cmake 3.20+ for Rust support
 # Used https://askubuntu.com/a/1157132 as reference
 RUN curl -s https://apt.kitware.com/keys/kitware-archive-latest.asc | \
        gpg --dearmor - > /etc/apt/trusted.gpg.d/kitware.gpg && \
@ -65,8 +63,7 @@ RUN apt-get update \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/* /var/cache/debconf /tmp/*

-
-# This symlink required by gcc to find lld compiler
+# This symlink is required by gcc to find the lld linker
 RUN ln -s /usr/bin/lld-${LLVM_VERSION} /usr/bin/ld.lld
 # for external_symbolizer_path
 RUN ln -s /usr/bin/llvm-symbolizer-${LLVM_VERSION} /usr/bin/llvm-symbolizer
@ -111,5 +108,4 @@ RUN arch=${TARGETARCH:-amd64} \
  && mv "/tmp/sccache-$SCCACHE_VERSION-$rarch-unknown-linux-musl/sccache" /usr/bin \
  && rm "/tmp/sccache-$SCCACHE_VERSION-$rarch-unknown-linux-musl" -r

-
 COPY process_functional_tests_result.py /
--- a/docs/changelogs/v23.12.4.15-stable.md
+++ b/docs/changelogs/v23.12.4.15-stable.md
@ -0,0 +1,21 @@
+---
+sidebar_position: 1
+sidebar_label: 2024
+---
+
+# 2024 Changelog
+
+### ClickHouse release v23.12.4.15-stable (4233d111d20) FIXME as compared to v23.12.3.40-stable (a594704ae75)
+
+#### Bug Fix (user-visible misbehavior in an official stable release)
+
+* Fix incorrect result of arrayElement / map[] on empty value [#59594](https://github.com/ClickHouse/ClickHouse/pull/59594) ([Raúl Marín](https://github.com/Algunenano)).
+* Fix crash in topK when merging empty states [#59603](https://github.com/ClickHouse/ClickHouse/pull/59603) ([Raúl Marín](https://github.com/Algunenano)).
+* Fix distributed table with a constant sharding key [#59606](https://github.com/ClickHouse/ClickHouse/pull/59606) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Fix leftPad / rightPad function with FixedString input [#59739](https://github.com/ClickHouse/ClickHouse/pull/59739) ([Raúl Marín](https://github.com/Algunenano)).
+
+#### NOT FOR CHANGELOG / INSIGNIFICANT
+
+* Fix 02720_row_policy_column_with_dots [#59453](https://github.com/ClickHouse/ClickHouse/pull/59453) ([Duc Canh Le](https://github.com/canhld94)).
+* Pin python dependencies in stateless tests [#59663](https://github.com/ClickHouse/ClickHouse/pull/59663) ([Raúl Marín](https://github.com/Algunenano)).
+
--- a/docs/changelogs/v24.1.3.31-stable.md
+++ b/docs/changelogs/v24.1.3.31-stable.md
@ -0,0 +1,34 @@
+---
+sidebar_position: 1
+sidebar_label: 2024
+---
+
+# 2024 Changelog
+
+### ClickHouse release v24.1.3.31-stable (135b08cbd28) FIXME as compared to v24.1.2.5-stable (b2605dd4a5a)
+
+#### Improvement
+* Backported in [#59569](https://github.com/ClickHouse/ClickHouse/issues/59569): Now dashboard understands both compressed and uncompressed state of URL's #hash (backward compatibility). Continuation of [#59124](https://github.com/ClickHouse/ClickHouse/issues/59124) . [#59548](https://github.com/ClickHouse/ClickHouse/pull/59548) ([Amos Bird](https://github.com/amosbird)).
+* Backported in [#59776](https://github.com/ClickHouse/ClickHouse/issues/59776): Added settings `split_parts_ranges_into_intersecting_and_non_intersecting_final` and `split_intersecting_parts_ranges_into_layers_final`. This settings are needed to disable optimizations for queries with `FINAL` and needed for debug only. [#59705](https://github.com/ClickHouse/ClickHouse/pull/59705) ([Maksim Kita](https://github.com/kitaisreal)).
+
+#### Bug Fix (user-visible misbehavior in an official stable release)
+
+* Fix `ASTAlterCommand::formatImpl` in case of column specific settings… [#59445](https://github.com/ClickHouse/ClickHouse/pull/59445) ([János Benjamin Antal](https://github.com/antaljanosbenjamin)).
+* Make MAX use the same rules as permutation for complex types [#59498](https://github.com/ClickHouse/ClickHouse/pull/59498) ([Raúl Marín](https://github.com/Algunenano)).
+* Fix corner case when passing `update_insert_deduplication_token_in_dependent_materialized_views` [#59544](https://github.com/ClickHouse/ClickHouse/pull/59544) ([Jordi Villar](https://github.com/jrdi)).
+* Fix incorrect result of arrayElement / map[] on empty value [#59594](https://github.com/ClickHouse/ClickHouse/pull/59594) ([Raúl Marín](https://github.com/Algunenano)).
+* Fix crash in topK when merging empty states [#59603](https://github.com/ClickHouse/ClickHouse/pull/59603) ([Raúl Marín](https://github.com/Algunenano)).
+* Maintain function alias in RewriteSumFunctionWithSumAndCountVisitor [#59658](https://github.com/ClickHouse/ClickHouse/pull/59658) ([Raúl Marín](https://github.com/Algunenano)).
+* Fix leftPad / rightPad function with FixedString input [#59739](https://github.com/ClickHouse/ClickHouse/pull/59739) ([Raúl Marín](https://github.com/Algunenano)).
+
+#### NO CL ENTRY
+
+* NO CL ENTRY:  'Revert "Backport [#59650](https://github.com/ClickHouse/ClickHouse/issues/59650) to 24.1: MergeTree FINAL optimization diagnostics and settings"'. [#59701](https://github.com/ClickHouse/ClickHouse/pull/59701) ([Raúl Marín](https://github.com/Algunenano)).
+
+#### NOT FOR CHANGELOG / INSIGNIFICANT
+
+* Fix 02720_row_policy_column_with_dots [#59453](https://github.com/ClickHouse/ClickHouse/pull/59453) ([Duc Canh Le](https://github.com/canhld94)).
+* Refactoring of dashboard state encoding [#59554](https://github.com/ClickHouse/ClickHouse/pull/59554) ([Sergei Trifonov](https://github.com/serxa)).
+* MergeTree FINAL optimization diagnostics and settings [#59650](https://github.com/ClickHouse/ClickHouse/pull/59650) ([Maksim Kita](https://github.com/kitaisreal)).
+* Pin python dependencies in stateless tests [#59663](https://github.com/ClickHouse/ClickHouse/pull/59663) ([Raúl Marín](https://github.com/Algunenano)).
+
--- a/docs/en/engines/table-engines/special/memory.md
+++ b/docs/en/engines/table-engines/special/memory.md
@ -6,6 +6,12 @@ sidebar_label:  Memory

 # Memory Table Engine

+:::note
+When using the Memory table engine on ClickHouse Cloud, data is not replicated across all nodes (by design). To guarantee that all queries are routed to the same node and that the Memory table engine works as expected, you can do one of the following:
+- Execute all operations in the same session
+- Use a client that uses TCP or the native interface (which enables support for sticky connections) such as [clickhouse-client](/en/interfaces/cli)
+:::
+
 The Memory engine stores data in RAM, in uncompressed form. Data is stored in exactly the same form as it is received when read. In other words, reading from this table is completely free.
 Concurrent data access is synchronized. Locks are short: read and write operations do not block each other.
 Indexes are not supported. Reading is parallelized.
--- a/docs/en/operations/backup.md
+++ b/docs/en/operations/backup.md
@ -451,3 +451,24 @@ To disallow concurrent backup/restore, you can use these settings respectively.

 The default value for both is true, so by default concurrent backup/restores are allowed.
 When these settings are false on a cluster, only 1 backup/restore is allowed to run on a cluster at a time.
+
+## Configuring BACKUP/RESTORE to use an AzureBlobStorage Endpoint
+
+To write backups to an AzureBlobStorage container you need the following pieces of information:
+- AzureBlobStorage endpoint connection string / url,
+- Container,
+- Path,
+- Account name (if url is specified)
+- Account Key (if url is specified)
+
+The destination for a backup will be specified like this:
+```
+AzureBlobStorage('<connection string>/<url>', '<container>', '<path>', '<account name>', '<account key>')
+```
+
+```sql
+BACKUP TABLE data TO AzureBlobStorage('DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://azurite1:10000/devstoreaccount1/;',
+    'test_container', 'data_backup');
+RESTORE TABLE data AS data_restored FROM AzureBlobStorage('DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://azurite1:10000/devstoreaccount1/;',
+    'test_container', 'data_backup');
+```
--- a/docs/en/operations/query-cache.md
+++ b/docs/en/operations/query-cache.md
@ -31,6 +31,10 @@ This reduces maintenance effort and avoids redundancy.

 ## Configuration Settings and Usage

+:::note
+In ClickHouse Cloud, you must use [query level settings](/en/operations/settings/query-level) to edit query cache settings. Editing [config level settings](/en/operations/configuration-files) is currently not supported.
+:::
+
 Setting [use_query_cache](settings/settings.md#use-query-cache) can be used to control whether a specific query or all queries of the
 current session should utilize the query cache. For example, the first execution of query

--- a/docs/en/operations/settings/query-complexity.md
+++ b/docs/en/operations/settings/query-complexity.md
@ -28,6 +28,8 @@ The maximum amount of RAM to use for running a query on a single server.

 The default setting is unlimited (set to `0`).

+Cloud default value: depends on the amount of RAM on the replica.
+
 The setting does not consider the volume of available memory or the total volume of memory on the machine.
 The restriction applies to a single query within a single server.
 You can use `SHOW PROCESSLIST` to see the current memory consumption for each query.
@ -104,7 +106,9 @@ Possible values:
 - Maximum volume of RAM (in bytes) that can be used by the single [GROUP BY](../../sql-reference/statements/select/group-by.md#select-group-by-clause) operation.
 - 0 — `GROUP BY` in external memory disabled.

-Default value: 0.
+Default value: `0`.
+
+Cloud default value: half the memory amount per replica.

 ## max_bytes_before_external_sort {#settings-max_bytes_before_external_sort}

@ -115,6 +119,8 @@ Enables or disables execution of `ORDER BY` clauses in external memory. See [ORD

 Default value: 0.

+Cloud default value: half the memory amount per replica.
+
 ## max_rows_to_sort {#max-rows-to-sort}

 A maximum number of rows before sorting. This allows you to limit memory consumption when sorting.
@ -129,7 +135,11 @@ What to do if the number of rows received before sorting exceeds one of the limi

 ## max_result_rows {#setting-max_result_rows}

-Limit on the number of rows in the result. Also checked for subqueries, and on remote servers when running parts of a distributed query.
+Limit on the number of rows in the result. Also checked for subqueries, and on remote servers when running parts of a distributed query. No limit is applied when value is `0`.
+
+Default value: `0`.
+
+Cloud default value: `0`.

 ## max_result_bytes {#max-result-bytes}

@ -137,10 +147,14 @@ Limit on the number of bytes in the result. The same as the previous setting.

 ## result_overflow_mode {#result-overflow-mode}

-What to do if the volume of the result exceeds one of the limits: ‘throw’ or ‘break’. By default, throw.
+What to do if the volume of the result exceeds one of the limits: ‘throw’ or ‘break’.

 Using ‘break’ is similar to using LIMIT. `Break` interrupts execution only at the block level. This means that amount of returned rows is greater than [max_result_rows](#setting-max_result_rows), multiple of [max_block_size](../../operations/settings/settings.md#setting-max_block_size) and depends on [max_threads](../../operations/settings/settings.md#max_threads).

+Default value: `throw`.
+
+Cloud default value: `throw`.
+
 Example:

 ``` sql
--- a/docs/en/operations/settings/settings-formats.md
+++ b/docs/en/operations/settings/settings-formats.md
@ -212,6 +212,8 @@ Possible values:

 Default value: `'basic'`.

+Cloud default value: `'best_effort'`.
+
 See also:

 - [DateTime data type.](../../sql-reference/data-types/datetime.md)
--- a/docs/en/operations/settings/settings.md
+++ b/docs/en/operations/settings/settings.md
@ -508,7 +508,9 @@ Possible values:
 - Any positive integer number of hops.
 - 0 — No hops allowed.

-Default value: 0.
+Default value: `0`.
+
+Cloud default value: `10`.

 ## insert_null_as_default {#insert_null_as_default}

@ -1126,7 +1128,9 @@ Possible values:
 - 0 (or 1) — `INSERT SELECT` no parallel execution.
 - Positive integer. Bigger than 1.

-Default value: 0.
+Default value: `0`.
+
+Cloud default value: from `2` to `4`, depending on the service size.

 Parallel `INSERT SELECT` has effect only if the `SELECT` part is executed in parallel, see [max_threads](#max_threads) setting.
 Higher values will lead to higher memory usage.
@ -1207,7 +1211,9 @@ Default value: 10000.

 Cancels HTTP read-only queries (e.g. SELECT) when a client closes the connection without waiting for the response.

-Default value: 0
+Default value: `0`.
+
+Cloud default value: `1`.

 ## poll_interval {#poll-interval}

@ -1946,6 +1952,8 @@ Possible values:

 Default value: `200`.

+Cloud default value: `1000`.
+
 ### async_insert_poll_timeout_ms {#async-insert-poll-timeout-ms}

 Timeout in milliseconds for polling data from asynchronous insert queue.
@ -2130,7 +2138,9 @@ Possible values:
 - Positive integer.
 - 0 — Retries are disabled

-Default value: 0
+Default value: 20
+
+Cloud default value: `20`.

 Keeper request retries are done after some timeout. The timeout is controlled by the following settings: `insert_keeper_retry_initial_backoff_ms`, `insert_keeper_retry_max_backoff_ms`.
 The first retry is done after `insert_keeper_retry_initial_backoff_ms` timeout. The consequent timeouts will be calculated as follows:
@ -2660,6 +2670,8 @@ Type: [UInt64](../../sql-reference/data-types/int-uint.md).

 Default value: 1000000000 nanoseconds (once a second).

+**Temporarily disabled in ClickHouse Cloud.**
+
 See also:

 - System table [trace_log](../../operations/system-tables/trace_log.md/#system_tables-trace_log)
@ -2683,6 +2695,8 @@ Type: [UInt64](../../sql-reference/data-types/int-uint.md).

 Default value: 1000000000 nanoseconds.

+**Temporarily disabled in ClickHouse Cloud.**
+
 See also:

 - System table [trace_log](../../operations/system-tables/trace_log.md/#system_tables-trace_log)
@ -2804,6 +2818,8 @@ Possible values:

 Default value: `0`.

+Cloud default value: `1`.
+
 **See Also**

 - [Distributed Table Engine](../../engines/table-engines/special/distributed.md/#distributed)
@ -3319,7 +3335,9 @@ Possible values:

 - a string representing any valid table engine name

-Default value: `None`
+Default value: `MergeTree`.
+
+Cloud default value: `SharedMergeTree`.

 **Example**

@ -3895,6 +3913,8 @@ Possible values:

 Default value: `0`.

+Cloud default value: `1`.
+
 ## database_replicated_initial_query_timeout_sec {#database_replicated_initial_query_timeout_sec}

 Sets how long initial DDL query should wait for Replicated database to process previous DDL queue entries in seconds.
@ -3933,6 +3953,8 @@ Possible values:

 Default value: `throw`.

+Cloud default value: `none`.
+
 ## flatten_nested {#flatten-nested}

 Sets the data format of a [nested](../../sql-reference/data-types/nested-data-structures/index.md) columns.
@ -4068,6 +4090,8 @@ Possible values:

 Default value: `1`.

+Cloud default value: `0`.
+
 :::note
 `alter_sync` is applicable to `Replicated` tables only, it does nothing to alters of not `Replicated` tables.
 :::
@ -4723,6 +4747,8 @@ other connections are cancelled. Queries with `max_parallel_replicas > 1` are su

 Enabled by default.

+Disabled by default on Cloud.
+
 ## hedged_connection_timeout {#hedged_connection_timeout}

 If we can't establish connection with replica after this timeout in hedged requests, we start working with the next replica without cancelling connection to the previous.
@ -5348,10 +5374,11 @@ Default value: `false`.

 ## max_partition_size_to_drop

-Restriction on dropping partitions in query time.
+Restriction on dropping partitions in query time. The value 0 means that you can drop partitions without any restrictions.

 Default value: 50 GB.
-The value 0 means that you can drop partitions without any restrictions.
+
+Cloud default value: 1 TB.

 :::note
 This query setting overwrites its server setting equivalent, see [max_partition_size_to_drop](/docs/en/operations/server-configuration-parameters/settings.md/#max-partition-size-to-drop)
@ -5359,10 +5386,11 @@ This query setting overwrites its server setting equivalent, see [max_partition_

 ## max_table_size_to_drop

-Restriction on deleting tables in query time.
+Restriction on deleting tables in query time. The value 0 means that you can delete all tables without any restrictions.

 Default value: 50 GB.
-The value 0 means that you can delete all tables without any restrictions.
+
+Cloud default value: 1 TB.

 :::note
 This query setting overwrites its server setting equivalent, see [max_table_size_to_drop](/docs/en/operations/server-configuration-parameters/settings.md/#max-table-size-to-drop)
--- a/docs/en/operations/storing-data.md
+++ b/docs/en/operations/storing-data.md
@ -206,7 +206,7 @@ Some of these settings will disable cache features per query/profile that are en

 - `read_from_filesystem_cache_if_exists_otherwise_bypass_cache` - allows to use cache in query only if it already exists, otherwise query data will not be written to local cache storage. Default: `false`.

- `enable_filesystem_cache_on_write_operations` - turn on `write-through` cache. This setting works only if setting `cache_on_write_operations` in cache configuration is turned on. Default: `false`.
+- `enable_filesystem_cache_on_write_operations` - turn on `write-through` cache. This setting works only if setting `cache_on_write_operations` in cache configuration is turned on. Default: `false`. Cloud default value: `true`.

 - `enable_filesystem_cache_log` - turn on logging to `system.filesystem_cache_log` table. Gives a detailed view of cache usage per query. It can be turn on for specific queries or enabled in a profile. Default: `false`.

--- a/docs/en/sql-reference/data-types/variant.md
+++ b/docs/en/sql-reference/data-types/variant.md
@ -1,5 +1,5 @@
 ---
-slug: /en/sql-reference/data-types/json
+slug: /en/sql-reference/data-types/variant
 sidebar_position: 55
 sidebar_label: Variant
 ---
--- a/docs/en/sql-reference/functions/time-series-functions.md
+++ b/docs/en/sql-reference/functions/time-series-functions.md
@ -6,11 +6,67 @@ sidebar_label: Time Series

 # Time Series Functions

-Below functions are used for time series analysis.
+Below functions are used for series data analysis.
+
+## seriesOutliersDetectTukey
+
+Detects outliers in series data using [Tukey Fences](https://en.wikipedia.org/wiki/Outlier#Tukey%27s_fences).
+
+**Syntax**
+
+``` sql
+seriesOutliersDetectTukey(series);
+seriesOutliersDetectTukey(series, min_percentile, max_percentile, K);
+```
+
+**Arguments**
+
+- `series` - An array of numeric values.
+- `min_percentile` - The minimum percentile to be used to calculate inter-quantile range [(IQR)](https://en.wikipedia.org/wiki/Interquartile_range). The value must be in range [2,98]. The default is 25.
+- `max_percentile` - The maximum percentile to be used to calculate inter-quantile range (IQR). The value must be in range [2,98]. The default is 75.
+- `K` - Non-negative constant value to detect mild or stronger outliers. The default value is 1.5.
+
+At least four data points are required in `series` to detect outliers.
+
+**Returned value**
+
+- Returns an array of the same length as the input array where each value represents score of possible anomaly of corresponding element in the series. A non-zero score indicates a possible anomaly.
+
+Type: [Array](../../sql-reference/data-types/array.md).
+
+**Examples**
+
+Query:
+
+``` sql
+SELECT seriesOutliersDetectTukey([-3, 2, 15, 3, 5, 6, 4, 5, 12, 45, 12, 3, 3, 4, 5, 6]) AS print_0;
+```
+
+Result:
+
+``` text
+┌───────────print_0─────────────────┐
+│[0,0,0,0,0,0,0,0,0,27,0,0,0,0,0,0] │
+└───────────────────────────────────┘
+```
+
+Query:
+
+``` sql
+SELECT seriesOutliersDetectTukey([-3, 2, 15, 3, 5, 6, 4.50, 5, 12, 45, 12, 3.40, 3, 4, 5, 6], 20, 80, 1.5) AS print_0;
+```
+
+Result:
+
+``` text
+┌─print_0──────────────────────────────┐
+│ [0,0,0,0,0,0,0,0,0,19.5,0,0,0,0,0,0] │
+└──────────────────────────────────────┘
+```

 ## seriesPeriodDetectFFT

-Finds the period of the given time series data using FFT
+Finds the period of the given series data data using FFT
 FFT - [Fast Fourier transform](https://en.wikipedia.org/wiki/Fast_Fourier_transform)

 **Syntax**
@ -25,7 +81,7 @@ seriesPeriodDetectFFT(series);

 **Returned value**

- A real value equal to the period of time series
+- A real value equal to the period of series data
 - Returns NAN when number of data points are less than four.

 Type: [Float64](../../sql-reference/data-types/float.md).
@ -60,7 +116,7 @@ Result:

 ## seriesDecomposeSTL

-Decomposes a time series using STL [(Seasonal-Trend Decomposition Procedure Based on Loess)](https://www.wessa.net/download/stl.pdf) into a season, a trend and a residual component. 
+Decomposes a series data using STL [(Seasonal-Trend Decomposition Procedure Based on Loess)](https://www.wessa.net/download/stl.pdf) into a season, a trend and a residual component. 

 **Syntax**

--- a/docs/en/sql-reference/statements/alter/partition.md
+++ b/docs/en/sql-reference/statements/alter/partition.md
@ -112,7 +112,7 @@ Note that:
 For the query to run successfully, the following conditions must be met:

 - Both tables must have the same structure.
- Both tables must have the same order by key and the same primary key.
+- Both tables must have the same partition key, the same order by key and the same primary key.
 - Both tables must have the same indices and projections.
 - Both tables must have the same storage policy.

--- a/docs/en/sql-reference/statements/create/table.md
+++ b/docs/en/sql-reference/statements/create/table.md
@ -514,6 +514,10 @@ ENGINE = MergeTree ORDER BY x;

 ## Temporary Tables

+:::note
+Please note that temporary tables are not replicated. As a result, there is no guarantee that data inserted into a temporary table will be available in other replicas. The primary use case where temporary tables can be useful is for querying or joining small external datasets during a single session.
+:::
+
 ClickHouse supports temporary tables which have the following characteristics:

 - Temporary tables disappear when the session ends, including if the connection is lost.
--- a/docs/ru/faq/general/ne-tormozit.md
+++ b/docs/ru/faq/general/ne-tormozit.md
@ -20,6 +20,6 @@ sidebar_position: 11

 Если вы не видели наших футболок, посмотрите видео о ClickHouse. Например, вот это:

-![iframe](https://www.youtube.com/embed/bSyQahMVZ7w)
+<iframe width="675" height="380" src="https://www.youtube.com/embed/bSyQahMVZ7w" frameborder="0" allow="accelerometer; autoplay; gyroscope; picture-in-picture" allowfullscreen></iframe>

 P.S. Эти футболки не продаются, а распространяются бесплатно на большинстве митапов [ClickHouse](https://clickhouse.com/#meet), обычно в награду за самые интересные вопросы или другие виды активного участия.
--- a/docs/ru/operations/system-tables/grants.md
+++ b/docs/ru/operations/system-tables/grants.md
@ -19,7 +19,7 @@ slug: /ru/operations/system-tables/grants
 -    `column` ([Nullable](../../sql-reference/data-types/nullable.md)([String](../../sql-reference/data-types/string.md))) — Имя столбца, к которому предоставляется доступ.

 -    `is_partial_revoke` ([UInt8](../../sql-reference/data-types/int-uint.md#uint-ranges)) — Логическое значение. Показывает, были ли отменены некоторые привилегии. Возможные значения:
- `0` — Строка описывает частичный отзыв.
- `1` — Строка описывает грант.
+- `0` — Строка описывает грант.
+- `1` — Строка описывает частичный отзыв.

 -    `grant_option` ([UInt8](../../sql-reference/data-types/int-uint.md#uint-ranges)) — Разрешение предоставлено с опцией `WITH GRANT OPTION`, подробнее см. [GRANT](../../sql-reference/statements/grant.md#grant-privigele-syntax).
--- a/packages/build
+++ b/packages/build
@ -130,6 +130,8 @@ if [ -n "$SANITIZER" ]; then
    fi
 elif [[ $BUILD_TYPE == 'debug' ]]; then
    VERSION_POSTFIX+="+debug"
+elif [[ $BUILD_TYPE =~ 'coverage' ]]; then
+    VERSION_POSTFIX+="+coverage"
 fi

 if [[ "$PKG_ROOT" != "$SOURCE" ]]; then
--- a/packages/clickhouse-client.yaml
+++ b/packages/clickhouse-client.yaml
@ -49,6 +49,12 @@ contents:
  dst: /usr/bin/clickhouse-client
 - src: root/usr/bin/clickhouse-local
  dst: /usr/bin/clickhouse-local
+- src: root/usr/bin/ch
+  dst: /usr/bin/ch
+- src: root/usr/bin/chc
+  dst: /usr/bin/chc
+- src: root/usr/bin/chl
+  dst: /usr/bin/chl
 - src: root/usr/bin/clickhouse-obfuscator
  dst: /usr/bin/clickhouse-obfuscator
 # docs
--- a/programs/CMakeLists.txt
+++ b/programs/CMakeLists.txt
@ -7,35 +7,16 @@ endif ()
 include(${ClickHouse_SOURCE_DIR}/cmake/split_debug_symbols.cmake)

 # The `clickhouse` binary is a multi purpose tool that contains multiple execution modes (client, server, etc.),
-# each of them may be built and linked as a separate library.
-# If you do not know what modes you need, turn this option OFF and enable SERVER and CLIENT only.
+# So client/server/... is just a symlink to `clickhouse` binary.
+#
+# But, there are several components that requires extra libraries, like keeper
+# requires NuRaft, that regular binary does not requires, so you can disable
+# compilation of this components.
+#
+# If you do not know what modes you need, turn then all.
 option (ENABLE_CLICKHOUSE_ALL "Enable all ClickHouse modes by default" ON)

-option (ENABLE_CLICKHOUSE_SERVER "Server mode (main mode)" ${ENABLE_CLICKHOUSE_ALL})
-option (ENABLE_CLICKHOUSE_CLIENT "Client mode (interactive tui/shell that connects to the server)"
-    ${ENABLE_CLICKHOUSE_ALL})
-
-# https://clickhouse.com/docs/en/operations/utilities/clickhouse-local/
-option (ENABLE_CLICKHOUSE_LOCAL "Local files fast processing mode" ${ENABLE_CLICKHOUSE_ALL})
-
-# https://clickhouse.com/docs/en/operations/utilities/clickhouse-benchmark/
-option (ENABLE_CLICKHOUSE_BENCHMARK "Queries benchmarking mode" ${ENABLE_CLICKHOUSE_ALL})
-
-option (ENABLE_CLICKHOUSE_EXTRACT_FROM_CONFIG "Configs processor (extract values etc.)" ${ENABLE_CLICKHOUSE_ALL})
-
-# https://clickhouse.com/docs/en/operations/utilities/clickhouse-compressor/
-option (ENABLE_CLICKHOUSE_COMPRESSOR "Data compressor and decompressor" ${ENABLE_CLICKHOUSE_ALL})
-
-# https://clickhouse.com/docs/en/operations/utilities/clickhouse-copier/
-option (ENABLE_CLICKHOUSE_COPIER "Inter-cluster data copying mode" ${ENABLE_CLICKHOUSE_ALL})
-
-option (ENABLE_CLICKHOUSE_FORMAT "Queries pretty-printer and formatter with syntax highlighting"
-    ${ENABLE_CLICKHOUSE_ALL})
-
 # https://clickhouse.com/docs/en/operations/utilities/clickhouse-obfuscator/
-option (ENABLE_CLICKHOUSE_OBFUSCATOR "Table data obfuscator (convert real data to benchmark-ready one)"
-    ${ENABLE_CLICKHOUSE_ALL})
-
 # https://clickhouse.com/docs/en/operations/utilities/odbc-bridge/
 # TODO Also needs NANODBC.
 if (ENABLE_ODBC AND NOT USE_MUSL)
@ -51,18 +32,12 @@ endif ()
 # https://presentations.clickhouse.com/matemarketing_2020/
 option (ENABLE_CLICKHOUSE_GIT_IMPORT "A tool to analyze Git repositories" ${ENABLE_CLICKHOUSE_ALL})

-option (ENABLE_CLICKHOUSE_STATIC_FILES_DISK_UPLOADER "A tool to export table data files to be later put to a static files web server" ${ENABLE_CLICKHOUSE_ALL})
-
 option (ENABLE_CLICKHOUSE_KEEPER "ClickHouse alternative to ZooKeeper" ${ENABLE_CLICKHOUSE_ALL})

 option (ENABLE_CLICKHOUSE_KEEPER_CONVERTER "Util allows to convert ZooKeeper logs and snapshots into clickhouse-keeper snapshot" ${ENABLE_CLICKHOUSE_ALL})

 option (ENABLE_CLICKHOUSE_KEEPER_CLIENT "ClickHouse Keeper Client" ${ENABLE_CLICKHOUSE_ALL})

-option (ENABLE_CLICKHOUSE_SU "A tool similar to 'su'" ${ENABLE_CLICKHOUSE_ALL})
-
-option (ENABLE_CLICKHOUSE_DISKS "A tool to manage disks" ${ENABLE_CLICKHOUSE_ALL})
-
 if (NOT ENABLE_NURAFT)
    # RECONFIGURE_MESSAGE_LEVEL should not be used here,
    # since ENABLE_NURAFT is set to OFF for FreeBSD and Darwin.
@ -71,27 +46,7 @@ if (NOT ENABLE_NURAFT)
    set(ENABLE_CLICKHOUSE_KEEPER_CONVERTER OFF)
 endif()

-option(ENABLE_CLICKHOUSE_INSTALL "Install ClickHouse without .deb/.rpm/.tgz packages (having the binary only)" ${ENABLE_CLICKHOUSE_ALL})
-
-message(STATUS "ClickHouse modes:")
-
-if (NOT ENABLE_CLICKHOUSE_SERVER)
-    message(WARNING "ClickHouse server mode is not going to be built.")
-else()
-    message(STATUS "Server mode: ON")
-endif()
-
-if (NOT ENABLE_CLICKHOUSE_CLIENT)
-    message(WARNING "ClickHouse client mode is not going to be built. You won't be able to connect to the server and run tests")
-else()
-    message(STATUS "Client mode: ON")
-endif()
-
-if (ENABLE_CLICKHOUSE_LOCAL)
-    message(STATUS "Local mode: ON")
-else()
-    message(STATUS "Local mode: OFF")
-endif()
+message(STATUS "ClickHouse extra components:")

 if (ENABLE_CLICKHOUSE_SELF_EXTRACTING)
    message(STATUS "Self-extracting executable: ON")
@ -99,42 +54,6 @@ else()
    message(STATUS "Self-extracting executable: OFF")
 endif()

-if (ENABLE_CLICKHOUSE_BENCHMARK)
-    message(STATUS "Benchmark mode: ON")
-else()
-    message(STATUS "Benchmark mode: OFF")
-endif()
-
-if (ENABLE_CLICKHOUSE_EXTRACT_FROM_CONFIG)
-    message(STATUS "Extract from config mode: ON")
-else()
-    message(STATUS "Extract from config mode: OFF")
-endif()
-
-if (ENABLE_CLICKHOUSE_COMPRESSOR)
-    message(STATUS "Compressor mode: ON")
-else()
-    message(STATUS "Compressor mode: OFF")
-endif()
-
-if (ENABLE_CLICKHOUSE_COPIER)
-    message(STATUS "Copier mode: ON")
-else()
-    message(STATUS "Copier mode: OFF")
-endif()
-
-if (ENABLE_CLICKHOUSE_FORMAT)
-    message(STATUS "Format mode: ON")
-else()
-    message(STATUS "Format mode: OFF")
-endif()
-
-if (ENABLE_CLICKHOUSE_OBFUSCATOR)
-    message(STATUS "Obfuscator mode: ON")
-else()
-    message(STATUS "Obfuscator mode: OFF")
-endif()
-
 if (ENABLE_CLICKHOUSE_ODBC_BRIDGE)
    message(STATUS "ODBC bridge mode: ON")
 else()
@ -147,18 +66,6 @@ else()
    message(STATUS "Library bridge mode: OFF")
 endif()

-if (ENABLE_CLICKHOUSE_INSTALL)
-    message(STATUS "ClickHouse install: ON")
-else()
-    message(STATUS "ClickHouse install: OFF")
-endif()
-
-if (ENABLE_CLICKHOUSE_GIT_IMPORT)
-    message(STATUS "ClickHouse git-import: ON")
-else()
-    message(STATUS "ClickHouse git-import: OFF")
-endif()
-
 if (ENABLE_CLICKHOUSE_KEEPER)
    message(STATUS "ClickHouse keeper mode: ON")
 else()
@ -177,19 +84,6 @@ else()
    message(STATUS "ClickHouse keeper-client mode: OFF")
 endif()

-
-if (ENABLE_CLICKHOUSE_DISKS)
-    message(STATUS "Clickhouse disks mode: ON")
-else()
-    message(STATUS "ClickHouse disks mode: OFF")
-endif()
-
-if (ENABLE_CLICKHOUSE_SU)
-    message(STATUS "ClickHouse su: ON")
-else()
-    message(STATUS "ClickHouse su: OFF")
-endif()
-
 configure_file (config_tools.h.in ${CONFIG_INCLUDE_PATH}/config_tools.h)

 macro(clickhouse_target_link_split_lib target name)
@ -272,42 +166,6 @@ endif ()
 target_link_libraries (clickhouse PRIVATE clickhouse_common_io string_utils ${HARMFUL_LIB})
 target_include_directories (clickhouse PRIVATE ${CMAKE_CURRENT_BINARY_DIR})

-if (ENABLE_CLICKHOUSE_SERVER)
-    clickhouse_target_link_split_lib(clickhouse server)
-endif ()
-if (ENABLE_CLICKHOUSE_CLIENT)
-    clickhouse_target_link_split_lib(clickhouse client)
-endif ()
-if (ENABLE_CLICKHOUSE_LOCAL)
-    clickhouse_target_link_split_lib(clickhouse local)
-endif ()
-if (ENABLE_CLICKHOUSE_BENCHMARK)
-    clickhouse_target_link_split_lib(clickhouse benchmark)
-endif ()
-if (ENABLE_CLICKHOUSE_COPIER)
-    clickhouse_target_link_split_lib(clickhouse copier)
-endif ()
-if (ENABLE_CLICKHOUSE_EXTRACT_FROM_CONFIG)
-    clickhouse_target_link_split_lib(clickhouse extract-from-config)
-endif ()
-if (ENABLE_CLICKHOUSE_COMPRESSOR)
-    clickhouse_target_link_split_lib(clickhouse compressor)
-endif ()
-if (ENABLE_CLICKHOUSE_FORMAT)
-    clickhouse_target_link_split_lib(clickhouse format)
-endif ()
-if (ENABLE_CLICKHOUSE_OBFUSCATOR)
-    clickhouse_target_link_split_lib(clickhouse obfuscator)
-endif ()
-if (ENABLE_CLICKHOUSE_GIT_IMPORT)
-    clickhouse_target_link_split_lib(clickhouse git-import)
-endif ()
-if (ENABLE_CLICKHOUSE_STATIC_FILES_DISK_UPLOADER)
-    clickhouse_target_link_split_lib(clickhouse static-files-disk-uploader)
-endif ()
-if (ENABLE_CLICKHOUSE_SU)
-    clickhouse_target_link_split_lib(clickhouse su)
-endif ()
 if (ENABLE_CLICKHOUSE_KEEPER)
    clickhouse_target_link_split_lib(clickhouse keeper)
 endif()
@ -317,77 +175,40 @@ endif()
 if (ENABLE_CLICKHOUSE_KEEPER_CLIENT)
    clickhouse_target_link_split_lib(clickhouse keeper-client)
 endif()
-if (ENABLE_CLICKHOUSE_INSTALL)
-    clickhouse_target_link_split_lib(clickhouse install)
-endif ()
-if (ENABLE_CLICKHOUSE_DISKS)
-    clickhouse_target_link_split_lib(clickhouse disks)
-endif ()
+clickhouse_target_link_split_lib(clickhouse install)

 set (CLICKHOUSE_BUNDLE)
+macro(clickhouse_program_install name lib_name)
+    clickhouse_target_link_split_lib(clickhouse ${lib_name})
+    add_custom_target (${name} ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse ${name} DEPENDS clickhouse)
+    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/${name}" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
+    list(APPEND CLICKHOUSE_BUNDLE ${name})
+
+    foreach(alias ${ARGN})
+        message(STATUS "Adding alias ${alias} for ${name}")
+        add_custom_target (${alias} ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse ${alias} DEPENDS clickhouse)
+        install (FILES "${CMAKE_CURRENT_BINARY_DIR}/${alias}" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
+        list(APPEND CLICKHOUSE_BUNDLE ${alias})
+    endforeach()
+endmacro()
+
 if (ENABLE_CLICKHOUSE_SELF_EXTRACTING)
    list(APPEND CLICKHOUSE_BUNDLE self-extracting)
 endif ()
-if (ENABLE_CLICKHOUSE_SERVER)
-    add_custom_target (clickhouse-server ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-server DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-server" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-server)
-endif ()
-if (ENABLE_CLICKHOUSE_CLIENT)
-    add_custom_target (clickhouse-client ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-client DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-client" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-client)
-endif ()
-if (ENABLE_CLICKHOUSE_LOCAL)
-    add_custom_target (clickhouse-local ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-local DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-local" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-local)
-endif ()
-if (ENABLE_CLICKHOUSE_BENCHMARK)
-    add_custom_target (clickhouse-benchmark ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-benchmark DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-benchmark" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-benchmark)
-endif ()
-if (ENABLE_CLICKHOUSE_COPIER)
-    add_custom_target (clickhouse-copier ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-copier DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-copier" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-copier)
-endif ()
-if (ENABLE_CLICKHOUSE_EXTRACT_FROM_CONFIG)
-    add_custom_target (clickhouse-extract-from-config ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-extract-from-config DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-extract-from-config" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-extract-from-config)
-endif ()
-if (ENABLE_CLICKHOUSE_COMPRESSOR)
-    add_custom_target (clickhouse-compressor ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-compressor DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-compressor" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-compressor)
-endif ()
-if (ENABLE_CLICKHOUSE_FORMAT)
-    add_custom_target (clickhouse-format ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-format DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-format" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-format)
-endif ()
-if (ENABLE_CLICKHOUSE_OBFUSCATOR)
-    add_custom_target (clickhouse-obfuscator ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-obfuscator DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-obfuscator" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-obfuscator)
-endif ()
-if (ENABLE_CLICKHOUSE_GIT_IMPORT)
-    add_custom_target (clickhouse-git-import ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-git-import DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-git-import" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-git-import)
-endif ()
-if (ENABLE_CLICKHOUSE_STATIC_FILES_DISK_UPLOADER)
-    add_custom_target (clickhouse-static-files-disk-uploader ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-static-files-disk-uploader DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-static-files-disk-uploader" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-static-files-disk-uploader)
-endif ()
-if (ENABLE_CLICKHOUSE_SU)
-    add_custom_target (clickhouse-su ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-su DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-su" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-su)
-endif ()
+
+clickhouse_program_install(clickhouse-server server)
+clickhouse_program_install(clickhouse-client client chc)
+clickhouse_program_install(clickhouse-local local chl ch)
+clickhouse_program_install(clickhouse-benchmark benchmark)
+clickhouse_program_install(clickhouse-copier copier)
+clickhouse_program_install(clickhouse-extract-from-config extract-from-config)
+clickhouse_program_install(clickhouse-compressor compressor)
+clickhouse_program_install(clickhouse-format format)
+clickhouse_program_install(clickhouse-obfuscator obfuscator)
+clickhouse_program_install(clickhouse-git-import git-import)
+clickhouse_program_install(clickhouse-static-files-disk-uploader static-files-disk-uploader)
+clickhouse_program_install(clickhouse-disks disks)
+clickhouse_program_install(clickhouse-su su)

 if (ENABLE_CLICKHOUSE_KEEPER)
    if (NOT BUILD_STANDALONE_KEEPER AND CREATE_KEEPER_SYMLINK)
@ -417,11 +238,6 @@ if (ENABLE_CLICKHOUSE_KEEPER_CLIENT)

    list(APPEND CLICKHOUSE_BUNDLE clickhouse-keeper-client)
 endif ()
-if (ENABLE_CLICKHOUSE_DISKS)
-    add_custom_target (clickhouse-disks ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-disks DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-disks" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    list(APPEND CLICKHOUSE_BUNDLE clickhouse-disks)
-endif ()

 add_custom_target (clickhouse-bundle ALL DEPENDS ${CLICKHOUSE_BUNDLE})

--- a/programs/benchmark/Benchmark.cpp
+++ b/programs/benchmark/Benchmark.cpp
@ -640,7 +640,8 @@ int mainEntryClickHouseBenchmark(int argc, char ** argv)
        {
            std::cout << "Usage: " << argv[0] << " [options] < queries.txt\n";
            std::cout << desc << "\n";
-            return 1;
+            std::cout << "\nSee also: https://clickhouse.com/docs/en/operations/utilities/clickhouse-benchmark/\n";
+            return 0;
        }

        print_stacktrace = options.count("stacktrace");
--- a/programs/client/Client.cpp
+++ b/programs/client/Client.cpp
@ -504,7 +504,7 @@ void Client::connect()
                        << "It may lack support for new features." << std::endl
                        << std::endl;
        }
-        else if (client_version_tuple > server_version_tuple)
+        else if (client_version_tuple > server_version_tuple && server_display_name != "clickhouse-cloud")
        {
            std::cout << "ClickHouse server version is older than ClickHouse client. "
                        << "It may indicate that the server is out of date and can be upgraded." << std::endl
@ -1000,6 +1000,7 @@ void Client::printHelpMessage(const OptionsDescription & options_description)
    std::cout << options_description.external_description.value() << "\n";
    std::cout << options_description.hosts_and_ports_description.value() << "\n";
    std::cout << "In addition, --param_name=value can be specified for substitution of parameters for parametrized queries.\n";
+    std::cout << "\nSee also: https://clickhouse.com/docs/en/integrations/sql-clients/cli\n";
 }


--- a/programs/compressor/Compressor.cpp
+++ b/programs/compressor/Compressor.cpp
@ -100,6 +100,7 @@ int mainEntryClickHouseCompressor(int argc, char ** argv)
            std::cout << "Usage: " << argv[0] << " [options] < INPUT > OUTPUT" << std::endl;
            std::cout << "Usage: " << argv[0] << " [options] INPUT OUTPUT" << std::endl;
            std::cout << desc << std::endl;
+            std::cout << "\nSee also: https://clickhouse.com/docs/en/operations/utilities/clickhouse-compressor/\n";
            return 0;
        }

--- a/programs/config_tools.h.in
+++ b/programs/config_tools.h.in
@ -2,23 +2,8 @@

 #pragma once

-#cmakedefine01 ENABLE_CLICKHOUSE_SERVER
-#cmakedefine01 ENABLE_CLICKHOUSE_CLIENT
-#cmakedefine01 ENABLE_CLICKHOUSE_LOCAL
-#cmakedefine01 ENABLE_CLICKHOUSE_BENCHMARK
-#cmakedefine01 ENABLE_CLICKHOUSE_PERFORMANCE_TEST
-#cmakedefine01 ENABLE_CLICKHOUSE_COPIER
-#cmakedefine01 ENABLE_CLICKHOUSE_EXTRACT_FROM_CONFIG
-#cmakedefine01 ENABLE_CLICKHOUSE_COMPRESSOR
-#cmakedefine01 ENABLE_CLICKHOUSE_FORMAT
-#cmakedefine01 ENABLE_CLICKHOUSE_OBFUSCATOR
-#cmakedefine01 ENABLE_CLICKHOUSE_GIT_IMPORT
-#cmakedefine01 ENABLE_CLICKHOUSE_INSTALL
 #cmakedefine01 ENABLE_CLICKHOUSE_ODBC_BRIDGE
 #cmakedefine01 ENABLE_CLICKHOUSE_LIBRARY_BRIDGE
 #cmakedefine01 ENABLE_CLICKHOUSE_KEEPER
 #cmakedefine01 ENABLE_CLICKHOUSE_KEEPER_CLIENT
 #cmakedefine01 ENABLE_CLICKHOUSE_KEEPER_CONVERTER
-#cmakedefine01 ENABLE_CLICKHOUSE_STATIC_FILES_DISK_UPLOADER
-#cmakedefine01 ENABLE_CLICKHOUSE_SU
-#cmakedefine01 ENABLE_CLICKHOUSE_DISKS
--- a/programs/copier/ClusterCopierApp.cpp
+++ b/programs/copier/ClusterCopierApp.cpp
@ -78,6 +78,7 @@ void ClusterCopierApp::handleHelp(const std::string &, const std::string &)
    help_formatter.setHeader("Copies tables from one cluster to another");
    help_formatter.setUsage("--config-file <config-file> --task-path <task-path>");
    help_formatter.format(std::cerr);
+    help_formatter.setFooter("See also: https://clickhouse.com/docs/en/operations/utilities/clickhouse-copier/");

    stopOptionsProcessing();
 }
--- a/programs/git-import/git-import.cpp
+++ b/programs/git-import/git-import.cpp
@ -172,6 +172,7 @@ clickhouse-client --query "INSERT INTO git.commits FORMAT TSV" < commits.tsv
 clickhouse-client --query "INSERT INTO git.file_changes FORMAT TSV" < file_changes.tsv
 clickhouse-client --query "INSERT INTO git.line_changes FORMAT TSV" < line_changes.tsv

+Check out this presentation: https://presentations.clickhouse.com/matemarketing_2020/
 )";

 namespace po = boost::program_options;
--- a/programs/install/Install.cpp
+++ b/programs/install/Install.cpp
@ -79,10 +79,6 @@ namespace ErrorCodes

 }

-/// ANSI escape sequence for intense color in terminal.
-#define HILITE "\033[1m"
-#define END_HILITE "\033[0m"
-
 #if defined(OS_DARWIN)
 /// Until createUser() and createGroup() are implemented, only sudo-less installations are supported/default for macOS.
 static constexpr auto DEFAULT_CLICKHOUSE_SERVER_USER = "";
@ -216,6 +212,16 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
 {
    try
    {
+        const char * start_hilite = "";
+        const char * end_hilite = "";
+
+        if (isatty(STDOUT_FILENO))
+        {
+            /// ANSI escape sequence for intense color in terminal.
+            start_hilite = "\033[1m";
+            end_hilite = "\033[0m";
+        }
+
        po::options_description desc;
        desc.add_options()
            ("help,h", "produce help message")
@ -236,9 +242,10 @@ int mainEntryClickHouseInstall(int argc, char ** argv)

        if (options.count("help"))
        {
+            std::cout << "Install ClickHouse without .deb/.rpm/.tgz packages (having the binary only)\n\n";
            std::cout << "Usage: " << formatWithSudo(std::string(argv[0]) + " install [options]", getuid() != 0) << '\n';
            std::cout << desc << '\n';
-            return 1;
+            return 0;
        }

        /// We need to copy binary to the binary directory.
@ -707,7 +714,7 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
        {
            fmt::print("Users config file {} already exists, will keep it and extract users info from it.\n", users_config_file.string());

-            /// Check if password for default user already specified.
+            /// Check if password for the default user already specified.
            ConfigProcessor processor(users_config_file.string(), /* throw_on_bad_incl = */ false, /* log_to_console = */ false);
            ConfigurationPtr configuration(new Poco::Util::XMLConfiguration(processor.processConfig()));

@ -799,13 +806,13 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
        /// Set up password for default user.
        if (has_password_for_default_user)
        {
-            fmt::print(HILITE "Password for default user is already specified. To remind or reset, see {} and {}." END_HILITE "\n",
-                       users_config_file.string(), users_d.string());
+            fmt::print("{}Password for the default user is already specified. To remind or reset, see {} and {}.{}\n",
+                start_hilite, users_config_file.string(), users_d.string(), end_hilite);
        }
        else if (!can_ask_password)
        {
-            fmt::print(HILITE "Password for default user is empty string. See {} and {} to change it." END_HILITE "\n",
-                       users_config_file.string(), users_d.string());
+            fmt::print("{}Password for the default user is an empty string. See {} and {} to change it.{}\n",
+                start_hilite, users_config_file.string(), users_d.string(), end_hilite);
        }
        else
        {
@ -814,7 +821,7 @@ int mainEntryClickHouseInstall(int argc, char ** argv)

            char buf[1000] = {};
            std::string password;
-            if (auto * result = readpassphrase("Enter password for default user: ", buf, sizeof(buf), 0))
+            if (auto * result = readpassphrase("Enter password for the default user: ", buf, sizeof(buf), 0))
                password = result;

            if (!password.empty())
@ -839,7 +846,7 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
                    "</clickhouse>\n";
                out.sync();
                out.finalize();
-                fmt::print(HILITE "Password for default user is saved in file {}." END_HILITE "\n", password_file);
+                fmt::print("{}Password for the default user is saved in file {}.{}\n", start_hilite, password_file, end_hilite);
 #else
                out << "<clickhouse>\n"
                    "    <users>\n"
@ -850,13 +857,13 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
                    "</clickhouse>\n";
                out.sync();
                out.finalize();
-                fmt::print(HILITE "Password for default user is saved in plaintext in file {}." END_HILITE "\n", password_file);
+                fmt::print("{}Password for the default user is saved in plaintext in file {}.{}\n", start_hilite, password_file, end_hilite);
 #endif
                has_password_for_default_user = true;
            }
            else
-                fmt::print(HILITE "Password for default user is empty string. See {} and {} to change it." END_HILITE "\n",
-                           users_config_file.string(), users_d.string());
+                fmt::print("{}Password for the default user is an empty string. See {} and {} to change it.{}\n",
+                    start_hilite, users_config_file.string(), users_d.string(), end_hilite);
        }

        /** Set capabilities for the binary.
--- a/programs/keeper-converter/KeeperConverter.cpp
+++ b/programs/keeper-converter/KeeperConverter.cpp
@ -1,5 +1,4 @@
 #include <iostream>
-#include <optional>
 #include <boost/program_options.hpp>

 #include <Coordination/KeeperSnapshotManager.h>
--- a/programs/local/LocalServer.cpp
+++ b/programs/local/LocalServer.cpp
@ -828,6 +828,7 @@ void LocalServer::printHelpMessage([[maybe_unused]] const OptionsDescription & o
    std::cout << options_description.main_description.value() << "\n";
    std::cout << getHelpFooter() << "\n";
    std::cout << "In addition, --param_name=value can be specified for substitution of parameters for parametrized queries.\n";
+    std::cout << "\nSee also: https://clickhouse.com/docs/en/operations/utilities/clickhouse-local/\n";
 #endif
 }

--- a/programs/main.cpp
+++ b/programs/main.cpp
@ -1,6 +1,7 @@
 #include <csignal>
 #include <csetjmp>
 #include <unistd.h>
+#include <fcntl.h>

 #include <new>
 #include <iostream>
@ -19,39 +20,32 @@
 #include <Common/IO.h>

 #include <base/phdr_cache.h>
+#include <base/coverage.h>


 /// Universal executable for various clickhouse applications
-#if ENABLE_CLICKHOUSE_SERVER
 int mainEntryClickHouseServer(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_CLIENT
 int mainEntryClickHouseClient(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_LOCAL
 int mainEntryClickHouseLocal(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_BENCHMARK
 int mainEntryClickHouseBenchmark(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_EXTRACT_FROM_CONFIG
 int mainEntryClickHouseExtractFromConfig(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_COMPRESSOR
 int mainEntryClickHouseCompressor(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_FORMAT
 int mainEntryClickHouseFormat(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_COPIER
 int mainEntryClickHouseClusterCopier(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_OBFUSCATOR
 int mainEntryClickHouseObfuscator(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_GIT_IMPORT
 int mainEntryClickHouseGitImport(int argc, char ** argv);
-#endif
+int mainEntryClickHouseStaticFilesDiskUploader(int argc, char ** argv);
+int mainEntryClickHouseSU(int argc, char ** argv);
+int mainEntryClickHouseDisks(int argc, char ** argv);
+
+int mainEntryClickHouseHashBinary(int, char **)
+{
+    /// Intentionally without newline. So you can run:
+    /// objcopy --add-section .clickhouse.hash=<(./clickhouse hash-binary) clickhouse
+    std::cout << getHashOfLoadedBinaryHex();
+    return 0;
+}
+
 #if ENABLE_CLICKHOUSE_KEEPER
 int mainEntryClickHouseKeeper(int argc, char ** argv);
 #endif
@ -61,30 +55,13 @@ int mainEntryClickHouseKeeperConverter(int argc, char ** argv);
 #if ENABLE_CLICKHOUSE_KEEPER_CLIENT
 int mainEntryClickHouseKeeperClient(int argc, char ** argv);
 #endif
-#if ENABLE_CLICKHOUSE_STATIC_FILES_DISK_UPLOADER
-int mainEntryClickHouseStaticFilesDiskUploader(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_SU
-int mainEntryClickHouseSU(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_INSTALL
+
+// install
 int mainEntryClickHouseInstall(int argc, char ** argv);
 int mainEntryClickHouseStart(int argc, char ** argv);
 int mainEntryClickHouseStop(int argc, char ** argv);
 int mainEntryClickHouseStatus(int argc, char ** argv);
 int mainEntryClickHouseRestart(int argc, char ** argv);
-#endif
-#if ENABLE_CLICKHOUSE_DISKS
-int mainEntryClickHouseDisks(int argc, char ** argv);
-#endif
-
-int mainEntryClickHouseHashBinary(int, char **)
-{
-    /// Intentionally without newline. So you can run:
-    /// objcopy --add-section .clickhouse.hash=<(./clickhouse hash-binary) clickhouse
-    std::cout << getHashOfLoadedBinaryHex();
-    return 0;
-}

 namespace
 {
@ -96,36 +73,22 @@ using MainFunc = int (*)(int, char**);
 /// Add an item here to register new application
 std::pair<std::string_view, MainFunc> clickhouse_applications[] =
 {
-#if ENABLE_CLICKHOUSE_LOCAL
    {"local", mainEntryClickHouseLocal},
-#endif
-#if ENABLE_CLICKHOUSE_CLIENT
    {"client", mainEntryClickHouseClient},
-#endif
-#if ENABLE_CLICKHOUSE_BENCHMARK
    {"benchmark", mainEntryClickHouseBenchmark},
-#endif
-#if ENABLE_CLICKHOUSE_SERVER
    {"server", mainEntryClickHouseServer},
-#endif
-#if ENABLE_CLICKHOUSE_EXTRACT_FROM_CONFIG
    {"extract-from-config", mainEntryClickHouseExtractFromConfig},
-#endif
-#if ENABLE_CLICKHOUSE_COMPRESSOR
    {"compressor", mainEntryClickHouseCompressor},
-#endif
-#if ENABLE_CLICKHOUSE_FORMAT
    {"format", mainEntryClickHouseFormat},
-#endif
-#if ENABLE_CLICKHOUSE_COPIER
    {"copier", mainEntryClickHouseClusterCopier},
-#endif
-#if ENABLE_CLICKHOUSE_OBFUSCATOR
    {"obfuscator", mainEntryClickHouseObfuscator},
-#endif
-#if ENABLE_CLICKHOUSE_GIT_IMPORT
    {"git-import", mainEntryClickHouseGitImport},
-#endif
+    {"static-files-disk-uploader", mainEntryClickHouseStaticFilesDiskUploader},
+    {"su", mainEntryClickHouseSU},
+    {"hash-binary", mainEntryClickHouseHashBinary},
+    {"disks", mainEntryClickHouseDisks},
+
+    // keeper
 #if ENABLE_CLICKHOUSE_KEEPER
    {"keeper", mainEntryClickHouseKeeper},
 #endif
@ -135,34 +98,20 @@ std::pair<std::string_view, MainFunc> clickhouse_applications[] =
 #if ENABLE_CLICKHOUSE_KEEPER_CLIENT
    {"keeper-client", mainEntryClickHouseKeeperClient},
 #endif
-#if ENABLE_CLICKHOUSE_INSTALL
+
+    // install
    {"install", mainEntryClickHouseInstall},
    {"start", mainEntryClickHouseStart},
    {"stop", mainEntryClickHouseStop},
    {"status", mainEntryClickHouseStatus},
    {"restart", mainEntryClickHouseRestart},
-#endif
-#if ENABLE_CLICKHOUSE_STATIC_FILES_DISK_UPLOADER
-    {"static-files-disk-uploader", mainEntryClickHouseStaticFilesDiskUploader},
-#endif
-#if ENABLE_CLICKHOUSE_SU
-    {"su", mainEntryClickHouseSU},
-#endif
-    {"hash-binary", mainEntryClickHouseHashBinary},
-#if ENABLE_CLICKHOUSE_DISKS
-    {"disks", mainEntryClickHouseDisks},
-#endif
 };

 /// Add an item here to register a new short name
 std::pair<std::string_view, std::string_view> clickhouse_short_names[] =
 {
-#if ENABLE_CLICKHOUSE_LOCAL
    {"chl", "local"},
-#endif
-#if ENABLE_CLICKHOUSE_CLIENT
    {"chc", "client"},
-#endif
 };

 int printHelp(int, char **)
@ -392,6 +341,50 @@ void checkHarmfulEnvironmentVariables(char ** argv)
 }
 #endif

+
+#if defined(SANITIZE_COVERAGE)
+__attribute__((no_sanitize("coverage")))
+void dumpCoverage()
+{
+    /// A user can request to dump the coverage information into files at exit.
+    /// This is useful for non-server applications such as clickhouse-format or clickhouse-client,
+    /// that cannot introspect it with SQL functions at runtime.
+
+    /// The CLICKHOUSE_WRITE_COVERAGE environment variable defines a prefix for a filename 'prefix.pid'
+    /// containing the list of addresses of covered .
+
+    /// The format is even simpler than Clang's "sancov": an array of 64-bit addresses, native byte order, no header.
+
+    if (const char * coverage_filename_prefix = getenv("CLICKHOUSE_WRITE_COVERAGE")) // NOLINT(concurrency-mt-unsafe)
+    {
+        auto dump = [](const std::string & name, auto span)
+        {
+            /// Write only non-zeros.
+            std::vector<uintptr_t> data;
+            data.reserve(span.size());
+            for (auto addr : span)
+                if (addr)
+                    data.push_back(addr);
+
+            int fd = ::open(name.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0400);
+            if (-1 == fd)
+            {
+                writeError("Cannot open a file to write the coverage data\n");
+            }
+            else
+            {
+                if (!writeRetry(fd, reinterpret_cast<const char *>(data.data()), data.size() * sizeof(data[0])))
+                    writeError("Cannot write the coverage data to a file\n");
+                if (0 != ::close(fd))
+                    writeError("Cannot close the file with coverage data\n");
+            }
+        };
+
+        dump(fmt::format("{}.{}", coverage_filename_prefix, getpid()), getCumulativeCoverage());
+    }
+}
+#endif
+
 }

 bool isClickhouseApp(std::string_view app_suffix, std::vector<char *> & argv)
@ -512,6 +505,12 @@ int main(int argc_, char ** argv_)
    if (main_func == printHelp && !argv.empty() && (argv.size() == 1 || argv[1][0] == '-'))
        main_func = mainEntryClickHouseLocal;

-    return main_func(static_cast<int>(argv.size()), argv.data());
+    int exit_code = main_func(static_cast<int>(argv.size()), argv.data());
+
+#if defined(SANITIZE_COVERAGE)
+    dumpCoverage();
+#endif
+
+    return exit_code;
 }
 #endif
--- a/programs/server/Server.cpp
+++ b/programs/server/Server.cpp
@ -557,7 +557,7 @@ static void sanityChecks(Server & server)
    {
        const char * filename = "/proc/sys/kernel/task_delayacct";
        if (readNumber(filename) == 0)
-            server.context()->addWarningMessage("Delay accounting is not enabled, OSIOWaitMicroseconds will not be gathered. Check " + String(filename));
+            server.context()->addWarningMessage("Delay accounting is not enabled, OSIOWaitMicroseconds will not be gathered. You can enable it using `echo 1 > " + String(filename) + "` or by using sysctl.");
    }
    catch (...) // NOLINT(bugprone-empty-catch)
    {
@ -826,10 +826,12 @@ try
        0, // We don't need any threads one all the parts will be deleted
        server_settings.max_parts_cleaning_thread_pool_size);

+    auto max_database_replicated_create_table_thread_pool_size = server_settings.max_database_replicated_create_table_thread_pool_size ?
+        server_settings.max_database_replicated_create_table_thread_pool_size : getNumberOfPhysicalCPUCores();
    getDatabaseReplicatedCreateTablesThreadPool().initialize(
-        server_settings.max_database_replicated_create_table_thread_pool_size,
+        max_database_replicated_create_table_thread_pool_size,
        0, // We don't need any threads once all the tables will be created
-        server_settings.max_database_replicated_create_table_thread_pool_size);
+        max_database_replicated_create_table_thread_pool_size);

    /// Initialize global local cache for remote filesystem.
    if (config().has("local_cache_for_remote_fs"))
--- a/programs/server/dashboard.html
+++ b/programs/server/dashboard.html
@ -527,10 +527,11 @@ let queries = [];

 /// Query parameters with predefined default values.
 /// All other parameters will be automatically found in the queries.
-let params = {
+let default_params = {
    'rounding': '60',
    'seconds': '86400'
 };
+let params = default_params;

 /// Palette generation for charts
 function generatePalette(baseColor, numColors) {
@ -594,13 +595,19 @@ let plots = [];
 let charts = document.getElementById('charts');

 /// This is not quite correct (we cannot really parse SQL with regexp) but tolerable.
-const query_param_regexp = /\{(\w+):[^}]+\}/g;
+const query_param_regexp = /\{(\w+):([^}]+)\}/g;

 /// Automatically parse more parameters from the queries.
 function findParamsInQuery(query, new_params) {
+    const typeDefault = (type) => type.includes('Int') ? '0'
+        : (type.includes('Float') ? '0.0'
+        : (type.includes('Bool') ? 'false'
+        : (type.includes('Date') ? new Date().toISOString().slice(0, 10)
+        : (type.includes('UUID') ? '00000000-0000-0000-0000-000000000000'
+        : ''))));
    for (let match of query.matchAll(query_param_regexp)) {
        const name = match[1];
-        new_params[name] = params[name] || '';
+        new_params[name] = params[name] || default_params[name] || typeDefault(match[2]);
    }
 }

--- a/programs/su/su.cpp
+++ b/programs/su/su.cpp
@ -107,6 +107,7 @@ try

    if (argc < 3)
    {
+        std::cout << "A tool similar to 'su'" << std::endl;
        std::cout << "Usage: ./clickhouse su user:group ..." << std::endl;
        exit(0); // NOLINT(concurrency-mt-unsafe)
    }
--- a/rust/CMakeLists.txt
+++ b/rust/CMakeLists.txt
@ -14,6 +14,11 @@ macro(configure_rustc)
        set(RUST_CFLAGS "${RUST_CFLAGS} --sysroot ${CMAKE_SYSROOT}")
    endif()

+    if (CMAKE_OSX_DEPLOYMENT_TARGET)
+        set(RUST_CXXFLAGS "${RUST_CXXFLAGS} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
+        set(RUST_CFLAGS "${RUST_CFLAGS} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
+    endif()
+
    if (USE_MUSL)
        set(RUST_CXXFLAGS "${RUST_CXXFLAGS} -D_LIBCPP_HAS_MUSL_LIBC=1")
    endif ()
@ -25,14 +30,23 @@ macro(configure_rustc)
        set(RUSTCWRAPPER "")
    endif()

-    set(RUSTFLAGS "[]")
+    set(RUSTFLAGS)
+    if (CMAKE_OSX_DEPLOYMENT_TARGET)
+        list(APPEND RUSTFLAGS "-C" "link-arg=-mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
+    endif()
+
    set(RUST_CARGO_BUILD_STD "")
    # For more info: https://doc.rust-lang.org/beta/unstable-book/compiler-flags/sanitizer.html#memorysanitizer
    if (SANITIZE STREQUAL "memory")
        set(RUST_CARGO_BUILD_STD "build-std = [\"std\", \"panic_abort\", \"core\", \"alloc\"]")
-        set(RUSTFLAGS "[\"-Zsanitizer=memory\", \"-Zsanitizer-memory-track-origins\"]")
+        list(APPEND RUSTFLAGS "-Zsanitizer=memory" "-Zsanitizer-memory-track-origins")
    endif()

+    list(TRANSFORM RUSTFLAGS PREPEND "\"")
+    list(TRANSFORM RUSTFLAGS APPEND "\"")
+    list(JOIN RUSTFLAGS "," RUSTFLAGS)
+    set(RUSTFLAGS "[${RUSTFLAGS}]")
+
    message(STATUS "RUST_CFLAGS: ${RUST_CFLAGS}")
    message(STATUS "RUST_CXXFLAGS: ${RUST_CXXFLAGS}")
    message(STATUS "RUSTFLAGS: ${RUSTFLAGS}")
--- a/src/AggregateFunctions/AggregateFunctionTopK.cpp
+++ b/src/AggregateFunctions/AggregateFunctionTopK.cpp
@ -234,6 +234,9 @@ public:

    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena *) const override
    {
+        if (!this->data(rhs).value.size())
+            return;
+
        auto & set = this->data(place).value;
        if (set.capacity() != reserved)
            set.resize(reserved);
--- a/src/Analyzer/ColumnNode.h
+++ b/src/Analyzer/ColumnNode.h
@ -108,6 +108,11 @@ public:
      */
    QueryTreeNodePtr getColumnSourceOrNull() const;

+    void setColumnSource(const QueryTreeNodePtr & source)
+    {
+        getSourceWeakPointer() = source;
+    }
+
    QueryTreeNodeType getNodeType() const override
    {
        return QueryTreeNodeType::COLUMN;
--- a/src/Analyzer/ConstantNode.cpp
+++ b/src/Analyzer/ConstantNode.cpp
@ -128,7 +128,10 @@ ASTPtr ConstantNode::toASTImpl(const ConvertToASTOptions & options) const
        }
    }

-    if (need_to_add_cast_function)
+    // Add cast if constant was created as a result of constant folding.
+    // Constant folding may lead to type transformation and literal on shard
+    // may have a different type.
+    if (need_to_add_cast_function || source_expression != nullptr)
    {
        auto constant_type_name_ast = std::make_shared<ASTLiteral>(constant_value->getType()->getName());
        return makeASTFunction("_CAST", std::move(constant_value_ast), std::move(constant_type_name_ast));
--- a/src/Analyzer/IQueryTreePass.h
+++ b/src/Analyzer/IQueryTreePass.h
@ -31,7 +31,7 @@ public:
    virtual String getDescription() = 0;

    /// Run pass over query tree
-    virtual void run(QueryTreeNodePtr query_tree_node, ContextPtr context) = 0;
+    virtual void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) = 0;

 };

--- a/src/Analyzer/Passes/AggregateFunctionsArithmericOperationsPass.cpp
+++ b/src/Analyzer/Passes/AggregateFunctionsArithmericOperationsPass.cpp
@ -194,7 +194,7 @@ private:

 }

-void AggregateFunctionsArithmericOperationsPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void AggregateFunctionsArithmericOperationsPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    AggregateFunctionsArithmericOperationsVisitor visitor(std::move(context));
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/AggregateFunctionsArithmericOperationsPass.h
+++ b/src/Analyzer/Passes/AggregateFunctionsArithmericOperationsPass.h
@ -17,7 +17,7 @@ public:

    String getDescription() override { return "Extract arithmeric operations from aggregate functions."; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;

 };

--- a/src/Analyzer/Passes/ArrayExistsToHasPass.cpp
+++ b/src/Analyzer/Passes/ArrayExistsToHasPass.cpp
@ -92,7 +92,7 @@ public:

 }

-void RewriteArrayExistsToHasPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void RewriteArrayExistsToHasPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    RewriteArrayExistsToHasVisitor visitor(context);
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/ArrayExistsToHasPass.h
+++ b/src/Analyzer/Passes/ArrayExistsToHasPass.h
@ -20,7 +20,7 @@ public:

    String getDescription() override { return "Rewrite arrayExists(func, arr) functions to has(arr, elem) when logically equivalent"; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
 };

 }
--- a/src/Analyzer/Passes/AutoFinalOnQueryPass.cpp
+++ b/src/Analyzer/Passes/AutoFinalOnQueryPass.cpp
@ -67,7 +67,7 @@ private:

 }

-void AutoFinalOnQueryPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void AutoFinalOnQueryPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    auto visitor = AutoFinalOnQueryPassVisitor(std::move(context));
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/AutoFinalOnQueryPass.h
+++ b/src/Analyzer/Passes/AutoFinalOnQueryPass.h
@ -25,7 +25,7 @@ public:
        return "Automatically applies final modifier to table expressions in queries if it is supported and if user level final setting is set";
    }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
 };

 }
--- a/src/Analyzer/Passes/ComparisonTupleEliminationPass.cpp
+++ b/src/Analyzer/Passes/ComparisonTupleEliminationPass.cpp
@ -213,7 +213,7 @@ private:

 }

-void ComparisonTupleEliminationPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void ComparisonTupleEliminationPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    ComparisonTupleEliminationPassVisitor visitor(std::move(context));
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/ComparisonTupleEliminationPass.h
+++ b/src/Analyzer/Passes/ComparisonTupleEliminationPass.h
@ -17,7 +17,7 @@ public:

    String getDescription() override { return "Rewrite tuples comparison into equivalent comparison of tuples arguments"; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;

 };

--- a/src/Analyzer/Passes/ConvertOrLikeChainPass.cpp
+++ b/src/Analyzer/Passes/ConvertOrLikeChainPass.cpp
@ -132,7 +132,7 @@ private:

 }

-void ConvertOrLikeChainPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void ConvertOrLikeChainPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    auto or_function_resolver = FunctionFactory::instance().get("or", context);
    auto match_function_resolver = FunctionFactory::instance().get("multiMatchAny", context);
--- a/src/Analyzer/Passes/ConvertOrLikeChainPass.h
+++ b/src/Analyzer/Passes/ConvertOrLikeChainPass.h
@ -14,7 +14,7 @@ public:

    String getDescription() override { return "Replaces all the 'or's with {i}like to multiMatchAny"; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
 };

 }
--- a/src/Analyzer/Passes/ConvertQueryToCNFPass.cpp
+++ b/src/Analyzer/Passes/ConvertQueryToCNFPass.cpp
@ -718,7 +718,7 @@ public:

 }

-void ConvertLogicalExpressionToCNFPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void ConvertLogicalExpressionToCNFPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    const auto & settings = context->getSettingsRef();
    if (!settings.convert_query_to_cnf)
--- a/src/Analyzer/Passes/ConvertQueryToCNFPass.h
+++ b/src/Analyzer/Passes/ConvertQueryToCNFPass.h
@ -12,7 +12,7 @@ public:

    String getDescription() override { return "Convert logical expression to CNF and apply optimizations using constraints"; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
 };

 }
--- a/src/Analyzer/Passes/CountDistinctPass.cpp
+++ b/src/Analyzer/Passes/CountDistinctPass.cpp
@ -87,7 +87,7 @@ public:

 }

-void CountDistinctPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void CountDistinctPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    CountDistinctVisitor visitor(std::move(context));
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/CountDistinctPass.h
+++ b/src/Analyzer/Passes/CountDistinctPass.h
@ -20,7 +20,7 @@ public:
        return "Optimize single countDistinct into count over subquery";
    }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;

 };

--- a/src/Analyzer/Passes/CrossToInnerJoinPass.cpp
+++ b/src/Analyzer/Passes/CrossToInnerJoinPass.cpp
@ -264,7 +264,7 @@ private:

 }

-void CrossToInnerJoinPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void CrossToInnerJoinPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    CrossToInnerJoinVisitor visitor(std::move(context));
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/CrossToInnerJoinPass.h
+++ b/src/Analyzer/Passes/CrossToInnerJoinPass.h
@ -22,7 +22,7 @@ public:
        return "Replace CROSS JOIN with INNER JOIN";
    }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
 };

 }
--- a/src/Analyzer/Passes/FunctionToSubcolumnsPass.cpp
+++ b/src/Analyzer/Passes/FunctionToSubcolumnsPass.cpp
@ -224,7 +224,7 @@ private:

 }

-void FunctionToSubcolumnsPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void FunctionToSubcolumnsPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    FunctionToSubcolumnsVisitor visitor(context);
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/FunctionToSubcolumnsPass.h
+++ b/src/Analyzer/Passes/FunctionToSubcolumnsPass.h
@ -24,7 +24,7 @@ public:

    String getDescription() override { return "Rewrite function to subcolumns, for example tupleElement(column, subcolumn) into column.subcolumn"; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;

 };

--- a/src/Analyzer/Passes/FuseFunctionsPass.cpp
+++ b/src/Analyzer/Passes/FuseFunctionsPass.cpp
@ -256,7 +256,7 @@ void tryFuseQuantiles(QueryTreeNodePtr query_tree_node, ContextPtr context)

 }

-void FuseFunctionsPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void FuseFunctionsPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    tryFuseSumCountAvg(query_tree_node, context);
    tryFuseQuantiles(query_tree_node, context);
--- a/src/Analyzer/Passes/FuseFunctionsPass.h
+++ b/src/Analyzer/Passes/FuseFunctionsPass.h
@ -20,7 +20,7 @@ public:

    String getDescription() override { return "Replaces several calls of aggregate functions of the same family into one call"; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
 };

 }
--- a/src/Analyzer/Passes/GroupingFunctionsResolvePass.cpp
+++ b/src/Analyzer/Passes/GroupingFunctionsResolvePass.cpp
@ -249,7 +249,7 @@ private:

 }

-void GroupingFunctionsResolvePass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void GroupingFunctionsResolvePass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    GroupingFunctionsResolveVisitor visitor(std::move(context));
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/GroupingFunctionsResolvePass.h
+++ b/src/Analyzer/Passes/GroupingFunctionsResolvePass.h
@ -24,7 +24,7 @@ public:

    String getDescription() override { return "Resolve GROUPING functions based on GROUP BY modifiers"; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;

 };

--- a/src/Analyzer/Passes/IfChainToMultiIfPass.cpp
+++ b/src/Analyzer/Passes/IfChainToMultiIfPass.cpp
@ -73,7 +73,7 @@ private:

 }

-void IfChainToMultiIfPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void IfChainToMultiIfPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    auto multi_if_function_ptr = FunctionFactory::instance().get("multiIf", context);
    IfChainToMultiIfPassVisitor visitor(std::move(multi_if_function_ptr), std::move(context));
--- a/src/Analyzer/Passes/IfChainToMultiIfPass.h
+++ b/src/Analyzer/Passes/IfChainToMultiIfPass.h
@ -18,7 +18,7 @@ public:

    String getDescription() override { return "Optimize if chain to multiIf"; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;

 };

--- a/src/Analyzer/Passes/IfConstantConditionPass.cpp
+++ b/src/Analyzer/Passes/IfConstantConditionPass.cpp
@ -57,7 +57,7 @@ public:

 }

-void IfConstantConditionPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void IfConstantConditionPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    IfConstantConditionVisitor visitor(std::move(context));
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/IfConstantConditionPass.h
+++ b/src/Analyzer/Passes/IfConstantConditionPass.h
@ -21,7 +21,7 @@ public:

    String getDescription() override { return "Optimize if, multiIf for constant condition."; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;

 };

--- a/src/Analyzer/Passes/IfTransformStringsToEnumPass.cpp
+++ b/src/Analyzer/Passes/IfTransformStringsToEnumPass.cpp
@ -190,7 +190,7 @@ public:

 }

-void IfTransformStringsToEnumPass::run(QueryTreeNodePtr query, ContextPtr context)
+void IfTransformStringsToEnumPass::run(QueryTreeNodePtr & query, ContextPtr context)
 {
    ConvertStringsToEnumVisitor visitor(std::move(context));
    visitor.visit(query);
--- a/src/Analyzer/Passes/IfTransformStringsToEnumPass.h
+++ b/src/Analyzer/Passes/IfTransformStringsToEnumPass.h
@ -33,7 +33,7 @@ public:

    String getDescription() override { return "Replaces string-type arguments in If and Transform to enum"; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
 };

 }
--- a/src/Analyzer/Passes/LogicalExpressionOptimizerPass.cpp
+++ b/src/Analyzer/Passes/LogicalExpressionOptimizerPass.cpp
@ -404,12 +404,12 @@ private:

            auto operand_type = and_operands[0]->getResultType();
            auto function_type = function_node.getResultType();
-            assert(!function_type->isNullable());
+            chassert(!function_type->isNullable());
            if (!function_type->equals(*operand_type))
            {
                /// Result of equality operator can be low cardinality, while AND always returns UInt8.
                /// In that case we replace `(lc = 1) AND (lc = 1)` with `(lc = 1) AS UInt8`
-                assert(function_type->equals(*removeLowCardinality(operand_type)));
+                chassert(function_type->equals(*removeLowCardinality(operand_type)));
                node = createCastFunction(std::move(and_operands[0]), function_type, getContext());
            }
            else
@ -427,7 +427,7 @@ private:
    void tryReplaceOrEqualsChainWithIn(QueryTreeNodePtr & node)
    {
        auto & function_node = node->as<FunctionNode &>();
-        assert(function_node.getFunctionName() == "or");
+        chassert(function_node.getFunctionName() == "or");

        QueryTreeNodes or_operands;

@ -486,7 +486,7 @@ private:
            /// first we create tuple from RHS of equals functions
            for (const auto & equals : equals_functions)
            {
-                is_any_nullable |= equals->getResultType()->isNullable();
+                is_any_nullable |= removeLowCardinality(equals->getResultType())->isNullable();

                const auto * equals_function = equals->as<FunctionNode>();
                assert(equals_function && equals_function->getFunctionName() == "equals");
@ -554,7 +554,7 @@ private:
    }
 };

-void LogicalExpressionOptimizerPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void LogicalExpressionOptimizerPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    LogicalExpressionOptimizerVisitor visitor(std::move(context));
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/LogicalExpressionOptimizerPass.h
+++ b/src/Analyzer/Passes/LogicalExpressionOptimizerPass.h
@ -109,7 +109,7 @@ public:
            "replace chains of equality functions inside an OR with a single IN operator";
    }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
 };

 }
--- a/src/Analyzer/Passes/MultiIfToIfPass.cpp
+++ b/src/Analyzer/Passes/MultiIfToIfPass.cpp
@ -52,7 +52,7 @@ private:

 }

-void MultiIfToIfPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void MultiIfToIfPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    auto if_function_ptr = FunctionFactory::instance().get("if", context);
    MultiIfToIfVisitor visitor(std::move(if_function_ptr), std::move(context));
--- a/src/Analyzer/Passes/MultiIfToIfPass.h
+++ b/src/Analyzer/Passes/MultiIfToIfPass.h
@ -17,7 +17,7 @@ public:

    String getDescription() override { return "Optimize multiIf with single condition to if."; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;

 };

--- a/src/Analyzer/Passes/NormalizeCountVariantsPass.cpp
+++ b/src/Analyzer/Passes/NormalizeCountVariantsPass.cpp
@ -64,7 +64,7 @@ private:

 }

-void NormalizeCountVariantsPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context)
+void NormalizeCountVariantsPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
    NormalizeCountVariantsVisitor visitor(context);
    visitor.visit(query_tree_node);
--- a/src/Analyzer/Passes/NormalizeCountVariantsPass.h
+++ b/src/Analyzer/Passes/NormalizeCountVariantsPass.h
@ -20,7 +20,7 @@ public:

    String getDescription() override { return "Optimize count(literal), sum(1) into count()."; }

-    void run(QueryTreeNodePtr query_tree_node, ContextPtr context) override;
+    void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;

 };

--- a/Show More
+++ b/Show More