Merge remote-tracking branch 'origin/master' into generic-clickhouse-local-fuzzer

2024-11-21 23:21:59 +00:00 · 2024-03-20 01:28:28 +01:00 · 2024-03-20 01:28:28 +01:00 · 7b7e260585
commit 7b7e260585
parent 2eb7de859d 99a81c848e
475 changed files with 5844 additions and 3289 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@ -5,9 +5,7 @@
 # a) the new check is not controversial (this includes many checks in readability-* and google-*) or
 # b) too noisy (checks with > 100 new warnings are considered noisy, this includes e.g. cppcoreguidelines-*).

-# TODO Let clang-tidy check headers in further directories
-#      --> HeaderFilterRegex: '^.*/(src|base|programs|utils)/.*(h|hpp)$'
-HeaderFilterRegex: '^.*/(base|programs|utils)/.*(h|hpp)$'
+HeaderFilterRegex: '^.*/(base|src|programs|utils)/.*(h|hpp)$'

 Checks: [
  '*',
@ -22,6 +20,7 @@ Checks: [
  '-bugprone-branch-clone',
  '-bugprone-easily-swappable-parameters',
  '-bugprone-exception-escape',
+  '-bugprone-forward-declaration-namespace',
  '-bugprone-implicit-widening-of-multiplication-result',
  '-bugprone-narrowing-conversions',
  '-bugprone-not-null-terminated-result',
@ -37,6 +36,8 @@ Checks: [
  '-cert-oop54-cpp',
  '-cert-oop57-cpp',

+  '-clang-analyzer-optin.performance.Padding',
+
  '-clang-analyzer-unix.Malloc',

  '-cppcoreguidelines-*', # impractical in a codebase as large as ClickHouse, also slow
--- a/base/base/getMemoryAmount.cpp
+++ b/base/base/getMemoryAmount.cpp
@ -50,9 +50,6 @@ std::optional<uint64_t> getCgroupsV2MemoryLimit()

 }

-/** Returns the size of physical memory (RAM) in bytes.
-  * Returns 0 on unsupported platform
-  */
 uint64_t getMemoryAmountOrZero()
 {
    int64_t num_pages = sysconf(_SC_PHYS_PAGES);
--- a/base/base/getMemoryAmount.h
+++ b/base/base/getMemoryAmount.h
@ -2,11 +2,10 @@

 #include <cstdint>

-/** Returns the size of physical memory (RAM) in bytes.
-  * Returns 0 on unsupported platform or if it cannot determine the size of physical memory.
-  */
+/// Returns the size in bytes of physical memory (RAM) available to the process. The value can
+/// be smaller than the total available RAM available to the system due to cgroups settings.
+/// Returns 0 on unsupported platform or if it cannot determine the size of physical memory.
 uint64_t getMemoryAmountOrZero();

-/** Throws exception if it cannot determine the size of physical memory.
-  */
+/// Throws exception if it cannot determine the size of physical memory.
 uint64_t getMemoryAmount();
--- a/base/poco/Net/include/Poco/Net/HTTPRequestHandlerFactory.h
+++ b/base/poco/Net/include/Poco/Net/HTTPRequestHandlerFactory.h
@ -30,7 +30,6 @@ namespace Net


    class HTTPServerRequest;
-    class HTTPServerResponse;
    class HTTPRequestHandler;


--- a/contrib/libmetrohash/src/metrohash64.cpp
+++ b/contrib/libmetrohash/src/metrohash64.cpp
@ -26,13 +26,13 @@ const uint8_t MetroHash64::test_seed_1[8] =   { 0x3B, 0x0D, 0x48, 0x1C, 0xF4, 0x



-MetroHash64::MetroHash64(const uint64_t seed)
+MetroHash64::MetroHash64(uint64_t seed)
 {
    Initialize(seed);
 }


-void MetroHash64::Initialize(const uint64_t seed)
+void MetroHash64::Initialize(uint64_t seed)
 {
    vseed = (static_cast<uint64_t>(seed) + k2) * k0;

@ -47,7 +47,7 @@ void MetroHash64::Initialize(const uint64_t seed)
 }


-void MetroHash64::Update(const uint8_t * const buffer, const uint64_t length)
+void MetroHash64::Update(const uint8_t * const buffer, uint64_t length)
 {
    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(buffer);
    const uint8_t * const end = ptr + length;
@ -62,7 +62,7 @@ void MetroHash64::Update(const uint8_t * const buffer, const uint64_t length)
        memcpy(input.b + (bytes % 32), ptr, static_cast<size_t>(fill));
        ptr   += fill;
        bytes += fill;
-        
+
        // input buffer is still partially filled
        if ((bytes % 32) != 0) return;

@ -72,7 +72,7 @@ void MetroHash64::Update(const uint8_t * const buffer, const uint64_t length)
        state.v[2] += read_u64(&input.b[16]) * k2; state.v[2] = rotate_right(state.v[2],29) + state.v[0];
        state.v[3] += read_u64(&input.b[24]) * k3; state.v[3] = rotate_right(state.v[3],29) + state.v[1];
    }
-    
+
    // bulk update
    bytes += static_cast<uint64_t>(end - ptr);
    while (ptr <= (end - 32))
@ -83,14 +83,14 @@ void MetroHash64::Update(const uint8_t * const buffer, const uint64_t length)
        state.v[2] += read_u64(ptr) * k2; ptr += 8; state.v[2] = rotate_right(state.v[2],29) + state.v[0];
        state.v[3] += read_u64(ptr) * k3; ptr += 8; state.v[3] = rotate_right(state.v[3],29) + state.v[1];
    }
-    
+
    // store remaining bytes in input buffer
    if (ptr < end)
        memcpy(input.b, ptr, static_cast<size_t>(end - ptr));
 }


-void MetroHash64::Finalize(uint8_t * const hash)
+void MetroHash64::Finalize(uint8_t * hash)
 {
    // finalize bulk loop, if used
    if (bytes >= 32)
@ -102,11 +102,11 @@ void MetroHash64::Finalize(uint8_t * const hash)

        state.v[0] = vseed + (state.v[0] ^ state.v[1]);
    }
-    
+
    // process any bytes remaining in the input buffer
    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(input.b);
    const uint8_t * const end = ptr + (bytes % 32);
-    
+
    if ((end - ptr) >= 16)
    {
        state.v[1]  = state.v[0] + (read_u64(ptr) * k2); ptr += 8; state.v[1] = rotate_right(state.v[1],29) * k3;
@ -139,7 +139,7 @@ void MetroHash64::Finalize(uint8_t * const hash)
        state.v[0] += read_u8 (ptr) * k3;
        state.v[0] ^= rotate_right(state.v[0], 37) * k1;
    }
-    
+
    state.v[0] ^= rotate_right(state.v[0], 28);
    state.v[0] *= k0;
    state.v[0] ^= rotate_right(state.v[0], 29);
@ -152,7 +152,7 @@ void MetroHash64::Finalize(uint8_t * const hash)
 }


-void MetroHash64::Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed)
+void MetroHash64::Hash(const uint8_t * buffer, uint64_t length, uint8_t * const hash, uint64_t seed)
 {
    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(buffer);
    const uint8_t * const end = ptr + length;
@ -238,7 +238,7 @@ bool MetroHash64::ImplementationVerified()

    // verify incremental implementation
    MetroHash64 metro;
-    
+
    metro.Initialize(0);
    metro.Update(reinterpret_cast<const uint8_t *>(MetroHash64::test_string), strlen(MetroHash64::test_string));
    metro.Finalize(hash);
@ -262,9 +262,9 @@ void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o

    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(key);
    const uint8_t * const end = ptr + len;
-    
+
    uint64_t hash = ((static_cast<uint64_t>(seed) + k2) * k0) + len;
-    
+
    if (len >= 32)
    {
        uint64_t v[4];
@ -272,7 +272,7 @@ void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
        v[1] = hash;
        v[2] = hash;
        v[3] = hash;
-        
+
        do
        {
            v[0] += read_u64(ptr) * k0; ptr += 8; v[0] = rotate_right(v[0],29) + v[2];
@ -288,7 +288,7 @@ void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
        v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 33) * k0;
        hash += v[0] ^ v[1];
    }
-    
+
    if ((end - ptr) >= 16)
    {
        uint64_t v0 = hash + (read_u64(ptr) * k0); ptr += 8; v0 = rotate_right(v0,33) * k1;
@ -297,32 +297,32 @@ void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
        v1 ^= rotate_right(v1 * k3, 35) + v0;
        hash += v1;
    }
-    
+
    if ((end - ptr) >= 8)
    {
        hash += read_u64(ptr) * k3; ptr += 8;
        hash ^= rotate_right(hash, 33) * k1;
-        
+
    }
-    
+
    if ((end - ptr) >= 4)
    {
        hash += read_u32(ptr) * k3; ptr += 4;
        hash ^= rotate_right(hash, 15) * k1;
    }
-    
+
    if ((end - ptr) >= 2)
    {
        hash += read_u16(ptr) * k3; ptr += 2;
        hash ^= rotate_right(hash, 13) * k1;
    }
-    
+
    if ((end - ptr) >= 1)
    {
        hash += read_u8 (ptr) * k3;
        hash ^= rotate_right(hash, 25) * k1;
    }
-    
+
    hash ^= rotate_right(hash, 33);
    hash *= k0;
    hash ^= rotate_right(hash, 33);
@ -336,13 +336,13 @@ void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
    static const uint64_t k0 = 0xD6D018F5;
    static const uint64_t k1 = 0xA2AA033B;
    static const uint64_t k2 = 0x62992FC1;
-    static const uint64_t k3 = 0x30BC5B29; 
+    static const uint64_t k3 = 0x30BC5B29;

    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(key);
    const uint8_t * const end = ptr + len;
-    
+
    uint64_t hash = ((static_cast<uint64_t>(seed) + k2) * k0) + len;
-    
+
    if (len >= 32)
    {
        uint64_t v[4];
@ -350,7 +350,7 @@ void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
        v[1] = hash;
        v[2] = hash;
        v[3] = hash;
-        
+
        do
        {
            v[0] += read_u64(ptr) * k0; ptr += 8; v[0] = rotate_right(v[0],29) + v[2];
@ -366,7 +366,7 @@ void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
        v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 30) * k0;
        hash += v[0] ^ v[1];
    }
-    
+
    if ((end - ptr) >= 16)
    {
        uint64_t v0 = hash + (read_u64(ptr) * k2); ptr += 8; v0 = rotate_right(v0,29) * k3;
@ -375,31 +375,31 @@ void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
        v1 ^= rotate_right(v1 * k3, 34) + v0;
        hash += v1;
    }
-    
+
    if ((end - ptr) >= 8)
    {
        hash += read_u64(ptr) * k3; ptr += 8;
        hash ^= rotate_right(hash, 36) * k1;
    }
-    
+
    if ((end - ptr) >= 4)
    {
        hash += read_u32(ptr) * k3; ptr += 4;
        hash ^= rotate_right(hash, 15) * k1;
    }
-    
+
    if ((end - ptr) >= 2)
    {
        hash += read_u16(ptr) * k3; ptr += 2;
        hash ^= rotate_right(hash, 15) * k1;
    }
-    
+
    if ((end - ptr) >= 1)
    {
        hash += read_u8 (ptr) * k3;
        hash ^= rotate_right(hash, 23) * k1;
    }
-    
+
    hash ^= rotate_right(hash, 28);
    hash *= k0;
    hash ^= rotate_right(hash, 29);
--- a/contrib/libmetrohash/src/metrohash64.h
+++ b/contrib/libmetrohash/src/metrohash64.h
@ -25,24 +25,24 @@ public:
    static const uint32_t bits = 64;

    // Constructor initializes the same as Initialize()
-    explicit MetroHash64(const uint64_t seed=0);
+    explicit MetroHash64(uint64_t seed=0);

    // Initializes internal state for new hash with optional seed
-    void Initialize(const uint64_t seed=0);
+    void Initialize(uint64_t seed=0);

    // Update the hash state with a string of bytes. If the length
    // is sufficiently long, the implementation switches to a bulk
    // hashing algorithm directly on the argument buffer for speed.
-    void Update(const uint8_t * buffer, const uint64_t length);
+    void Update(const uint8_t * buffer, uint64_t length);

    // Constructs the final hash and writes it to the argument buffer.
    // After a hash is finalized, this instance must be Initialized()-ed
    // again or the behavior of Update() and Finalize() is undefined.
-    void Finalize(uint8_t * const hash);
+    void Finalize(uint8_t * hash);

    // A non-incremental function implementation. This can be significantly
    // faster than the incremental implementation for some usage patterns.
-    static void Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed=0);
+    static void Hash(const uint8_t * buffer, uint64_t length, uint8_t * hash, uint64_t seed=0);

    // Does implementation correctly execute test vectors?
    static bool ImplementationVerified();
--- a/docker/test/fuzzer/run-fuzzer.sh
+++ b/docker/test/fuzzer/run-fuzzer.sh
@ -174,7 +174,14 @@ function fuzz
    mkdir -p /var/run/clickhouse-server

    # NOTE: we use process substitution here to preserve keep $! as a pid of clickhouse-server
-    clickhouse-server --config-file db/config.xml --pid-file /var/run/clickhouse-server/clickhouse-server.pid -- --path db > server.log 2>&1 &
+    # server.log -> CH logs
+    # stderr.log -> Process logs (sanitizer)
+    clickhouse-server \
+        --config-file db/config.xml \
+        --pid-file /var/run/clickhouse-server/clickhouse-server.pid \
+        --  --path db \
+            --logger.console=0 \
+            --logger.log=server.log > stderr.log 2>&1 &
    server_pid=$!

    kill -0 $server_pid
@ -303,7 +310,7 @@ quit
    if [ "$server_died" == 1 ]
    then
        # The server has died.
-        if ! rg --text -o 'Received signal.*|Logical error.*|Assertion.*failed|Failed assertion.*|.*runtime error: .*|.*is located.*|(SUMMARY|ERROR): [a-zA-Z]+Sanitizer:.*|.*_LIBCPP_ASSERT.*|.*Child process was terminated by signal 9.*' server.log > description.txt
+        if ! rg --text -o 'Received signal.*|Logical error.*|Assertion.*failed|Failed assertion.*|.*runtime error: .*|.*is located.*|(SUMMARY|ERROR): [a-zA-Z]+Sanitizer:.*|.*_LIBCPP_ASSERT.*|.*Child process was terminated by signal 9.*' server.log stderr.log > description.txt
        then
            echo "Lost connection to server. See the logs." > description.txt
        fi
@ -427,6 +434,7 @@ p.links a { padding: 5px; margin: 3px; background: #FFF; line-height: 2; white-s
  <a href="run.log">run.log</a>
  <a href="fuzzer.log.zst">fuzzer.log.zst</a>
  <a href="server.log.zst">server.log.zst</a>
+  <a href="stderr.log">stderr.log</a>
  <a href="main.log">main.log</a>
  <a href="dmesg.log">dmesg.log</a>
  ${CORE_LINK}
--- a/docker/test/stateless/run.sh
+++ b/docker/test/stateless/run.sh
@ -61,6 +61,18 @@ if [[ -n "$BUGFIX_VALIDATE_CHECK" ]] && [[ "$BUGFIX_VALIDATE_CHECK" -eq 1 ]]; th
    rm /etc/clickhouse-server/users.d/s3_cache_new.xml
    rm /etc/clickhouse-server/config.d/zero_copy_destructive_operations.xml

+    #todo: remove these after 24.3 released.
+    sudo cat /etc/clickhouse-server/config.d/azure_storage_conf.xml \
+      | sed "s|<object_storage_type>azure|<object_storage_type>azure_blob_storage|" \
+      > /etc/clickhouse-server/config.d/azure_storage_conf.xml.tmp
+    sudo mv /etc/clickhouse-server/config.d/azure_storage_conf.xml.tmp /etc/clickhouse-server/config.d/azure_storage_conf.xml
+
+    #todo: remove these after 24.3 released.
+    sudo cat /etc/clickhouse-server/config.d/storage_conf.xml \
+      | sed "s|<object_storage_type>local|<object_storage_type>local_blob_storage|" \
+      > /etc/clickhouse-server/config.d/storage_conf.xml.tmp
+    sudo mv /etc/clickhouse-server/config.d/storage_conf.xml.tmp /etc/clickhouse-server/config.d/storage_conf.xml
+
    function remove_keeper_config()
    {
        sudo cat /etc/clickhouse-server/config.d/keeper_port.xml \
@ -77,7 +89,7 @@ fi
 if [ "$NUM_TRIES" -gt "1" ]; then
    export THREAD_FUZZER_CPU_TIME_PERIOD_US=1000
    export THREAD_FUZZER_SLEEP_PROBABILITY=0.1
-    export THREAD_FUZZER_SLEEP_TIME_US=100000
+    export THREAD_FUZZER_SLEEP_TIME_US_MAX=100000

    export THREAD_FUZZER_pthread_mutex_lock_BEFORE_MIGRATE_PROBABILITY=1
    export THREAD_FUZZER_pthread_mutex_lock_AFTER_MIGRATE_PROBABILITY=1
@ -88,10 +100,10 @@ if [ "$NUM_TRIES" -gt "1" ]; then
    export THREAD_FUZZER_pthread_mutex_lock_AFTER_SLEEP_PROBABILITY=0.001
    export THREAD_FUZZER_pthread_mutex_unlock_BEFORE_SLEEP_PROBABILITY=0.001
    export THREAD_FUZZER_pthread_mutex_unlock_AFTER_SLEEP_PROBABILITY=0.001
-    export THREAD_FUZZER_pthread_mutex_lock_BEFORE_SLEEP_TIME_US=10000
-    export THREAD_FUZZER_pthread_mutex_lock_AFTER_SLEEP_TIME_US=10000
-    export THREAD_FUZZER_pthread_mutex_unlock_BEFORE_SLEEP_TIME_US=10000
-    export THREAD_FUZZER_pthread_mutex_unlock_AFTER_SLEEP_TIME_US=10000
+    export THREAD_FUZZER_pthread_mutex_lock_BEFORE_SLEEP_TIME_US_MAX=10000
+    export THREAD_FUZZER_pthread_mutex_lock_AFTER_SLEEP_TIME_US_MAX=10000
+    export THREAD_FUZZER_pthread_mutex_unlock_BEFORE_SLEEP_TIME_US_MAX=10000
+    export THREAD_FUZZER_pthread_mutex_unlock_AFTER_SLEEP_TIME_US_MAX=10000

    mkdir -p /var/run/clickhouse-server
    # simplest way to forward env variables to server
--- a/docker/test/stateless/stress_tests.lib
+++ b/docker/test/stateless/stress_tests.lib
@ -215,7 +215,7 @@ function check_server_start()
 function check_logs_for_critical_errors()
 {
    # Sanitizer asserts
-    sed -n '/WARNING:.*anitizer/,/^$/p' >> /test_output/tmp
+    sed -n '/WARNING:.*anitizer/,/^$/p' /var/log/clickhouse-server/stderr.log >> /test_output/tmp
    rg -Fav -e "ASan doesn't fully support makecontext/swapcontext functions" -e "DB::Exception" /test_output/tmp > /dev/null \
        && echo -e "Sanitizer assert (in stderr.log)$FAIL$(head_escaped /test_output/tmp)" >> /test_output/test_results.tsv \
        || echo -e "No sanitizer asserts$OK" >> /test_output/test_results.tsv
--- a/docker/test/stress/run.sh
+++ b/docker/test/stress/run.sh
@ -27,7 +27,7 @@ install_packages package_folder
 # and find more potential issues.
 export THREAD_FUZZER_CPU_TIME_PERIOD_US=1000
 export THREAD_FUZZER_SLEEP_PROBABILITY=0.1
-export THREAD_FUZZER_SLEEP_TIME_US=100000
+export THREAD_FUZZER_SLEEP_TIME_US_MAX=100000

 export THREAD_FUZZER_pthread_mutex_lock_BEFORE_MIGRATE_PROBABILITY=1
 export THREAD_FUZZER_pthread_mutex_lock_AFTER_MIGRATE_PROBABILITY=1
@ -38,11 +38,11 @@ export THREAD_FUZZER_pthread_mutex_lock_BEFORE_SLEEP_PROBABILITY=0.001
 export THREAD_FUZZER_pthread_mutex_lock_AFTER_SLEEP_PROBABILITY=0.001
 export THREAD_FUZZER_pthread_mutex_unlock_BEFORE_SLEEP_PROBABILITY=0.001
 export THREAD_FUZZER_pthread_mutex_unlock_AFTER_SLEEP_PROBABILITY=0.001
-export THREAD_FUZZER_pthread_mutex_lock_BEFORE_SLEEP_TIME_US=10000
+export THREAD_FUZZER_pthread_mutex_lock_BEFORE_SLEEP_TIME_US_MAX=10000

-export THREAD_FUZZER_pthread_mutex_lock_AFTER_SLEEP_TIME_US=10000
-export THREAD_FUZZER_pthread_mutex_unlock_BEFORE_SLEEP_TIME_US=10000
-export THREAD_FUZZER_pthread_mutex_unlock_AFTER_SLEEP_TIME_US=10000
+export THREAD_FUZZER_pthread_mutex_lock_AFTER_SLEEP_TIME_US_MAX=10000
+export THREAD_FUZZER_pthread_mutex_unlock_BEFORE_SLEEP_TIME_US_MAX=10000
+export THREAD_FUZZER_pthread_mutex_unlock_AFTER_SLEEP_TIME_US_MAX=10000

 export THREAD_FUZZER_EXPLICIT_SLEEP_PROBABILITY=0.01
 export THREAD_FUZZER_EXPLICIT_MEMORY_EXCEPTION_PROBABILITY=0.01
--- a/docs/en/engines/table-engines/integrations/jdbc.md
+++ b/docs/en/engines/table-engines/integrations/jdbc.md
@ -6,6 +6,11 @@ sidebar_label: JDBC

 # JDBC

+:::note
+clickhouse-jdbc-bridge contains experimental codes and is no longer supported. It may contain reliability issues and security vulnerabilities. Use it at your own risk. 
+ClickHouse recommend using built-in table functions in ClickHouse which provide a better alternative for ad-hoc querying scenarios (Postgres, MySQL, MongoDB, etc).
+:::
+
 Allows ClickHouse to connect to external databases via [JDBC](https://en.wikipedia.org/wiki/Java_Database_Connectivity).

 To implement the JDBC connection, ClickHouse uses the separate program [clickhouse-jdbc-bridge](https://github.com/ClickHouse/clickhouse-jdbc-bridge) that should run as a daemon.
--- a/docs/en/engines/table-engines/special/memory.md
+++ b/docs/en/engines/table-engines/special/memory.md
@ -21,3 +21,79 @@ When restarting a server, data disappears from the table and the table becomes e
 Normally, using this table engine is not justified. However, it can be used for tests, and for tasks where maximum speed is required on a relatively small number of rows (up to approximately 100,000,000).

 The Memory engine is used by the system for temporary tables with external query data (see the section “External data for processing a query”), and for implementing `GLOBAL IN` (see the section “IN operators”).
+
+Upper and lower bounds can be specified to limit Memory engine table size, effectively allowing it to act as a circular buffer (see [Engine Parameters](#engine-parameters)).
+
+## Engine Parameters {#engine-parameters}
+
+- `min_bytes_to_keep` — Minimum bytes to keep when memory table is size-capped.
+  - Default value: `0`
+  - Requires `max_bytes_to_keep`
+- `max_bytes_to_keep` — Maximum bytes to keep within memory table where oldest rows are deleted on each insertion (i.e circular buffer). Max bytes can exceed the stated limit if the oldest batch of rows to remove falls under the `min_bytes_to_keep` limit when adding a large block.
+  - Default value: `0`
+- `min_rows_to_keep` — Minimum rows to keep when memory table is size-capped.
+  - Default value: `0`
+  - Requires `max_rows_to_keep`
+- `max_rows_to_keep` — Maximum rows to keep within memory table where oldest rows are deleted on each insertion (i.e circular buffer). Max rows can exceed the stated limit if the oldest batch of rows to remove falls under the `min_rows_to_keep` limit when adding a large block.
+  - Default value: `0`
+
+## Usage {#usage}
+
+
+**Initialize settings**
+``` sql
+CREATE TABLE memory (i UInt32) ENGINE = Memory SETTINGS min_rows_to_keep = 100, max_rows_to_keep = 1000;
+```
+
+**Note:** Both `bytes` and `rows` capping parameters can be set at the same time, however, the lower bounds of `max` and `min` will be adhered to.
+
+## Examples {#examples}
+``` sql
+CREATE TABLE memory (i UInt32) ENGINE = Memory SETTINGS min_bytes_to_keep = 4096, max_bytes_to_keep = 16384;
+
+/* 1. testing oldest block doesn't get deleted due to min-threshold - 3000 rows */
+INSERT INTO memory SELECT * FROM numbers(0, 1600); -- 8'192 bytes
+
+/* 2. adding block that doesn't get deleted */
+INSERT INTO memory SELECT * FROM numbers(1000, 100); -- 1'024 bytes
+
+/* 3. testing oldest block gets deleted - 9216 bytes - 1100 */
+INSERT INTO memory SELECT * FROM numbers(9000, 1000); -- 8'192 bytes
+
+/* 4. checking a very large block overrides all */
+INSERT INTO memory SELECT * FROM numbers(9000, 10000); -- 65'536 bytes
+
+SELECT total_bytes, total_rows FROM system.tables WHERE name = 'memory' and database = currentDatabase();
+```
+
+``` text
+┌─total_bytes─┬─total_rows─┐
+│       65536 │      10000 │
+└─────────────┴────────────┘
+```
+
+also, for rows:
+
+``` sql
+CREATE TABLE memory (i UInt32) ENGINE = Memory SETTINGS min_rows_to_keep = 4000, max_rows_to_keep = 10000;
+
+/* 1. testing oldest block doesn't get deleted due to min-threshold - 3000 rows */
+INSERT INTO memory SELECT * FROM numbers(0, 1600); -- 1'600 rows
+
+/* 2. adding block that doesn't get deleted */
+INSERT INTO memory SELECT * FROM numbers(1000, 100); -- 100 rows
+
+/* 3. testing oldest block gets deleted - 9216 bytes - 1100 */
+INSERT INTO memory SELECT * FROM numbers(9000, 1000); -- 1'000 rows
+
+/* 4. checking a very large block overrides all */
+INSERT INTO memory SELECT * FROM numbers(9000, 10000); -- 10'000 rows
+
+SELECT total_bytes, total_rows FROM system.tables WHERE name = 'memory' and database = currentDatabase();
+```
+
+``` text
+┌─total_bytes─┬─total_rows─┐
+│       65536 │      10000 │
+└─────────────┴────────────┘
+```
--- a/docs/en/getting-started/example-datasets/tw-weather.md
+++ b/docs/en/getting-started/example-datasets/tw-weather.md
@ -0,0 +1,293 @@
+---
+slug: /en/getting-started/example-datasets/tw-weather
+sidebar_label: Taiwan Historical Weather Datasets
+sidebar_position: 1
+description: 131 million rows of weather observation data for the last 128 yrs
+---
+
+# Taiwan Historical Weather Datasets
+
+This dataset contains historical meteorological observations measurements for the last 128 years. Each row is a measurement for a point in date time and weather station.
+
+The origin of this dataset is available [here](https://github.com/Raingel/historical_weather) and the list of weather station numbers can be found [here](https://github.com/Raingel/weather_station_list).
+
+> The sources of meteorological datasets include the meteorological stations that are established by the Central Weather Administration (station code is beginning with C0, C1, and 4) and the agricultural meteorological stations belonging to the Council of Agriculture (station code other than those mentioned above):
+
+    - StationId
+    - MeasuredDate, the observation time
+    - StnPres, the station air pressure
+    - SeaPres, the sea level pressure
+    - Td, the dew point temperature
+    - RH, the relative humidity
+    - Other elements where available
+
+## Downloading the data
+
+- A [pre-processed version](#pre-processed-data) of the data for the ClickHouse, which has been cleaned, re-structured, and enriched. This dataset covers the years from 1896 to 2023.
+- [Download the original raw data](#original-raw-data) and convert to the format required by ClickHouse. Users wanting to add their own columns may wish to explore or complete their approaches.
+
+### Pre-processed data
+
+The dataset has also been re-structured from a measurement per line to a row per weather station id and measured date, i.e.
+
+```csv
+StationId,MeasuredDate,StnPres,Tx,RH,WS,WD,WSGust,WDGust,Precp,GloblRad,TxSoil0cm,TxSoil5cm,TxSoil20cm,TxSoil50cm,TxSoil100cm,SeaPres,Td,PrecpHour,SunShine,TxSoil10cm,EvapA,Visb,UVI,Cloud Amount,TxSoil30cm,TxSoil200cm,TxSoil300cm,TxSoil500cm,VaporPressure
+C0X100,2016-01-01 01:00:00,1022.1,16.1,72,1.1,8.0,,,,,,,,,,,,,,,,,,,,,,,
+C0X100,2016-01-01 02:00:00,1021.6,16.0,73,1.2,358.0,,,,,,,,,,,,,,,,,,,,,,,
+C0X100,2016-01-01 03:00:00,1021.3,15.8,74,1.5,353.0,,,,,,,,,,,,,,,,,,,,,,,
+C0X100,2016-01-01 04:00:00,1021.2,15.8,74,1.7,8.0,,,,,,,,,,,,,,,,,,,,,,,
+```
+
+It is easy to query and ensure that the resulting table has less sparse and some elements are null because they're not available to be measured in this weather station.
+
+This dataset is available in the following Google CloudStorage location. Either download the dataset to your local filesystem (and insert them with the ClickHouse client) or insert them directly into the ClickHouse (see [Inserting from URL](#inserting-from-url)).
+
+To download:
+
+```bash
+wget https://storage.googleapis.com/taiwan-weather-observaiton-datasets/preprocessed_weather_daily_1896_2023.tar.gz
+
+# Option: Validate the checksum
+md5sum preprocessed_weather_daily_1896_2023.tar.gz
+# Checksum should be equal to: 11b484f5bd9ddafec5cfb131eb2dd008
+
+tar -xzvf preprocessed_weather_daily_1896_2023.tar.gz
+daily_weather_preprocessed_1896_2023.csv
+
+# Option: Validate the checksum
+md5sum daily_weather_preprocessed_1896_2023.csv
+# Checksum should be equal to: 1132248c78195c43d93f843753881754
+```
+
+### Original raw data
+
+The following details are about the steps to download the original raw data to transform and convert as you want.
+
+#### Download
+
+To download the original raw data:
+
+```bash
+mkdir tw_raw_weather_data && cd tw_raw_weather_data
+
+wget https://storage.googleapis.com/taiwan-weather-observaiton-datasets/raw_data_weather_daily_1896_2023.tar.gz
+
+# Option: Validate the checksum
+md5sum raw_data_weather_daily_1896_2023.tar.gz
+# Checksum should be equal to: b66b9f137217454d655e3004d7d1b51a
+
+tar -xzvf raw_data_weather_daily_1896_2023.tar.gz
+466920_1928.csv
+466920_1929.csv
+466920_1930.csv
+466920_1931.csv
+...
+
+# Option: Validate the checksum
+cat *.csv | md5sum
+# Checksum should be equal to: b26db404bf84d4063fac42e576464ce1
+```
+
+#### Retrieve the Taiwan weather stations
+
+```bash
+wget -O weather_sta_list.csv https://github.com/Raingel/weather_station_list/raw/main/data/weather_sta_list.csv
+
+# Option: Convert the UTF-8-BOM to UTF-8 encoding
+sed -i '1s/^\xEF\xBB\xBF//' weather_sta_list.csv
+```
+
+## Create table schema
+
+Create the MergeTree table in ClickHouse (from the ClickHouse client).
+
+```bash
+CREATE TABLE tw_weather_data (
+    StationId String null,
+    MeasuredDate DateTime64,
+    StnPres Float64 null,
+    SeaPres Float64 null,
+    Tx Float64 null,
+    Td Float64 null,
+    RH Float64 null,
+    WS Float64 null,
+    WD Float64 null,
+    WSGust Float64 null,
+    WDGust Float64 null,
+    Precp Float64 null,
+    PrecpHour Float64 null,
+    SunShine Float64 null,
+    GloblRad Float64 null,
+    TxSoil0cm Float64 null,
+    TxSoil5cm Float64 null,
+    TxSoil10cm Float64 null,
+    TxSoil20cm Float64 null,
+    TxSoil50cm Float64 null,
+    TxSoil100cm Float64 null,
+    TxSoil30cm Float64 null,
+    TxSoil200cm Float64 null,
+    TxSoil300cm Float64 null,
+    TxSoil500cm Float64 null,
+    VaporPressure Float64 null,
+    UVI Float64 null,
+    "Cloud Amount" Float64 null,
+    EvapA Float64 null,
+    Visb Float64 null
+)
+ENGINE = MergeTree
+ORDER BY (MeasuredDate);
+```
+
+## Inserting into ClickHouse
+
+### Inserting from local file
+
+Data can be inserted from a local file as follows (from the ClickHouse client):
+
+```sql
+INSERT INTO tw_weather_data FROM INFILE '/path/to/daily_weather_preprocessed_1896_2023.csv'
+```
+
+where `/path/to` represents the specific user path to the local file on the disk.
+
+And the sample response output is as follows after inserting data into the ClickHouse:
+
+```response
+Query id: 90e4b524-6e14-4855-817c-7e6f98fbeabb
+
+Ok.
+131985329 rows in set. Elapsed: 71.770 sec. Processed 131.99 million rows, 10.06 GB (1.84 million rows/s., 140.14 MB/s.)
+Peak memory usage: 583.23 MiB.
+```
+
+### Inserting from URL
+
+```sql
+INSERT INTO tw_weather_data SELECT *
+FROM url('https://storage.googleapis.com/taiwan-weather-observaiton-datasets/daily_weather_preprocessed_1896_2023.csv', 'CSVWithNames')
+
+```
+To know how to speed this up, please see our blog post on [tuning large data loads](https://clickhouse.com/blog/supercharge-your-clickhouse-data-loads-part2).
+
+## Check data rows and sizes
+
+1. Let's see how many rows are inserted:
+
+```sql
+SELECT formatReadableQuantity(count())
+FROM tw_weather_data;
+```
+
+```response
+┌─formatReadableQuantity(count())─┐
+│ 131.99 million                  │
+└─────────────────────────────────┘
+```
+
+2. Let's see how much disk space are used for this table:
+
+```sql
+SELECT
+    formatReadableSize(sum(bytes)) AS disk_size,
+    formatReadableSize(sum(data_uncompressed_bytes)) AS uncompressed_size
+FROM system.parts
+WHERE (`table` = 'tw_weather_data') AND active
+```
+
+```response
+┌─disk_size─┬─uncompressed_size─┐
+│ 2.13 GiB  │ 32.94 GiB         │
+└───────────┴───────────────────┘
+```
+
+## Sample queries
+
+### Q1: Retrieve the highest dew point temperature for each weather station in the specific year
+
+```sql
+SELECT
+    StationId,
+    max(Td) AS max_td
+FROM tw_weather_data
+WHERE (year(MeasuredDate) = 2023) AND (Td IS NOT NULL)
+GROUP BY StationId
+
+┌─StationId─┬─max_td─┐
+│ 466940    │      1 │
+│ 467300    │      1 │
+│ 467540    │      1 │
+│ 467490    │      1 │
+│ 467080    │      1 │
+│ 466910    │      1 │
+│ 467660    │      1 │
+│ 467270    │      1 │
+│ 467350    │      1 │
+│ 467571    │      1 │
+│ 466920    │      1 │
+│ 467650    │      1 │
+│ 467550    │      1 │
+│ 467480    │      1 │
+│ 467610    │      1 │
+│ 467050    │      1 │
+│ 467590    │      1 │
+│ 466990    │      1 │
+│ 467060    │      1 │
+│ 466950    │      1 │
+│ 467620    │      1 │
+│ 467990    │      1 │
+│ 466930    │      1 │
+│ 467110    │      1 │
+│ 466881    │      1 │
+│ 467410    │      1 │
+│ 467441    │      1 │
+│ 467420    │      1 │
+│ 467530    │      1 │
+│ 466900    │      1 │
+└───────────┴────────┘
+
+30 rows in set. Elapsed: 0.045 sec. Processed 6.41 million rows, 187.33 MB (143.92 million rows/s., 4.21 GB/s.)
+```
+
+### Q2: Raw data fetching with the specific duration time range, fields and weather station
+
+```sql
+SELECT
+    StnPres,
+    SeaPres,
+    Tx,
+    Td,
+    RH,
+    WS,
+    WD,
+    WSGust,
+    WDGust,
+    Precp,
+    PrecpHour
+FROM tw_weather_data
+WHERE (StationId = 'C0UB10') AND (MeasuredDate >= '2023-12-23') AND (MeasuredDate < '2023-12-24')
+ORDER BY MeasuredDate ASC
+LIMIT 10
+```
+
+```response
+┌─StnPres─┬─SeaPres─┬───Tx─┬───Td─┬─RH─┬──WS─┬──WD─┬─WSGust─┬─WDGust─┬─Precp─┬─PrecpHour─┐
+│  1029.5 │    ᴺᵁᴸᴸ │ 11.8 │ ᴺᵁᴸᴸ │ 78 │ 2.7 │ 271 │    5.5 │    275 │ -99.8 │     -99.8 │
+│  1029.8 │    ᴺᵁᴸᴸ │ 12.3 │ ᴺᵁᴸᴸ │ 78 │ 2.7 │ 289 │    5.5 │    308 │ -99.8 │     -99.8 │
+│  1028.6 │    ᴺᵁᴸᴸ │ 12.3 │ ᴺᵁᴸᴸ │ 79 │ 2.3 │ 251 │    6.1 │    289 │ -99.8 │     -99.8 │
+│  1028.2 │    ᴺᵁᴸᴸ │   13 │ ᴺᵁᴸᴸ │ 75 │ 4.3 │ 312 │    7.5 │    316 │ -99.8 │     -99.8 │
+│  1027.8 │    ᴺᵁᴸᴸ │ 11.1 │ ᴺᵁᴸᴸ │ 89 │ 7.1 │ 310 │   11.6 │    322 │ -99.8 │     -99.8 │
+│  1027.8 │    ᴺᵁᴸᴸ │ 11.6 │ ᴺᵁᴸᴸ │ 90 │ 3.1 │ 269 │   10.7 │    295 │ -99.8 │     -99.8 │
+│  1027.9 │    ᴺᵁᴸᴸ │ 12.3 │ ᴺᵁᴸᴸ │ 89 │ 4.7 │ 296 │    8.1 │    310 │ -99.8 │     -99.8 │
+│  1028.2 │    ᴺᵁᴸᴸ │ 12.2 │ ᴺᵁᴸᴸ │ 94 │ 2.5 │ 246 │    7.1 │    283 │ -99.8 │     -99.8 │
+│  1028.4 │    ᴺᵁᴸᴸ │ 12.5 │ ᴺᵁᴸᴸ │ 94 │ 3.1 │ 265 │    4.8 │    297 │ -99.8 │     -99.8 │
+│  1028.3 │    ᴺᵁᴸᴸ │ 13.6 │ ᴺᵁᴸᴸ │ 91 │ 1.2 │ 273 │    4.4 │    256 │ -99.8 │     -99.8 │
+└─────────┴─────────┴──────┴──────┴────┴─────┴─────┴────────┴────────┴───────┴───────────┘
+
+10 rows in set. Elapsed: 0.009 sec. Processed 91.70 thousand rows, 2.33 MB (9.67 million rows/s., 245.31 MB/s.)
+```
+
+## Credits
+
+We would like to acknowledge the efforts of the Central Weather Administration and Agricultural Meteorological Observation Network (Station) of the Council of Agriculture for preparing, cleaning, and distributing this dataset. We appreciate your efforts.
+
+Ou, J.-H., Kuo, C.-H., Wu, Y.-F., Lin, G.-C., Lee, M.-H., Chen, R.-K., Chou, H.-P., Wu, H.-Y., Chu, S.-C., Lai, Q.-J., Tsai, Y.-C., Lin, C.-C., Kuo, C.-C., Liao, C.-T., Chen, Y.-N., Chu, Y.-W., Chen, C.-Y., 2023. Application-oriented deep learning model for early warning of rice blast in Taiwan. Ecological Informatics 73, 101950. https://doi.org/10.1016/j.ecoinf.2022.101950 [13/12/2022]
--- a/docs/en/interfaces/cli.md
+++ b/docs/en/interfaces/cli.md
@ -178,7 +178,7 @@ You can pass parameters to `clickhouse-client` (all parameters have a default va
 - `--password` – The password. Default value: empty string.
 - `--ask-password` - Prompt the user to enter a password.
 - `--query, -q` – The query to process when using non-interactive mode. `--query` can be specified multiple times, e.g. `--query "SELECT 1" --query "SELECT 2"`. Cannot be used simultaneously with `--queries-file`.
- `--queries-file` – file path with queries to execute. `--queries-file` can be specified multiple times, e.g. `--query queries1.sql --query queries2.sql`. Cannot be used simultaneously with `--query`.
+- `--queries-file` – file path with queries to execute. `--queries-file` can be specified multiple times, e.g. `--queries-file  queries1.sql --queries-file  queries2.sql`. Cannot be used simultaneously with `--query`.
 - `--multiquery, -n` – If specified, multiple queries separated by semicolons can be listed after the `--query` option. For convenience, it is also possible to omit `--query` and pass the queries directly after `--multiquery`.
 - `--multiline, -m` – If specified, allow multiline queries (do not send the query on Enter).
 - `--database, -d` – Select the current default database. Default value: the current database from the server settings (‘default’ by default).
--- a/docs/en/operations/configuration-files.md
+++ b/docs/en/operations/configuration-files.md
@ -95,9 +95,11 @@ which is equal to

 ## Substituting Configuration {#substitution}

-The config can also define “substitutions”. If an element has the `incl` attribute, the corresponding substitution from the file will be used as the value. By default, the path to the file with substitutions is `/etc/metrika.xml`. This can be changed in the [include_from](../operations/server-configuration-parameters/settings.md#server_configuration_parameters-include_from) element in the server config. The substitution values are specified in `/clickhouse/substitution_name` elements in this file. If a substitution specified in `incl` does not exist, it is recorded in the log. To prevent ClickHouse from logging missing substitutions, specify the `optional="true"` attribute (for example, settings for [macros](../operations/server-configuration-parameters/settings.md#macros)).
+The config can define substitutions. There are two types of substitutions:

-If you want to replace an entire element with a substitution use `include` as the element name.
+- If an element has the `incl` attribute, the corresponding substitution from the file will be used as the value. By default, the path to the file with substitutions is `/etc/metrika.xml`. This can be changed in the [include_from](../operations/server-configuration-parameters/settings.md#server_configuration_parameters-include_from) element in the server config. The substitution values are specified in `/clickhouse/substitution_name` elements in this file. If a substitution specified in `incl` does not exist, it is recorded in the log. To prevent ClickHouse from logging missing substitutions, specify the `optional="true"` attribute (for example, settings for [macros](../operations/server-configuration-parameters/settings.md#macros)).
+
+- If you want to replace an entire element with a substitution, use `include` as the element name. Substitutions can also be performed from ZooKeeper by specifying attribute `from_zk = "/path/to/node"`. In this case, the element value is replaced with the contents of the Zookeeper node at `/path/to/node`. This also works with you store an entire XML subtree as a Zookeeper node, it will be fully inserted into the source element.

 XML substitution example:

@ -114,7 +116,7 @@ XML substitution example:
 </clickhouse>
 ```

-Substitutions can also be performed from ZooKeeper. To do this, specify the attribute `from_zk = "/path/to/node"`. The element value is replaced with the contents of the node at `/path/to/node` in ZooKeeper. You can also put an entire XML subtree on the ZooKeeper node, and it will be fully inserted into the source element.
+If you want to merge the substituting content with the existing configuration instead of appending you can use attribute `merge="true"`, for example: `<include from_zk="/some_path" merge="true">`. In this case, the existing configuration will be merged with the content from the substitution and the existing configuration settings will be replaced with values from substitution.

 ## Encrypting and Hiding Configuration {#encryption}

--- a/docs/en/operations/server-configuration-parameters/settings.md
+++ b/docs/en/operations/server-configuration-parameters/settings.md
@ -933,9 +933,9 @@ Hard limit is configured via system tools

 ## database_atomic_delay_before_drop_table_sec {#database_atomic_delay_before_drop_table_sec}

-Sets the delay before remove table data in seconds. If the query has `SYNC` modifier, this setting is ignored.
+The delay before a table data is dropped in seconds. If the `DROP TABLE` query has a `SYNC` modifier, this setting is ignored.

-Default value: `480` (8 minute).
+Default value: `480` (8 minutes).

 ## database_catalog_unused_dir_hide_timeout_sec {#database_catalog_unused_dir_hide_timeout_sec}

--- a/docs/en/operations/settings/settings.md
+++ b/docs/en/operations/settings/settings.md
@ -4337,6 +4337,18 @@ Possible values:

 Default value: `0`.

+
+## function_locate_has_mysql_compatible_argument_order {#function-locate-has-mysql-compatible-argument-order}
+
+Controls the order of arguments in function [locate](../../sql-reference/functions/string-search-functions.md#locate).
+
+Possible values:
+
+- 0 — Function `locate` accepts arguments `(haystack, needle[, start_pos])`.
+- 1 — Function `locate` accepts arguments `(needle, haystack, [, start_pos])` (MySQL-compatible behavior)
+
+Default value: `1`.
+
 ## date_time_overflow_behavior {#date_time_overflow_behavior}

 Defines the behavior when [Date](../../sql-reference/data-types/date.md), [Date32](../../sql-reference/data-types/date32.md), [DateTime](../../sql-reference/data-types/datetime.md), [DateTime64](../../sql-reference/data-types/datetime64.md) or integers are converted into Date, Date32, DateTime or DateTime64 but the value cannot be represented in the result type.
--- a/docs/en/sql-reference/functions/geo/polygon.md
+++ b/docs/en/sql-reference/functions/geo/polygon.md
@ -4,6 +4,67 @@ sidebar_label: Polygons
 title: "Functions for Working with Polygons"
 ---

+## WKT
+
+Returns a WKT (Well Known Text) geometric object from various [Geo Data Types](../../data-types/geo.md). Supported WKT objects are: 
+
+- POINT
+- POLYGON
+- MULTIPOLYGON
+
+**Syntax**
+
+```sql
+WKT(geo_data)
+```
+
+**Parameters**
+
+`geo_data` can be one of the following [Geo Data Types](../../data-types/geo.md) or their underlying primitive types:
+
+- [Point](../../data-types/geo.md#point)
+- [Ring](../../data-types/geo.md#ring)
+- [Polygon](../../data-types/geo.md#polygon)
+- [MultiPolygon](../../data-types/geo.md#multipolygon)
+
+**Returned value**
+
+- WKT geometric object `POINT` is returned for a Point.
+- WKT geometric object `POLYGON` is returned for a Polygon
+- WKT geometric object `MULTIPOLYGON` is returned for a MultiPolygon. 
+
+**Examples**
+
+POINT from tuple:
+
+```sql
+SELECT wkt((0., 0.));
+```
+
+```response
+POINT(0 0)
+```
+
+POLYGON from an array of tuples or an array of tuple arrays:
+
+```sql
+SELECT wkt([(0., 0.), (10., 0.), (10., 10.), (0., 10.)]);
+```
+
+```response
+POLYGON((0 0,10 0,10 10,0 10))
+```
+
+MULTIPOLYGON from an array of multi-dimensional tuple arrays:
+
+```sql
+SELECT wkt([[[(0., 0.), (10., 0.), (10., 10.), (0., 10.)], [(4., 4.), (5., 4.), (5., 5.), (4., 5.)]], [[(-10., -10.), (-10., -9.), (-9., 10.)]]]);
+```
+
+```response
+MULTIPOLYGON(((0 0,10 0,10 10,0 10,0 0),(4 4,5 4,5 5,4 5,4 4)),((-10 -10,-10 -9,-9 10,-10 -10)))
+```
+
 ## readWKTMultiPolygon

 Converts a WKT (Well Known Text) MultiPolygon into a MultiPolygon type.
--- a/docs/en/sql-reference/functions/string-search-functions.md
+++ b/docs/en/sql-reference/functions/string-search-functions.md
@ -30,7 +30,6 @@ position(haystack, needle[, start_pos])

 Alias:
 - `position(needle IN haystack)`
- `locate(haystack, needle[, start_pos])`.

 **Arguments**

@ -49,7 +48,7 @@ If substring `needle` is empty, these rules apply:
 - if `start_pos >= 1` and `start_pos <= length(haystack) + 1`: return `start_pos`
 - otherwise: return `0`

-The same rules also apply to functions `positionCaseInsensitive`, `positionUTF8` and `positionCaseInsensitiveUTF8`
+The same rules also apply to functions `locate`, `positionCaseInsensitive`, `positionUTF8` and `positionCaseInsensitiveUTF8`.

 Type: `Integer`.

@ -114,6 +113,21 @@ SELECT
 └─────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┘
 ```

+## locate
+
+Like [position](#position) but with arguments `haystack` and `locate` switched.
+
+The behavior of this function depends on the ClickHouse version:
+- in versions < v24.3, `locate` was an alias of function `position` and accepted arguments `(haystack, needle[, start_pos])`.
+- in versions >= 24.3,, `locate` is an individual function (for better compatibility with MySQL) and accepts arguments `(needle, haystack[, start_pos])`. The previous behavior
+  can be restored using setting [function_locate_has_mysql_compatible_argument_order = false](../../operations/settings/settings.md#function-locate-has-mysql-compatible-argument-order);
+
+**Syntax**
+
+``` sql
+locate(needle, haystack[, start_pos])
+```
+
 ## positionCaseInsensitive

 Like [position](#position) but searches case-insensitively.
--- a/docs/en/sql-reference/statements/alter/partition.md
+++ b/docs/en/sql-reference/statements/alter/partition.md
@ -350,6 +350,7 @@ ALTER TABLE mt DELETE IN PARTITION ID '2' WHERE p = 2;
 You can specify the partition expression in `ALTER ... PARTITION` queries in different ways:

 - As a value from the `partition` column of the `system.parts` table. For example, `ALTER TABLE visits DETACH PARTITION 201901`.
+- Using the keyword `ALL`. It can be used only with DROP/DETACH/ATTACH. For example, `ALTER TABLE visits ATTACH PARTITION ALL`.
 - As a tuple of expressions or constants that matches (in types) the table partitioning keys tuple. In the case of a single element partitioning key, the expression should be wrapped in the `tuple (...)` function. For example, `ALTER TABLE visits DETACH PARTITION tuple(toYYYYMM(toDate('2019-01-25')))`.
 - Using the partition ID. Partition ID is a string identifier of the partition (human-readable, if possible) that is used as the names of partitions in the file system and in ZooKeeper. The partition ID must be specified in the `PARTITION ID` clause, in a single quotes. For example, `ALTER TABLE visits DETACH PARTITION ID '201901'`.
 - In the [ALTER ATTACH PART](#alter_attach-partition) and [DROP DETACHED PART](#alter_drop-detached) query, to specify the name of a part, use string literal with a value from the `name` column of the [system.detached_parts](/docs/en/operations/system-tables/detached_parts.md/#system_tables-detached_parts) table. For example, `ALTER TABLE visits ATTACH PART '201901_1_1_0'`.
--- a/docs/en/sql-reference/statements/undrop.md
+++ b/docs/en/sql-reference/statements/undrop.md
@ -13,13 +13,6 @@ a system table called `system.dropped_tables`.

 If you have a materialized view without a `TO` clause associated with the dropped table, then you will also have to UNDROP the inner table of that view.

-:::note
-UNDROP TABLE is experimental.  To use it add this setting: 
-```sql
-set allow_experimental_undrop_table_query = 1;
-```
-:::
-
 :::tip
 Also see [DROP TABLE](/docs/en/sql-reference/statements/drop.md)
 :::
@ -32,60 +25,53 @@ UNDROP TABLE [db.]name [UUID '<uuid>'] [ON CLUSTER cluster]

 **Example**

-``` sql
-set allow_experimental_undrop_table_query = 1;
-```
-
 ```sql
-CREATE TABLE undropMe
+CREATE TABLE tab
 (
    `id` UInt8
 )
 ENGINE = MergeTree
-ORDER BY id
-```
+ORDER BY id;
+
+DROP TABLE tab;

-```sql
-DROP TABLE undropMe
-```
-```sql
 SELECT *
 FROM system.dropped_tables
-FORMAT Vertical
+FORMAT Vertical;
 ```
+
 ```response
 Row 1:
 ──────
 index:                 0
 database:              default
-table:                 undropMe
+table:                 tab
 uuid:                  aa696a1a-1d70-4e60-a841-4c80827706cc
 engine:                MergeTree
-metadata_dropped_path: /var/lib/clickhouse/metadata_dropped/default.undropMe.aa696a1a-1d70-4e60-a841-4c80827706cc.sql
+metadata_dropped_path: /var/lib/clickhouse/metadata_dropped/default.tab.aa696a1a-1d70-4e60-a841-4c80827706cc.sql
 table_dropped_time:    2023-04-05 14:12:12

 1 row in set. Elapsed: 0.001 sec. 
 ```
+
 ```sql
-UNDROP TABLE undropMe
-```
-```response
-Ok.
-```
-```sql
+UNDROP TABLE tab;
+
 SELECT *
 FROM system.dropped_tables
-FORMAT Vertical
-```
+FORMAT Vertical;
+
 ```response
 Ok.

 0 rows in set. Elapsed: 0.001 sec. 
 ```
+
 ```sql
-DESCRIBE TABLE undropMe
-FORMAT Vertical
+DESCRIBE TABLE tab
+FORMAT Vertical;
 ```
+
 ```response
 Row 1:
 ──────
--- a/docs/en/sql-reference/table-functions/jdbc.md
+++ b/docs/en/sql-reference/table-functions/jdbc.md
@ -6,6 +6,11 @@ sidebar_label: jdbc

 # jdbc

+:::note
+clickhouse-jdbc-bridge contains experimental codes and is no longer supported. It may contain reliability issues and security vulnerabilities. Use it at your own risk. 
+ClickHouse recommend using built-in table functions in ClickHouse which provide a better alternative for ad-hoc querying scenarios (Postgres, MySQL, MongoDB, etc).
+:::
+
 `jdbc(datasource, schema, table)` - returns table that is connected via JDBC driver.

 This table function requires separate [clickhouse-jdbc-bridge](https://github.com/ClickHouse/clickhouse-jdbc-bridge) program to be running.
--- a/programs/keeper-client/Commands.cpp
+++ b/programs/keeper-client/Commands.cpp
@ -2,6 +2,7 @@
 #include "Commands.h"
 #include <queue>
 #include "KeeperClient.h"
+#include "Parsers/CommonParsers.h"


 namespace DB
@ -106,13 +107,13 @@ bool CreateCommand::parse(IParser::Pos & pos, std::shared_ptr<ASTKeeperQuery> &

    int mode = zkutil::CreateMode::Persistent;

-    if (ParserKeyword{"PERSISTENT"}.ignore(pos, expected))
+    if (ParserKeyword(Keyword::PERSISTENT).ignore(pos, expected))
        mode = zkutil::CreateMode::Persistent;
-    else if (ParserKeyword{"EPHEMERAL"}.ignore(pos, expected))
+    else if (ParserKeyword(Keyword::EPHEMERAL).ignore(pos, expected))
        mode = zkutil::CreateMode::Ephemeral;
-    else if (ParserKeyword{"EPHEMERAL SEQUENTIAL"}.ignore(pos, expected))
+    else if (ParserKeyword(Keyword::EPHEMERAL_SEQUENTIAL).ignore(pos, expected))
        mode = zkutil::CreateMode::EphemeralSequential;
-    else if (ParserKeyword{"PERSISTENT SEQUENTIAL"}.ignore(pos, expected))
+    else if (ParserKeyword(Keyword::PERSISTENT_SEQUENTIAL).ignore(pos, expected))
        mode = zkutil::CreateMode::PersistentSequential;

    node->args.push_back(std::move(mode));
@ -382,12 +383,16 @@ void RMRCommand::execute(const ASTKeeperQuery * query, KeeperClient * client) co

 bool ReconfigCommand::parse(IParser::Pos & pos, std::shared_ptr<ASTKeeperQuery> & node, DB::Expected & expected) const
 {
+    ParserKeyword s_add(Keyword::ADD);
+    ParserKeyword s_remove(Keyword::REMOVE);
+    ParserKeyword s_set(Keyword::SET);
+
    ReconfigCommand::Operation operation;
-    if (ParserKeyword{"ADD"}.ignore(pos, expected))
+    if (s_add.ignore(pos, expected))
        operation = ReconfigCommand::Operation::ADD;
-    else if (ParserKeyword{"REMOVE"}.ignore(pos, expected))
+    else if (s_remove.ignore(pos, expected))
        operation = ReconfigCommand::Operation::REMOVE;
-    else if (ParserKeyword{"SET"}.ignore(pos, expected))
+    else if (s_set.ignore(pos, expected))
        operation = ReconfigCommand::Operation::SET;
    else
        return false;
--- a/programs/keeper/Keeper.cpp
+++ b/programs/keeper/Keeper.cpp
@ -10,6 +10,7 @@
 #include <IO/UseSSL.h>
 #include <Core/ServerUUID.h>
 #include <Common/logger_useful.h>
+#include <Common/CgroupsMemoryUsageObserver.h>
 #include <Common/ErrorHandlers.h>
 #include <Common/assertProcessUserMatchesDataOwner.h>
 #include <Common/makeSocketAddress.h>
@ -623,6 +624,25 @@ try
    buildLoggers(config(), logger());
    main_config_reloader->start();

+    std::optional<CgroupsMemoryUsageObserver> cgroups_memory_usage_observer;
+    try
+    {
+        auto wait_time = config().getUInt64("keeper_server.cgroups_memory_observer_wait_time", 15);
+        if (wait_time != 0)
+        {
+            cgroups_memory_usage_observer.emplace(std::chrono::seconds(wait_time));
+            /// Not calling cgroups_memory_usage_observer->setLimits() here (as for the normal ClickHouse server) because Keeper controls
+            /// its memory usage by other means (via setting 'max_memory_usage_soft_limit').
+            cgroups_memory_usage_observer->setOnMemoryAmountAvailableChangedFn([&]() { main_config_reloader->reload(); });
+            cgroups_memory_usage_observer->startThread();
+        }
+    }
+    catch (Exception &)
+    {
+        tryLogCurrentException(log, "Disabling cgroup memory observer because of an error during initialization");
+    }
+
+
    LOG_INFO(log, "Ready for connections.");

    waitForTerminationRequest();
--- a/programs/server/Server.cpp
+++ b/programs/server/Server.cpp
@ -733,8 +733,6 @@ try
    LOG_INFO(log, "Available CPU instruction sets: {}", cpu_info);
 #endif

-    sanityChecks(*this);
-
    // Initialize global thread pool. Do it before we fetch configs from zookeeper
    // nodes (`from_zk`), because ZooKeeper interface uses the pool. We will
    // ignore `max_thread_pool_size` in configs we fetch from ZK, but oh well.
@ -904,6 +902,7 @@ try
        config_processor.savePreprocessedConfig(loaded_config, config().getString("path", DBMS_DEFAULT_PATH));
        config().removeConfiguration(old_configuration.get());
        config().add(loaded_config.configuration.duplicate(), PRIO_DEFAULT, false);
+        global_context->setConfig(loaded_config.configuration);
    }

    Settings::checkNoSettingNamesAtTopLevel(config(), config_path);
@ -911,6 +910,9 @@ try
    /// We need to reload server settings because config could be updated via zookeeper.
    server_settings.loadSettingsFromConfig(config());

+    /// NOTE: Do sanity checks after we loaded all possible substitutions (for the configuration) from ZK
+    sanityChecks(*this);
+
 #if defined(OS_LINUX)
    std::string executable_path = getExecutablePath();

@ -1294,7 +1296,7 @@ try
    std::optional<CgroupsMemoryUsageObserver> cgroups_memory_usage_observer;
    try
    {
-        UInt64 wait_time = server_settings.cgroups_memory_usage_observer_wait_time;
+        auto wait_time = server_settings.cgroups_memory_usage_observer_wait_time;
        if (wait_time != 0)
            cgroups_memory_usage_observer.emplace(std::chrono::seconds(wait_time));
    }
@ -1360,7 +1362,7 @@ try
            {
                double hard_limit_ratio = new_server_settings.cgroup_memory_watcher_hard_limit_ratio;
                double soft_limit_ratio = new_server_settings.cgroup_memory_watcher_soft_limit_ratio;
-                cgroups_memory_usage_observer->setLimits(
+                cgroups_memory_usage_observer->setMemoryUsageLimits(
                    static_cast<uint64_t>(max_server_memory_usage * hard_limit_ratio),
                    static_cast<uint64_t>(max_server_memory_usage * soft_limit_ratio));
            }
@ -1718,6 +1720,12 @@ try
        throw;
    }

+    if (cgroups_memory_usage_observer)
+    {
+        cgroups_memory_usage_observer->setOnMemoryAmountAvailableChangedFn([&]() { main_config_reloader->reload(); });
+        cgroups_memory_usage_observer->startThread();
+    }
+
    /// Reload config in SYSTEM RELOAD CONFIG query.
    global_context->setConfigReloadCallback([&]()
    {
--- a/src/Access/AccessBackup.cpp
+++ b/src/Access/AccessBackup.cpp
@ -297,7 +297,7 @@ namespace


 std::pair<String, BackupEntryPtr> makeBackupEntryForAccess(
-    const std::vector<std::pair<UUID, AccessEntityPtr>> access_entities,
+    const std::vector<std::pair<UUID, AccessEntityPtr>> & access_entities,
    const String & data_path_in_backup,
    size_t counter,
    const AccessControl & access_control)
@ -326,7 +326,7 @@ void AccessRestorerFromBackup::addDataPath(const String & data_path)
        return;

    fs::path data_path_in_backup_fs = data_path;
-    Strings filenames = backup->listFiles(data_path);
+    Strings filenames = backup->listFiles(data_path, /*recursive*/ false);
    if (filenames.empty())
        return;

--- a/src/Access/AccessBackup.h
+++ b/src/Access/AccessBackup.h
@ -21,7 +21,7 @@ struct RestoreSettings;

 /// Makes a backup of access entities of a specified type.
 std::pair<String, BackupEntryPtr> makeBackupEntryForAccess(
-    const std::vector<std::pair<UUID, AccessEntityPtr>> access_entities,
+    const std::vector<std::pair<UUID, AccessEntityPtr>> & access_entities,
    const String & data_path_in_backup,
    size_t counter,
    const AccessControl & access_control);
--- a/src/Access/Common/AuthenticationType.cpp
+++ b/src/Access/Common/AuthenticationType.cpp
@ -13,63 +13,63 @@ namespace ErrorCodes

 const AuthenticationTypeInfo & AuthenticationTypeInfo::get(AuthenticationType type_)
 {
-    static constexpr auto make_info = [](const char * raw_name_, bool is_password_ = false)
+    static constexpr auto make_info = [](Keyword keyword_, bool is_password_ = false)
    {
-        String init_name = raw_name_;
+        String init_name = String(toStringView(keyword_));
        boost::to_lower(init_name);
-        return AuthenticationTypeInfo{raw_name_, std::move(init_name), is_password_};
+        return AuthenticationTypeInfo{keyword_, std::move(init_name), is_password_};
    };

    switch (type_)
    {
        case AuthenticationType::NO_PASSWORD:
        {
-            static const auto info = make_info("NO_PASSWORD");
+            static const auto info = make_info(Keyword::NO_PASSWORD);
            return info;
        }
        case AuthenticationType::PLAINTEXT_PASSWORD:
        {
-            static const auto info = make_info("PLAINTEXT_PASSWORD", true);
+            static const auto info = make_info(Keyword::PLAINTEXT_PASSWORD, true);
            return info;
        }
        case AuthenticationType::SHA256_PASSWORD:
        {
-            static const auto info = make_info("SHA256_PASSWORD", true);
+            static const auto info = make_info(Keyword::SHA256_PASSWORD, true);
            return info;
        }
        case AuthenticationType::DOUBLE_SHA1_PASSWORD:
        {
-            static const auto info = make_info("DOUBLE_SHA1_PASSWORD", true);
+            static const auto info = make_info(Keyword::DOUBLE_SHA1_PASSWORD, true);
            return info;
        }
        case AuthenticationType::LDAP:
        {
-            static const auto info = make_info("LDAP");
+            static const auto info = make_info(Keyword::LDAP);
            return info;
        }
        case AuthenticationType::KERBEROS:
        {
-            static const auto info = make_info("KERBEROS");
+            static const auto info = make_info(Keyword::KERBEROS);
            return info;
        }
        case AuthenticationType::SSL_CERTIFICATE:
        {
-            static const auto info = make_info("SSL_CERTIFICATE");
+            static const auto info = make_info(Keyword::SSL_CERTIFICATE);
            return info;
        }
        case AuthenticationType::BCRYPT_PASSWORD:
        {
-            static const auto info = make_info("BCRYPT_PASSWORD", true);
+            static const auto info = make_info(Keyword::BCRYPT_PASSWORD, true);
            return info;
        }
        case AuthenticationType::SSH_KEY:
        {
-            static const auto info = make_info("SSH_KEY");
+            static const auto info = make_info(Keyword::SSH_KEY);
            return info;
        }
        case AuthenticationType::HTTP:
        {
-            static const auto info = make_info("HTTP");
+            static const auto info = make_info(Keyword::HTTP);
            return info;
        }
        case AuthenticationType::MAX:
--- a/src/Access/Common/AuthenticationType.h
+++ b/src/Access/Common/AuthenticationType.h
@ -1,6 +1,7 @@
 #pragma once

 #include <base/types.h>
+#include <Parsers/CommonParsers.h>

 namespace DB
 {
@ -45,7 +46,7 @@ enum class AuthenticationType

 struct AuthenticationTypeInfo
 {
-    const char * const raw_name;
+    Keyword keyword; // Keyword used in parser
    const String name; /// Lowercased with underscores, e.g. "sha256_password".
    bool is_password;
    static const AuthenticationTypeInfo & get(AuthenticationType type_);
@ -53,7 +54,7 @@ struct AuthenticationTypeInfo

 inline String toString(AuthenticationType type_)
 {
-    return AuthenticationTypeInfo::get(type_).raw_name;
+    return String(toStringView(AuthenticationTypeInfo::get(type_).keyword));
 }

 }
--- a/src/Access/ContextAccessParams.cpp
+++ b/src/Access/ContextAccessParams.cpp
@ -7,7 +7,7 @@ namespace DB
 {

 ContextAccessParams::ContextAccessParams(
-    const std::optional<UUID> user_id_,
+    std::optional<UUID> user_id_,
    bool full_access_,
    bool use_default_roles_,
    const std::shared_ptr<const std::vector<UUID>> & current_roles_,
--- a/src/Access/ContextAccessParams.h
+++ b/src/Access/ContextAccessParams.h
@ -15,7 +15,7 @@ class ContextAccessParams
 {
 public:
    ContextAccessParams(
-        const std::optional<UUID> user_id_,
+        std::optional<UUID> user_id_,
        bool full_access_,
        bool use_default_roles_,
        const std::shared_ptr<const std::vector<UUID>> & current_roles_,
--- a/src/Access/GSSAcceptor.h
+++ b/src/Access/GSSAcceptor.h
@ -34,7 +34,7 @@ public:
    };

    explicit GSSAcceptorContext(const Params & params_);
-    virtual ~GSSAcceptorContext() override;
+    ~GSSAcceptorContext() override;

    GSSAcceptorContext(const GSSAcceptorContext &) = delete;
    GSSAcceptorContext(GSSAcceptorContext &&) = delete;
--- a/src/Access/LDAPAccessStorage.cpp
+++ b/src/Access/LDAPAccessStorage.cpp
@ -204,7 +204,7 @@ void LDAPAccessStorage::assignRolesNoLock(User & user, const LDAPClient::SearchR
 }


-void LDAPAccessStorage::assignRolesNoLock(User & user, const LDAPClient::SearchResultsList & external_roles, const std::size_t external_roles_hash) const
+void LDAPAccessStorage::assignRolesNoLock(User & user, const LDAPClient::SearchResultsList & external_roles, std::size_t external_roles_hash) const
 {
    const auto & user_name = user.getName();
    auto & granted_roles = user.granted_roles;
--- a/src/Access/LDAPAccessStorage.h
+++ b/src/Access/LDAPAccessStorage.h
@ -33,29 +33,29 @@ public:
    static constexpr char STORAGE_TYPE[] = "ldap";

    explicit LDAPAccessStorage(const String & storage_name_, AccessControl & access_control_, const Poco::Util::AbstractConfiguration & config, const String & prefix);
-    virtual ~LDAPAccessStorage() override = default;
+    ~LDAPAccessStorage() override = default;

    String getLDAPServerName() const;

    // IAccessStorage implementations.
-    virtual const char * getStorageType() const override;
-    virtual String getStorageParamsJSON() const override;
-    virtual bool isReadOnly() const override { return true; }
-    virtual bool exists(const UUID & id) const override;
+    const char * getStorageType() const override;
+    String getStorageParamsJSON() const override;
+    bool isReadOnly() const override { return true; }
+    bool exists(const UUID & id) const override;

 private: // IAccessStorage implementations.
-    virtual std::optional<UUID> findImpl(AccessEntityType type, const String & name) const override;
-    virtual std::vector<UUID> findAllImpl(AccessEntityType type) const override;
-    virtual AccessEntityPtr readImpl(const UUID & id, bool throw_if_not_exists) const override;
-    virtual std::optional<std::pair<String, AccessEntityType>> readNameWithTypeImpl(const UUID & id, bool throw_if_not_exists) const override;
-    virtual std::optional<AuthResult> authenticateImpl(const Credentials & credentials, const Poco::Net::IPAddress & address, const ExternalAuthenticators & external_authenticators, bool throw_if_user_not_exists, bool allow_no_password, bool allow_plaintext_password) const override;
+    std::optional<UUID> findImpl(AccessEntityType type, const String & name) const override;
+    std::vector<UUID> findAllImpl(AccessEntityType type) const override;
+    AccessEntityPtr readImpl(const UUID & id, bool throw_if_not_exists) const override;
+    std::optional<std::pair<String, AccessEntityType>> readNameWithTypeImpl(const UUID & id, bool throw_if_not_exists) const override;
+    std::optional<AuthResult> authenticateImpl(const Credentials & credentials, const Poco::Net::IPAddress & address, const ExternalAuthenticators & external_authenticators, bool throw_if_user_not_exists, bool allow_no_password, bool allow_plaintext_password) const override;

    void setConfiguration(const Poco::Util::AbstractConfiguration & config, const String & prefix);
    void processRoleChange(const UUID & id, const AccessEntityPtr & entity);

    void applyRoleChangeNoLock(bool grant, const UUID & role_id, const String & role_name);
    void assignRolesNoLock(User & user, const LDAPClient::SearchResultsList & external_roles) const;
-    void assignRolesNoLock(User & user, const LDAPClient::SearchResultsList & external_roles, const std::size_t external_roles_hash) const;
+    void assignRolesNoLock(User & user, const LDAPClient::SearchResultsList & external_roles, std::size_t external_roles_hash) const;
    void updateAssignedRolesNoLock(const UUID & id, const String & user_name, const LDAPClient::SearchResultsList & external_roles) const;
    std::set<String> mapExternalRolesNoLock(const LDAPClient::SearchResultsList & external_roles) const;
    bool areLDAPCredentialsValidNoLock(const User & user, const Credentials & credentials,
--- a/src/AggregateFunctions/AggregateFunctionFlameGraph.cpp
+++ b/src/AggregateFunctions/AggregateFunctionFlameGraph.cpp
@ -252,7 +252,6 @@ void dumpFlameGraph(
    fillColumn(chars, offsets, out.str());
 }

-// NOLINTBEGIN(clang-analyzer-optin.performance.Padding)
 struct AggregateFunctionFlameGraphData
 {
    struct Entry
@ -469,7 +468,6 @@ struct AggregateFunctionFlameGraphData
        DB::dumpFlameGraph(tree.dump(max_depth, min_bytes), chars, offsets);
    }
 };
-// NOLINTEND(clang-analyzer-optin.performance.Padding)

 /// Aggregate function which builds a flamegraph using the list of stacktraces.
 /// The output is an array of strings which can be used by flamegraph.pl util.
--- a/src/AggregateFunctions/AggregateFunctionMLMethod.h
+++ b/src/AggregateFunctions/AggregateFunctionMLMethod.h
@ -157,7 +157,7 @@ public:

    void update(UInt64 batch_size, std::vector<Float64> & weights, Float64 & bias, Float64 learning_rate, const std::vector<Float64> & batch_gradient) override;

-    virtual void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;
+    void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;

    void write(WriteBuffer & buf) const override;

@ -189,7 +189,7 @@ public:

    void update(UInt64 batch_size, std::vector<Float64> & weights, Float64 & bias, Float64 learning_rate, const std::vector<Float64> & batch_gradient) override;

-    virtual void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;
+    void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;

    void write(WriteBuffer & buf) const override;

@ -226,7 +226,7 @@ public:

    void update(UInt64 batch_size, std::vector<Float64> & weights, Float64 & bias, Float64 learning_rate, const std::vector<Float64> & batch_gradient) override;

-    virtual void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;
+    void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;

    void write(WriteBuffer & buf) const override;

--- a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
+++ b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
@ -234,9 +234,6 @@ namespace ErrorCodes
    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
 }

-namespace
-{
-
 template <template <typename> typename FunctionTemplate, StatisticsFunctionKind kind>
 AggregateFunctionPtr createAggregateFunctionStatisticsUnary(
    const std::string & name, const DataTypes & argument_types, const Array & parameters, const Settings *)
@ -273,5 +270,3 @@ AggregateFunctionPtr createAggregateFunctionStatisticsBinary(
 }

 }
-
-}
--- a/src/AggregateFunctions/AggregateFunctionUniqCombined.h
+++ b/src/AggregateFunctions/AggregateFunctionUniqCombined.h
@ -42,9 +42,6 @@ struct UniqCombinedHashTableGrower : public HashTableGrowerWithPrecalculation<>
    void increaseSize() { increaseSizeDegree(1); }
 };

-namespace
-{
-
 template <typename T, UInt8 K, typename HashValueType>
 struct AggregateFunctionUniqCombinedData
 {
@ -268,8 +265,6 @@ AggregateFunctionPtr createAggregateFunctionWithK(const DataTypes & argument_typ
        return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunctionVariadic<false, false>>(argument_types, params);
 }

-}
-
 template <UInt8 K>
 AggregateFunctionPtr createAggregateFunctionWithHashType(bool use_64_bit_hash, const DataTypes & argument_types, const Array & params)
 {
--- a/src/AggregateFunctions/Combinators/AggregateFunctionNull.h
+++ b/src/AggregateFunctions/Combinators/AggregateFunctionNull.h
@ -521,7 +521,7 @@ public:
            }
        }

-        chassert(nullable_filters.size() > 0);
+        chassert(!nullable_filters.empty());
        bool found_one = false;
        if (nullable_filters.size() == 1)
        {
--- a/src/AggregateFunctions/DDSketch/Store.h
+++ b/src/AggregateFunctions/DDSketch/Store.h
@ -38,7 +38,7 @@ public:
        offset = other->offset;
    }

-    int length()
+    int length() const
    {
        return static_cast<int>(bins.size());
    }
--- a/src/AggregateFunctions/QuantileExact.h
+++ b/src/AggregateFunctions/QuantileExact.h
@ -150,7 +150,7 @@ struct QuantileExactExclusive : public QuantileExact<Value>
                return static_cast<Float64>(*std::min_element(array.begin(), array.end()));

            ::nth_element(array.begin(), array.begin() + n - 1, array.end());
-            auto nth_elem = std::min_element(array.begin() + n, array.end());
+            auto * nth_elem = std::min_element(array.begin() + n, array.end());

            return static_cast<Float64>(array[n - 1]) + (h - n) * static_cast<Float64>(*nth_elem - array[n - 1]);
        }
@ -179,7 +179,7 @@ struct QuantileExactExclusive : public QuantileExact<Value>
                else
                {
                    ::nth_element(array.begin() + prev_n, array.begin() + n - 1, array.end());
-                    auto nth_elem = std::min_element(array.begin() + n, array.end());
+                    auto * nth_elem = std::min_element(array.begin() + n, array.end());

                    result[indices[i]] = static_cast<Float64>(array[n - 1]) + (h - n) * static_cast<Float64>(*nth_elem - array[n - 1]);
                    prev_n = n - 1;
@ -214,7 +214,7 @@ struct QuantileExactInclusive : public QuantileExact<Value>
            else if (n < 1)
                return static_cast<Float64>(*std::min_element(array.begin(), array.end()));
            ::nth_element(array.begin(), array.begin() + n - 1, array.end());
-            auto nth_elem = std::min_element(array.begin() + n, array.end());
+            auto * nth_elem = std::min_element(array.begin() + n, array.end());

            return static_cast<Float64>(array[n - 1]) + (h - n) * static_cast<Float64>(*nth_elem - array[n - 1]);
        }
@ -241,7 +241,7 @@ struct QuantileExactInclusive : public QuantileExact<Value>
                else
                {
                    ::nth_element(array.begin() + prev_n, array.begin() + n - 1, array.end());
-                    auto nth_elem = std::min_element(array.begin() + n, array.end());
+                    auto * nth_elem = std::min_element(array.begin() + n, array.end());

                    result[indices[i]] = static_cast<Float64>(array[n - 1]) + (h - n) * (static_cast<Float64>(*nth_elem) - array[n - 1]);
                    prev_n = n - 1;
--- a/src/AggregateFunctions/ReservoirSamplerDeterministic.h
+++ b/src/AggregateFunctions/ReservoirSamplerDeterministic.h
@ -191,7 +191,7 @@ public:
            /// TODO: After implementation of "versioning aggregate function state",
            /// change the serialization format.
            Element elem;
-            memset(&elem, 0, sizeof(elem));
+            memset(&elem, 0, sizeof(elem)); /// NOLINT(bugprone-undefined-memory-manipulation)
            elem = samples[i];

            DB::transformEndianness<std::endian::little>(elem);
--- a/src/AggregateFunctions/SingleValueData.h
+++ b/src/AggregateFunctions/SingleValueData.h
@ -23,7 +23,7 @@ struct SingleValueDataBase
    /// For example argMin holds 1 of these (for the result), while keeping a template for the value
    static constexpr UInt32 MAX_STORAGE_SIZE = 64;

-    virtual ~SingleValueDataBase() { }
+    virtual ~SingleValueDataBase() = default;
    virtual bool has() const = 0;
    virtual void insertResultInto(IColumn &) const = 0;
    virtual void write(WriteBuffer &, const ISerialization &) const = 0;
--- a/src/AggregateFunctions/UniqExactSet.h
+++ b/src/AggregateFunctions/UniqExactSet.h
@ -39,8 +39,8 @@ public:
    /// This method will convert all the SingleLevelSet to TwoLevelSet in parallel if the hashsets are not all singlelevel or not all twolevel.
    static void parallelizeMergePrepare(const std::vector<UniqExactSet *> & data_vec, ThreadPool & thread_pool)
    {
-        unsigned long single_level_set_num = 0;
-        unsigned long all_single_hash_size = 0;
+        UInt64 single_level_set_num = 0;
+        UInt64 all_single_hash_size = 0;

        for (auto ele : data_vec)
        {
--- a/src/Analyzer/Passes/QueryAnalysisPass.h
+++ b/src/Analyzer/Passes/QueryAnalysisPass.h
@ -77,7 +77,7 @@ public:
      * Available expression columns are extracted from table expression.
      * Table expression node must have query, union, table, table function type.
      */
-    QueryAnalysisPass(QueryTreeNodePtr table_expression_, bool only_analyze_ = false);
+    explicit QueryAnalysisPass(QueryTreeNodePtr table_expression_, bool only_analyze_ = false);

    String getName() override
    {
--- a/src/Backups/BackupCoordinationRemote.cpp
+++ b/src/Backups/BackupCoordinationRemote.cpp
@ -1,6 +1,7 @@
 #include <Backups/BackupCoordinationRemote.h>

 #include <base/hex.h>
+#include <boost/algorithm/string/split.hpp>

 #include <Access/Common/AccessEntityType.h>
 #include <Backups/BackupCoordinationReplicatedAccess.h>
--- a/src/Backups/BackupSettings.h
+++ b/src/Backups/BackupSettings.h
@ -26,7 +26,7 @@ struct BackupSettings
    String password;

    /// S3 storage class.
-    String s3_storage_class = "";
+    String s3_storage_class;

    /// If this is set to true then only create queries will be written to backup,
    /// without the data of tables.
--- a/src/Backups/BackupsWorker.cpp
+++ b/src/Backups/BackupsWorker.cpp
@ -327,7 +327,7 @@ public:
                metric_active_threads = CurrentMetrics::RestoreThreadsActive;
                metric_active_threads = CurrentMetrics::RestoreThreadsScheduled;
                max_threads = num_restore_threads;
-                use_queue = (thread_pool_id != ThreadPoolId::RESTORE);
+                use_queue = true;
                break;
            }
        }
--- a/src/Backups/IBackup.h
+++ b/src/Backups/IBackup.h
@ -80,7 +80,7 @@ public:

    /// Returns names of entries stored in a specified directory in the backup.
    /// If `directory` is empty or '/' the functions returns entries in the backup's root.
-    virtual Strings listFiles(const String & directory, bool recursive = false) const = 0;
+    virtual Strings listFiles(const String & directory, bool recursive) const = 0;

    /// Checks if a specified directory contains any files.
    /// The function returns the same as `!listFiles(directory).empty()`.
@ -108,11 +108,9 @@ public:
    virtual std::unique_ptr<SeekableReadBuffer> readFile(const SizeAndChecksum & size_and_checksum) const = 0;

    /// Copies a file from the backup to a specified destination disk. Returns the number of bytes written.
-    virtual size_t copyFileToDisk(const String & file_name, DiskPtr destination_disk, const String & destination_path,
-                                  WriteMode write_mode = WriteMode::Rewrite) const = 0;
+    virtual size_t copyFileToDisk(const String & file_name, DiskPtr destination_disk, const String & destination_path, WriteMode write_mode) const = 0;

-    virtual size_t copyFileToDisk(const SizeAndChecksum & size_and_checksum, DiskPtr destination_disk, const String & destination_path,
-                                  WriteMode write_mode = WriteMode::Rewrite) const = 0;
+    virtual size_t copyFileToDisk(const SizeAndChecksum & size_and_checksum, DiskPtr destination_disk, const String & destination_path, WriteMode write_mode) const = 0;

    /// Puts a new entry to the backup.
    virtual void writeFile(const BackupFileInfo & file_info, BackupEntryPtr entry) = 0;
--- a/src/Backups/RestorerFromBackup.cpp
+++ b/src/Backups/RestorerFromBackup.cpp
@ -273,7 +273,7 @@ void RestorerFromBackup::findRootPathsInBackup()
    root_paths_in_backup.push_back(root_path);

    /// Add shard-related part to the root path.
-    Strings shards_in_backup = backup->listFiles(root_path / "shards");
+    Strings shards_in_backup = backup->listFiles(root_path / "shards", /*recursive*/ false);
    if (shards_in_backup.empty())
    {
        if (restore_settings.shard_num_in_backup > 1)
@ -295,7 +295,7 @@ void RestorerFromBackup::findRootPathsInBackup()
    }

    /// Add replica-related part to the root path.
-    Strings replicas_in_backup = backup->listFiles(root_path / "replicas");
+    Strings replicas_in_backup = backup->listFiles(root_path / "replicas", /*recursive*/ false);
    if (replicas_in_backup.empty())
    {
        if (restore_settings.replica_num_in_backup > 1)
@ -514,7 +514,7 @@ void RestorerFromBackup::findDatabaseInBackupImpl(const String & database_name_i
        if (!metadata_path && !try_metadata_path.empty() && backup->fileExists(try_metadata_path))
            metadata_path = try_metadata_path;

-        Strings file_names = backup->listFiles(try_tables_metadata_path);
+        Strings file_names = backup->listFiles(try_tables_metadata_path, /*recursive*/ false);
        for (const String & file_name : file_names)
        {
            if (!file_name.ends_with(".sql"))
@ -575,7 +575,7 @@ void RestorerFromBackup::findEverythingInBackup(const std::set<String> & except_

    for (const auto & root_path_in_backup : root_paths_in_backup)
    {
-        Strings file_names = backup->listFiles(root_path_in_backup / "metadata");
+        Strings file_names = backup->listFiles(root_path_in_backup / "metadata", /*recursive*/ false);
        for (String & file_name : file_names)
        {
            if (file_name.ends_with(".sql"))
--- a/src/Client/HedgedConnectionsFactory.h
+++ b/src/Client/HedgedConnectionsFactory.h
@ -159,7 +159,7 @@ private:
    size_t requested_connections_count = 0;

    const size_t max_parallel_replicas = 0;
-    const bool skip_unavailable_shards = 0;
+    const bool skip_unavailable_shards = false;
 };

 }
--- a/src/Client/TestHint.h
+++ b/src/Client/TestHint.h
@ -77,12 +77,12 @@ private:
    {
        if (actual_server_error && std::find(server_errors.begin(), server_errors.end(), actual_server_error) == server_errors.end())
            return false;
-        if (!actual_server_error && server_errors.size())
+        if (!actual_server_error && !server_errors.empty())
            return false;

        if (actual_client_error && std::find(client_errors.begin(), client_errors.end(), actual_client_error) == client_errors.end())
            return false;
-        if (!actual_client_error && client_errors.size())
+        if (!actual_client_error && !client_errors.empty())
            return false;

        return true;
@ -90,7 +90,7 @@ private:

    bool lostExpectedError(int actual_server_error, int actual_client_error) const
    {
-        return (server_errors.size() && !actual_server_error) || (client_errors.size() && !actual_client_error);
+        return (!server_errors.empty() && !actual_server_error) || (!client_errors.empty() && !actual_client_error);
    }
 };

--- a/src/Columns/ColumnUnique.h
+++ b/src/Columns/ColumnUnique.h
@ -671,7 +671,7 @@ IColumnUnique::IndexesWithOverflow ColumnUnique<ColumnType>::uniqueInsertRangeWi
    size_t max_dictionary_size)
 {
    auto overflowed_keys = column_holder->cloneEmpty();
-    auto overflowed_keys_ptr = typeid_cast<ColumnType *>(overflowed_keys.get());
+    auto * overflowed_keys_ptr = typeid_cast<ColumnType *>(overflowed_keys.get());
    if (!overflowed_keys_ptr)
        throw Exception(ErrorCodes::LOGICAL_ERROR, "Invalid keys type for ColumnUnique.");

--- a/src/Columns/ReverseIndex.h
+++ b/src/Columns/ReverseIndex.h
@ -86,7 +86,7 @@ struct ReverseIndexHashTableCell
    {
        /// Careful: apparently this uses SFINAE to redefine isZero for all types
        /// except the IndexType, for which the default ZeroTraits::isZero is used.
-        static_assert(!std::is_same_v<typename std::decay<T>::type, typename std::decay<IndexType>::type>);
+        static_assert(!std::is_same_v<typename std::decay_t<T>, typename std::decay_t<IndexType>>);
        return false;
    }

--- a/src/Common/AllocatorWithMemoryTracking.h
+++ b/src/Common/AllocatorWithMemoryTracking.h
@ -26,10 +26,10 @@ struct AllocatorWithMemoryTracking

    [[nodiscard]] T * allocate(size_t n)
    {
-        if (n > std::numeric_limits<size_t>::max() / sizeof(T))
+        if (n > std::numeric_limits<size_t>::max() / sizeof(T)) /// NOLINT(bugprone-sizeof-expression)
            throw std::bad_alloc();

-        size_t bytes = n * sizeof(T);
+        size_t bytes = n * sizeof(T); /// NOLINT(bugprone-sizeof-expression)
        auto trace = CurrentMemoryTracker::alloc(bytes);

        T * p = static_cast<T *>(malloc(bytes));
@ -43,7 +43,7 @@ struct AllocatorWithMemoryTracking

    void deallocate(T * p, size_t n) noexcept
    {
-        size_t bytes = n * sizeof(T);
+        size_t bytes = n * sizeof(T); /// NOLINT(bugprone-sizeof-expression)

        free(p);
        auto trace = CurrentMemoryTracker::free(bytes);
--- a/src/Common/Arena.h
+++ b/src/Common/Arena.h
@ -49,7 +49,7 @@ private:

        MemoryChunk() = default;

-        void swap(MemoryChunk & other)
+        void swap(MemoryChunk & other) noexcept
        {
            std::swap(begin, other.begin);
            std::swap(pos, other.pos);
@ -57,12 +57,12 @@ private:
            prev.swap(other.prev);
        }

-        MemoryChunk(MemoryChunk && other)
+        MemoryChunk(MemoryChunk && other) noexcept
        {
            *this = std::move(other);
        }

-        MemoryChunk & operator=(MemoryChunk && other)
+        MemoryChunk & operator=(MemoryChunk && other) noexcept
        {
            swap(other);
            return *this;
--- a/src/Common/AsyncLoader.cpp
+++ b/src/Common/AsyncLoader.cpp
@ -39,7 +39,7 @@ void logAboutProgress(LoggerPtr log, size_t processed, size_t total, AtomicStopw
 {
    if (total && (processed % PRINT_MESSAGE_EACH_N_OBJECTS == 0 || watch.compareAndRestart(PRINT_MESSAGE_EACH_N_SECONDS)))
    {
-        LOG_INFO(log, "Processed: {}%", static_cast<Int64>(processed * 1000.0 / total) * 0.1);
+        LOG_INFO(log, "Processed: {:.1f}%", static_cast<double>(processed) * 100.0 / total);
        watch.restart();
    }
 }
--- a/src/Common/CgroupsMemoryUsageObserver.cpp
+++ b/src/Common/CgroupsMemoryUsageObserver.cpp
@ -9,6 +9,7 @@
 #include <IO/ReadBufferFromFileDescriptor.h>
 #include <IO/ReadHelpers.h>
 #include <base/cgroupsv2.h>
+#include <base/getMemoryAmount.h>
 #include <base/sleep.h>

 #include <filesystem>
@ -36,7 +37,7 @@ namespace ErrorCodes
 CgroupsMemoryUsageObserver::CgroupsMemoryUsageObserver(std::chrono::seconds wait_time_)
    : log(getLogger("CgroupsMemoryUsageObserver"))
    , wait_time(wait_time_)
-    , file(log)
+    , memory_usage_file(log)
 {
    LOG_INFO(log, "Initialized cgroups memory limit observer, wait time is {} sec", wait_time.count());
 }
@ -46,13 +47,13 @@ CgroupsMemoryUsageObserver::~CgroupsMemoryUsageObserver()
    stopThread();
 }

-void CgroupsMemoryUsageObserver::setLimits(uint64_t hard_limit_, uint64_t soft_limit_)
+void CgroupsMemoryUsageObserver::setMemoryUsageLimits(uint64_t hard_limit_, uint64_t soft_limit_)
 {
+    std::lock_guard<std::mutex> limit_lock(limit_mutex);
+
    if (hard_limit_ == hard_limit && soft_limit_ == soft_limit)
        return;

-    stopThread();
-
    hard_limit = hard_limit_;
    soft_limit = soft_limit_;

@ -83,10 +84,10 @@ void CgroupsMemoryUsageObserver::setLimits(uint64_t hard_limit_, uint64_t soft_l
            mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".purge", nullptr, nullptr, nullptr, 0);
 #endif
            /// Reset current usage in memory tracker. Expect zero for free_memory_in_allocator_arenas as we just purged them.
-            uint64_t current_usage = readMemoryUsage();
-            MemoryTracker::setRSS(current_usage, 0);
+            uint64_t memory_usage = memory_usage_file.readMemoryUsage();
+            MemoryTracker::setRSS(memory_usage, 0);

-            LOG_INFO(log, "Purged jemalloc arenas. Current memory usage is {}", ReadableSize(current_usage));
+            LOG_INFO(log, "Purged jemalloc arenas. Current memory usage is {}", ReadableSize(memory_usage));
        }
        else
        {
@ -94,14 +95,13 @@ void CgroupsMemoryUsageObserver::setLimits(uint64_t hard_limit_, uint64_t soft_l
        }
    };

-    startThread();
-
    LOG_INFO(log, "Set new limits, soft limit: {}, hard limit: {}", ReadableSize(soft_limit_), ReadableSize(hard_limit_));
 }

-uint64_t CgroupsMemoryUsageObserver::readMemoryUsage() const
+void CgroupsMemoryUsageObserver::setOnMemoryAmountAvailableChangedFn(OnMemoryAmountAvailableChangedFn on_memory_amount_available_changed_)
 {
-    return file.readMemoryUsage();
+    std::lock_guard<std::mutex> memory_amount_available_changed_lock(memory_amount_available_changed_mutex);
+    on_memory_amount_available_changed = on_memory_amount_available_changed_;
 }

 namespace
@ -163,7 +163,7 @@ std::pair<std::string, CgroupsMemoryUsageObserver::CgroupsVersion> getCgroupsFil

 }

-CgroupsMemoryUsageObserver::File::File(LoggerPtr log_)
+CgroupsMemoryUsageObserver::MemoryUsageFile::MemoryUsageFile(LoggerPtr log_)
    : log(log_)
 {
    std::tie(file_name, version) = getCgroupsFileName();
@ -177,7 +177,7 @@ CgroupsMemoryUsageObserver::File::File(LoggerPtr log_)
            file_name, "Cannot open file '{}'", file_name);
 }

-CgroupsMemoryUsageObserver::File::~File()
+CgroupsMemoryUsageObserver::MemoryUsageFile::~MemoryUsageFile()
 {
    assert(fd != -1);
    if (::close(fd) != 0)
@ -195,7 +195,7 @@ CgroupsMemoryUsageObserver::File::~File()
    }
 }

-uint64_t CgroupsMemoryUsageObserver::File::readMemoryUsage() const
+uint64_t CgroupsMemoryUsageObserver::MemoryUsageFile::readMemoryUsage() const
 {
    /// File read is probably not read is thread-safe, just to be sure
    std::lock_guard lock(mutex);
@ -278,6 +278,9 @@ void CgroupsMemoryUsageObserver::runThread()
 {
    setThreadName("CgrpMemUsgObsr");

+    last_available_memory_amount = getMemoryAmount();
+    LOG_INFO(log, "Memory amount initially available to the process is {}", ReadableSize(last_available_memory_amount));
+
    std::unique_lock lock(thread_mutex);
    while (true)
    {
@ -286,8 +289,42 @@ void CgroupsMemoryUsageObserver::runThread()

        try
        {
-            uint64_t memory_usage = file.readMemoryUsage();
-            processMemoryUsage(memory_usage);
+            uint64_t available_memory_amount = getMemoryAmount();
+            if (available_memory_amount != last_available_memory_amount)
+            {
+                LOG_INFO(log, "Memory amount available to the process changed from {} to {}", ReadableSize(last_available_memory_amount), ReadableSize(available_memory_amount));
+                last_available_memory_amount = available_memory_amount;
+                std::lock_guard<std::mutex> memory_amount_available_changed_lock(memory_amount_available_changed_mutex);
+                on_memory_amount_available_changed();
+            }
+
+            std::lock_guard<std::mutex> limit_lock(limit_mutex);
+            if (soft_limit > 0 && hard_limit > 0)
+            {
+                uint64_t memory_usage = memory_usage_file.readMemoryUsage();
+                if (memory_usage > hard_limit)
+                {
+                    if (last_memory_usage <= hard_limit)
+                        on_hard_limit(true);
+                }
+                else
+                {
+                    if (last_memory_usage > hard_limit)
+                        on_hard_limit(false);
+                }
+
+                if (memory_usage > soft_limit)
+                {
+                    if (last_memory_usage <= soft_limit)
+                        on_soft_limit(true);
+                }
+                else
+                {
+                    if (last_memory_usage > soft_limit)
+                        on_soft_limit(false);
+                }
+                last_memory_usage = memory_usage;
+            }
        }
        catch (...)
        {
@ -296,33 +333,6 @@ void CgroupsMemoryUsageObserver::runThread()
    }
 }

-void CgroupsMemoryUsageObserver::processMemoryUsage(uint64_t current_usage)
-{
-    if (current_usage > hard_limit)
-    {
-        if (last_usage <= hard_limit)
-            on_hard_limit(true);
-    }
-    else
-    {
-        if (last_usage > hard_limit)
-            on_hard_limit(false);
-    }
-
-    if (current_usage > soft_limit)
-    {
-        if (last_usage <= soft_limit)
-            on_soft_limit(true);
-    }
-    else
-    {
-        if (last_usage > soft_limit)
-            on_soft_limit(false);
-    }
-
-    last_usage = current_usage;
-}
-
 }

 #endif
--- a/src/Common/CgroupsMemoryUsageObserver.h
+++ b/src/Common/CgroupsMemoryUsageObserver.h
@ -2,57 +2,71 @@

 #include <Common/ThreadPool.h>

-#include <atomic>
 #include <chrono>
 #include <mutex>

 namespace DB
 {

-/// Periodically reads the current memory usage from Linux cgroups.
-/// You can specify soft or hard memory limits:
-/// - When the soft memory limit is hit, drop jemalloc cache.
-/// - When the hard memory limit is hit, update MemoryTracking metric to throw memory exceptions faster.
+/// Does two things:
+/// 1. Periodically reads the memory usage of the process from Linux cgroups.
+///    You can specify soft or hard memory limits:
+///    - When the soft memory limit is hit, drop jemalloc cache.
+///    - When the hard memory limit is hit, update MemoryTracking metric to throw memory exceptions faster.
+///    The goal of this is to avoid that the process hits the maximum allowed memory limit at which there is a good
+///    chance that the Limux OOM killer terminates it. All of this is done is because internal memory tracking in
+///    ClickHouse can unfortunately under-estimate the actually used memory.
+/// 2. Periodically reads the the maximum memory available to the process (which can change due to cgroups settings).
+///    You can specify a callback to react on changes. The callback typically reloads the configuration, i.e. Server
+///    or Keeper configuration file. This reloads settings 'max_server_memory_usage' (Server) and 'max_memory_usage_soft_limit'
+///    (Keeper) from which various other internal limits are calculated, including the soft and hard limits for (1.).
+///    The goal of this is to provide elasticity when the container is scaled-up/scaled-down. The mechanism (polling
+///    cgroups) is quite implicit, unfortunately there is currently no better way to communicate memory threshold changes
+///    to the database.
 #if defined(OS_LINUX)
 class CgroupsMemoryUsageObserver
 {
 public:
+    using OnMemoryLimitFn = std::function<void(bool)>;
+    using OnMemoryAmountAvailableChangedFn = std::function<void()>;
+
    enum class CgroupsVersion
    {
        V1,
        V2
-
    };
+
    explicit CgroupsMemoryUsageObserver(std::chrono::seconds wait_time_);
    ~CgroupsMemoryUsageObserver();

-    void setLimits(uint64_t hard_limit_, uint64_t soft_limit_);
+    void setMemoryUsageLimits(uint64_t hard_limit_, uint64_t soft_limit_);
+    void setOnMemoryAmountAvailableChangedFn(OnMemoryAmountAvailableChangedFn on_memory_amount_available_changed_);

-    size_t getHardLimit() const { return hard_limit; }
-    size_t getSoftLimit() const { return soft_limit; }
-
-    uint64_t readMemoryUsage() const;
+    void startThread();

 private:
    LoggerPtr log;

-    std::atomic<size_t> hard_limit = 0;
-    std::atomic<size_t> soft_limit = 0;
-
    const std::chrono::seconds wait_time;

-    using CallbackFn = std::function<void(bool)>;
-    CallbackFn on_hard_limit;
-    CallbackFn on_soft_limit;
+    std::mutex limit_mutex;
+    size_t hard_limit TSA_GUARDED_BY(limit_mutex) = 0;
+    size_t soft_limit TSA_GUARDED_BY(limit_mutex) = 0;
+    OnMemoryLimitFn on_hard_limit TSA_GUARDED_BY(limit_mutex);
+    OnMemoryLimitFn on_soft_limit TSA_GUARDED_BY(limit_mutex);

-    uint64_t last_usage = 0;
+    std::mutex memory_amount_available_changed_mutex;
+    OnMemoryAmountAvailableChangedFn on_memory_amount_available_changed TSA_GUARDED_BY(memory_amount_available_changed_mutex);
+
+    uint64_t last_memory_usage = 0;        /// how much memory does the process use
+    uint64_t last_available_memory_amount; /// how much memory can the process use

    /// Represents the cgroup virtual file that shows the memory consumption of the process's cgroup.
-    struct File
+    struct MemoryUsageFile
    {
    public:
-        explicit File(LoggerPtr log_);
-        ~File();
+        explicit MemoryUsageFile(LoggerPtr log_);
+        ~MemoryUsageFile();
        uint64_t readMemoryUsage() const;
    private:
        LoggerPtr log;
@ -62,13 +76,11 @@ private:
        std::string file_name;
    };

-    File file;
+    MemoryUsageFile memory_usage_file;

-    void startThread();
    void stopThread();

    void runThread();
-    void processMemoryUsage(uint64_t usage);

    std::mutex thread_mutex;
    std::condition_variable cond;
@ -79,13 +91,13 @@ private:
 #else
 class CgroupsMemoryUsageObserver
 {
+    using OnMemoryAmountAvailableChangedFn = std::function<void()>;
 public:
    explicit CgroupsMemoryUsageObserver(std::chrono::seconds) {}

-    void setLimits(uint64_t, uint64_t) {}
-    size_t readMemoryUsage() { return 0; }
-    size_t getHardLimit() { return 0; }
-    size_t getSoftLimit() { return 0; }
+    void setMemoryUsageLimits(uint64_t, uint64_t) {}
+    void setOnMemoryAmountAvailableChangedFn(OnMemoryAmountAvailableChangedFn) {}
+    void startThread() {}
 };
 #endif

--- a/src/Common/Config/ConfigProcessor.cpp
+++ b/src/Common/Config/ConfigProcessor.cpp
@ -427,6 +427,8 @@ void ConfigProcessor::doIncludesRecursive(

    /// Replace the original contents, not add to it.
    bool replace = attributes->getNamedItem("replace");
+    /// Merge with the original contents
+    bool merge = attributes->getNamedItem("merge");

    bool included_something = false;

@ -450,7 +452,6 @@ void ConfigProcessor::doIncludesRecursive(
        }
        else
        {
-            /// Replace the whole node not just contents.
            if (node->nodeName() == "include")
            {
                const NodeListPtr children = node_to_include->childNodes();
@ -458,8 +459,18 @@ void ConfigProcessor::doIncludesRecursive(
                for (Node * child = children->item(0); child; child = next_child)
                {
                    next_child = child->nextSibling();
-                    NodePtr new_node = config->importNode(child, true);
-                    node->parentNode()->insertBefore(new_node, node);
+
+                    /// Recursively replace existing nodes in merge mode
+                    if (merge)
+                    {
+                        NodePtr new_node = config->importNode(child->parentNode(), true);
+                        mergeRecursive(config, node->parentNode(), new_node);
+                    }
+                    else  /// Append to existing node by default
+                    {
+                        NodePtr new_node = config->importNode(child, true);
+                        node->parentNode()->insertBefore(new_node, node);
+                    }
                }

                node->parentNode()->removeChild(node);
@ -777,9 +788,9 @@ ConfigProcessor::LoadedConfig ConfigProcessor::loadConfig(bool allow_zk_includes
 }

 ConfigProcessor::LoadedConfig ConfigProcessor::loadConfigWithZooKeeperIncludes(
-        zkutil::ZooKeeperNodeCache & zk_node_cache,
-        const zkutil::EventPtr & zk_changed_event,
-        bool fallback_to_preprocessed)
+    zkutil::ZooKeeperNodeCache & zk_node_cache,
+    const zkutil::EventPtr & zk_changed_event,
+    bool fallback_to_preprocessed)
 {
    XMLDocumentPtr config_xml;
    bool has_zk_includes;
--- a/src/Common/FrequencyHolder.h
+++ b/src/Common/FrequencyHolder.h
@ -47,7 +47,6 @@ public:
        HashMap<UInt16, Float64> map;
    };

-public:
    using Map = HashMap<StringRef, Float64>;
    using Container = std::vector<Language>;

--- a/src/Common/HTTPConnectionPool.h
+++ b/src/Common/HTTPConnectionPool.h
@ -44,11 +44,12 @@ public:
    virtual const Metrics & getMetrics() const = 0;
    virtual ~IHTTPConnectionPoolForEndpoint() = default;

+    IHTTPConnectionPoolForEndpoint(const IHTTPConnectionPoolForEndpoint &) = delete;
+    IHTTPConnectionPoolForEndpoint & operator=(const IHTTPConnectionPoolForEndpoint &) = delete;
+
 protected:
    IHTTPConnectionPoolForEndpoint() = default;

-    IHTTPConnectionPoolForEndpoint(const IHTTPConnectionPoolForEndpoint &) = delete;
-    IHTTPConnectionPoolForEndpoint & operator=(const IHTTPConnectionPoolForEndpoint &) = delete;
 };

 enum class HTTPConnectionGroupType
@ -70,11 +71,12 @@ public:
        static constexpr size_t warning_step = 100;
    };

-private:
-    HTTPConnectionPools();
    HTTPConnectionPools(const HTTPConnectionPools &) = delete;
    HTTPConnectionPools & operator=(const HTTPConnectionPools &) = delete;

+private:
+    HTTPConnectionPools();
+
 public:
    static HTTPConnectionPools & instance();

--- a/src/Common/HashTable/FixedHashMap.h
+++ b/src/Common/HashTable/FixedHashMap.h
@ -109,6 +109,9 @@ public:

    using Base::Base;

+    FixedHashMap() = default;
+    FixedHashMap(size_t ) {} /// NOLINT
+
    template <typename Func, bool>
    void ALWAYS_INLINE mergeToViaEmplace(Self & that, Func && func)
    {
--- a/src/Common/HashTable/HashTable.h
+++ b/src/Common/HashTable/HashTable.h
@ -92,7 +92,8 @@ inline bool bitEquals(T && a, T && b)
    using RealT = std::decay_t<T>;

    if constexpr (std::is_floating_point_v<RealT>)
-        return 0 == memcmp(&a, &b, sizeof(RealT));  /// Note that memcmp with constant size is compiler builtin.
+        /// Note that memcmp with constant size is compiler builtin.
+        return 0 == memcmp(&a, &b, sizeof(RealT)); /// NOLINT
    else
        return a == b;
 }
@ -644,7 +645,7 @@ protected:

        /// Copy to a new location and zero the old one.
        x.setHash(hash_value);
-        memcpy(static_cast<void*>(&buf[place_value]), &x, sizeof(x));
+        memcpy(static_cast<void*>(&buf[place_value]), &x, sizeof(x)); /// NOLINT(bugprone-undefined-memory-manipulation)
        x.setZero();

        /// Then the elements that previously were in collision with this can move to the old place.
--- a/src/Common/HashTable/StringHashMap.h
+++ b/src/Common/HashTable/StringHashMap.h
@ -12,7 +12,7 @@ struct StringHashMapCell : public HashMapCell<Key, TMapped, StringHashTableHash,
    using Base::Base;
    static constexpr bool need_zero_value_storage = false;
    // external
-    StringRef getKey() const { return toStringRef(this->value.first); } /// NOLINT
+    StringRef getKey() const { return toStringView(this->value.first); } /// NOLINT
    // internal
    static const Key & getKey(const value_type & value_) { return value_.first; }
 };
@ -32,7 +32,7 @@ struct StringHashMapCell<StringKey16, TMapped> : public HashMapCell<StringKey16,
    void setZero() { this->value.first.items[1] = 0; }

    // external
-    StringRef getKey() const { return toStringRef(this->value.first); } /// NOLINT
+    StringRef getKey() const { return toStringView(this->value.first); } /// NOLINT
    // internal
    static const StringKey16 & getKey(const value_type & value_) { return value_.first; }
 };
@ -53,7 +53,7 @@ struct StringHashMapCell<StringKey24, TMapped> : public HashMapCell<StringKey24,
    void setZero() { this->value.first.c = 0; }

    // external
-    StringRef getKey() const { return toStringRef(this->value.first); } /// NOLINT
+    StringRef getKey() const { return toStringView(this->value.first); } /// NOLINT
    // internal
    static const StringKey24 & getKey(const value_type & value_) { return value_.first; }
 };
--- a/src/Common/HashTable/StringHashTable.h
+++ b/src/Common/HashTable/StringHashTable.h
@ -19,7 +19,7 @@ struct StringKey24
    bool operator==(const StringKey24 rhs) const { return a == rhs.a && b == rhs.b && c == rhs.c; }
 };

-inline StringRef ALWAYS_INLINE toStringRef(const StringKey8 & n)
+inline StringRef ALWAYS_INLINE toStringView(const StringKey8 & n)
 {
    assert(n != 0);
 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
@ -28,7 +28,7 @@ inline StringRef ALWAYS_INLINE toStringRef(const StringKey8 & n)
    return {reinterpret_cast<const char *>(&n), 8ul - (std::countl_zero(n) >> 3)};
 #endif
 }
-inline StringRef ALWAYS_INLINE toStringRef(const StringKey16 & n)
+inline StringRef ALWAYS_INLINE toStringView(const StringKey16 & n)
 {
    assert(n.items[1] != 0);
 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
@ -37,7 +37,7 @@ inline StringRef ALWAYS_INLINE toStringRef(const StringKey16 & n)
    return {reinterpret_cast<const char *>(&n), 16ul - (std::countl_zero(n.items[1]) >> 3)};
 #endif
 }
-inline StringRef ALWAYS_INLINE toStringRef(const StringKey24 & n)
+inline StringRef ALWAYS_INLINE toStringView(const StringKey24 & n)
 {
    assert(n.c != 0);
 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
--- a/src/Common/HashTable/TwoLevelStringHashTable.h
+++ b/src/Common/HashTable/TwoLevelStringHashTable.h
@ -38,6 +38,7 @@ public:
    Impl impls[NUM_BUCKETS];

    TwoLevelStringHashTable() = default;
+    TwoLevelStringHashTable(size_t ) {} /// NOLINT

    template <typename Source>
    explicit TwoLevelStringHashTable(const Source & src)
--- a/src/Common/HostResolvePool.h
+++ b/src/Common/HostResolvePool.h
@ -67,8 +67,8 @@ public:
    class Entry
    {
    public:
-        explicit Entry(Entry && entry) = default;
-        explicit Entry(Entry & entry) = delete;
+        Entry(Entry && entry) = default;
+        Entry(Entry & entry) = delete;

        // no access as r-value
        const String * operator->() && = delete;
@ -89,7 +89,7 @@ public:

        Entry(HostResolver & pool_, Poco::Net::IPAddress address_)
            : pool(pool_.getWeakFromThis())
-            , address(std::move(address_))
+            , address(address_)
            , resolved_host(address.toString())
        { }

@ -126,14 +126,14 @@ protected:
    struct Record
    {
        Record(Poco::Net::IPAddress address_, Poco::Timestamp resolve_time_)
-            : address(std::move(address_))
+            : address(address_)
            , resolve_time(resolve_time_)
        {}

-        explicit Record(Record && rec) = default;
+        Record(Record && rec) = default;
        Record& operator=(Record && s) = default;

-        explicit Record(const Record & rec) = default;
+        Record(const Record & rec) = default;
        Record& operator=(const Record & s) = default;

        Poco::Net::IPAddress address;
@ -198,10 +198,11 @@ class HostResolversPool
 {
 private:
    HostResolversPool() = default;
+
+public:
    HostResolversPool(const HostResolversPool &) = delete;
    HostResolversPool & operator=(const HostResolversPool &) = delete;

-public:
    static HostResolversPool & instance();

    void dropCache();
--- a/src/Common/IntervalKind.cpp
+++ b/src/Common/IntervalKind.cpp
@ -240,7 +240,7 @@ const char * IntervalKind::toNameOfFunctionExtractTimePart() const
            return "toDayOfMonth";
        case IntervalKind::Kind::Week:
            // TODO: SELECT toRelativeWeekNum(toDate('2017-06-15')) - toRelativeWeekNum(toStartOfYear(toDate('2017-06-15')))
-            // else if (ParserKeyword("WEEK").ignore(pos, expected))
+            // else if (ParserKeyword(Keyword::WEEK).ignore(pos, expected))
            //    function_name = "toRelativeWeekNum";
            throw Exception(ErrorCodes::SYNTAX_ERROR, "The syntax 'EXTRACT(WEEK FROM date)' is not supported, cannot extract the number of a week");
        case IntervalKind::Kind::Month:
--- a/src/Common/MortonUtils.h
+++ b/src/Common/MortonUtils.h
@ -27,7 +27,7 @@
  */


-namespace
+namespace impl
 {
    /// After the most significant bit 1, set all subsequent less significant bits to 1 as well.
    inline UInt64 toMask(UInt64 n)
@ -85,7 +85,7 @@ void intervalBinaryPartition(UInt64 first, UInt64 last, F && callback)
    /// split = 15:   00001111

    UInt64 diff = first ^ last;
-    UInt64 mask = toMask(diff) >> 1;
+    UInt64 mask = impl::toMask(diff) >> 1;

    /// The current interval represents a whole range with fixed prefix.
    if ((first & mask) == 0 && (last & mask) == mask)
--- a/src/Common/NaNUtils.h
+++ b/src/Common/NaNUtils.h
@ -25,6 +25,18 @@ inline bool isFinite(T x)
        return true;
 }

+template <typename T>
+bool canConvertTo(Float64 x)
+{
+    if constexpr (std::is_floating_point_v<T>)
+        return true;
+    if (!isFinite(x))
+        return false;
+    if (x > Float64(std::numeric_limits<T>::max()) || x < Float64(std::numeric_limits<T>::lowest()))
+        return false;
+
+    return true;
+}

 template <typename T>
 T NaNOrZero()
--- a/src/Common/NamedCollections/NamedCollectionUtils.cpp
+++ b/src/Common/NamedCollections/NamedCollectionUtils.cpp
@ -17,6 +17,7 @@
 #include <Common/NamedCollections/NamedCollections.h>
 #include <Common/NamedCollections/NamedCollectionConfiguration.h>

+#include <filesystem>

 namespace fs = std::filesystem;

--- a/src/Common/NetException.h
+++ b/src/Common/NetException.h
@ -29,7 +29,7 @@ public:
    }

    NetException * clone() const override { return new NetException(*this); }
-    void rethrow() const override { throw *this; }
+    void rethrow() const override { throw *this; } /// NOLINT(cert-err60-cpp)

 private:
    const char * name() const noexcept override { return "DB::NetException"; }
--- a/src/Common/PODArray.h
+++ b/src/Common/PODArray.h
@ -301,6 +301,8 @@ public:
    }
 };

+/// NOLINTBEGIN(bugprone-sizeof-expression)
+
 template <typename T, size_t initial_bytes, typename TAllocator, size_t pad_right_, size_t pad_left_>
 class PODArray : public PODArrayBase<sizeof(T), initial_bytes, TAllocator, pad_right_, pad_left_>
 {
@ -755,6 +757,8 @@ public:
    }
 };

+/// NOLINTEND(bugprone-sizeof-expression)
+
 template <typename T, size_t initial_bytes, typename TAllocator, size_t pad_right_, size_t pad_left_>
 void swap(PODArray<T, initial_bytes, TAllocator, pad_right_, pad_left_> & lhs, PODArray<T, initial_bytes, TAllocator, pad_right_, pad_left_> & rhs) /// NOLINT
 {
--- a/src/Common/ProxyConfiguration.h
+++ b/src/Common/ProxyConfiguration.h
@ -50,7 +50,7 @@ struct ProxyConfiguration
    bool tunneling = false;
    Protocol original_request_protocol = Protocol::HTTP;

-    bool isEmpty() const { return host.size() == 0; }
+    bool isEmpty() const { return host.empty(); }
 };

 }
--- a/src/Common/Scheduler/Nodes/DynamicResourceManager.h
+++ b/src/Common/Scheduler/Nodes/DynamicResourceManager.h
@ -85,7 +85,6 @@ private:
        StatePtr state; // hold state to avoid ResourceLink invalidation due to resource deregistration from SchedulerRoot
    };

-private:
    SchedulerRoot scheduler;
    std::mutex mutex;
    StatePtr state;
--- a/src/Common/Scheduler/Nodes/FairPolicy.h
+++ b/src/Common/Scheduler/Nodes/FairPolicy.h
@ -248,7 +248,6 @@ private:
            parent->activateChild(this);
    }

-private:
    /// Beginning of `items` vector is heap of active children: [0; `heap_size`).
    /// Next go inactive children in unsorted order.
    /// NOTE: we have to track vruntime of inactive children for max-min fairness.
--- a/src/Common/Scheduler/SchedulerRoot.h
+++ b/src/Common/Scheduler/SchedulerRoot.h
@ -231,7 +231,6 @@ private:
        value->next = nullptr;
    }

-private:
    void schedulerThread()
    {
        while (!stop_flag.load())
@ -253,7 +252,6 @@ private:
        request->execute();
    }

-private:
    TResource * current = nullptr; // round-robin pointer
    std::unordered_map<ISchedulerNode *, TResource> children; // resources by pointer
    std::atomic<bool> stop_flag = false;
--- a/src/Common/ThreadFuzzer.cpp
+++ b/src/Common/ThreadFuzzer.cpp
@ -86,12 +86,12 @@ static std::atomic<int> num_cpus = 0;
        static std::atomic<double> NAME##_before_yield_probability = 0; \
        static std::atomic<double> NAME##_before_migrate_probability = 0; \
        static std::atomic<double> NAME##_before_sleep_probability = 0; \
-        static std::atomic<double> NAME##_before_sleep_time_us = 0; \
+        static std::atomic<double> NAME##_before_sleep_time_us_max = 0; \
 \
        static std::atomic<double> NAME##_after_yield_probability = 0; \
        static std::atomic<double> NAME##_after_migrate_probability = 0; \
        static std::atomic<double> NAME##_after_sleep_probability = 0; \
-        static std::atomic<double> NAME##_after_sleep_time_us = 0;
+        static std::atomic<double> NAME##_after_sleep_time_us_max = 0;

 FOR_EACH_WRAPPED_FUNCTION(DEFINE_WRAPPER_PARAMS)

@ -110,7 +110,7 @@ void ThreadFuzzer::initConfiguration()
    initFromEnv(yield_probability, "THREAD_FUZZER_YIELD_PROBABILITY");
    initFromEnv(migrate_probability, "THREAD_FUZZER_MIGRATE_PROBABILITY");
    initFromEnv(sleep_probability, "THREAD_FUZZER_SLEEP_PROBABILITY");
-    initFromEnv(sleep_time_us, "THREAD_FUZZER_SLEEP_TIME_US");
+    initFromEnv(sleep_time_us_max, "THREAD_FUZZER_SLEEP_TIME_US_MAX");
    initFromEnv(explicit_sleep_probability, "THREAD_FUZZER_EXPLICIT_SLEEP_PROBABILITY");
    initFromEnv(explicit_memory_exception_probability, "THREAD_FUZZER_EXPLICIT_MEMORY_EXCEPTION_PROBABILITY");

@ -119,13 +119,12 @@ void ThreadFuzzer::initConfiguration()
        initFromEnv(NAME##_before_yield_probability, "THREAD_FUZZER_" #NAME "_BEFORE_YIELD_PROBABILITY"); \
        initFromEnv(NAME##_before_migrate_probability, "THREAD_FUZZER_" #NAME "_BEFORE_MIGRATE_PROBABILITY"); \
        initFromEnv(NAME##_before_sleep_probability, "THREAD_FUZZER_" #NAME "_BEFORE_SLEEP_PROBABILITY"); \
-        initFromEnv(NAME##_before_sleep_time_us, "THREAD_FUZZER_" #NAME "_BEFORE_SLEEP_TIME_US"); \
+        initFromEnv(NAME##_before_sleep_time_us_max, "THREAD_FUZZER_" #NAME "_BEFORE_SLEEP_TIME_US_MAX"); \
 \
        initFromEnv(NAME##_after_yield_probability, "THREAD_FUZZER_" #NAME "_AFTER_YIELD_PROBABILITY"); \
        initFromEnv(NAME##_after_migrate_probability, "THREAD_FUZZER_" #NAME "_AFTER_MIGRATE_PROBABILITY"); \
        initFromEnv(NAME##_after_sleep_probability, "THREAD_FUZZER_" #NAME "_AFTER_SLEEP_PROBABILITY"); \
-        initFromEnv(NAME##_after_sleep_time_us, "THREAD_FUZZER_" #NAME "_AFTER_SLEEP_TIME_US");
-
+        initFromEnv(NAME##_after_sleep_time_us_max, "THREAD_FUZZER_" #NAME "_AFTER_SLEEP_TIME_US_MAX");
    FOR_EACH_WRAPPED_FUNCTION(INIT_WRAPPER_PARAMS)

 #    undef INIT_WRAPPER_PARAMS
@ -146,7 +145,7 @@ bool ThreadFuzzer::isEffective() const
            return true; \
        if (NAME##_before_sleep_probability.load(std::memory_order_relaxed) > 0.0) \
            return true; \
-        if (NAME##_before_sleep_time_us.load(std::memory_order_relaxed) > 0.0) \
+        if (NAME##_before_sleep_time_us_max.load(std::memory_order_relaxed) > 0.0) \
            return true; \
 \
        if (NAME##_after_yield_probability.load(std::memory_order_relaxed) > 0.0) \
@ -155,7 +154,7 @@ bool ThreadFuzzer::isEffective() const
            return true; \
        if (NAME##_after_sleep_probability.load(std::memory_order_relaxed) > 0.0) \
            return true; \
-        if (NAME##_after_sleep_time_us.load(std::memory_order_relaxed) > 0.0) \
+        if (NAME##_after_sleep_time_us_max.load(std::memory_order_relaxed) > 0.0) \
            return true;

    FOR_EACH_WRAPPED_FUNCTION(CHECK_WRAPPER_PARAMS)
@ -166,7 +165,7 @@ bool ThreadFuzzer::isEffective() const
    return cpu_time_period_us != 0
        && (yield_probability > 0
            || migrate_probability > 0
-            || (sleep_probability > 0 && sleep_time_us > 0));
+            || (sleep_probability > 0 && sleep_time_us_max > 0));
 }

 void ThreadFuzzer::stop()
@ -190,7 +189,7 @@ static void injectionImpl(
    double yield_probability,
    double migrate_probability,
    double sleep_probability,
-    double sleep_time_us)
+    double sleep_time_us_max)
 {
    DENY_ALLOCATIONS_IN_SCOPE;
    if (!ThreadFuzzer::isStarted())
@ -221,10 +220,10 @@ static void injectionImpl(
 #endif

    if (sleep_probability > 0
-        && sleep_time_us > 0
+        && sleep_time_us_max > 0
        && std::bernoulli_distribution(sleep_probability)(thread_local_rng))
    {
-        sleepForNanoseconds(static_cast<uint64_t>(sleep_time_us * 1000));
+        sleepForNanoseconds((thread_local_rng() % static_cast<uint64_t>(sleep_time_us_max)) * 1000); /*may sleep(0)*/
    }
 }

@ -232,19 +231,19 @@ static ALWAYS_INLINE void injection(
    double yield_probability,
    double migrate_probability,
    double sleep_probability,
-    double sleep_time_us)
+    double sleep_time_us_max)
 {
    DENY_ALLOCATIONS_IN_SCOPE;
    if (!ThreadFuzzer::isStarted())
        return;

-    injectionImpl(yield_probability, migrate_probability, sleep_probability, sleep_time_us);
+    injectionImpl(yield_probability, migrate_probability, sleep_probability, sleep_time_us_max);
 }

 void ThreadFuzzer::maybeInjectSleep()
 {
    auto & fuzzer = ThreadFuzzer::instance();
-    injection(fuzzer.yield_probability, fuzzer.migrate_probability, fuzzer.explicit_sleep_probability, fuzzer.sleep_time_us);
+    injection(fuzzer.yield_probability, fuzzer.migrate_probability, fuzzer.explicit_sleep_probability, fuzzer.sleep_time_us_max);
 }

 /// Sometimes maybeInjectSleep() is not enough and we need to inject an exception.
@ -265,7 +264,7 @@ void ThreadFuzzer::signalHandler(int)
    DENY_ALLOCATIONS_IN_SCOPE;
    auto saved_errno = errno;
    auto & fuzzer = ThreadFuzzer::instance();
-    injection(fuzzer.yield_probability, fuzzer.migrate_probability, fuzzer.sleep_probability, fuzzer.sleep_time_us);
+    injection(fuzzer.yield_probability, fuzzer.migrate_probability, fuzzer.sleep_probability, fuzzer.sleep_time_us_max);
    errno = saved_errno;
 }

@ -309,13 +308,13 @@ void ThreadFuzzer::setup() const
        NAME##_before_yield_probability.load(std::memory_order_relaxed),   \
        NAME##_before_migrate_probability.load(std::memory_order_relaxed), \
        NAME##_before_sleep_probability.load(std::memory_order_relaxed),   \
-        NAME##_before_sleep_time_us.load(std::memory_order_relaxed));
+        NAME##_before_sleep_time_us_max.load(std::memory_order_relaxed));
 #define INJECTION_AFTER(NAME) \
    injectionImpl(                                                         \
        NAME##_after_yield_probability.load(std::memory_order_relaxed),    \
        NAME##_after_migrate_probability.load(std::memory_order_relaxed),  \
        NAME##_after_sleep_probability.load(std::memory_order_relaxed),    \
-        NAME##_after_sleep_time_us.load(std::memory_order_relaxed));
+        NAME##_after_sleep_time_us_max.load(std::memory_order_relaxed));

 /// ThreadFuzzer intercepts pthread_mutex_lock()/pthread_mutex_unlock().
 ///
--- a/src/Common/ThreadFuzzer.h
+++ b/src/Common/ThreadFuzzer.h
@ -16,7 +16,7 @@ namespace DB
  * THREAD_FUZZER_YIELD_PROBABILITY   - probability to do 'sched_yield'.
  * THREAD_FUZZER_MIGRATE_PROBABILITY - probability to set CPU affinity to random CPU core.
  * THREAD_FUZZER_SLEEP_PROBABILITY   - probability to sleep.
-  * THREAD_FUZZER_SLEEP_TIME_US       - amount of time to sleep in microseconds.
+  * THREAD_FUZZER_SLEEP_TIME_US_MAX   - max amount of time to sleep in microseconds, actual sleep time is randomized.
  *
  * ThreadFuzzer will do nothing if environment variables are not set accordingly.
  *
@ -33,16 +33,14 @@ namespace DB
  *
  * Notes:
  * - it can be also implemented with instrumentation (example: LLVM Xray) instead of signals.
-  * - we should also make the sleep time random.
-  * - sleep and migration obviously helps, but the effect of yield is unclear.
  *
  * In addition, we allow to inject glitches around thread synchronization functions.
  * Example:
  *
  * THREAD_FUZZER_pthread_mutex_lock_BEFORE_SLEEP_PROBABILITY=0.001
-  * THREAD_FUZZER_pthread_mutex_lock_BEFORE_SLEEP_TIME_US=10000
+  * THREAD_FUZZER_pthread_mutex_lock_BEFORE_SLEEP_TIME_US_MAX=10000
  * THREAD_FUZZER_pthread_mutex_lock_AFTER_SLEEP_PROBABILITY=0.001
-  * THREAD_FUZZER_pthread_mutex_lock_AFTER_SLEEP_TIME_US=10000
+  * THREAD_FUZZER_pthread_mutex_lock_AFTER_SLEEP_TIME_US_MAX=10000
  */
 class ThreadFuzzer
 {
@ -67,7 +65,8 @@ private:
    double yield_probability = 0;
    double migrate_probability = 0;
    double sleep_probability = 0;
-    double sleep_time_us = 0;
+    double sleep_time_us_max = 0;
+
    double explicit_sleep_probability = 0;
    double explicit_memory_exception_probability = 0;

--- a/src/Common/ZooKeeper/ZooKeeperImpl.h
+++ b/src/Common/ZooKeeper/ZooKeeperImpl.h
@ -291,7 +291,7 @@ private:
    class ThreadReference
    {
    public:
-        const ThreadReference & operator = (ThreadFromGlobalPool && thread_)
+        ThreadReference & operator = (ThreadFromGlobalPool && thread_)
        {
            std::lock_guard<std::mutex> l(lock);
            thread = std::move(thread_);
--- a/src/Common/ZooKeeper/ZooKeeperRetries.h
+++ b/src/Common/ZooKeeper/ZooKeeperRetries.h
@ -120,7 +120,7 @@ public:

        iteration_succeeded = false;
        user_error.code = code;
-        user_error.message = std::move(message);
+        user_error.message = message;
        user_error.exception = exception;
        keeper_error = KeeperError{};
    }
--- a/src/Common/examples/chaos_sanitizer.cpp
+++ b/src/Common/examples/chaos_sanitizer.cpp
@ -12,7 +12,7 @@
 /** Proves that ThreadFuzzer helps to find concurrency bugs.
  *
  * for i in {1..10}; do ./chaos_sanitizer 1000000; done
-  * for i in {1..10}; do THREAD_FUZZER_CPU_TIME_PERIOD_US=1000 THREAD_FUZZER_SLEEP_PROBABILITY=0.1 THREAD_FUZZER_SLEEP_TIME_US=100000 ./chaos_sanitizer 1000000; done
+  * for i in {1..10}; do THREAD_FUZZER_CPU_TIME_PERIOD_US=1000 THREAD_FUZZER_SLEEP_PROBABILITY=0.1 THREAD_FUZZER_SLEEP_TIME_US_MAX=100000 ./chaos_sanitizer 1000000; done
  */
 int main(int argc, char ** argv)
 {
--- a/src/Common/memory.h
+++ b/src/Common/memory.h
@ -215,7 +215,7 @@ inline ALWAYS_INLINE size_t untrackMemory(void * ptr [[maybe_unused]], Allocatio
 #endif
        trace = CurrentMemoryTracker::free(actual_size);
    }
-    catch (...)
+    catch (...) /// NOLINT(bugprone-empty-catch)
    {
    }

--- a/src/Common/mysqlxx/mysqlxx/Transaction.h
+++ b/src/Common/mysqlxx/mysqlxx/Transaction.h
@ -27,7 +27,7 @@ public:
            if (!finished)
                rollback();
        }
-        catch (...)
+        catch (...) /// NOLINT(bugprone-empty-catch)
        {
        }
    }
--- a/src/Common/mysqlxx/mysqlxx/Types.h
+++ b/src/Common/mysqlxx/mysqlxx/Types.h
@ -36,7 +36,7 @@ using Int64 = int64_t;
 using UInt32 = uint32_t;
 using Int32 = int32_t;

-using MYSQL_LENGTH = unsigned long;
+using MYSQL_LENGTH = unsigned long; /// NOLINT
 using MYSQL_LENGTHS = MYSQL_LENGTH *;
 using MYSQL_FIELDS = MYSQL_FIELD *;

--- a/src/Common/threadPoolCallbackRunner.h
+++ b/src/Common/threadPoolCallbackRunner.h
@ -57,7 +57,7 @@ template <typename Result, typename T>
 std::future<Result> scheduleFromThreadPool(T && task, ThreadPool & pool, const std::string & thread_name, Priority priority = {})
 {
    auto schedule = threadPoolCallbackRunner<Result, T>(pool, thread_name);
-    return schedule(std::move(task), priority);
+    return schedule(std::move(task), priority); /// NOLINT
 }

 }
--- a/src/Compression/CompressionCodecDeflateQpl.h
+++ b/src/Compression/CompressionCodecDeflateQpl.h
@ -26,7 +26,7 @@ public:

    qpl_job * acquireJob(UInt32 & job_id);
    void releaseJob(UInt32 job_id);
-    const bool & isJobPoolReady() { return job_pool_ready; }
+    const bool & isJobPoolReady() const { return job_pool_ready; }

 private:
    bool tryLockJob(UInt32 index);
--- a/src/Coordination/WriteBufferFromNuraftBuffer.h
+++ b/src/Coordination/WriteBufferFromNuraftBuffer.h
@ -16,7 +16,7 @@ public:
    ~WriteBufferFromNuraftBuffer() override;

 private:
-    void finalizeImpl() override final;
+    void finalizeImpl() final;

    void nextImpl() override;

--- a/src/Core/BaseSettings.cpp
+++ b/src/Core/BaseSettings.cpp
@ -41,13 +41,13 @@ BaseSettingsHelpers::Flags BaseSettingsHelpers::readFlags(ReadBuffer & in)

 void BaseSettingsHelpers::throwSettingNotFound(std::string_view name)
 {
-    throw Exception(ErrorCodes::UNKNOWN_SETTING, "Unknown setting {}", String{name});
+    throw Exception(ErrorCodes::UNKNOWN_SETTING, "Unknown setting '{}'", String{name});
 }


 void BaseSettingsHelpers::warningSettingNotFound(std::string_view name)
 {
-    LOG_WARNING(getLogger("Settings"), "Unknown setting {}, skipping", name);
+    LOG_WARNING(getLogger("Settings"), "Unknown setting '{}', skipping", name);
 }

 }
--- a/src/Core/Field.h
+++ b/src/Core/Field.h
@ -40,6 +40,7 @@ using FieldVector = std::vector<Field, AllocatorWithMemoryTracking<Field>>;
 /// construct a Field of Array or a Tuple type. An alternative approach would be
 /// to construct both of these types from FieldVector, and have the caller
 /// specify the desired Field type explicitly.
+/// NOLINTBEGIN(modernize-type-traits)
 #define DEFINE_FIELD_VECTOR(X) \
 struct X : public FieldVector \
 { \
@ -48,6 +49,7 @@ struct X : public FieldVector \

 DEFINE_FIELD_VECTOR(Array);
 DEFINE_FIELD_VECTOR(Tuple);
+/// NOLINTEND(modernize-type-traits)

 /// An array with the following structure: [(key1, value1), (key2, value2), ...]
 DEFINE_FIELD_VECTOR(Map); /// TODO: use map instead of vector.
--- a/src/Core/MySQL/MySQLReplication.h
+++ b/src/Core/MySQL/MySQLReplication.h
@ -546,7 +546,7 @@ namespace MySQLReplication
        virtual void setGTIDSets(GTIDSets sets) = 0;
        virtual void setChecksumSignatureLength(size_t checksum_signature_length_) = 0;

-        virtual ~IFlavor() override = default;
+        ~IFlavor() override = default;
    };

    class MySQLFlavor : public IFlavor
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@ -175,6 +175,7 @@ class IColumn;
    M(Bool, enable_positional_arguments, true, "Enable positional arguments in ORDER BY, GROUP BY and LIMIT BY", 0) \
    M(Bool, enable_extended_results_for_datetime_functions, false, "Enable date functions like toLastDayOfMonth return Date32 results (instead of Date results) for Date32/DateTime64 arguments.", 0) \
    M(Bool, allow_nonconst_timezone_arguments, false, "Allow non-const timezone arguments in certain time-related functions like toTimeZone(), fromUnixTimestamp*(), snowflakeToDateTime*()", 0) \
+    M(Bool, function_locate_has_mysql_compatible_argument_order, true, "Function locate() has arguments (needle, haystack[, start_pos]) like in MySQL instead of (haystack, needle[, start_pos]) like function position()", 0) \
    \
    M(Bool, group_by_use_nulls, false, "Treat columns mentioned in ROLLUP, CUBE or GROUPING SETS as Nullable", 0) \
    \
@ -840,6 +841,9 @@ class IColumn;
    M(Bool, compatibility_ignore_auto_increment_in_create_table, false, "Ignore AUTO_INCREMENT keyword in column declaration if true, otherwise return error. It simplifies migration from MySQL", 0) \
    M(Bool, multiple_joins_try_to_keep_original_names, false, "Do not add aliases to top level expression list on multiple joins rewrite", 0) \
    M(Bool, optimize_sorting_by_input_stream_properties, true, "Optimize sorting by sorting properties of input stream", 0) \
+    M(UInt64, keeper_max_retries, 10, "Max retries for general keeper operations", 0) \
+    M(UInt64, keeper_retry_initial_backoff_ms, 100, "Initial backoff timeout for general keeper operations", 0) \
+    M(UInt64, keeper_retry_max_backoff_ms, 5000, "Max backoff timeout for general keeper operations", 0) \
    M(UInt64, insert_keeper_max_retries, 20, "Max retries for keeper operations during insert", 0) \
    M(UInt64, insert_keeper_retry_initial_backoff_ms, 100, "Initial backoff timeout for keeper operations during insert", 0) \
    M(UInt64, insert_keeper_retry_max_backoff_ms, 10000, "Max backoff timeout for keeper operations during insert", 0) \
@ -1194,7 +1198,6 @@ class IColumn;
    FORMAT_FACTORY_SETTINGS(M, ALIAS)  \
    OBSOLETE_FORMAT_SETTINGS(M, ALIAS) \

-/// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
 DECLARE_SETTINGS_TRAITS_ALLOW_CUSTOM_SETTINGS(SettingsTraits, LIST_OF_SETTINGS)


@ -1239,7 +1242,6 @@ private:
 /*
 * User-specified file format settings for File and URL engines.
 */
-/// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
 DECLARE_SETTINGS_TRAITS(FormatFactorySettingsTraits, LIST_OF_ALL_FORMAT_SETTINGS)

 struct FormatFactorySettings : public BaseSettings<FormatFactorySettingsTraits>
--- a/src/Core/SettingsChangesHistory.h
+++ b/src/Core/SettingsChangesHistory.h
@ -94,8 +94,12 @@ static std::map<ClickHouseVersion, SettingsChangesHistory::SettingsChanges> sett
              {"input_format_json_use_string_type_for_ambiguous_paths_in_named_tuples_inference_from_objects", false, false, "Allow to use String type for ambiguous paths during named tuple inference from JSON objects"},
              {"throw_if_deduplication_in_dependent_materialized_views_enabled_with_async_insert", false, true, "Deduplication is dependent materialized view cannot work together with async inserts."},
              {"parallel_replicas_allow_in_with_subquery", false, true, "If true, subquery for IN will be executed on every follower replica"},
+              {"function_locate_has_mysql_compatible_argument_order", false, true, "Increase compatibility with MySQL's locate function."},
              {"filesystem_cache_reserve_space_wait_lock_timeout_milliseconds", 1000, 1000, "Wait time to lock cache for sapce reservation in filesystem cache"},
              {"max_parser_backtracks", 0, 1000000, "Limiting the complexity of parsing"},
+              {"keeper_max_retries", 10, 10, "Max retries for general keeper operations"},
+              {"keeper_retry_initial_backoff_ms", 100, 100, "Initial backoff timeout for general keeper operations"},
+              {"keeper_retry_max_backoff_ms", 5000, 5000, "Max backoff timeout for general keeper operations"},
              }},
    {"24.2", {{"allow_suspicious_variant_types", true, false, "Don't allow creating Variant type with suspicious variants by default"},
              {"validate_experimental_and_suspicious_types_inside_nested_types", false, true, "Validate usage of experimental and suspicious types inside nested types"},
--- a/src/Core/tests/gtest_charset_conv.cpp
+++ b/src/Core/tests/gtest_charset_conv.cpp
@ -5,14 +5,12 @@
 namespace DB
 {

-// NOLINTBEGIN(clang-analyzer-optin.performance.Padding)
 struct CheckResult
 {
    Int32 id;
    String name;
    bool need_convert;
 };
-// NOLINTEND(clang-analyzer-optin.performance.Padding)

 TEST(CharsetTest, CharsetTest)
 {
--- a/src/Daemon/BaseDaemon.h
+++ b/src/Daemon/BaseDaemon.h
@ -103,7 +103,7 @@ public:

    GraphiteWriter * getGraphiteWriter(const std::string & config_name = DEFAULT_GRAPHITE_CONFIG_NAME)
    {
-        if (graphite_writers.count(config_name))
+        if (graphite_writers.contains(config_name))
            return graphite_writers[config_name].get();
        return nullptr;
    }
@ -183,7 +183,7 @@ std::optional<std::reference_wrapper<Daemon>> BaseDaemon::tryGetInstance()
    {
        ptr = dynamic_cast<Daemon *>(&Poco::Util::Application::instance());
    }
-    catch (const Poco::NullPointerException &)
+    catch (const Poco::NullPointerException &) /// NOLINT(bugprone-empty-catch)
    {
        /// if daemon doesn't exist than instance() throw NullPointerException
    }
--- a/src/DataTypes/NumberTraits.h
+++ b/src/DataTypes/NumberTraits.h
@ -217,11 +217,13 @@ template <typename A> struct ToInteger

 // CLICKHOUSE-29. The same depth, different signs
 // NOTE: This case is applied for 64-bit integers only (for backward compatibility), but could be used for any-bit integers
+/// NOLINTBEGIN(misc-redundant-expression)
 template <typename A, typename B>
 constexpr bool LeastGreatestSpecialCase =
    std::is_integral_v<A> && std::is_integral_v<B>
    && (8 == sizeof(A) && sizeof(A) == sizeof(B))
    && (is_signed_v<A> ^ is_signed_v<B>);
+/// NOLINTEND(misc-redundant-expression)

 template <typename A, typename B>
 using ResultOfLeast = std::conditional_t<LeastGreatestSpecialCase<A, B>,
--- a/src/DataTypes/Serializations/SerializationCustomSimpleText.h
+++ b/src/DataTypes/Serializations/SerializationCustomSimpleText.h
@ -18,7 +18,7 @@ public:
    explicit SerializationCustomSimpleText(const SerializationPtr & nested_);

    // Methods that subclasses must override in order to get full serialization/deserialization support.
-    virtual void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override = 0;
+    void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override = 0;
    /// whole = true means that buffer contains only one value, so we should read until EOF.
    /// It's needed to check if there is garbage after parsed field.
    virtual void deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings &, bool whole) const = 0;
--- a/src/DataTypes/Serializations/SerializationSparse.h
+++ b/src/DataTypes/Serializations/SerializationSparse.h
@ -27,7 +27,7 @@ public:

    Kind getKind() const override { return Kind::SPARSE; }

-    virtual void enumerateStreams(
+    void enumerateStreams(
        EnumerateStreamsSettings & settings,
        const StreamCallback & callback,
        const SubstreamData & data) const override;
--- a/src/DataTypes/Serializations/SerializationVariantElement.cpp
+++ b/src/DataTypes/Serializations/SerializationVariantElement.cpp
@ -205,8 +205,8 @@ void SerializationVariantElement::removeVariantFromPath(DB::ISerialization::Subs
 SerializationVariantElement::VariantSubcolumnCreator::VariantSubcolumnCreator(
    const ColumnPtr & local_discriminators_,
    const String & variant_element_name_,
-    const ColumnVariant::Discriminator global_variant_discriminator_,
-    const ColumnVariant::Discriminator local_variant_discriminator_)
+    ColumnVariant::Discriminator global_variant_discriminator_,
+    ColumnVariant::Discriminator local_variant_discriminator_)
    : local_discriminators(local_discriminators_)
    , variant_element_name(variant_element_name_)
    , global_variant_discriminator(global_variant_discriminator_)
--- a/Show More
+++ b/Show More