Merge branch 'master' into dynamic-constraints

2024-11-21 23:21:59 +00:00 · 2024-10-09 11:22:30 +08:00 · 2024-10-09 11:22:30 +08:00 · e0ae648b1c
commit e0ae648b1c
parent 41588b05cf eefe70472e
945 changed files with 10348 additions and 8456 deletions
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@ -16,3 +16,6 @@

 # Applied Black formatter for Python code
 e6f5a3f98b21ba99cf274a9833797889e020a2b3
+
+# Enabling clang-tidy readability-else-no-return rule
+67c1e89d90ef576e62f8b1c68269742a3c6f9b1e
--- a/base/base/DecomposedFloat.h
+++ b/base/base/DecomposedFloat.h
@ -110,7 +110,6 @@ struct DecomposedFloat
        {
            if (!isNegative())
                return rhs > 0 ? -1 : 1;
-            else
            return rhs >= 0 ? -1 : 1;
        }

@ -128,7 +127,6 @@ struct DecomposedFloat

                if (mantissa() == 0)
                    return 0;
-                else
                return -1;
            }
        }
@ -169,7 +167,6 @@ struct DecomposedFloat
        /// Float has no fractional part means that the numbers are equal.
        if (large_and_always_integer || (mantissa() & ((1ULL << (Traits::mantissa_bits - normalizedExponent())) - 1)) == 0)
            return 0;
-        else
        /// Float has fractional part means its abs value is larger.
        return isNegative() ? -1 : 1;
    }
--- a/base/base/JSON.cpp
+++ b/base/base/JSON.cpp
@ -205,7 +205,6 @@ JSON::ElementType JSON::getType() const
            Pos after_string = skipString();
            if (after_string < ptr_end && *after_string == ':')
                return TYPE_NAME_VALUE_PAIR;
-            else
            return TYPE_STRING;
        }
        default:
@ -474,7 +473,6 @@ JSON::Pos JSON::searchField(const char * data, size_t size) const

    if (it == end())
        return nullptr;
-    else
    return it->data();
 }

@ -487,7 +485,7 @@ bool JSON::hasEscapes() const

    if (*pos == '"')
        return false;
-    else if (*pos == '\\')
+    if (*pos == '\\')
        return true;
    throw JSONException("JSON: unexpected end of data.");
 }
@ -503,7 +501,7 @@ bool JSON::hasSpecialChars() const

    if (*pos == '"')
        return false;
-    else if (pos < ptr_end)
+    if (pos < ptr_end)
        return true;
    throw JSONException("JSON: unexpected end of data.");
 }
@ -682,9 +680,8 @@ double JSON::toDouble() const

    if (type == TYPE_NUMBER)
        return getDouble();
-    else if (type == TYPE_STRING)
+    if (type == TYPE_STRING)
        return JSON(ptr_begin + 1, ptr_end, level + 1).getDouble();
-    else
    throw JSONException("JSON: cannot convert value to double.");
 }

@ -694,9 +691,8 @@ Int64 JSON::toInt() const

    if (type == TYPE_NUMBER)
        return getInt();
-    else if (type == TYPE_STRING)
+    if (type == TYPE_STRING)
        return JSON(ptr_begin + 1, ptr_end, level + 1).getInt();
-    else
    throw JSONException("JSON: cannot convert value to signed integer.");
 }

@ -706,9 +702,8 @@ UInt64 JSON::toUInt() const

    if (type == TYPE_NUMBER)
        return getUInt();
-    else if (type == TYPE_STRING)
+    if (type == TYPE_STRING)
        return JSON(ptr_begin + 1, ptr_end, level + 1).getUInt();
-    else
    throw JSONException("JSON: cannot convert value to unsigned integer.");
 }

@ -718,12 +713,10 @@ std::string JSON::toString() const

    if (type == TYPE_STRING)
        return getString();
-    else
-    {
+
    Pos pos = skipElement();
    return std::string(ptr_begin, pos - ptr_begin);
 }
-}


 JSON::iterator JSON::iterator::begin() const
--- a/base/base/JSON.h
+++ b/base/base/JSON.h
@ -203,9 +203,7 @@ T JSON::getWithDefault(const std::string & key, const T & default_) const

        if (key_json.isType<T>())
            return key_json.get<T>();
-        else
        return default_;
    }
-    else
    return default_;
 }
--- a/base/base/StringRef.h
+++ b/base/base/StringRef.h
@ -151,19 +151,19 @@ inline bool memequalWide(const char * p1, const char * p2, size_t size)
            return unalignedLoad<uint64_t>(p1) == unalignedLoad<uint64_t>(p2)
                && unalignedLoad<uint64_t>(p1 + size - 8) == unalignedLoad<uint64_t>(p2 + size - 8);
        }
-        else if (size >= 4)
+        if (size >= 4)
        {
            /// Chunks of 4..7 bytes.
            return unalignedLoad<uint32_t>(p1) == unalignedLoad<uint32_t>(p2)
                && unalignedLoad<uint32_t>(p1 + size - 4) == unalignedLoad<uint32_t>(p2 + size - 4);
        }
-        else if (size >= 2)
+        if (size >= 2)
        {
            /// Chunks of 2..3 bytes.
            return unalignedLoad<uint16_t>(p1) == unalignedLoad<uint16_t>(p2)
                && unalignedLoad<uint16_t>(p1 + size - 2) == unalignedLoad<uint16_t>(p2 + size - 2);
        }
-        else if (size >= 1)
+        if (size >= 1)
        {
            /// A single byte.
            return *p1 == *p2;
--- a/base/base/argsToConfig.cpp
+++ b/base/base/argsToConfig.cpp
@ -53,10 +53,9 @@ void argsToConfig(const Poco::Util::Application::ArgVec & argv,
                key = arg.substr(key_start);
            continue;
        }
-        else
-        {
+
        key = "";
-        }
+

        if (key_start == std::string::npos)
            continue;
--- a/base/base/find_symbols.h
+++ b/base/base/find_symbols.h
@ -330,7 +330,6 @@ inline const char * find_first_symbols_dispatch(const char * begin, const char *
 #if defined(__SSE4_2__)
    if (sizeof...(symbols) >= 5)
        return find_first_symbols_sse42<positive, return_mode, sizeof...(symbols), symbols...>(begin, end);
-    else
 #endif
    return find_first_symbols_sse2<positive, return_mode, symbols...>(begin, end);
 }
@ -341,7 +340,6 @@ inline const char * find_first_symbols_dispatch(const std::string_view haystack,
 #if defined(__SSE4_2__)
    if (symbols.str.size() >= 5)
        return find_first_symbols_sse42<positive, return_mode>(haystack.begin(), haystack.end(), symbols);
-    else
 #endif
    return find_first_symbols_sse2<positive, return_mode>(haystack.begin(), haystack.end(), symbols.str.data(), symbols.str.size());
 }
--- a/base/base/getMemoryAmount.cpp
+++ b/base/base/getMemoryAmount.cpp
@ -33,7 +33,6 @@ std::optional<uint64_t> getCgroupsV2MemoryLimit()
            uint64_t value;
            if (setting_file >> value)
                return {value};
-            else
            return {}; /// e.g. the cgroups default "max"
        }
        current_cgroup = current_cgroup.parent_path();
--- a/docs/changelogs/v24.3.12.75-lts.md
+++ b/docs/changelogs/v24.3.12.75-lts.md
@ -0,0 +1,49 @@
+---
+sidebar_position: 1
+sidebar_label: 2024
+---
+
+# 2024 Changelog
+
+### ClickHouse release v24.3.12.75-lts (7cb5dff8019) FIXME as compared to v24.3.11.7-lts (28795d0a47e)
+
+#### Improvement
+* Backported in [#69607](https://github.com/ClickHouse/ClickHouse/issues/69607): Improved memory accounting for cgroups v2 to exclude the amount occupied by the page cache. [#65470](https://github.com/ClickHouse/ClickHouse/pull/65470) ([Nikita Taranov](https://github.com/nickitat)).
+
+#### Bug Fix (user-visible misbehavior in an official stable release)
+* Backported in [#69785](https://github.com/ClickHouse/ClickHouse/issues/69785): Fix attaching table when pg dbname contains "-" in MaterializedPostgreSQL. [#62730](https://github.com/ClickHouse/ClickHouse/pull/62730) ([takakawa](https://github.com/takakawa)).
+* Backported in [#69461](https://github.com/ClickHouse/ClickHouse/issues/69461): Fix expiration in `RoleCache`. [#67748](https://github.com/ClickHouse/ClickHouse/pull/67748) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Backported in [#68217](https://github.com/ClickHouse/ClickHouse/issues/68217): Fixed a NULL pointer dereference, triggered by a specially crafted query, that crashed the server via hopEnd, hopStart, tumbleEnd, and tumbleStart. [#68098](https://github.com/ClickHouse/ClickHouse/pull/68098) ([Salvatore Mesoraca](https://github.com/aiven-sal)).
+* Backported in [#69437](https://github.com/ClickHouse/ClickHouse/issues/69437): After unexpected restart, fail to start replication of ReplicatedMergeTree due to abnormal handling of covered-by-broken part. [#68584](https://github.com/ClickHouse/ClickHouse/pull/68584) ([baolin](https://github.com/baolinhuang)).
+* Backported in [#69827](https://github.com/ClickHouse/ClickHouse/issues/69827): Make `ColumnsDescription::toString` format each column using the same `IAST::FormatState object`. This results in uniform columns metadata being written to disk and ZooKeeper. [#68733](https://github.com/ClickHouse/ClickHouse/pull/68733) ([Miсhael Stetsyuk](https://github.com/mstetsyuk)).
+* Backported in [#69294](https://github.com/ClickHouse/ClickHouse/issues/69294): Fix merging of aggregated data for grouping sets. [#68744](https://github.com/ClickHouse/ClickHouse/pull/68744) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Backported in [#70470](https://github.com/ClickHouse/ClickHouse/issues/70470): Fix inf loop after `restore replica` in the replicated merge tree with zero copy. [#69293](https://github.com/ClickHouse/ClickHouse/pull/69293) ([MikhailBurdukov](https://github.com/MikhailBurdukov)).
+* Backported in [#69456](https://github.com/ClickHouse/ClickHouse/issues/69456): Fix undefined behavior when all connection attempts fail getting a connection for insertions. [#69390](https://github.com/ClickHouse/ClickHouse/pull/69390) ([Pablo Marcos](https://github.com/pamarcos)).
+* Backported in [#69497](https://github.com/ClickHouse/ClickHouse/issues/69497): Fixed a `LOGICAL_ERROR` with function `sqidDecode` ([#69450](https://github.com/ClickHouse/ClickHouse/issues/69450)). [#69451](https://github.com/ClickHouse/ClickHouse/pull/69451) ([Robert Schulze](https://github.com/rschu1ze)).
+* Backported in [#69724](https://github.com/ClickHouse/ClickHouse/issues/69724): Keep original order of conditions during move to prewhere. Previously the order could change and it could lead to failing queries when the order is important. [#69560](https://github.com/ClickHouse/ClickHouse/pull/69560) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#69668](https://github.com/ClickHouse/ClickHouse/issues/69668): Fix Keeper multi-request preprocessing after ZNOAUTH error. [#69627](https://github.com/ClickHouse/ClickHouse/pull/69627) ([Antonio Andelic](https://github.com/antonio2368)).
+* Backported in [#69792](https://github.com/ClickHouse/ClickHouse/issues/69792): Make getHyperrectangleForRowGroup not throw an exception when the data type in parquet file is not convertable into the requested data type. Solved the user's problem when the Parquet file had Decimal64 data type and the column data type was DateTime. [#69745](https://github.com/ClickHouse/ClickHouse/pull/69745) ([Miсhael Stetsyuk](https://github.com/mstetsyuk)).
+* Backported in [#70089](https://github.com/ClickHouse/ClickHouse/issues/70089): Now SQL security will work with parameterized views correctly. [#69984](https://github.com/ClickHouse/ClickHouse/pull/69984) ([pufit](https://github.com/pufit)).
+* Backported in [#70077](https://github.com/ClickHouse/ClickHouse/issues/70077): Closes [#69752](https://github.com/ClickHouse/ClickHouse/issues/69752). [#69985](https://github.com/ClickHouse/ClickHouse/pull/69985) ([pufit](https://github.com/pufit)).
+* Backported in [#70162](https://github.com/ClickHouse/ClickHouse/issues/70162): Fix wrong LOGICAL_ERROR when replacing literals in ranges. [#70122](https://github.com/ClickHouse/ClickHouse/pull/70122) ([Pablo Marcos](https://github.com/pamarcos)).
+* Backported in [#70232](https://github.com/ClickHouse/ClickHouse/issues/70232): Check for Nullable(Nothing) type during ALTER TABLE MODIFY COLUMN/QUERY to prevent tables with such data type. [#70123](https://github.com/ClickHouse/ClickHouse/pull/70123) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70179](https://github.com/ClickHouse/ClickHouse/issues/70179): Fix data race in ColumnObject/ColumnTuple decompress method that could lead to heap use after free. [#70137](https://github.com/ClickHouse/ClickHouse/pull/70137) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70241](https://github.com/ClickHouse/ClickHouse/issues/70241): Fix the password being displayed in `system.query_log` for users with bcrypt password authentication method. [#70148](https://github.com/ClickHouse/ClickHouse/pull/70148) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Backported in [#70397](https://github.com/ClickHouse/ClickHouse/issues/70397): Fix crash when using WITH FILL incorrectly. [#70338](https://github.com/ClickHouse/ClickHouse/pull/70338) ([Raúl Marín](https://github.com/Algunenano)).
+
+#### NO CL CATEGORY
+
+* Backported in [#69526](https://github.com/ClickHouse/ClickHouse/issues/69526):. [#67029](https://github.com/ClickHouse/ClickHouse/pull/67029) ([Alexander Tokmakov](https://github.com/tavplubix)).
+
+#### NOT FOR CHANGELOG / INSIGNIFICANT
+
+* Backported in [#69506](https://github.com/ClickHouse/ClickHouse/issues/69506): Better handling of errors from azure storage. [#62306](https://github.com/ClickHouse/ClickHouse/pull/62306) ([Anton Popov](https://github.com/CurtizJ)).
+* Backported in [#69955](https://github.com/ClickHouse/ClickHouse/issues/69955): Output an operation error for ZK Multi request failed operation into log. [#68127](https://github.com/ClickHouse/ClickHouse/pull/68127) ([Aleksei Filatov](https://github.com/aalexfvk)).
+* Backported in [#69485](https://github.com/ClickHouse/ClickHouse/issues/69485): Fix test_role & test_keeper_s3_snapshot integration tests. [#69013](https://github.com/ClickHouse/ClickHouse/pull/69013) ([Shankar](https://github.com/shiyer7474)).
+* Backported in [#70028](https://github.com/ClickHouse/ClickHouse/issues/70028): Remove stale moving parts without zookeeper. [#69075](https://github.com/ClickHouse/ClickHouse/pull/69075) ([Kirill](https://github.com/kirillgarbar)).
+* Backported in [#69421](https://github.com/ClickHouse/ClickHouse/issues/69421): Fix: Not-ready Set with parallel replicas. [#69264](https://github.com/ClickHouse/ClickHouse/pull/69264) ([Igor Nikonov](https://github.com/devcrafter)).
+* Backported in [#69747](https://github.com/ClickHouse/ClickHouse/issues/69747): Add function `kill_ci_runner`. Kill runner when pre-pull failed. [#69557](https://github.com/ClickHouse/ClickHouse/pull/69557) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Backported in [#69636](https://github.com/ClickHouse/ClickHouse/issues/69636): Add more contexts to the debug action and use it broadly. [#69599](https://github.com/ClickHouse/ClickHouse/pull/69599) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* The test is flaky and the feature experimental. [#70269](https://github.com/ClickHouse/ClickHouse/pull/70269) ([Raúl Marín](https://github.com/Algunenano)).
+* Fix test distributed inter server secret in 24.3. [#70325](https://github.com/ClickHouse/ClickHouse/pull/70325) ([Raúl Marín](https://github.com/Algunenano)).
+
--- a/docs/changelogs/v24.8.5.115-lts.md
+++ b/docs/changelogs/v24.8.5.115-lts.md
@ -0,0 +1,73 @@
+---
+sidebar_position: 1
+sidebar_label: 2024
+---
+
+# 2024 Changelog
+
+### ClickHouse release v24.8.5.115-lts (8c4cb00a384) FIXME as compared to v24.8.4.13-lts (53195bc189b)
+
+#### Improvement
+* Backported in [#70046](https://github.com/ClickHouse/ClickHouse/issues/70046): Add new column readonly_duration to the system.replicas table. Needed to be able to distinguish actual readonly replicas from sentinel ones in alerts. [#69871](https://github.com/ClickHouse/ClickHouse/pull/69871) ([Miсhael Stetsyuk](https://github.com/mstetsyuk)).
+
+#### Bug Fix (user-visible misbehavior in an official stable release)
+* Backported in [#69786](https://github.com/ClickHouse/ClickHouse/issues/69786): Fix attaching table when pg dbname contains "-" in MaterializedPostgreSQL. [#62730](https://github.com/ClickHouse/ClickHouse/pull/62730) ([takakawa](https://github.com/takakawa)).
+* Backported in [#70318](https://github.com/ClickHouse/ClickHouse/issues/70318): Fixed error on generated columns in MaterializedPostgreSQL when adnum ordering is broken [#63161](https://github.com/ClickHouse/ClickHouse/issues/63161). Fixed error on id column with nextval expression as default MaterializedPostgreSQL when there are generated columns in table. Fixed error on dropping publication with symbols except [a-z1-9-]. [#67664](https://github.com/ClickHouse/ClickHouse/pull/67664) ([Kruglov Kirill](https://github.com/1on)).
+* Backported in [#69467](https://github.com/ClickHouse/ClickHouse/issues/69467): Fix expiration in `RoleCache`. [#67748](https://github.com/ClickHouse/ClickHouse/pull/67748) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Backported in [#69735](https://github.com/ClickHouse/ClickHouse/issues/69735): Fix crash in `lag`/`lead` which is introduced in [#67091](https://github.com/ClickHouse/ClickHouse/issues/67091). [#68262](https://github.com/ClickHouse/ClickHouse/pull/68262) ([lgbo](https://github.com/lgbo-ustc)).
+* Backported in [#69444](https://github.com/ClickHouse/ClickHouse/issues/69444): After unexpected restart, fail to start replication of ReplicatedMergeTree due to abnormal handling of covered-by-broken part. [#68584](https://github.com/ClickHouse/ClickHouse/pull/68584) ([baolin](https://github.com/baolinhuang)).
+* Backported in [#69810](https://github.com/ClickHouse/ClickHouse/issues/69810): Make `ColumnsDescription::toString` format each column using the same `IAST::FormatState object`. This results in uniform columns metadata being written to disk and ZooKeeper. [#68733](https://github.com/ClickHouse/ClickHouse/pull/68733) ([Miсhael Stetsyuk](https://github.com/mstetsyuk)).
+* Backported in [#69757](https://github.com/ClickHouse/ClickHouse/issues/69757): Fix incorrect results of Fix uniq and GROUP BY for JSON/Dynamic types. [#69203](https://github.com/ClickHouse/ClickHouse/pull/69203) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70195](https://github.com/ClickHouse/ClickHouse/issues/70195): Fix insertion of incomplete type into Dynamic during deserialization. It could lead to `Parameter out of bound` errors. [#69291](https://github.com/ClickHouse/ClickHouse/pull/69291) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#69398](https://github.com/ClickHouse/ClickHouse/issues/69398): Mark Dynamic type as not safe primary key type to avoid issues with Fields. [#69311](https://github.com/ClickHouse/ClickHouse/pull/69311) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#69704](https://github.com/ClickHouse/ClickHouse/issues/69704): Improve restoring of access entities' dependencies. [#69346](https://github.com/ClickHouse/ClickHouse/pull/69346) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Backported in [#69459](https://github.com/ClickHouse/ClickHouse/issues/69459): Fix undefined behavior when all connection attempts fail getting a connection for insertions. [#69390](https://github.com/ClickHouse/ClickHouse/pull/69390) ([Pablo Marcos](https://github.com/pamarcos)).
+* Backported in [#69503](https://github.com/ClickHouse/ClickHouse/issues/69503): Fixed a `LOGICAL_ERROR` with function `sqidDecode` ([#69450](https://github.com/ClickHouse/ClickHouse/issues/69450)). [#69451](https://github.com/ClickHouse/ClickHouse/pull/69451) ([Robert Schulze](https://github.com/rschu1ze)).
+* Backported in [#69480](https://github.com/ClickHouse/ClickHouse/issues/69480): Quick fix for s3queue problem on 24.6 or create query with database replicated. [#69454](https://github.com/ClickHouse/ClickHouse/pull/69454) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Backported in [#69535](https://github.com/ClickHouse/ClickHouse/issues/69535): Fixed case when memory consumption was too high because of the squashing in `INSERT INTO ... SELECT` or `CREATE TABLE AS SELECT` queries. [#69469](https://github.com/ClickHouse/ClickHouse/pull/69469) ([Yarik Briukhovetskyi](https://github.com/yariks5s)).
+* Backported in [#69696](https://github.com/ClickHouse/ClickHouse/issues/69696): Keep original order of conditions during move to prewhere. Previously the order could change and it could lead to failing queries when the order is important. [#69560](https://github.com/ClickHouse/ClickHouse/pull/69560) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70439](https://github.com/ClickHouse/ClickHouse/issues/70439): Fix vrash during insertion into FixedString column in PostgreSQL engine. [#69584](https://github.com/ClickHouse/ClickHouse/pull/69584) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#69666](https://github.com/ClickHouse/ClickHouse/issues/69666): Fix Keeper multi-request preprocessing after ZNOAUTH error. [#69627](https://github.com/ClickHouse/ClickHouse/pull/69627) ([Antonio Andelic](https://github.com/antonio2368)).
+* Backported in [#70191](https://github.com/ClickHouse/ClickHouse/issues/70191): Fix crash when executing `create view t as (with recursive 42 as ttt select ttt);`. [#69676](https://github.com/ClickHouse/ClickHouse/pull/69676) ([Han Fei](https://github.com/hanfei1991)).
+* Backported in [#69798](https://github.com/ClickHouse/ClickHouse/issues/69798): Make getHyperrectangleForRowGroup not throw an exception when the data type in parquet file is not convertable into the requested data type. Solved the user's problem when the Parquet file had Decimal64 data type and the column data type was DateTime. [#69745](https://github.com/ClickHouse/ClickHouse/pull/69745) ([Miсhael Stetsyuk](https://github.com/mstetsyuk)).
+* Backported in [#70410](https://github.com/ClickHouse/ClickHouse/issues/70410): Fixed `maxMapState` throwing 'Bad get' if value type is DateTime64. [#69787](https://github.com/ClickHouse/ClickHouse/pull/69787) ([Michael Kolupaev](https://github.com/al13n321)).
+* Backported in [#70019](https://github.com/ClickHouse/ClickHouse/issues/70019): Fix analyzer default with old compatibility value. [#69895](https://github.com/ClickHouse/ClickHouse/pull/69895) ([Raúl Marín](https://github.com/Algunenano)).
+* Backported in [#69941](https://github.com/ClickHouse/ClickHouse/issues/69941): Don't check dependencies during CREATE OR REPLACE VIEW during DROP of old table. Previously CREATE OR REPLACE query failed when there are dependent tables of the recreated view. [#69907](https://github.com/ClickHouse/ClickHouse/pull/69907) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70001](https://github.com/ClickHouse/ClickHouse/issues/70001): Now SQL security will work with parameterized views correctly. [#69984](https://github.com/ClickHouse/ClickHouse/pull/69984) ([pufit](https://github.com/pufit)).
+* Backported in [#70081](https://github.com/ClickHouse/ClickHouse/issues/70081): Closes [#69752](https://github.com/ClickHouse/ClickHouse/issues/69752). [#69985](https://github.com/ClickHouse/ClickHouse/pull/69985) ([pufit](https://github.com/pufit)).
+* Backported in [#70068](https://github.com/ClickHouse/ClickHouse/issues/70068): Fixes `Block structure mismatch` for queries with nested views and `WHERE` condition. Fixes [#66209](https://github.com/ClickHouse/ClickHouse/issues/66209). [#70054](https://github.com/ClickHouse/ClickHouse/pull/70054) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Backported in [#70166](https://github.com/ClickHouse/ClickHouse/issues/70166): Fix wrong LOGICAL_ERROR when replacing literals in ranges. [#70122](https://github.com/ClickHouse/ClickHouse/pull/70122) ([Pablo Marcos](https://github.com/pamarcos)).
+* Backported in [#70236](https://github.com/ClickHouse/ClickHouse/issues/70236): Check for Nullable(Nothing) type during ALTER TABLE MODIFY COLUMN/QUERY to prevent tables with such data type. [#70123](https://github.com/ClickHouse/ClickHouse/pull/70123) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70203](https://github.com/ClickHouse/ClickHouse/issues/70203): Fix wrong result with skipping index. [#70127](https://github.com/ClickHouse/ClickHouse/pull/70127) ([Raúl Marín](https://github.com/Algunenano)).
+* Backported in [#70183](https://github.com/ClickHouse/ClickHouse/issues/70183): Fix data race in ColumnObject/ColumnTuple decompress method that could lead to heap use after free. [#70137](https://github.com/ClickHouse/ClickHouse/pull/70137) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70251](https://github.com/ClickHouse/ClickHouse/issues/70251): Fix possible hung in ALTER COLUMN with Dynamic type. [#70144](https://github.com/ClickHouse/ClickHouse/pull/70144) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70228](https://github.com/ClickHouse/ClickHouse/issues/70228): Use correct `max_types` parameter during Dynamic type creation for JSON subcolumn. [#70147](https://github.com/ClickHouse/ClickHouse/pull/70147) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70243](https://github.com/ClickHouse/ClickHouse/issues/70243): Fix the password being displayed in `system.query_log` for users with bcrypt password authentication method. [#70148](https://github.com/ClickHouse/ClickHouse/pull/70148) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Backported in [#70432](https://github.com/ClickHouse/ClickHouse/issues/70432): Fix possible crash in JSON column. [#70172](https://github.com/ClickHouse/ClickHouse/pull/70172) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70307](https://github.com/ClickHouse/ClickHouse/issues/70307): Fix multiple issues with arrayMin and arrayMax. [#70207](https://github.com/ClickHouse/ClickHouse/pull/70207) ([Raúl Marín](https://github.com/Algunenano)).
+* Backported in [#70274](https://github.com/ClickHouse/ClickHouse/issues/70274): Respect setting allow_simdjson in JSON type parser. [#70218](https://github.com/ClickHouse/ClickHouse/pull/70218) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70345](https://github.com/ClickHouse/ClickHouse/issues/70345): Don't modify global settings with startup scripts. Previously, changing a setting in a startup script would change it globally. [#70310](https://github.com/ClickHouse/ClickHouse/pull/70310) ([Antonio Andelic](https://github.com/antonio2368)).
+* Backported in [#70426](https://github.com/ClickHouse/ClickHouse/issues/70426): Fix ALTER of Dynamic type with reducing max_types parameter that could lead to server crash. [#70328](https://github.com/ClickHouse/ClickHouse/pull/70328) ([Pavel Kruglov](https://github.com/Avogar)).
+* Backported in [#70371](https://github.com/ClickHouse/ClickHouse/issues/70371): Fix crash when using WITH FILL incorrectly. [#70338](https://github.com/ClickHouse/ClickHouse/pull/70338) ([Raúl Marín](https://github.com/Algunenano)).
+
+#### NO CL ENTRY
+
+* NO CL ENTRY:  'Revert "Backport [#70146](https://github.com/ClickHouse/ClickHouse/issues/70146) to 24.8: Upgrade integration-runner image"'. [#70324](https://github.com/ClickHouse/ClickHouse/pull/70324) ([Max K.](https://github.com/maxknv)).
+
+#### NOT FOR CHANGELOG / INSIGNIFICANT
+
+* Backported in [#69961](https://github.com/ClickHouse/ClickHouse/issues/69961): Output an operation error for ZK Multi request failed operation into log. [#68127](https://github.com/ClickHouse/ClickHouse/pull/68127) ([Aleksei Filatov](https://github.com/aalexfvk)).
+* Backported in [#69491](https://github.com/ClickHouse/ClickHouse/issues/69491): Fix test_role & test_keeper_s3_snapshot integration tests. [#69013](https://github.com/ClickHouse/ClickHouse/pull/69013) ([Shankar](https://github.com/shiyer7474)).
+* Backported in [#69953](https://github.com/ClickHouse/ClickHouse/issues/69953): Remove stale moving parts without zookeeper. [#69075](https://github.com/ClickHouse/ClickHouse/pull/69075) ([Kirill](https://github.com/kirillgarbar)).
+* Backported in [#69353](https://github.com/ClickHouse/ClickHouse/issues/69353): Fix: Not-ready Set with parallel replicas. [#69264](https://github.com/ClickHouse/ClickHouse/pull/69264) ([Igor Nikonov](https://github.com/devcrafter)).
+* Backported in [#69427](https://github.com/ClickHouse/ClickHouse/issues/69427): Fix 24.8 setting compatibility `rows_before_aggregation`. [#69394](https://github.com/ClickHouse/ClickHouse/pull/69394) ([Nikita Fomichev](https://github.com/fm4v)).
+* Backported in [#69689](https://github.com/ClickHouse/ClickHouse/issues/69689): Add function `kill_ci_runner`. Kill runner when pre-pull failed. [#69557](https://github.com/ClickHouse/ClickHouse/pull/69557) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Backported in [#69639](https://github.com/ClickHouse/ClickHouse/issues/69639): Add more contexts to the debug action and use it broadly. [#69599](https://github.com/ClickHouse/ClickHouse/pull/69599) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Backported in [#69721](https://github.com/ClickHouse/ClickHouse/issues/69721): Prohibit `ALTER TABLE ... ADD INDEX ... TYPE` inverted if setting = 0. [#69684](https://github.com/ClickHouse/ClickHouse/pull/69684) ([Robert Schulze](https://github.com/rschu1ze)).
+* Backported in [#69972](https://github.com/ClickHouse/ClickHouse/issues/69972): S3Queue: support having deprecated settings to not fail server startup. [#69769](https://github.com/ClickHouse/ClickHouse/pull/69769) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Backported in [#70283](https://github.com/ClickHouse/ClickHouse/issues/70283): Improve pipdeptree generator for docker images. - Update requirements.txt for the integration tests runner container - Remove some small dependencies, improve `helpers/retry_decorator.py` - Upgrade docker-compose from EOL version 1 to version 2. [#70146](https://github.com/ClickHouse/ClickHouse/pull/70146) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Backported in [#70260](https://github.com/ClickHouse/ClickHouse/issues/70260): Update test_storage_s3_queue/test.py. [#70159](https://github.com/ClickHouse/ClickHouse/pull/70159) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Backported in [#70314](https://github.com/ClickHouse/ClickHouse/issues/70314): CI: Remove await feature from release branches. [#70294](https://github.com/ClickHouse/ClickHouse/pull/70294) ([Max K.](https://github.com/maxknv)).
+* Backported in [#70380](https://github.com/ClickHouse/ClickHouse/issues/70380): Fix tiny mistake, responsible for some of kafka test flaps. Example [report](https://s3.amazonaws.com/clickhouse-test-reports/0/3198aafac59c368993e7b5f49d95674cc1b1be18/integration_tests__release__[2_4].html). [#70352](https://github.com/ClickHouse/ClickHouse/pull/70352) ([filimonov](https://github.com/filimonov)).
+* Backported in [#70405](https://github.com/ClickHouse/ClickHouse/issues/70405): Closes [#69634](https://github.com/ClickHouse/ClickHouse/issues/69634). [#70354](https://github.com/ClickHouse/ClickHouse/pull/70354) ([pufit](https://github.com/pufit)).
+
--- a/docs/en/operations/settings/query-complexity.md
+++ b/docs/en/operations/settings/query-complexity.md
@ -49,6 +49,18 @@ Default values are defined in [Settings.h](https://github.com/ClickHouse/ClickHo

 See also the description of [max_memory_usage](#settings_max_memory_usage).

+For example if you want to set `max_memory_usage_for_user` to 1000 bytes for a user named `clickhouse_read`, you can use the statement
+
+``` sql
+ALTER USER clickhouse_read SETTINGS max_memory_usage_for_user = 1000;
+```
+
+You can verify it worked by logging out of your client, logging back in, then use the `getSetting` function:
+
+```sql
+SELECT getSetting('max_memory_usage_for_user');
+```
+
 ## max_rows_to_read {#max-rows-to-read}

 The following restrictions can be checked on each block (instead of on each row). That is, the restrictions can be broken a little.
--- a/docs/en/operations/settings/settings-users.md
+++ b/docs/en/operations/settings/settings-users.md
@ -6,7 +6,7 @@ sidebar_label: User Settings

 # Users and Roles Settings

-The `users` section of the `user.xml` configuration file contains user settings.
+The `users` section of the `users.xml` configuration file contains user settings.

 :::note
 ClickHouse also supports [SQL-driven workflow](../../guides/sre/user-management/index.md#access-control) for managing users. We recommend using it.
--- a/docs/en/sql-reference/data-types/dynamic.md
+++ b/docs/en/sql-reference/data-types/dynamic.md
@ -297,99 +297,259 @@ $$)
 └───────────────┴────────────────┴───────────────┴──────┴───────┴────────────┴─────────┘
 ```

-## Comparing values of Dynamic type
+## Using Dynamic type in functions

-Values of `Dynamic` types are compared similar to values of `Variant` type:
+Most of the functions support arguments with type `Dynamic`. In this case the function is executed separately on each internal data type stored inside `Dynamic` column.
+When the result type of the function depends on the arguments types, the result of such function executed with `Dynamic` arguments will be `Dynamic`. When the result type of the function doesn't depend on the arguments types - the result will be `Nullable(T)` where `T` the usual result type of this function.
+
+Examples:
+
+```sql
+CREATE TABLE test (d Dynamic) ENGINE=Memory;
+INSERT INTO test VALUES (NULL), (1::Int8), (2::Int16), (3::Int32), (4::Int64);
+```
+
+```sql
+SELECT d, dynamicType(d) FROM test;
+```
+
+```text
+┌─d────┬─dynamicType(d)─┐
+│ ᴺᵁᴸᴸ │ None           │
+│ 1    │ Int8           │
+│ 2    │ Int16          │
+│ 3    │ Int32          │
+│ 4    │ Int64          │
+└──────┴────────────────┘
+```
+
+```sql
+SELECT d, d + 1 AS res, toTypeName(res), dynamicType(res) FROM test;
+```
+
+```text
+┌─d────┬─res──┬─toTypeName(res)─┬─dynamicType(res)─┐
+│ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ Dynamic         │ None             │
+│ 1    │ 2    │ Dynamic         │ Int16            │
+│ 2    │ 3    │ Dynamic         │ Int32            │
+│ 3    │ 4    │ Dynamic         │ Int64            │
+│ 4    │ 5    │ Dynamic         │ Int64            │
+└──────┴──────┴─────────────────┴──────────────────┘
+```
+
+```sql
+SELECT d, d + d AS res, toTypeName(res), dynamicType(res) FROM test;
+```
+
+```text
+┌─d────┬─res──┬─toTypeName(res)─┬─dynamicType(res)─┐
+│ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ Dynamic         │ None             │
+│ 1    │ 2    │ Dynamic         │ Int16            │
+│ 2    │ 4    │ Dynamic         │ Int32            │
+│ 3    │ 6    │ Dynamic         │ Int64            │
+│ 4    │ 8    │ Dynamic         │ Int64            │
+└──────┴──────┴─────────────────┴──────────────────┘
+```
+
+```sql
+SELECT d, d < 3 AS res, toTypeName(res) FROM test;
+```
+
+```text
+┌─d────┬──res─┬─toTypeName(res)─┐
+│ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ Nullable(UInt8) │
+│ 1    │    1 │ Nullable(UInt8) │
+│ 2    │    1 │ Nullable(UInt8) │
+│ 3    │    0 │ Nullable(UInt8) │
+│ 4    │    0 │ Nullable(UInt8) │
+└──────┴──────┴─────────────────┘
+```
+
+```sql
+SELECT d, exp2(d) AS res, toTypeName(res) FROM test;
+```
+
+```sql
+┌─d────┬──res─┬─toTypeName(res)───┐
+│ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ Nullable(Float64) │
+│ 1    │    2 │ Nullable(Float64) │
+│ 2    │    4 │ Nullable(Float64) │
+│ 3    │    8 │ Nullable(Float64) │
+│ 4    │   16 │ Nullable(Float64) │
+└──────┴──────┴───────────────────┘
+```
+
+```sql
+TRUNCATE TABLE test;
+INSERT INTO test VALUES (NULL), ('str_1'), ('str_2');
+SELECT d, dynamicType(d) FROM test;
+```
+
+```text
+┌─d─────┬─dynamicType(d)─┐
+│ ᴺᵁᴸᴸ  │ None           │
+│ str_1 │ String         │
+│ str_2 │ String         │
+└───────┴────────────────┘
+```
+
+```sql
+SELECT d, upper(d) AS res, toTypeName(res) FROM test;
+```
+
+```text
+┌─d─────┬─res───┬─toTypeName(res)──┐
+│ ᴺᵁᴸᴸ  │ ᴺᵁᴸᴸ  │ Nullable(String) │
+│ str_1 │ STR_1 │ Nullable(String) │
+│ str_2 │ STR_2 │ Nullable(String) │
+└───────┴───────┴──────────────────┘
+```
+
+```sql
+SELECT d, extract(d, '([0-3])') AS res, toTypeName(res) FROM test;
+```
+
+```text
+┌─d─────┬─res──┬─toTypeName(res)──┐
+│ ᴺᵁᴸᴸ  │ ᴺᵁᴸᴸ │ Nullable(String) │
+│ str_1 │ 1    │ Nullable(String) │
+│ str_2 │ 2    │ Nullable(String) │
+└───────┴──────┴──────────────────┘
+```
+
+```sql
+TRUNCATE TABLE test;
+INSERT INTO test VALUES (NULL), ([1, 2]), ([3, 4]);
+SELECT d, dynamicType(d) FROM test;
+```
+
+```text
+┌─d─────┬─dynamicType(d)─┐
+│ ᴺᵁᴸᴸ  │ None           │
+│ [1,2] │ Array(Int64)   │
+│ [3,4] │ Array(Int64)   │
+└───────┴────────────────┘
+```
+
+```sql
+SELECT d, d[1] AS res, toTypeName(res), dynamicType(res) FROM test;
+```
+
+```text
+┌─d─────┬─res──┬─toTypeName(res)─┬─dynamicType(res)─┐
+│ ᴺᵁᴸᴸ  │ ᴺᵁᴸᴸ │ Dynamic         │ None             │
+│ [1,2] │ 1    │ Dynamic         │ Int64            │
+│ [3,4] │ 3    │ Dynamic         │ Int64            │
+└───────┴──────┴─────────────────┴──────────────────┘
+```
+
+If function cannot be executed on some type inside `Dynamic` column, the exception will be thrown:
+
+```sql
+INSERT INTO test VALUES (42), (43), ('str_1');
+SELECT d, dynamicType(d) FROM test;
+```
+
+
+```text
+┌─d─────┬─dynamicType(d)─┐
+│ 42    │ Int64          │
+│ 43    │ Int64          │
+│ str_1 │ String         │
+└───────┴────────────────┘
+┌─d─────┬─dynamicType(d)─┐
+│ ᴺᵁᴸᴸ  │ None           │
+│ [1,2] │ Array(Int64)   │
+│ [3,4] │ Array(Int64)   │
+└───────┴────────────────┘
+```
+
+```sql
+SELECT d, d + 1 AS res, toTypeName(res), dynamicType(d) FROM test;
+```
+
+```text
+Received exception:
+Code: 43. DB::Exception: Illegal types Array(Int64) and UInt8 of arguments of function plus: while executing 'FUNCTION plus(__table1.d : 3, 1_UInt8 :: 1) -> plus(__table1.d, 1_UInt8) Dynamic : 0'. (ILLEGAL_TYPE_OF_ARGUMENT)
+```
+
+We can filter out unneeded types:
+
+```sql
+SELECT d, d + 1 AS res, toTypeName(res), dynamicType(res) FROM test WHERE dynamicType(d) NOT IN ('String', 'Array(Int64)', 'None')
+```
+
+```text
+┌─d──┬─res─┬─toTypeName(res)─┬─dynamicType(res)─┐
+│ 42 │ 43  │ Dynamic         │ Int64            │
+│ 43 │ 44  │ Dynamic         │ Int64            │
+└────┴─────┴─────────────────┴──────────────────┘
+```
+
+Or extract required type as subcolumn:
+
+```sql
+SELECT d, d.Int64 + 1 AS res, toTypeName(res) FROM test;
+```
+
+```text
+┌─d─────┬──res─┬─toTypeName(res)─┐
+│ 42    │   43 │ Nullable(Int64) │
+│ 43    │   44 │ Nullable(Int64) │
+│ str_1 │ ᴺᵁᴸᴸ │ Nullable(Int64) │
+└───────┴──────┴─────────────────┘
+┌─d─────┬──res─┬─toTypeName(res)─┐
+│ ᴺᵁᴸᴸ  │ ᴺᵁᴸᴸ │ Nullable(Int64) │
+│ [1,2] │ ᴺᵁᴸᴸ │ Nullable(Int64) │
+│ [3,4] │ ᴺᵁᴸᴸ │ Nullable(Int64) │
+└───────┴──────┴─────────────────┘
+```
+
+## Using Dynamic type in ORDER BY and GROUP BY
+
+During `ORDER BY` and `GROUP BY` values of `Dynamic` types are compared similar to values of `Variant` type:
 The result of operator `<` for values `d1` with underlying type `T1` and `d2` with underlying type `T2`  of a type `Dynamic` is defined as follows:
 - If `T1 = T2 = T`, the result will be `d1.T < d2.T` (underlying values will be compared).
 - If `T1 != T2`, the result will be `T1 < T2` (type names will be compared).

+By default `Dynamic` type is not allowed in `GROUP BY`/`ORDER BY` keys, if you want to use it consider its special comparison rule and enable `allow_suspicious_types_in_group_by`/`allow_suspicious_types_in_order_by` settings.
+
 Examples:
 ```sql
-CREATE TABLE test (d1 Dynamic, d2 Dynamic) ENGINE=Memory;
-INSERT INTO test VALUES (42, 42), (42, 43), (42, 'abc'), (42, [1, 2, 3]), (42, []), (42, NULL);
+CREATE TABLE test (d Dynamic) ENGINE=Memory;
+INSERT INTO test VALUES (42), (43), ('abc'), ('abd'), ([1, 2, 3]), ([]), (NULL);
 ```

 ```sql
-SELECT d2, dynamicType(d2) as d2_type from test order by d2;
+SELECT d, dynamicType(d) FROM test;
 ```

 ```text
-┌─d2──────┬─d2_type──────┐
+┌─d───────┬─dynamicType(d)─┐
+│ 42      │ Int64          │
+│ 43      │ Int64          │
+│ abc     │ String         │
+│ abd     │ String         │
+│ [1,2,3] │ Array(Int64)   │
+│ []      │ Array(Int64)   │
+│ ᴺᵁᴸᴸ    │ None           │
+└─────────┴────────────────┘
+```
+
+```sql
+SELECT d, dynamicType(d) FROM test ORDER BY d SETTINGS allow_suspicious_types_in_order_by=1;
+```
+
+```sql
+┌─d───────┬─dynamicType(d)─┐
 │ []      │ Array(Int64)   │
 │ [1,2,3] │ Array(Int64)   │
 │ 42      │ Int64          │
 │ 43      │ Int64          │
 │ abc     │ String         │
+│ abd     │ String         │
 │ ᴺᵁᴸᴸ    │ None           │
-└─────────┴──────────────┘
-```
-
-```sql
-SELECT d1, dynamicType(d1) as d1_type, d2, dynamicType(d2) as d2_type, d1 = d2, d1 < d2, d1 > d2 from test;
-```
-
-```text
-┌─d1─┬─d1_type─┬─d2──────┬─d2_type──────┬─equals(d1, d2)─┬─less(d1, d2)─┬─greater(d1, d2)─┐
-│ 42 │ Int64   │ 42      │ Int64        │              1 │            0 │               0 │
-│ 42 │ Int64   │ 43      │ Int64        │              0 │            1 │               0 │
-│ 42 │ Int64   │ abc     │ String       │              0 │            1 │               0 │
-│ 42 │ Int64   │ [1,2,3] │ Array(Int64) │              0 │            0 │               1 │
-│ 42 │ Int64   │ []      │ Array(Int64) │              0 │            0 │               1 │
-│ 42 │ Int64   │ ᴺᵁᴸᴸ    │ None         │              0 │            1 │               0 │
-└────┴─────────┴─────────┴──────────────┴────────────────┴──────────────┴─────────────────┘
-```
-
-If you need to find the row with specific `Dynamic` value, you can do one of the following:
-
- Cast value to the `Dynamic` type:
-
-```sql
-SELECT * FROM test WHERE d2 == [1,2,3]::Array(UInt32)::Dynamic;
-```
-
-```text
-┌─d1─┬─d2──────┐
-│ 42 │ [1,2,3] │
-└────┴─────────┘
-```
-
- Compare `Dynamic` subcolumn with required type:
-
-```sql
-SELECT * FROM test WHERE d2.`Array(Int65)` == [1,2,3] -- or using variantElement(d2, 'Array(UInt32)')
-```
-
-```text
-┌─d1─┬─d2──────┐
-│ 42 │ [1,2,3] │
-└────┴─────────┘
-```
-
-Sometimes it can be useful to make additional check on dynamic type as subcolumns with complex types like `Array/Map/Tuple` cannot be inside `Nullable` and will have default values instead of `NULL` on rows with different types:
-
-```sql
-SELECT d2, d2.`Array(Int64)`, dynamicType(d2) FROM test WHERE d2.`Array(Int64)` == [];
-```
-
-```text
-┌─d2───┬─d2.Array(UInt32)─┬─dynamicType(d2)─┐
-│ 42   │ []               │ Int64           │
-│ 43   │ []               │ Int64           │
-│ abc  │ []               │ String          │
-│ []   │ []               │ Array(Int32)    │
-│ ᴺᵁᴸᴸ │ []               │ None            │
-└──────┴──────────────────┴─────────────────┘
-```
-
-```sql
-SELECT d2, d2.`Array(Int64)`, dynamicType(d2) FROM test WHERE dynamicType(d2) == 'Array(Int64)' AND d2.`Array(Int64)` == [];
-```
-
-```text
-┌─d2─┬─d2.Array(UInt32)─┬─dynamicType(d2)─┐
-│ [] │ []               │ Array(Int64)    │
-└────┴──────────────────┴─────────────────┘
+└─────────┴────────────────┘
 ```

 **Note:** values of dynamic types with different numeric types are considered as different values and not compared between each other, their type names are compared instead.
@ -399,7 +559,7 @@ Example:
 ```sql
 CREATE TABLE test (d Dynamic) ENGINE=Memory;
 INSERT INTO test VALUES (1::UInt32), (1::Int64), (100::UInt32), (100::Int64);
-SELECT d, dynamicType(d) FROM test ORDER by d;
+SELECT d, dynamicType(d) FROM test ORDER BY d SETTINGS allow_suspicious_types_in_order_by=1;
 ```

 ```text
@ -411,8 +571,20 @@ SELECT d, dynamicType(d) FROM test ORDER by d;
 └─────┴────────────────┘
 ```

-**Note** by default `Dynamic` type is not allowed in `GROUP BY`/`ORDER BY` keys, if you want to use it consider its special comparison rule and enable `allow_suspicious_types_in_group_by`/`allow_suspicious_types_in_order_by` settings.
+```sql
+SELECT d, dynamicType(d) FROM test GROUP by d SETTINGS allow_suspicious_types_in_group_by=1;
+```

+```text
+┌─d───┬─dynamicType(d)─┐
+│ 1   │ Int64          │
+│ 100 │ UInt32         │
+│ 1   │ UInt32         │
+│ 100 │ Int64          │
+└─────┴────────────────┘
+```
+
+**Note:** the described comparison rule is not applied during execution of comparison functions like `<`/`>`/`=` and others because of [special work](#using-dynamic-type-in-functions) of functions with `Dynamic` type

 ## Reaching the limit in number of different data types stored inside Dynamic

--- a/docs/en/sql-reference/functions/date-time-functions.md
+++ b/docs/en/sql-reference/functions/date-time-functions.md
@ -1972,7 +1972,7 @@ Result:

 ## toISOYear

-Converts a date, or date with time, to a UInt16 number containing the ISO Year number.
+Converts a date, or date with time, to the ISO year as a UInt16 number.

 **Syntax**

@ -1982,11 +1982,11 @@ toISOYear(value)

 **Arguments**

- `value` — The value with date or date with time.
+- `value` — The value with date or date with time. [Date](../data-types/date.md), [Date32](../data-types/date32.md), [DateTime](../data-types/datetime.md) or [DateTime64](../data-types/datetime64.md)

 **Returned value**

- `value` converted to the current ISO year number. [UInt16](../data-types/int-uint.md).
+- The input value converted to a ISO year number. [UInt16](../data-types/int-uint.md).

 **Example**

@ -1995,7 +1995,7 @@ Query:
 ```sql
 SELECT
  toISOYear(toDate('2024/10/02')) as year1,
-  toISOYear(toDateTime('2024/10/02 01:30:00')) as year2
+  toISOYear(toDateTime('2024-10-02 01:30:00')) as year2
 ```

 Result:
--- a/docs/en/sql-reference/functions/ip-address-functions.md
+++ b/docs/en/sql-reference/functions/ip-address-functions.md
@ -288,11 +288,11 @@ toIPv4OrDefault(value)

 **Arguments**

- `value` — The value with IPv4 address.
+- `value` — A string-encoded IPv4 address. [String](../data-types/string.md)

 **Returned value**

- `value` converted to the current IPv4 address. [String](../data-types/string.md).
+- `value` converted to an IPv4 address. [IPv4](../data-types/ipv4.md).

 **Example**

@ -324,11 +324,11 @@ toIPv4OrNull(value)

 **Arguments**

- `value` — The value with IPv4 address.
+- `value` — A string-encoded IPv4 address. [String](../data-types/string.md)

 **Returned value**

- `value` converted to the current IPv4 address. [String](../data-types/string.md).
+- `value` converted to an IPv4 address. [IPv4](../data-types/ipv4.md).

 **Example**

--- a/docs/en/sql-reference/functions/other-functions.md
+++ b/docs/en/sql-reference/functions/other-functions.md
@ -202,7 +202,7 @@ Result:

 Returns the type name of the passed argument.

-If `NULL` is passed, then the function returns type `Nullable(Nothing)`, which corresponds to ClickHouse's internal `NULL` representation.
+If `NULL` is passed, the function returns type `Nullable(Nothing)`, which corresponds to ClickHouse's internal `NULL` representation.

 **Syntax**

@ -212,11 +212,11 @@ toTypeName(value)

 **Arguments**

- `value` — The value with any arbitrary.
+- `value` — A value of arbitrary type.

 **Returned value**

- `value` converted to the current data type name. [String](../data-types/string.md).
+- The data type name of the input value. [String](../data-types/string.md).

 **Example**

@ -410,13 +410,37 @@ Code: 44. DB::Exception: Received from localhost:9000. DB::Exception: Illegal ty

 ## ignore

-Accepts any arguments, including `NULL` and does nothing. Always returns 0.
-The argument is internally still evaluated. Useful e.g. for benchmarks.
+Accepts arbitrary arguments and unconditionally returns `0`.
+The argument is still evaluated internally, making it useful for eg. benchmarking.

 **Syntax**

 ```sql
-ignore(x)
+ignore([arg1[, arg2[, ...]])
+```
+
+**Arguments**
+
+- Accepts arbitrarily many arguments of arbitrary type, including `NULL`.
+
+**Returned value**
+
+- Returns `0`.
+
+**Example**
+
+Query:
+
+```sql
+SELECT ignore(0, 'ClickHouse', NULL);
+```
+
+Result:
+
+```response
+┌─ignore(0, 'ClickHouse', NULL)─┐
+│                             0 │
+└───────────────────────────────┘
 ```

 ## sleep
@ -524,13 +548,9 @@ Useful in table engine parameters of `CREATE TABLE` queries where you need to sp
 currentDatabase()
 ```

-**Arguments**
-
-None.
-
 **Returned value**

- `value` returns the current database name. [String](../data-types/string.md).
+- Returns the current database name. [String](../data-types/string.md).

 **Example**

@ -579,6 +599,42 @@ Result:
 └───────────────┘
 ```

+## currentSchemas
+
+Returns a single-element array with the name of the current database schema.
+
+**Syntax**
+
+```sql
+currentSchemas(bool)
+```
+
+Alias: `current_schemas`.
+
+**Arguments**
+
+- `bool`: A boolean value. [Bool](../data-types/boolean.md).
+
+:::note
+The boolean argument is ignored. It only exists for the sake of compatibility with the [implementation](https://www.postgresql.org/docs/7.3/functions-misc.html) of this function in PostgreSQL.
+:::
+
+**Returned values**
+
+- Returns a single-element array with the name of the current database
+
+**Example**
+
+```sql
+SELECT currentSchemas(true);
+```
+
+Result:
+
+```response
+['default']
+```
+
 ## isConstant

 Returns whether the argument is a constant expression.
@ -1821,7 +1877,7 @@ toColumnTypeName(value)

 **Example**

-Difference between `toTypeName ' and ' toColumnTypeName`:
+Difference between `toTypeName` and `toColumnTypeName`:

 ```sql
 SELECT toTypeName(CAST('2018-01-01 01:02:03' AS DateTime))
@ -3897,13 +3953,15 @@ Retrieves the connection ID of the client that submitted the current query and r
 connectionId()
 ```

+Alias: `connection_id`.
+
 **Parameters**

 None.

 **Returned value**

-Returns an integer of type UInt64.
+The current connection ID. [UInt64](../data-types/int-uint.md).

 **Implementation details**

@ -3921,40 +3979,6 @@ SELECT connectionId();
 0
 ```

-## connection_id
-
-An alias of `connectionId`. Retrieves the connection ID of the client that submitted the current query and returns it as a UInt64 integer.
-
-**Syntax**
-
-```sql
-connection_id()
-```
-
-**Parameters**
-
-None.
-
-**Returned value**
-
-Returns an integer of type UInt64.
-
-**Implementation details**
-
-This function is most useful in debugging scenarios or for internal purposes within the MySQL handler. It was created for compatibility with [MySQL's `CONNECTION_ID` function](https://dev.mysql.com/doc/refman/8.0/en/information-functions.html#function_connection-id) It is not typically used in production queries.
-
-**Example**
-
-Query:
-
-```sql
-SELECT connection_id();
-```
-
-```response
-0
-```
-
 ## getClientHTTPHeader

 Get the value of an HTTP header.
--- a/docs/en/sql-reference/functions/string-search-functions.md
+++ b/docs/en/sql-reference/functions/string-search-functions.md
@ -755,7 +755,7 @@ Result:

 ## match {#match}

-Returns whether string `haystack` matches the regular expression `pattern` in [re2 regular syntax](https://github.com/google/re2/wiki/Syntax).
+Returns whether string `haystack` matches the regular expression `pattern` in [re2 regular expression syntax](https://github.com/google/re2/wiki/Syntax).

 Matching is based on UTF-8, e.g. `.` matches the Unicode code point `¥` which is represented in UTF-8 using two bytes. The regular
 expression must not contain null bytes. If the haystack or the pattern are not valid UTF-8, then the behavior is undefined.
@ -852,9 +852,10 @@ multiFuzzyMatchAllIndices(haystack, distance, \[pattern<sub>1</sub>, pattern<sub

 ## extract

-Extracts a fragment of a string using a regular expression. If `haystack` does not match the `pattern` regex, an empty string is returned.
+Returns the first match of a regular expression in a string.
+If `haystack` does not match the `pattern` regex, an empty string is returned. 

-For regex without subpatterns, the function uses the fragment that matches the entire regex. Otherwise, it uses the fragment that matches the first subpattern.
+If the regular expression has capturing groups, the function matches the input string against the first capturing group.

 **Syntax**

@ -862,13 +863,36 @@ For regex without subpatterns, the function uses the fragment that matches the e
 extract(haystack, pattern)
 ```

+*Arguments**
+
+- `haystack` — Input string. [String](../data-types/string.md).
+- `pattern` — Regular expression with [re2 regular expression syntax](https://github.com/google/re2/wiki/Syntax).
+
+**Returned value**
+
+- The first match of the regular expression in the haystack string. [String](../data-types/string.md).
+
+**Example**
+
+Query:
+
+```sql
+SELECT extract('number: 1, number: 2, number: 3', '\\d+') AS result;
+```
+
+Result:
+
+```response
+┌─result─┐
+│ 1      │
+└────────┘
+```
+
 ## extractAll

-Extracts all fragments of a string using a regular expression. If `haystack` does not match the `pattern` regex, an empty string is returned.
+Returns an array of all matches of a regular expression in a string. If `haystack` does not match the `pattern` regex, an empty string is returned.

-Returns an array of strings consisting of all matches of the regex.
-
-The behavior with respect to subpatterns is the same as in function `extract`.
+The behavior with respect to sub-patterns is the same as in function [`extract`](#extract).

 **Syntax**

@ -876,6 +900,31 @@ The behavior with respect to subpatterns is the same as in function `extract`.
 extractAll(haystack, pattern)
 ```

+*Arguments**
+
+- `haystack` — Input string. [String](../data-types/string.md).
+- `pattern` — Regular expression with [re2 regular expression syntax](https://github.com/google/re2/wiki/Syntax).
+
+**Returned value**
+
+- Array of matches of the regular expression in the haystack string. [Array](../data-types/array.md)([String](../data-types/string.md)).
+
+**Example**
+
+Query:
+
+```sql
+SELECT extractAll('number: 1, number: 2, number: 3', '\\d+') AS result;
+```
+
+Result:
+
+```response
+┌─result────────┐
+│ ['1','2','3'] │
+└───────────────┘
+```
+
 ## extractAllGroupsHorizontal

 Matches all groups of the `haystack` string using the `pattern` regular expression. Returns an array of arrays, where the first array includes all fragments matching the first group, the second array - matching the second group, etc.
@ -891,7 +940,7 @@ extractAllGroupsHorizontal(haystack, pattern)
 **Arguments**

 - `haystack` — Input string. [String](../data-types/string.md).
- `pattern` — Regular expression with [re2 syntax](https://github.com/google/re2/wiki/Syntax). Must contain groups, each group enclosed in parentheses. If `pattern` contains no groups, an exception is thrown. [String](../data-types/string.md).
+- `pattern` — Regular expression with [re2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). Must contain groups, each group enclosed in parentheses. If `pattern` contains no groups, an exception is thrown. [String](../data-types/string.md).

 **Returned value**

@ -915,6 +964,39 @@ Result:
 └──────────────────────────────────────────────────────────────────────────────────────────┘
 ```

+## extractGroups
+
+Match all groups of given input string with a given regular expression, returns an array of arrays of matches.
+
+**Syntax**
+
+``` sql
+extractGroups(haystack, pattern)
+```
+
+**Arguments**
+
+- `haystack` — Input string. [String](../data-types/string.md).
+- `pattern` — Regular expression with [re2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). Must contain groups, each group enclosed in parentheses. If `pattern` contains no groups, an exception is thrown. [String](../data-types/string.md).
+
+**Returned value**
+
+- Array of arrays of matches. [Array](../data-types/array.md).
+
+**Example**
+
+``` sql
+SELECT extractGroups('hello abc=111 world', '("[^"]+"|\\w+)=("[^"]+"|\\w+)') AS result;
+```
+
+Result:
+
+``` text
+┌─result────────┐
+│ ['abc','111'] │
+└───────────────┘
+```
+
 ## extractAllGroupsVertical

 Matches all groups of the `haystack` string using the `pattern` regular expression. Returns an array of arrays, where each array includes matching fragments from every group. Fragments are grouped in order of appearance in the `haystack`.
@ -928,7 +1010,7 @@ extractAllGroupsVertical(haystack, pattern)
 **Arguments**

 - `haystack` — Input string. [String](../data-types/string.md).
- `pattern` — Regular expression with [re2 syntax](https://github.com/google/re2/wiki/Syntax). Must contain groups, each group enclosed in parentheses. If `pattern` contains no groups, an exception is thrown. [String](../data-types/string.md).
+- `pattern` — Regular expression with [re2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). Must contain groups, each group enclosed in parentheses. If `pattern` contains no groups, an exception is thrown. [String](../data-types/string.md).

 **Returned value**

@ -1484,7 +1566,7 @@ countMatches(haystack, pattern)
 **Arguments**

 - `haystack` — The string to search in. [String](../../sql-reference/syntax.md#syntax-string-literal).
- `pattern` — The regular expression with [re2 syntax](https://github.com/google/re2/wiki/Syntax). [String](../data-types/string.md).
+- `pattern` — The regular expression with [re2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). [String](../data-types/string.md).

 **Returned value**

@ -1529,7 +1611,7 @@ countMatchesCaseInsensitive(haystack, pattern)
 **Arguments**

 - `haystack` — The string to search in. [String](../../sql-reference/syntax.md#syntax-string-literal).
- `pattern` — The regular expression with [re2 syntax](https://github.com/google/re2/wiki/Syntax). [String](../data-types/string.md).
+- `pattern` — The regular expression with [re2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). [String](../data-types/string.md).

 **Returned value**

--- a/docs/en/sql-reference/statements/select/intersect.md
+++ b/docs/en/sql-reference/statements/select/intersect.md
@ -29,7 +29,7 @@ The condition could be any expression based on your requirements.
 Here is a simple example that intersects the numbers 1 to 10 with the numbers 3 to 8:

 ```sql
-SELECT number FROM numbers(1,10) INTERSECT SELECT number FROM numbers(3,6);
+SELECT number FROM numbers(1,10) INTERSECT SELECT number FROM numbers(3,8);
 ```

 Result:
--- a/docs/en/sql-reference/statements/show.md
+++ b/docs/en/sql-reference/statements/show.md
@ -351,11 +351,15 @@ Shows privileges for a user.
 **Syntax**

 ``` sql
-SHOW GRANTS [FOR user1 [, user2 ...]]
+SHOW GRANTS [FOR user1 [, user2 ...]] [WITH IMPLICIT] [FINAL]
 ```

 If user is not specified, the query returns privileges for the current user.

+The `WITH IMPLICIT` modifier allows to show the implicit grants (e.g., `GRANT SELECT ON system.one`)
+
+The `FINAL` modifier merges all grants from the user and its granted roles (with inheritance)
+
 ## SHOW CREATE USER

 Shows parameters that were used at a [user creation](../../sql-reference/statements/create/user.md).
--- a/docs/ru/operations/settings/settings-users.md
+++ b/docs/ru/operations/settings/settings-users.md
@ -6,7 +6,7 @@ sidebar_label: "Настройки пользователей"

 # Настройки пользователей {#nastroiki-polzovatelei}

-Раздел `users` конфигурационного файла `user.xml` содержит настройки для пользователей.
+Раздел `users` конфигурационного файла `users.xml` содержит настройки для пользователей.

 :::note Информация
 Для управления пользователями рекомендуется использовать [SQL-ориентированный воркфлоу](../access-rights.md#access-control), который также поддерживается в ClickHouse.
--- a/docs/ru/sql-reference/statements/select/intersect.md
+++ b/docs/ru/sql-reference/statements/select/intersect.md
@ -29,7 +29,7 @@ FROM table2
 Запрос:

 ``` sql
-SELECT number FROM numbers(1,10) INTERSECT SELECT number FROM numbers(3,6);
+SELECT number FROM numbers(1,10) INTERSECT SELECT number FROM numbers(3,8);
 ```

 Результат:
--- a/docs/ru/sql-reference/statements/show.md
+++ b/docs/ru/sql-reference/statements/show.md
@ -234,11 +234,14 @@ SHOW DICTIONARIES FROM db LIKE '%reg%' LIMIT 2
 ### Синтаксис {#show-grants-syntax}

 ``` sql
-SHOW GRANTS [FOR user]
+SHOW GRANTS [FOR user1 [, user2 ...]] [WITH IMPLICIT] [FINAL]
 ```

 Если пользователь не задан, запрос возвращает привилегии текущего пользователя.

+`WITH IMPLICIT` добавляет неявные привилегии (например `GRANT SELECT ON system.one`).
+
+`FINAL` объединяет все текущие привилегии с привилегиями всех ролей пользователя (с наследованием).


 ## SHOW CREATE USER {#show-create-user-statement}
--- a/docs/zh/operations/settings/settings-users.md
+++ b/docs/zh/operations/settings/settings-users.md
@ -8,7 +8,7 @@ sidebar_label: "\u7528\u6237\u8BBE\u7F6E"

 # 用户设置 {#user-settings}

-`user.xml` 中的 `users` 配置段包含了用户配置
+`users.xml` 中的 `users` 配置段包含了用户配置

 :::note
 ClickHouse还支持 [SQL驱动的工作流](/docs/en/operations/access-rights#access-control) 用于管理用户。 我们建议使用它。
--- a/docs/zh/sql-reference/statements/show.md
+++ b/docs/zh/sql-reference/statements/show.md
@ -110,7 +110,7 @@ SHOW DICTIONARIES FROM db LIKE '%reg%' LIMIT 2
 ### 语法 {#show-grants-syntax}

 ``` sql
-SHOW GRANTS [FOR user]
+SHOW GRANTS [FOR user1 [, user2 ...]] [WITH IMPLICIT] [FINAL]
 ```

 如果未指定用户，输出当前用户的权限
--- a/programs/bash-completion/completions/clickhouse-bootstrap
+++ b/programs/bash-completion/completions/clickhouse-bootstrap
@ -155,7 +155,7 @@ function _clickhouse_quote()
 function _clickhouse_get_options()
 {
    # By default --help will not print all settings, this is done only under --verbose
-    "$@" --help --verbose 2>&1 | awk -F '[ ,=<>.]' '{ for (i=1; i <= NF; ++i) { if (substr($i, 1, 1) == "-" && length($i) > 1) print $i; } }' | sort -u
+    "$@" --help --verbose 2>&1 | LANG=c awk -F '[ ,=<>.]' '{ for (i=1; i <= NF; ++i) { if (substr($i, 1, 1) == "-" && length($i) > 1) print $i; } }' | sort -u
 }

 function _complete_for_clickhouse_generic_bin_impl()
--- a/programs/benchmark/Benchmark.cpp
+++ b/programs/benchmark/Benchmark.cpp
@ -445,8 +445,7 @@ private:
                    shutdown = true;
                    throw;
                }
-                else
-                {
+
                std::cerr << getCurrentExceptionMessage(print_stacktrace,
                    true /*check embedded stack trace*/) << std::endl;

@ -454,7 +453,6 @@ private:
                ++comparison_info_per_interval[info_index]->errors;
                ++comparison_info_total[info_index]->errors;
            }
-            }
            // Count failed queries toward executed, so that we'd reach
            // max_iterations even if every run fails.
            ++queries_executed;
--- a/programs/client/Client.cpp
+++ b/programs/client/Client.cpp
@ -479,14 +479,11 @@ void Client::connect()
            break;
        }
        catch (const Exception & e)
-        {
-            if (e.code() == DB::ErrorCodes::AUTHENTICATION_FAILED)
        {
            /// This problem can't be fixed with reconnection so it is not attempted
+            if (e.code() == DB::ErrorCodes::AUTHENTICATION_FAILED)
                throw;
-            }
-            else
-            {
+
            if (attempted_address_index == hosts_and_ports.size() - 1)
                throw;

@ -503,7 +500,6 @@ void Client::connect()
            }
        }
    }
-    }

    server_version = toString(server_version_major) + "." + toString(server_version_minor) + "." + toString(server_version_patch);
    load_suggestions = is_interactive && (server_revision >= Suggest::MIN_SERVER_REVISION) && !config().getBool("disable_suggestion", false);
--- a/programs/disks/CommandCopy.cpp
+++ b/programs/disks/CommandCopy.cpp
@ -46,7 +46,7 @@ public:
                path_from,
                disk_from.getDisk()->getName());
        }
-        else if (disk_from.getDisk()->isFile(path_from))
+        if (disk_from.getDisk()->isFile(path_from))
        {
            auto target_location = getTargetLocation(path_from, disk_to, path_to);
            if (!disk_to.getDisk()->exists(target_location) || disk_to.getDisk()->isFile(target_location))
@ -77,7 +77,7 @@ public:
            {
                throw Exception(ErrorCodes::BAD_ARGUMENTS, "cannot overwrite non-directory {} with directory {}", path_to, target_location);
            }
-            else if (!disk_to.getDisk()->exists(target_location))
+            if (!disk_to.getDisk()->exists(target_location))
            {
                disk_to.getDisk()->createDirectory(target_location);
            }
--- a/programs/disks/CommandList.cpp
+++ b/programs/disks/CommandList.cpp
@ -72,13 +72,9 @@ private:
            auto path = [&]() -> String
            {
                if (relative_path.ends_with("/"))
-                {
                    return relative_path + file_name;
-                }
-                else
-                {
+
                return relative_path + "/" + file_name;
-                }
            }();
            if (disk.isDirectory(path))
            {
--- a/programs/disks/CommandMove.cpp
+++ b/programs/disks/CommandMove.cpp
@ -53,12 +53,10 @@ public:
                {
                    throw Exception(ErrorCodes::BAD_ARGUMENTS, "cannot move '{}' to '{}': Directory not empty", path_from, target_location);
                }
-                else
-                {
+
                disk.getDisk()->moveDirectory(path_from, target_location);
            }
        }
-        }
        else if (!disk.getDisk()->exists(path_from))
        {
            throw Exception(
--- a/programs/disks/CommandRemove.cpp
+++ b/programs/disks/CommandRemove.cpp
@ -32,17 +32,15 @@ public:
        {
            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Path {} on disk {} doesn't exist", path, disk.getDisk()->getName());
        }
-        else if (disk.getDisk()->isDirectory(path))
+        if (disk.getDisk()->isDirectory(path))
        {
            if (!recursive)
            {
                throw Exception(ErrorCodes::BAD_ARGUMENTS, "cannot remove '{}': Is a directory", path);
            }
-            else
-            {
+
            disk.getDisk()->removeRecursive(path);
        }
-        }
        else
        {
            disk.getDisk()->removeFileIfExists(path);
--- a/programs/disks/CommandWrite.cpp
+++ b/programs/disks/CommandWrite.cpp
@ -33,14 +33,10 @@ public:
        auto in = [&]() -> std::unique_ptr<ReadBufferFromFileBase>
        {
            if (!path_from.has_value())
-            {
                return std::make_unique<ReadBufferFromFileDescriptor>(STDIN_FILENO);
-            }
-            else
-            {
+
            String relative_path_from = disk.getRelativeFromRoot(path_from.value());
            return disk.getDisk()->readFile(relative_path_from, getReadSettings());
-            }
        }();

        auto out = disk.getDisk()->writeFile(path_to);
--- a/programs/disks/DisksApp.cpp
+++ b/programs/disks/DisksApp.cpp
@ -127,13 +127,12 @@ std::vector<String> DisksApp::getCompletions(const String & prefix) const
        }
        return getEmptyCompletion(command->command_name);
    }
-    else if (arguments.size() == 1)
+    if (arguments.size() == 1)
    {
        String command_prefix = arguments[0];
        return getCommandsToComplete(command_prefix);
    }
-    else
-    {
+
    String last_token = arguments.back();
    CommandPtr command;
    try
@ -144,23 +143,17 @@ std::vector<String> DisksApp::getCompletions(const String & prefix) const
    {
        return {last_token};
    }
+
    std::vector<String> answer = {};
    if (command->command_name == "help")
-        {
        return getCommandsToComplete(last_token);
-        }
-        else
-        {
+
    answer = [&]() -> std::vector<String>
    {
        if (multidisk_commands.contains(command->command_name))
-                {
            return client->getAllFilesByPatternFromAllDisks(last_token);
-                }
-                else
-                {
+
        return client->getCurrentDiskWithPath().getAllFilesByPattern(last_token);
-                }
    }();

    for (const auto & disk_name : client->getAllDiskNames())
@ -178,18 +171,15 @@ std::vector<String> DisksApp::getCompletions(const String & prefix) const
            answer.push_back(option_sign);
        }
    }
-        }
+
    if (!answer.empty())
    {
        std::sort(answer.begin(), answer.end());
        return answer;
    }
-        else
-        {
+
    return {last_token};
 }
-    }
-}

 bool DisksApp::processQueryText(const String & text)
 {
@ -210,11 +200,11 @@ bool DisksApp::processQueryText(const String & text)
    catch (DB::Exception & err)
    {
        int code = getCurrentExceptionCode();
+
        if (code == ErrorCodes::LOGICAL_ERROR)
-        {
            throw std::move(err);
-        }
-        else if (code == ErrorCodes::BAD_ARGUMENTS)
+
+        if (code == ErrorCodes::BAD_ARGUMENTS)
        {
            std::cerr << err.message() << "\n"
                      << "\n";
--- a/programs/disks/DisksClient.cpp
+++ b/programs/disks/DisksClient.cpp
@ -49,11 +49,9 @@ std::vector<String> DiskWithPath::listAllFilesByPath(const String & any_path) co
        disk->listFiles(getRelativeFromRoot(any_path), file_names);
        return file_names;
    }
-    else
-    {
+
    return {};
 }
-}

 std::vector<String> DiskWithPath::getAllFilesByPattern(const String & pattern) const
 {
@ -61,23 +59,15 @@ std::vector<String> DiskWithPath::getAllFilesByPattern(const String & pattern) c
    {
        auto slash_pos = pattern.find_last_of('/');
        if (slash_pos >= pattern.size())
-        {
            return {"", pattern};
-        }
-        else
-        {
+
        return {pattern.substr(0, slash_pos + 1), pattern.substr(slash_pos + 1, pattern.size() - slash_pos - 1)};
-        }
    }();

    if (!isDirectory(path_before))
-    {
        return {};
-    }
-    else
-    {
-        std::vector<String> file_names = listAllFilesByPath(path_before);

+    std::vector<String> file_names = listAllFilesByPath(path_before);
    std::vector<String> answer;

    for (const auto & file_name : file_names)
@ -93,7 +83,6 @@ std::vector<String> DiskWithPath::getAllFilesByPattern(const String & pattern) c
        }
    }
    return answer;
-    }
 };

 void DiskWithPath::setPath(const String & any_path)
--- a/programs/disks/ICommand.cpp
+++ b/programs/disks/ICommand.cpp
@ -39,13 +39,9 @@ DiskWithPath & ICommand::getDiskWithPath(DisksClient & client, const CommandLine
 {
    auto disk_name = getValueFromCommandLineOptionsWithOptional<String>(options, name);
    if (disk_name.has_value())
-    {
        return client.getDiskWithPath(disk_name.value());
-    }
-    else
-    {
+
    return client.getCurrentDiskWithPath();
 }
-}

 }
--- a/programs/disks/ICommand.h
+++ b/programs/disks/ICommand.h
@ -63,40 +63,28 @@ protected:
    static T getValueFromCommandLineOptionsThrow(const CommandLineOptions & options, const String & name)
    {
        if (options.count(name))
-        {
            return getValueFromCommandLineOptions<T>(options, name);
-        }
-        else
-        {
+
        throw DB::Exception(ErrorCodes::BAD_ARGUMENTS, "Mandatory argument '{}' is missing", name);
    }
-    }

    template <typename T>
    static T getValueFromCommandLineOptionsWithDefault(const CommandLineOptions & options, const String & name, const T & default_value)
    {
        if (options.count(name))
-        {
            return getValueFromCommandLineOptions<T>(options, name);
-        }
-        else
-        {
+
        return default_value;
    }
-    }

    template <typename T>
    static std::optional<T> getValueFromCommandLineOptionsWithOptional(const CommandLineOptions & options, const String & name)
    {
        if (options.count(name))
-        {
            return std::optional{getValueFromCommandLineOptions<T>(options, name)};
-        }
-        else
-        {
+
        return std::nullopt;
    }
-    }

    DiskWithPath & getDiskWithPath(DisksClient & client, const CommandLineOptions & options, const String & name);

--- a/programs/install/Install.cpp
+++ b/programs/install/Install.cpp
@ -110,7 +110,7 @@ static auto executeScript(const std::string & command, bool throw_on_error = fal
        sh->wait();
        return 0;
    }
-    else
+
    return sh->tryWait();
 }

--- a/programs/library-bridge/CatBoostLibraryHandlerFactory.cpp
+++ b/programs/library-bridge/CatBoostLibraryHandlerFactory.cpp
@ -26,8 +26,7 @@ CatBoostLibraryHandlerPtr CatBoostLibraryHandlerFactory::tryGetModel(const Strin

    if (found)
        return handler->second;
-    else
-    {
+
    if (create_if_not_found)
    {
        auto new_handler = std::make_shared<CatBoostLibraryHandler>(library_path, model_path);
@ -37,7 +36,6 @@ CatBoostLibraryHandlerPtr CatBoostLibraryHandlerFactory::tryGetModel(const Strin
    }
    return nullptr;
 }
-}

 void CatBoostLibraryHandlerFactory::removeModel(const String & model_path)
 {
--- a/programs/library-bridge/LibraryBridgeHandlerFactory.cpp
+++ b/programs/library-bridge/LibraryBridgeHandlerFactory.cpp
@ -25,7 +25,7 @@ std::unique_ptr<HTTPRequestHandler> LibraryBridgeHandlerFactory::createRequestHa
    {
        if (uri.getPath() == "/extdict_ping")
            return std::make_unique<ExternalDictionaryLibraryBridgeExistsHandler>(getContext());
-        else if (uri.getPath() == "/catboost_ping")
+        if (uri.getPath() == "/catboost_ping")
            return std::make_unique<CatBoostLibraryBridgeExistsHandler>(getContext());
    }

@ -33,7 +33,7 @@ std::unique_ptr<HTTPRequestHandler> LibraryBridgeHandlerFactory::createRequestHa
    {
        if (uri.getPath() == "/extdict_request")
            return std::make_unique<ExternalDictionaryLibraryBridgeRequestHandler>(getContext());
-        else if (uri.getPath() == "/catboost_request")
+        if (uri.getPath() == "/catboost_request")
            return std::make_unique<CatBoostLibraryBridgeRequestHandler>(getContext());
    }

--- a/programs/library-bridge/LibraryBridgeHandlers.cpp
+++ b/programs/library-bridge/LibraryBridgeHandlers.cpp
@ -158,12 +158,10 @@ void ExternalDictionaryLibraryBridgeRequestHandler::handleRequest(HTTPServerRequ
                out.finalize();
                return;
            }
-            else
-            {
+
            LOG_TRACE(log, "Cannot clone from dictionary with id: {}, will call extDict_libNew instead", from_dictionary_id);
            lib_new = true;
        }
-        }
        if (lib_new)
        {
            auto & read_buf = request.getStream();
--- a/programs/obfuscator/Obfuscator.cpp
+++ b/programs/obfuscator/Obfuscator.cpp
@ -231,7 +231,7 @@ static Int64 transformSigned(Int64 x, UInt64 seed)
 {
    if (x >= 0)
        return transform(x, seed);
-    else
+
    return -transform(-x, seed);    /// It works Ok even for minimum signed number.
 }

@ -1105,7 +1105,7 @@ public:
        {
            if (isUInt(data_type))
                return std::make_unique<UnsignedIntegerModel>(seed);
-            else
+
            return std::make_unique<SignedIntegerModel>(seed);
        }

--- a/programs/odbc-bridge/getIdentifierQuote.cpp
+++ b/programs/odbc-bridge/getIdentifierQuote.cpp
@ -39,11 +39,11 @@ IdentifierQuotingStyle getQuotingStyle(nanodbc::ConnectionHolderPtr connection)
    auto identifier_quote = getIdentifierQuote(connection);
    if (identifier_quote.empty())
        return IdentifierQuotingStyle::Backticks;
-    else if (identifier_quote[0] == '`')
+    if (identifier_quote[0] == '`')
        return IdentifierQuotingStyle::Backticks;
-    else if (identifier_quote[0] == '"')
+    if (identifier_quote[0] == '"')
        return IdentifierQuotingStyle::DoubleQuotes;
-    else
+
    throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
                    "Can not map quote identifier '{}' to IdentifierQuotingStyle value", identifier_quote);
 }
--- a/programs/odbc-bridge/validateODBCConnectionString.cpp
+++ b/programs/odbc-bridge/validateODBCConnectionString.cpp
@ -127,7 +127,7 @@ std::string validateODBCConnectionString(const std::string & connection_string)

        if (*pos == '{')
            return read_escaped_value();
-        else
+
        return read_plain_value();
    };

@ -206,13 +206,11 @@ std::string validateODBCConnectionString(const std::string & connection_string)
                reconstructed_connection_string.append(value_pos, next_pos - value_pos);
                break;
            }
-            else
-            {
+
            reconstructed_connection_string.append(value_pos, next_pos - value_pos);
            reconstructed_connection_string.append("}}");
            value_pos = next_pos + 1;
        }
-        }

        reconstructed_connection_string += '}';
    };
--- a/programs/server/Server.cpp
+++ b/programs/server/Server.cpp
@ -69,6 +69,7 @@
 #include <Interpreters/registerInterpreters.h>
 #include <Interpreters/JIT/CompiledExpressionCache.h>
 #include <Access/AccessControl.h>
+#include <Storages/MaterializedView/RefreshSet.h>
 #include <Storages/MergeTree/MergeTreeSettings.h>
 #include <Storages/StorageReplicatedMergeTree.h>
 #include <Storages/System/attachSystemTables.h>
@ -2083,6 +2084,12 @@ try

    try
    {
+        /// Don't run background queries until we loaded tables.
+        /// (In particular things would break if a background drop query happens before the
+        /// loadMarkedAsDroppedTables() call below - it'll see dropped table metadata and try to
+        /// drop the table a second time and throw an exception.)
+        global_context->getRefreshSet().setRefreshesStopped(true);
+
        auto & database_catalog = DatabaseCatalog::instance();
        /// We load temporary database first, because projections need it.
        database_catalog.initializeAndLoadTemporaryDatabase();
@ -2122,6 +2129,8 @@ try
        database_catalog.assertDatabaseExists(default_database);
        /// Load user-defined SQL functions.
        global_context->getUserDefinedSQLObjectsStorage().loadObjects();
+
+        global_context->getRefreshSet().setRefreshesStopped(false);
    }
    catch (...)
    {
--- a/src/Access/AccessBackup.cpp
+++ b/src/Access/AccessBackup.cpp
@ -116,16 +116,14 @@ namespace
                        reading_dependents = false;
                        continue;
                    }
-                    else if (line == "DEPENDENTS")
+                    if (line == "DEPENDENTS")
                    {
                        reading_dependents = true;
                        reading_dependencies = false;
                        continue;
                    }
-                    else if (line.empty())
-                    {
+                    if (line.empty())
                        continue;
-                    }

                    size_t separator1 = line.find('\t');
                    size_t separator2 = line.find('\t', separator1 + 1);
--- a/src/Access/AccessControl.cpp
+++ b/src/Access/AccessControl.cpp
@ -134,7 +134,7 @@ public:
                            "' registered for user-defined settings",
                            String{setting_name}, boost::algorithm::join(registered_prefixes, "' or '"));
        }
-        else
+
        throw Exception(ErrorCodes::UNKNOWN_SETTING, "Unknown setting '{}'", String{setting_name});
    }

@ -830,7 +830,6 @@ std::shared_ptr<const EnabledQuota> AccessControl::getAuthenticationQuota(
                                            quota_key,
                                            throw_if_client_key_empty);
    }
-    else
    return nullptr;
 }

--- a/src/Access/AccessRights.cpp
+++ b/src/Access/AccessRights.cpp
@ -1155,9 +1155,6 @@ private:

        calculateMinMaxFlags();

-        if (!isLeaf())
-            return;
-
        auto new_flags = function(flags, min_flags_with_children, max_flags_with_children, level, grant_option);

        if (new_flags != flags)
@ -1483,16 +1480,16 @@ bool AccessRights::isGrantedImplHelper(const AccessRightsElement & element) cons
    {
        if (element.anyParameter())
            return isGrantedImpl<grant_option, wildcard>(element.access_flags);
-        else
+
        return isGrantedImpl<grant_option, wildcard>(element.access_flags, element.parameter);
    }
-    else if (element.anyDatabase())
+    if (element.anyDatabase())
        return isGrantedImpl<grant_option, wildcard>(element.access_flags);
-    else if (element.anyTable())
+    if (element.anyTable())
        return isGrantedImpl<grant_option, wildcard>(element.access_flags, element.database);
-    else if (element.anyColumn())
+    if (element.anyColumn())
        return isGrantedImpl<grant_option, wildcard>(element.access_flags, element.database, element.table);
-    else
+
    return isGrantedImpl<grant_option, wildcard>(element.access_flags, element.database, element.table, element.columns);
 }

@ -1503,17 +1500,15 @@ bool AccessRights::isGrantedImpl(const AccessRightsElement & element) const
    {
        if (element.grant_option)
            return isGrantedImplHelper<true, true>(element);
-        else
+
        return isGrantedImplHelper<grant_option, true>(element);
    }
-    else
-    {
+
    if (element.grant_option)
        return isGrantedImplHelper<true, wildcard>(element);
-        else
+
    return isGrantedImplHelper<grant_option, wildcard>(element);
 }
-}

 template <bool grant_option, bool wildcard>
 bool AccessRights::isGrantedImpl(const AccessRightsElements & elements) const
--- a/src/Access/AuthenticationData.cpp
+++ b/src/Access/AuthenticationData.cpp
@ -501,10 +501,9 @@ AuthenticationData AuthenticationData::fromAST(const ASTAuthenticationData & que
            auth_data.setPasswordHashBinary(AuthenticationData::Util::stringToDigest(value));
            return auth_data;
        }
-        else
-        {
+
        auth_data.setPasswordHashHex(value);
-        }
+

        if (query.type == AuthenticationType::SHA256_PASSWORD && args_size == 2)
        {
--- a/src/Access/Common/AccessFlags.cpp
+++ b/src/Access/Common/AccessFlags.cpp
@ -247,7 +247,6 @@ namespace
                const auto & unused_node = *(owned_nodes.begin()->second);
                if (unused_node.node_type == UNKNOWN)
                    throw Exception(ErrorCodes::LOGICAL_ERROR, "Parent group '{}' not found", unused_node.keyword);
-                else
                throw Exception(ErrorCodes::LOGICAL_ERROR, "Access type '{}' should have parent group", unused_node.keyword);
            }
        }
--- a/src/Access/Common/AllowedClientHosts.cpp
+++ b/src/Access/Common/AllowedClientHosts.cpp
@ -61,7 +61,7 @@ namespace
        {
            if (addr.family() == IPAddress::Family::IPv4 && addr_v6 == toIPv6(addr))
                return true;
-            else if (addr.family() == IPAddress::Family::IPv6 && addr_v6 == addr)
+            if (addr.family() == IPAddress::Family::IPv6 && addr_v6 == addr)
                return true;
        }

@ -267,9 +267,8 @@ String AllowedClientHosts::IPSubnet::toString() const
    unsigned int prefix_length = mask.prefixLength();
    if (isMaskAllBitsOne())
        return prefix.toString();
-    else if (IPAddress{prefix_length, mask.family()} == mask)
+    if (IPAddress{prefix_length, mask.family()} == mask)
        return fs::path(prefix.toString()) / std::to_string(prefix_length);
-    else
    return fs::path(prefix.toString()) / mask.toString();
 }

@ -575,11 +574,10 @@ bool AllowedClientHosts::contains(const IPAddress & client_address) const
        parseLikePattern(pattern, subnet, name, name_regexp);
        if (subnet)
            return check_subnet(*subnet);
-        else if (name)
+        if (name)
            return check_name(*name);
-        else if (name_regexp)
+        if (name_regexp)
            return check_name_regexp(*name_regexp);
-        else
        return false;
    };

--- a/src/Access/Common/QuotaDefs.cpp
+++ b/src/Access/Common/QuotaDefs.cpp
@ -28,7 +28,6 @@ String QuotaTypeInfo::valueToString(QuotaValue value) const
 {
    if (!(value % output_denominator))
        return std::to_string(value / output_denominator);
-    else
    return toString(static_cast<double>(value) / output_denominator);
 }

@ -36,7 +35,6 @@ QuotaValue QuotaTypeInfo::stringToValue(const String & str) const
 {
    if (output_denominator == 1)
        return static_cast<QuotaValue>(parse<UInt64>(str));
-    else
    return static_cast<QuotaValue>(parse<Float64>(str) * output_denominator);
 }

--- a/src/Access/ContextAccess.cpp
+++ b/src/Access/ContextAccess.cpp
@ -64,7 +64,27 @@ namespace
    }


-    AccessRights addImplicitAccessRights(const AccessRights & access, const AccessControl & access_control)
+    std::array<UUID, 1> to_array(const UUID & id)
+    {
+        std::array<UUID, 1> ids;
+        ids[0] = id;
+        return ids;
+    }
+
+    /// Helper for using in templates.
+    std::string_view getDatabase() { return {}; }
+
+    template <typename... OtherArgs>
+    std::string_view getDatabase(std::string_view arg1, const OtherArgs &...) { return arg1; }
+
+    std::string_view getTableEngine() { return {}; }
+
+    template <typename... OtherArgs>
+    std::string_view getTableEngine(std::string_view arg1, const OtherArgs &...) { return arg1; }
+}
+
+
+AccessRights ContextAccess::addImplicitAccessRights(const AccessRights & access, const AccessControl & access_control)
 {
    AccessFlags max_flags;

@ -254,26 +274,6 @@ namespace
 }


-    std::array<UUID, 1> to_array(const UUID & id)
-    {
-        std::array<UUID, 1> ids;
-        ids[0] = id;
-        return ids;
-    }
-
-    /// Helper for using in templates.
-    std::string_view getDatabase() { return {}; }
-
-    template <typename... OtherArgs>
-    std::string_view getDatabase(std::string_view arg1, const OtherArgs &...) { return arg1; }
-
-    std::string_view getTableEngine() { return {}; }
-
-    template <typename... OtherArgs>
-    std::string_view getTableEngine(std::string_view arg1, const OtherArgs &...) { return arg1; }
-}
-
-
 std::shared_ptr<const ContextAccess> ContextAccess::fromContext(const ContextPtr & context)
 {
    return ContextAccessWrapper::fromContext(context)->getAccess();
@ -728,7 +728,6 @@ bool ContextAccess::checkAccessImplHelper(const ContextPtr & context, AccessFlag
                    "For queries over HTTP, method GET implies readonly. "
                    "You should use method POST for modifying queries");
            }
-            else
            return access_denied(ErrorCodes::READONLY, "{}: Cannot execute query in readonly mode");
        }
    }
@ -770,16 +769,16 @@ bool ContextAccess::checkAccessImplHelper(const ContextPtr & context, const Acce
    {
        if (element.anyParameter())
            return checkAccessImpl<throw_if_denied, grant_option, wildcard>(context, element.access_flags);
-        else
+
        return checkAccessImpl<throw_if_denied, grant_option, wildcard>(context, element.access_flags, element.parameter);
    }
-    else if (element.anyDatabase())
+    if (element.anyDatabase())
        return checkAccessImpl<throw_if_denied, grant_option, wildcard>(context, element.access_flags);
-    else if (element.anyTable())
+    if (element.anyTable())
        return checkAccessImpl<throw_if_denied, grant_option, wildcard>(context, element.access_flags, element.database);
-    else if (element.anyColumn())
+    if (element.anyColumn())
        return checkAccessImpl<throw_if_denied, grant_option, wildcard>(context, element.access_flags, element.database, element.table);
-    else
+
    return checkAccessImpl<throw_if_denied, grant_option, wildcard>(context, element.access_flags, element.database, element.table, element.columns);
 }

@ -790,17 +789,15 @@ bool ContextAccess::checkAccessImpl(const ContextPtr & context, const AccessRigh
    {
        if (element.grant_option)
            return checkAccessImplHelper<throw_if_denied, true, true>(context, element);
-        else
+
        return checkAccessImplHelper<throw_if_denied, grant_option, true>(context, element);
    }
-    else
-    {
+
    if (element.grant_option)
        return checkAccessImplHelper<throw_if_denied, true, wildcard>(context, element);
-        else
+
    return checkAccessImplHelper<throw_if_denied, grant_option, wildcard>(context, element);
 }
-}

 template <bool throw_if_denied, bool grant_option, bool wildcard>
 bool ContextAccess::checkAccessImpl(const ContextPtr & context, const AccessRightsElements & elements) const
--- a/src/Access/ContextAccess.h
+++ b/src/Access/ContextAccess.h
@ -132,6 +132,8 @@ public:
    /// Checks if grantees are allowed for the current user, throws an exception if not.
    void checkGranteesAreAllowed(const std::vector<UUID> & grantee_ids) const;

+    static AccessRights addImplicitAccessRights(const AccessRights & access, const AccessControl & access_control);
+
    ContextAccess(const AccessControl & access_control_, const Params & params_);
    ~ContextAccess();

--- a/src/Access/ContextAccessParams.cpp
+++ b/src/Access/ContextAccessParams.cpp
@ -89,9 +89,8 @@ bool operator ==(const ContextAccessParams & left, const ContextAccessParams & r
        {
            if (!x)
                return !y;
-            else if (!y)
+            if (!y)
                return false;
-            else
            return *x == *y;
        }
        else
@ -132,22 +131,20 @@ bool operator <(const ContextAccessParams & left, const ContextAccessParams & ri
        {
            if (!x)
                return y ? -1 : 0;
-            else if (!y)
+            if (!y)
                return 1;
-            else if (*x == *y)
+            if (*x == *y)
                return 0;
-            else if (*x < *y)
+            if (*x < *y)
                return -1;
-            else
            return 1;
        }
        else
        {
            if (x == y)
                return 0;
-            else if (x < y)
+            if (x < y)
                return -1;
-            else
            return 1;
        }
    };
--- a/src/Access/KerberosInit.cpp
+++ b/src/Access/KerberosInit.cpp
@ -166,7 +166,6 @@ void KerberosInit::init(const String & keytab_file, const String & principal, co
        ret = krb5_get_init_creds_keytab(k5.ctx, &my_creds, k5.me, keytab, 0, nullptr, options);
        if (ret)
            throw Exception(ErrorCodes::KERBEROS_ERROR, "Error in getting initial credentials: {}", fmtError(ret));
-        else
        LOG_TRACE(log, "Got initial credentials");
    }
    else
--- a/src/Access/LDAPAccessStorage.cpp
+++ b/src/Access/LDAPAccessStorage.cpp
@ -330,10 +330,7 @@ std::set<String> LDAPAccessStorage::mapExternalRolesNoLock(const LDAPClient::Sea

        for (const auto & external_role : external_role_set)
        {
-            if (
-                prefix.size() < external_role.size() &&
-                external_role.compare(0, prefix.size(), prefix) == 0
-            )
+            if (prefix.size() < external_role.size() && external_role.starts_with(prefix))
            {
                role_names.emplace(external_role, prefix.size());
            }
--- a/src/Access/QuotaCache.cpp
+++ b/src/Access/QuotaCache.cpp
@ -62,7 +62,6 @@ String QuotaCache::QuotaInfo::calculateKey(const EnabledQuota & enabled, bool th
                    "Quota {} (for user {}) requires a client supplied key.",
                    quota->getName(),
                    params.user_name);
-            else
            return ""; // Authentication quota has no client key at time of authentication.
        }
        case QuotaKeyType::CLIENT_KEY_OR_USER_NAME:
--- a/src/Access/RolesOrUsersSet.cpp
+++ b/src/Access/RolesOrUsersSet.cpp
@ -80,15 +80,13 @@ void RolesOrUsersSet::init(const ASTRolesOrUsersSet & ast, const AccessControl *
                return *id;
            return access_control->getID<Role>(name);
        }
-        else if (ast.allow_users)
+        if (ast.allow_users)
        {
            return access_control->getID<User>(name);
        }
-        else
-        {
+
        assert(ast.allow_roles);
        return access_control->getID<Role>(name);
-        }
    };

    if (!ast.names.empty() && !all)
--- a/src/Access/SettingsAuthResponseParser.cpp
+++ b/src/Access/SettingsAuthResponseParser.cpp
@ -28,7 +28,7 @@ SettingsAuthResponseParser::parse(const Poco::Net::HTTPResponse & response, std:
    try
    {
        Poco::Dynamic::Var json = parser.parse(*body_stream);
-        Poco::JSON::Object::Ptr obj = json.extract<Poco::JSON::Object::Ptr>();
+        const Poco::JSON::Object::Ptr & obj = json.extract<Poco::JSON::Object::Ptr>();
        Poco::JSON::Object::Ptr settings_obj = obj->getObject(settings_key);

        if (settings_obj)
--- a/src/Access/SettingsConstraints.cpp
+++ b/src/Access/SettingsConstraints.cpp
@ -54,7 +54,6 @@ SettingSourceRestrictions getSettingSourceRestrictions(std::string_view name)
    auto settingConstraintIter = SETTINGS_SOURCE_RESTRICTIONS.find(name);
    if (settingConstraintIter != SETTINGS_SOURCE_RESTRICTIONS.end())
        return settingConstraintIter->second;
-    else
    return SettingSourceRestrictions(); // allows everything
 }

@ -310,7 +309,6 @@ bool SettingsConstraints::Checker::check(SettingChange & change,
    {
        if (reaction == THROW_ON_VIOLATION)
            throw Exception(explain, code);
-        else
        return false;
    }

@ -335,7 +333,6 @@ bool SettingsConstraints::Checker::check(SettingChange & change,
    {
        if (reaction == THROW_ON_VIOLATION)
            throw Exception(ErrorCodes::SETTING_CONSTRAINT_VIOLATION, "Setting {} should not be changed", setting_name);
-        else
        return false;
    }

@ -351,7 +348,6 @@ bool SettingsConstraints::Checker::check(SettingChange & change,
                max_value,
                min_value,
                setting_name);
-        else
        return false;
    }

@ -362,7 +358,6 @@ bool SettingsConstraints::Checker::check(SettingChange & change,
            throw Exception(ErrorCodes::SETTING_CONSTRAINT_VIOLATION, "Setting {} shouldn't be less than {}",
                setting_name, applyVisitor(FieldVisitorToString(), min_value));
        }
-        else
        change.value = min_value;
    }

@ -373,7 +368,6 @@ bool SettingsConstraints::Checker::check(SettingChange & change,
            throw Exception(ErrorCodes::SETTING_CONSTRAINT_VIOLATION, "Setting {} shouldn't be greater than {}",
                setting_name, applyVisitor(FieldVisitorToString(), max_value));
        }
-        else
        change.value = max_value;
    }

@ -381,7 +375,6 @@ bool SettingsConstraints::Checker::check(SettingChange & change,
    {
        if (reaction == THROW_ON_VIOLATION)
            throw Exception(ErrorCodes::READONLY, "Setting {} is not allowed to be set by {}", setting_name, toString(source));
-        else
        return false;
    }

--- a/src/Access/UsersConfigAccessStorage.cpp
+++ b/src/Access/UsersConfigAccessStorage.cpp
@ -649,7 +649,6 @@ namespace
                {
                    if (users_without_row_policies_can_read_rows)
                        continue;
-                    else
                    filter = "1";
                }

--- a/src/AggregateFunctions/AggregateFunctionAnyRespectNulls.cpp
+++ b/src/AggregateFunctions/AggregateFunctionAnyRespectNulls.cpp
@ -157,13 +157,13 @@ public:
        d.status = static_cast<Data::Status>(k);
        if (d.status == Data::Status::NotSet)
            return;
-        else if (d.status == Data::Status::SetNull)
+        if (d.status == Data::Status::SetNull)
        {
            if (!returns_nullable_type)
                throw Exception(ErrorCodes::INCORRECT_DATA, "Incorrect type (NULL) in non-nullable {}State", getName());
            return;
        }
-        else if (d.status == Data::Status::SetOther)
+        if (d.status == Data::Status::SetOther)
        {
            serialization->deserializeBinary(d.value, buf, {});
            return;
--- a/src/AggregateFunctions/AggregateFunctionDeltaSum.cpp
+++ b/src/AggregateFunctions/AggregateFunctionDeltaSum.cpp
@ -148,9 +148,8 @@ AggregateFunctionPtr createAggregateFunctionDeltaSum(
    if (isInteger(data_type) || isFloat(data_type))
        return AggregateFunctionPtr(createWithNumericType<AggregationFunctionDeltaSum>(
            *data_type, arguments, params));
-    else
-        throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument for aggregate function {}",
-            arguments[0]->getName(), name);
+    throw Exception(
+        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument for aggregate function {}", arguments[0]->getName(), name);
 }
 }

--- a/src/AggregateFunctions/AggregateFunctionFactory.cpp
+++ b/src/AggregateFunctions/AggregateFunctionFactory.cpp
@ -137,13 +137,12 @@ AggregateFunctionFactory::getAssociatedFunctionByNullsAction(const String & name
 {
    if (action == NullsAction::RESPECT_NULLS)
    {
-        if (auto it = respect_nulls.find(name); it == respect_nulls.end())
+        auto it = respect_nulls.find(name);
+        if (it == respect_nulls.end())
            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Function {} does not support RESPECT NULLS", name);
-        else if (auto associated_it = aggregate_functions.find(it->second); associated_it != aggregate_functions.end())
+        if (auto associated_it = aggregate_functions.find(it->second); associated_it != aggregate_functions.end())
            return {associated_it->second};
-        else
-            throw Exception(
-                ErrorCodes::LOGICAL_ERROR, "Unable to find the function {} (equivalent to '{} RESPECT NULLS')", it->second, name);
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Unable to find the function {} (equivalent to '{} RESPECT NULLS')", it->second, name);
    }

    if (action == NullsAction::IGNORE_NULLS)
@ -152,7 +151,6 @@ AggregateFunctionFactory::getAssociatedFunctionByNullsAction(const String & name
        {
            if (auto associated_it = aggregate_functions.find(it->second); associated_it != aggregate_functions.end())
                return {associated_it->second};
-            else
            throw Exception(
                ErrorCodes::LOGICAL_ERROR, "Unable to find the function {} (equivalent to '{} IGNORE NULLS')", it->second, name);
        }
@ -263,7 +261,6 @@ AggregateFunctionPtr AggregateFunctionFactory::getImpl(
    if (!hints.empty())
        throw Exception(ErrorCodes::UNKNOWN_AGGREGATE_FUNCTION,
                        "Unknown aggregate function {}{}. Maybe you meant: {}", name, extra_info, toString(hints));
-    else
    throw Exception(ErrorCodes::UNKNOWN_AGGREGATE_FUNCTION, "Unknown aggregate function {}{}", name, extra_info);
 }

--- a/src/AggregateFunctions/AggregateFunctionFlameGraph.cpp
+++ b/src/AggregateFunctions/AggregateFunctionFlameGraph.cpp
@ -328,8 +328,7 @@ struct AggregateFunctionFlameGraphData
            list = list->next;
            return entry;
        }
-        else
-        {
+
        Entry * parent = list;
        while (parent->next && parent->next->size != size)
            parent = parent->next;
@ -343,7 +342,6 @@ struct AggregateFunctionFlameGraphData

        return nullptr;
    }
-    }

    void add(UInt64 ptr, Int64 size, const UInt64 * stack, size_t stack_size, Arena * arena)
    {
--- a/src/AggregateFunctions/AggregateFunctionGroupArray.cpp
+++ b/src/AggregateFunctions/AggregateFunctionGroupArray.cpp
@ -90,7 +90,6 @@ struct GroupArraySamplerData
        /// With a large number of values, we will generate random numbers several times slower.
        if (lim <= static_cast<UInt64>(pcg32_fast::max()))
            return rng() % lim;
-        else
        return (static_cast<UInt64>(rng()) * (static_cast<UInt64>(pcg32::max()) + 1ULL) + static_cast<UInt64>(rng())) % lim;
    }

@ -797,8 +796,8 @@ AggregateFunctionPtr createAggregateFunctionGroupArray(
            throw Exception(ErrorCodes::BAD_ARGUMENTS, "groupArrayLast make sense only with max_elems (groupArrayLast(max_elems)())");
        return createAggregateFunctionGroupArrayImpl<GroupArrayTrait</* Thas_limit= */ false, Tlast, /* Tsampler= */ Sampler::NONE>>(argument_types[0], parameters, max_elems, std::nullopt);
    }
-    else
-        return createAggregateFunctionGroupArrayImpl<GroupArrayTrait</* Thas_limit= */ true, Tlast, /* Tsampler= */ Sampler::NONE>>(argument_types[0], parameters, max_elems, std::nullopt);
+    return createAggregateFunctionGroupArrayImpl<GroupArrayTrait</* Thas_limit= */ true, Tlast, /* Tsampler= */ Sampler::NONE>>(
+        argument_types[0], parameters, max_elems, std::nullopt);
 }

 AggregateFunctionPtr createAggregateFunctionGroupArraySample(
--- a/src/AggregateFunctions/AggregateFunctionGroupArrayIntersect.cpp
+++ b/src/AggregateFunctions/AggregateFunctionGroupArrayIntersect.cpp
@ -381,24 +381,23 @@ IAggregateFunction * createWithExtraTypes(const DataTypePtr & argument_type, con
 {
    WhichDataType which(argument_type);
    if (which.idx == TypeIndex::Date) return new AggregateFunctionGroupArrayIntersectDate(argument_type, parameters);
-    else if (which.idx == TypeIndex::DateTime) return new AggregateFunctionGroupArrayIntersectDateTime(argument_type, parameters);
-    else if (which.idx == TypeIndex::Date32) return new AggregateFunctionGroupArrayIntersectDate32(argument_type, parameters);
-    else if (which.idx == TypeIndex::DateTime64)
+    if (which.idx == TypeIndex::DateTime)
+        return new AggregateFunctionGroupArrayIntersectDateTime(argument_type, parameters);
+    if (which.idx == TypeIndex::Date32)
+        return new AggregateFunctionGroupArrayIntersectDate32(argument_type, parameters);
+    if (which.idx == TypeIndex::DateTime64)
    {
        const auto * datetime64_type = dynamic_cast<const DataTypeDateTime64 *>(argument_type.get());
        const auto return_type = std::make_shared<DataTypeArray>(std::make_shared<DataTypeDateTime64>(datetime64_type->getScale()));

        return new AggregateFunctionGroupArrayIntersectGeneric<true>(argument_type, parameters, return_type);
    }
-    else
-    {
+
    /// Check that we can use plain version of AggregateFunctionGroupArrayIntersectGeneric
    if (argument_type->isValueUnambiguouslyRepresentedInContiguousMemoryRegion())
        return new AggregateFunctionGroupArrayIntersectGeneric<true>(argument_type, parameters);
-        else
    return new AggregateFunctionGroupArrayIntersectGeneric<false>(argument_type, parameters);
 }
-}

 inline AggregateFunctionPtr createAggregateFunctionGroupArrayIntersectImpl(const std::string & name, const DataTypePtr & argument_type, const Array & parameters)
 {
--- a/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.cpp
+++ b/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.cpp
@ -65,7 +65,6 @@ struct MovingSumData : public MovingData<T>
    {
        if (idx < window_size)
            return this->value[idx];
-        else
        return this->value[idx] - this->value[idx - window_size];
    }
 };
@ -79,7 +78,6 @@ struct MovingAvgData : public MovingData<T>
    {
        if (idx < window_size)
            return this->value[idx] / T(window_size);
-        else
        return (this->value[idx] - this->value[idx - window_size]) / T(window_size);
    }
 };
@ -285,17 +283,13 @@ AggregateFunctionPtr createAggregateFunctionMoving(
    {
        if (isDecimal(argument_type))
            return createAggregateFunctionMovingImpl<Function, std::false_type, std::true_type>(name, argument_type);
-        else
        return createAggregateFunctionMovingImpl<Function, std::false_type, std::false_type>(name, argument_type);
    }
-    else
-    {
+
    if (isDecimal(argument_type))
        return createAggregateFunctionMovingImpl<Function, std::true_type, std::true_type>(name, argument_type, max_elems);
-        else
    return createAggregateFunctionMovingImpl<Function, std::true_type, std::false_type>(name, argument_type, max_elems);
 }
-}

 }

--- a/src/AggregateFunctions/AggregateFunctionGroupArraySorted.cpp
+++ b/src/AggregateFunctions/AggregateFunctionGroupArraySorted.cpp
@ -391,21 +391,20 @@ AggregateFunctionPtr createAggregateFunctionGroupArray(
    {
        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Parameter for aggregate function {} should have limit argument", name);
    }
-    else if (parameters.size() == 1)
+    if (parameters.size() == 1)
    {
        auto type = parameters[0].getType();
        if (type != Field::Types::Int64 && type != Field::Types::UInt64)
            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Parameter for aggregate function {} should be positive number", name);

-        if ((type == Field::Types::Int64 && parameters[0].safeGet<Int64>() < 0) ||
-            (type == Field::Types::UInt64 && parameters[0].safeGet<UInt64>() == 0))
+        if ((type == Field::Types::Int64 && parameters[0].safeGet<Int64>() < 0)
+            || (type == Field::Types::UInt64 && parameters[0].safeGet<UInt64>() == 0))
            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Parameter for aggregate function {} should be positive number", name);

        max_elems = parameters[0].safeGet<UInt64>();
    }
    else
-        throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
-            "Function {} does not support this number of arguments", name);
+        throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} does not support this number of arguments", name);

    if (max_elems > group_array_sorted_sort_strategy_max_elements_threshold)
        return createAggregateFunctionGroupArraySortedImpl<GroupArraySortedSort>(argument_types[0], parameters, max_elems);
--- a/src/AggregateFunctions/AggregateFunctionGroupBitmap.cpp
+++ b/src/AggregateFunctions/AggregateFunctionGroupBitmap.cpp
@ -133,7 +133,6 @@ public:
    {
        if (revision >= STATE_VERSION_1_MIN_REVISION)
            return 1;
-        else
        return 0;
    }

--- a/src/AggregateFunctions/AggregateFunctionGroupBitmapData.h
+++ b/src/AggregateFunctions/AggregateFunctionGroupBitmapData.h
@ -88,7 +88,6 @@ public:
    {
        if (isSmall())
            return small.size();
-        else
        return roaring_bitmap->cardinality();
    }

@ -454,7 +453,6 @@ public:

        if (isSmall())
            return small.find(static_cast<T>(x)) != small.end();
-        else
        return roaring_bitmap->contains(static_cast<Value>(x));
    }

@ -554,8 +552,7 @@ public:
                r1.add(elem);
            return answer.size();
        }
-        else
-        {
+
        UInt64 count = 0;
        for (auto it = roaring_bitmap->begin(); it != roaring_bitmap->end(); ++it)
        {
@ -572,7 +569,6 @@ public:
        }
        return count;
    }
-    }

    UInt64 rb_offset_limit(UInt64 offset, UInt64 limit, RoaringBitmapWithSmallSet & r1) const /// NOLINT
    {
@ -591,8 +587,7 @@ public:
                r1.add(it->getValue());
            return count;
        }
-        else
-        {
+
        UInt64 count = 0;
        UInt64 offset_count = 0;
        auto it = roaring_bitmap->begin();
@ -603,7 +598,6 @@ public:
            r1.add(*it);
        return count;
    }
-    }

    UInt64 rb_min() const /// NOLINT
    {
@ -620,7 +614,6 @@ public:
            }
            return min_val;
        }
-        else
        return roaring_bitmap->minimum();
    }

@ -639,7 +632,6 @@ public:
            }
            return max_val;
        }
-        else
        return roaring_bitmap->maximum();
    }

--- a/src/AggregateFunctions/AggregateFunctionGroupConcat.cpp
+++ b/src/AggregateFunctions/AggregateFunctionGroupConcat.cpp
@ -275,7 +275,6 @@ AggregateFunctionPtr createAggregateFunctionGroupConcat(

    if (has_limit)
        return std::make_shared<GroupConcatImpl</* has_limit= */ true>>(argument_types[0], parameters, limit, delimiter);
-    else
    return std::make_shared<GroupConcatImpl</* has_limit= */ false>>(argument_types[0], parameters, limit, delimiter);
 }

--- a/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
+++ b/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
@ -276,17 +276,16 @@ IAggregateFunction * createWithExtraTypes(const DataTypePtr & argument_type, TAr
 {
    WhichDataType which(argument_type);
    if (which.idx == TypeIndex::Date) return new AggregateFunctionGroupUniqArrayDate<HasLimit>(argument_type, args...);
-    else if (which.idx == TypeIndex::DateTime) return new AggregateFunctionGroupUniqArrayDateTime<HasLimit>(argument_type, args...);
-    else if (which.idx == TypeIndex::IPv4) return new AggregateFunctionGroupUniqArrayIPv4<HasLimit>(argument_type, args...);
-    else
-    {
+    if (which.idx == TypeIndex::DateTime)
+        return new AggregateFunctionGroupUniqArrayDateTime<HasLimit>(argument_type, args...);
+    if (which.idx == TypeIndex::IPv4)
+        return new AggregateFunctionGroupUniqArrayIPv4<HasLimit>(argument_type, args...);
+
    /// Check that we can use plain version of AggregateFunctionGroupUniqArrayGeneric
    if (argument_type->isValueUnambiguouslyRepresentedInContiguousMemoryRegion())
        return new AggregateFunctionGroupUniqArrayGeneric<true, HasLimit>(argument_type, args...);
-        else
    return new AggregateFunctionGroupUniqArrayGeneric<false, HasLimit>(argument_type, args...);
 }
-}

 template <typename HasLimit, typename ... TArgs>
 inline AggregateFunctionPtr createAggregateFunctionGroupUniqArrayImpl(const std::string & name, const DataTypePtr & argument_type, TArgs ... args)
@ -336,7 +335,6 @@ AggregateFunctionPtr createAggregateFunctionGroupUniqArray(

    if (!limit_size)
        return createAggregateFunctionGroupUniqArrayImpl<std::false_type>(name, argument_types[0], parameters);
-    else
    return createAggregateFunctionGroupUniqArrayImpl<std::true_type>(name, argument_types[0], parameters, max_elems);
 }

--- a/src/AggregateFunctions/AggregateFunctionMaxIntersections.cpp
+++ b/src/AggregateFunctions/AggregateFunctionMaxIntersections.cpp
@ -87,7 +87,6 @@ public:
    {
        if (kind_ == AggregateFunctionIntersectionsKind::Count)
            return std::make_shared<DataTypeUInt64>();
-        else
        return std::make_shared<DataTypeNumber<PointType>>();
    }

--- a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
@ -138,7 +138,9 @@ public:
    {
        if (other.count == 0)
            return;
-        else if (count == 0)
+
+        /// NOLINTBEGIN(readability-else-after-return)
+        if (count == 0)
        {
            compress_threshold = other.compress_threshold;
            relative_error = other.relative_error;
@ -237,6 +239,7 @@ public:
            doCompress(2 * merged_relative_error * merged_count);
            compressed = true;
        }
+        /// NOLINTEND(readability-else-after-return)
    }

    void write(WriteBuffer & buf) const
@ -292,13 +295,11 @@ private:
            Int64 max_rank = min_rank + curr_sample.delta;
            if (max_rank - target_error <= rank && rank <= min_rank + target_error)
                return {i, min_rank, curr_sample.value};
-            else
-            {
+
            ++i;
            curr_sample = sampled[i];
            min_rank += curr_sample.g;
        }
-        }
        return {sampled.size() - 1, 0, sampled.back().value};
    }

--- a/src/AggregateFunctions/AggregateFunctionSequenceMatch.cpp
+++ b/src/AggregateFunctions/AggregateFunctionSequenceMatch.cpp
@ -747,7 +747,7 @@ AggregateFunctionPtr createAggregateFunctionSequenceBase(
    WhichDataType which(argument_types.front().get());
    if (which.isDateTime())
        return std::make_shared<AggregateFunction<DataTypeDateTime::FieldType, Data<DataTypeDateTime::FieldType>>>(argument_types, params, pattern);
-    else if (which.isDate())
+    if (which.isDate())
        return std::make_shared<AggregateFunction<DataTypeDate::FieldType, Data<DataTypeDate::FieldType>>>(argument_types, params, pattern);

    throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
--- a/src/AggregateFunctions/AggregateFunctionStatistics.cpp
+++ b/src/AggregateFunctions/AggregateFunctionStatistics.cpp
@ -124,7 +124,6 @@ private:
    {
        if (count < 2)
            return std::numeric_limits<Float64>::infinity();
-        else
        return m2 / (count - 1);
    }

@ -137,9 +136,8 @@ private:
    {
        if (count == 0)
            return std::numeric_limits<Float64>::infinity();
-        else if (count == 1)
+        if (count == 1)
            return 0.0;
-        else
        return m2 / count;
    }

@ -363,7 +361,6 @@ private:
    {
        if (count < 2)
            return std::numeric_limits<Float64>::infinity();
-        else
        return co_moment / (count - 1);
    }

@ -371,9 +368,8 @@ private:
    {
        if (count == 0)
            return std::numeric_limits<Float64>::infinity();
-        else if (count == 1)
+        if (count == 1)
            return 0.0;
-        else
        return co_moment / count;
    }

@ -381,7 +377,6 @@ private:
    {
        if (count < 2)
            return std::numeric_limits<Float64>::infinity();
-        else
        return co_moment / sqrt(left_m2 * right_m2);
    }

--- a/src/AggregateFunctions/AggregateFunctionSumMap.cpp
+++ b/src/AggregateFunctions/AggregateFunctionSumMap.cpp
@ -112,7 +112,6 @@ public:
    {
        if (revision >= STATE_VERSION_1_MIN_REVISION)
            return 1;
-        else
        return 0;
    }

@ -764,7 +763,6 @@ void registerAggregateFunctionSumMap(AggregateFunctionFactory & factory)
        auto [keys_type, values_types, tuple_argument] = parseArguments(name, arguments);
        if (tuple_argument)
            return std::make_shared<AggregateFunctionSumMap<false, true>>(keys_type, values_types, arguments, params);
-        else
        return std::make_shared<AggregateFunctionSumMap<false, false>>(keys_type, values_types, arguments, params);
    });

@ -773,7 +771,6 @@ void registerAggregateFunctionSumMap(AggregateFunctionFactory & factory)
        auto [keys_type, values_types, tuple_argument] = parseArguments(name, arguments);
        if (tuple_argument)
            return std::make_shared<AggregateFunctionMinMap<true>>(keys_type, values_types, arguments, params);
-        else
        return std::make_shared<AggregateFunctionMinMap<false>>(keys_type, values_types, arguments, params);
    });

@ -782,7 +779,6 @@ void registerAggregateFunctionSumMap(AggregateFunctionFactory & factory)
        auto [keys_type, values_types, tuple_argument] = parseArguments(name, arguments);
        if (tuple_argument)
            return std::make_shared<AggregateFunctionMaxMap<true>>(keys_type, values_types, arguments, params);
-        else
        return std::make_shared<AggregateFunctionMaxMap<false>>(keys_type, values_types, arguments, params);
    });

@ -793,7 +789,6 @@ void registerAggregateFunctionSumMap(AggregateFunctionFactory & factory)
        auto [keys_type, values_types, tuple_argument] = parseArguments(name, arguments);
        if (tuple_argument)
            return std::make_shared<AggregateFunctionSumMap<true, true>>(keys_type, values_types, arguments, params);
-        else
        return std::make_shared<AggregateFunctionSumMap<true, false>>(keys_type, values_types, arguments, params);
    });

@ -802,7 +797,6 @@ void registerAggregateFunctionSumMap(AggregateFunctionFactory & factory)
        auto [keys_type, values_types, tuple_argument] = parseArguments(name, arguments);
        if (tuple_argument)
            return std::make_shared<AggregateFunctionSumMapFiltered<false, true>>(keys_type, values_types, arguments, params);
-        else
        return std::make_shared<AggregateFunctionSumMapFiltered<false, false>>(keys_type, values_types, arguments, params);
    });

@ -811,7 +805,6 @@ void registerAggregateFunctionSumMap(AggregateFunctionFactory & factory)
        auto [keys_type, values_types, tuple_argument] = parseArguments(name, arguments);
        if (tuple_argument)
            return std::make_shared<AggregateFunctionSumMapFiltered<true, true>>(keys_type, values_types, arguments, params);
-        else
        return std::make_shared<AggregateFunctionSumMapFiltered<true, false>>(keys_type, values_types, arguments, params);
    });
 }
--- a/src/AggregateFunctions/AggregateFunctionTTest.h
+++ b/src/AggregateFunctions/AggregateFunctionTTest.h
@ -96,25 +96,18 @@ public:
                std::move(names)
            );
        }
-        else
-        {
-            DataTypes types
-            {
+
+        DataTypes types{
            std::make_shared<DataTypeNumber<Float64>>(),
            std::make_shared<DataTypeNumber<Float64>>(),
        };

-            Strings names
-            {
+        Strings names{
            "t_statistic",
            "p_value",
        };

-            return std::make_shared<DataTypeTuple>(
-                std::move(types),
-                std::move(names)
-            );
-        }
+        return std::make_shared<DataTypeTuple>(std::move(types), std::move(names));
    }

    bool allocatesMemoryInArena() const override { return false; }
--- a/src/AggregateFunctions/AggregateFunctionTopK.cpp
+++ b/src/AggregateFunctions/AggregateFunctionTopK.cpp
@ -79,7 +79,6 @@ public:
    {
        if (is_approx_top_k)
            return  is_weighted ? "approx_top_sum" : "approx_top_k";
-        else
        return is_weighted ? "topKWeighted" : "topK";
    }

@ -106,7 +105,6 @@ public:
                std::move(names)
            ));
        }
-        else
        return std::make_shared<DataTypeArray>(argument_types_[0]);
    }

@ -226,7 +224,6 @@ public:
    {
        if (is_approx_top_k)
            return  is_weighted ? "approx_top_sum" : "approx_top_k";
-        else
        return is_weighted ? "topKWeighted" : "topK";
    }

@ -253,10 +250,8 @@ public:
                std::move(names)
            ));

-        } else
-        {
-            return std::make_shared<DataTypeArray>(argument_types_[0]);
        }
+        return std::make_shared<DataTypeArray>(argument_types_[0]);
    }

    bool allocatesMemoryInArena() const override
@ -440,8 +435,8 @@ IAggregateFunction * createWithExtraTypes(const DataTypes & argument_types, UInt
    /// Check that we can use plain version of AggregateFunctionTopKGeneric
    if (argument_types[0]->isValueUnambiguouslyRepresentedInContiguousMemoryRegion())
        return new AggregateFunctionTopKGeneric<true, is_weighted>(threshold, reserved, include_counts, is_approx_top_k, argument_types, params);
-    else
-        return new AggregateFunctionTopKGeneric<false, is_weighted>(threshold, reserved, include_counts, is_approx_top_k, argument_types, params);
+    return new AggregateFunctionTopKGeneric<false, is_weighted>(
+        threshold, reserved, include_counts, is_approx_top_k, argument_types, params);
 }


--- a/src/AggregateFunctions/AggregateFunctionUniq.cpp
+++ b/src/AggregateFunctions/AggregateFunctionUniq.cpp
@ -54,25 +54,24 @@ createAggregateFunctionUniq(const std::string & name, const DataTypes & argument
        WhichDataType which(argument_type);
        if (res)
            return res;
-        else if (which.isDate())
+        if (which.isDate())
            return std::make_shared<AggregateFunctionUniq<DataTypeDate::FieldType, Data>>(argument_types);
-        else if (which.isDate32())
+        if (which.isDate32())
            return std::make_shared<AggregateFunctionUniq<DataTypeDate32::FieldType, Data>>(argument_types);
-        else if (which.isDateTime())
+        if (which.isDateTime())
            return std::make_shared<AggregateFunctionUniq<DataTypeDateTime::FieldType, Data>>(argument_types);
-        else if (which.isStringOrFixedString())
+        if (which.isStringOrFixedString())
            return std::make_shared<AggregateFunctionUniq<String, Data>>(argument_types);
-        else if (which.isUUID())
+        if (which.isUUID())
            return std::make_shared<AggregateFunctionUniq<DataTypeUUID::FieldType, Data>>(argument_types);
-        else if (which.isIPv4())
+        if (which.isIPv4())
            return std::make_shared<AggregateFunctionUniq<DataTypeIPv4::FieldType, Data>>(argument_types);
-        else if (which.isIPv6())
+        if (which.isIPv6())
            return std::make_shared<AggregateFunctionUniq<DataTypeIPv6::FieldType, Data>>(argument_types);
-        else if (which.isTuple())
+        if (which.isTuple())
        {
            if (use_exact_hash_function)
                return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic<true, true>>>(argument_types);
-            else
            return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic<false, true>>>(argument_types);
        }
    }
@ -80,7 +79,6 @@ createAggregateFunctionUniq(const std::string & name, const DataTypes & argument
    /// "Variadic" method also works as a fallback generic case for single argument.
    if (use_exact_hash_function)
        return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic<true, false>>>(argument_types);
-    else
    return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic<false, false>>>(argument_types);
 }

@ -107,33 +105,45 @@ createAggregateFunctionUniq(const std::string & name, const DataTypes & argument
        WhichDataType which(argument_type);
        if (res)
            return res;
-        else if (which.isDate())
-            return std::make_shared<AggregateFunctionUniq<DataTypeDate::FieldType, Data<DataTypeDate::FieldType, is_able_to_parallelize_merge>>>(argument_types);
-        else if (which.isDate32())
-            return std::make_shared<AggregateFunctionUniq<DataTypeDate32::FieldType, Data<DataTypeDate32::FieldType, is_able_to_parallelize_merge>>>(argument_types);
-        else if (which.isDateTime())
-            return std::make_shared<AggregateFunctionUniq<DataTypeDateTime::FieldType, Data<DataTypeDateTime::FieldType, is_able_to_parallelize_merge>>>(argument_types);
-        else if (which.isStringOrFixedString())
+        if (which.isDate())
+            return std::make_shared<
+                AggregateFunctionUniq<DataTypeDate::FieldType, Data<DataTypeDate::FieldType, is_able_to_parallelize_merge>>>(
+                argument_types);
+        if (which.isDate32())
+            return std::make_shared<
+                AggregateFunctionUniq<DataTypeDate32::FieldType, Data<DataTypeDate32::FieldType, is_able_to_parallelize_merge>>>(
+                argument_types);
+        if (which.isDateTime())
+            return std::make_shared<
+                AggregateFunctionUniq<DataTypeDateTime::FieldType, Data<DataTypeDateTime::FieldType, is_able_to_parallelize_merge>>>(
+                argument_types);
+        if (which.isStringOrFixedString())
            return std::make_shared<AggregateFunctionUniq<String, Data<String, is_able_to_parallelize_merge>>>(argument_types);
-        else if (which.isUUID())
-            return std::make_shared<AggregateFunctionUniq<DataTypeUUID::FieldType, Data<DataTypeUUID::FieldType, is_able_to_parallelize_merge>>>(argument_types);
-        else if (which.isIPv4())
-            return std::make_shared<AggregateFunctionUniq<DataTypeIPv4::FieldType, Data<DataTypeIPv4::FieldType, is_able_to_parallelize_merge>>>(argument_types);
-        else if (which.isIPv6())
-            return std::make_shared<AggregateFunctionUniq<DataTypeIPv6::FieldType, Data<DataTypeIPv6::FieldType, is_able_to_parallelize_merge>>>(argument_types);
-        else if (which.isTuple())
+        if (which.isUUID())
+            return std::make_shared<
+                AggregateFunctionUniq<DataTypeUUID::FieldType, Data<DataTypeUUID::FieldType, is_able_to_parallelize_merge>>>(
+                argument_types);
+        if (which.isIPv4())
+            return std::make_shared<
+                AggregateFunctionUniq<DataTypeIPv4::FieldType, Data<DataTypeIPv4::FieldType, is_able_to_parallelize_merge>>>(
+                argument_types);
+        if (which.isIPv6())
+            return std::make_shared<
+                AggregateFunctionUniq<DataTypeIPv6::FieldType, Data<DataTypeIPv6::FieldType, is_able_to_parallelize_merge>>>(
+                argument_types);
+        if (which.isTuple())
        {
            if (use_exact_hash_function)
-                return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic<true, true, is_able_to_parallelize_merge>>>(argument_types);
-            else
-                return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic<false, true, is_able_to_parallelize_merge>>>(argument_types);
+                return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic<true, true, is_able_to_parallelize_merge>>>(
+                    argument_types);
+            return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic<false, true, is_able_to_parallelize_merge>>>(
+                argument_types);
        }
    }

    /// "Variadic" method also works as a fallback generic case for single argument.
    if (use_exact_hash_function)
        return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic<true, false, is_able_to_parallelize_merge>>>(argument_types);
-    else
    return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic<false, false, is_able_to_parallelize_merge>>>(argument_types);
 }

@ -155,9 +165,11 @@ void registerAggregateFunctionsUniq(AggregateFunctionFactory & factory)
        if (settings && (*settings)[Setting::max_threads] > 1)
            return createAggregateFunctionUniq<
                true, AggregateFunctionUniqExactData, AggregateFunctionUniqExactDataForVariadic, true /* is_able_to_parallelize_merge */>(name, argument_types, params, settings);
-        else
        return createAggregateFunctionUniq<
-                true, AggregateFunctionUniqExactData, AggregateFunctionUniqExactDataForVariadic, false /* is_able_to_parallelize_merge */>(name, argument_types, params, settings);
+            true,
+            AggregateFunctionUniqExactData,
+            AggregateFunctionUniqExactDataForVariadic,
+            false /* is_able_to_parallelize_merge */>(name, argument_types, params, settings);
    };
    factory.registerFunction("uniqExact", {assign_bool_param, properties});

--- a/src/AggregateFunctions/AggregateFunctionUniqCombined.h
+++ b/src/AggregateFunctions/AggregateFunctionUniqCombined.h
@ -235,33 +235,39 @@ AggregateFunctionPtr createAggregateFunctionWithK(const DataTypes & argument_typ
        WhichDataType which(argument_type);
        if (res)
            return res;
-        else if (which.isDate())
-            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeDate::FieldType>>(argument_types, params);
-        else if (which.isDate32())
-            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeDate32::FieldType>>(argument_types, params);
-        else if (which.isDateTime())
-            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeDateTime::FieldType>>(argument_types, params);
-        else if (which.isStringOrFixedString())
+        if (which.isDate())
+            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeDate::FieldType>>(
+                argument_types, params);
+        if (which.isDate32())
+            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeDate32::FieldType>>(
+                argument_types, params);
+        if (which.isDateTime())
+            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeDateTime::FieldType>>(
+                argument_types, params);
+        if (which.isStringOrFixedString())
            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<String>>(argument_types, params);
-        else if (which.isUUID())
-            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeUUID::FieldType>>(argument_types, params);
-        else if (which.isIPv4())
-            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeIPv4::FieldType>>(argument_types, params);
-        else if (which.isIPv6())
-            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeIPv6::FieldType>>(argument_types, params);
-        else if (which.isTuple())
+        if (which.isUUID())
+            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeUUID::FieldType>>(
+                argument_types, params);
+        if (which.isIPv4())
+            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeIPv4::FieldType>>(
+                argument_types, params);
+        if (which.isIPv6())
+            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunction<DataTypeIPv6::FieldType>>(
+                argument_types, params);
+        if (which.isTuple())
        {
            if (use_exact_hash_function)
-                return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunctionVariadic<true, true>>(argument_types, params);
-            else
-                return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunctionVariadic<false, true>>(argument_types, params);
+                return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunctionVariadic<true, true>>(
+                    argument_types, params);
+            return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunctionVariadic<false, true>>(
+                argument_types, params);
        }
    }

    /// "Variadic" method also works as a fallback generic case for a single argument.
    if (use_exact_hash_function)
        return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunctionVariadic<true, false>>(argument_types, params);
-    else
    return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunctionVariadic<false, false>>(argument_types, params);
 }

@ -270,7 +276,6 @@ AggregateFunctionPtr createAggregateFunctionWithHashType(bool use_64_bit_hash, c
 {
    if (use_64_bit_hash)
        return createAggregateFunctionWithK<K, UInt64>(argument_types, params);
-    else
    return createAggregateFunctionWithK<K, UInt32>(argument_types, params);
 }

--- a/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp
+++ b/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp
@ -324,21 +324,20 @@ AggregateFunctionPtr createAggregateFunctionUniqUpTo(const std::string & name, c
        WhichDataType which(argument_type);
        if (res)
            return res;
-        else if (which.isDate())
+        if (which.isDate())
            return std::make_shared<AggregateFunctionUniqUpTo<DataTypeDate::FieldType>>(threshold, argument_types, params);
-        else if (which.isDate32())
+        if (which.isDate32())
            return std::make_shared<AggregateFunctionUniqUpTo<DataTypeDate32::FieldType>>(threshold, argument_types, params);
-        else if (which.isDateTime())
+        if (which.isDateTime())
            return std::make_shared<AggregateFunctionUniqUpTo<DataTypeDateTime::FieldType>>(threshold, argument_types, params);
-        else if (which.isStringOrFixedString())
+        if (which.isStringOrFixedString())
            return std::make_shared<AggregateFunctionUniqUpTo<String>>(threshold, argument_types, params);
-        else if (which.isUUID())
+        if (which.isUUID())
            return std::make_shared<AggregateFunctionUniqUpTo<DataTypeUUID::FieldType>>(threshold, argument_types, params);
-        else if (which.isTuple())
+        if (which.isTuple())
        {
            if (use_exact_hash_function)
                return std::make_shared<AggregateFunctionUniqUpToVariadic<true, true>>(argument_types, params, threshold);
-            else
            return std::make_shared<AggregateFunctionUniqUpToVariadic<false, true>>(argument_types, params, threshold);
        }
    }
@ -346,7 +345,6 @@ AggregateFunctionPtr createAggregateFunctionUniqUpTo(const std::string & name, c
    /// "Variadic" method also works as a fallback generic case for single argument.
    if (use_exact_hash_function)
        return std::make_shared<AggregateFunctionUniqUpToVariadic<true, false>>(argument_types, params, threshold);
-    else
    return std::make_shared<AggregateFunctionUniqUpToVariadic<false, false>>(argument_types, params, threshold);
 }

--- a/src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp
+++ b/src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp
@ -180,10 +180,9 @@ private:
            {
                if (first_event)
                    break;
-                else
                continue;
            }
-            else if (event_idx == 0)
+            if (event_idx == 0)
            {
                events_timestamp[0] = std::make_pair(timestamp, timestamp);
                first_event = true;
@ -326,10 +325,11 @@ createAggregateFunctionWindowFunnel(const std::string & name, const DataTypes &
    WhichDataType which(arguments.front().get());
    if (res)
        return res;
-    else if (which.isDate())
+    if (which.isDate())
        return std::make_shared<AggregateFunctionWindowFunnel<DataTypeDate::FieldType, Data<DataTypeDate::FieldType>>>(arguments, params);
-    else if (which.isDateTime())
-        return std::make_shared<AggregateFunctionWindowFunnel<DataTypeDateTime::FieldType, Data<DataTypeDateTime::FieldType>>>(arguments, params);
+    if (which.isDateTime())
+        return std::make_shared<AggregateFunctionWindowFunnel<DataTypeDateTime::FieldType, Data<DataTypeDateTime::FieldType>>>(
+            arguments, params);

    throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
                    "Illegal type {} of first argument of aggregate function {}, must "
--- a/src/AggregateFunctions/Combinators/AggregateFunctionDistinct.cpp
+++ b/src/AggregateFunctions/Combinators/AggregateFunctionDistinct.cpp
@ -50,10 +50,8 @@ public:
                return std::make_shared<
                    AggregateFunctionDistinct<
                        AggregateFunctionDistinctSingleGenericData<true>>>(nested_function, arguments, params);
-            else
-                return std::make_shared<
-                    AggregateFunctionDistinct<
-                        AggregateFunctionDistinctSingleGenericData<false>>>(nested_function, arguments, params);
+            return std::make_shared<AggregateFunctionDistinct<AggregateFunctionDistinctSingleGenericData<false>>>(
+                nested_function, arguments, params);
        }

        return std::make_shared<AggregateFunctionDistinct<AggregateFunctionDistinctMultipleGenericData>>(nested_function, arguments, params);
--- a/src/AggregateFunctions/Combinators/AggregateFunctionIf.cpp
+++ b/src/AggregateFunctions/Combinators/AggregateFunctionIf.cpp
@ -473,29 +473,21 @@ AggregateFunctionPtr AggregateFunctionIf::getOwnNullAdapter(
        {
            return std::make_shared<AggregateFunctionIfNullUnary<true, true>>(nested_function->getName(), nested_func, arguments, params);
        }
-        else
-        {
+
        if (need_to_serialize_flag)
            return std::make_shared<AggregateFunctionIfNullUnary<false, true>>(nested_function->getName(), nested_func, arguments, params);
-            else
        return std::make_shared<AggregateFunctionIfNullUnary<false, false>>(nested_function->getName(), nested_func, arguments, params);
    }
-    }
-    else
-    {
+
    if (return_type_is_nullable)
    {
        return std::make_shared<AggregateFunctionIfNullVariadic<true, true>>(nested_function, arguments, params);
    }
-        else
-        {
+
    if (need_to_serialize_flag)
        return std::make_shared<AggregateFunctionIfNullVariadic<false, true>>(nested_function, arguments, params);
-            else
    return std::make_shared<AggregateFunctionIfNullVariadic<false, false>>(nested_function, arguments, params);
 }
-    }
-}

 void registerAggregateFunctionCombinatorIf(AggregateFunctionCombinatorFactory & factory)
 {
--- a/src/AggregateFunctions/Combinators/AggregateFunctionMap.cpp
+++ b/src/AggregateFunctions/Combinators/AggregateFunctionMap.cpp
@ -450,9 +450,8 @@ public:
                auto action = NullsAction::EMPTY;
                return aggr_func_factory.get(nested_func_name + "MappedArrays", action, arguments, params, out_properties);
            }
-            else
-                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Aggregation '{}Map' is not implemented for mapped arrays",
-                                 nested_func_name);
+            throw Exception(
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Aggregation '{}Map' is not implemented for mapped arrays", nested_func_name);
        }
    }
 };
--- a/src/AggregateFunctions/Combinators/AggregateFunctionNull.cpp
+++ b/src/AggregateFunctions/Combinators/AggregateFunctionNull.cpp
@ -112,7 +112,6 @@ public:
              */
            if (properties.returns_default_when_only_null)
                return std::make_shared<AggregateFunctionNothingUInt64>(arguments, params);
-            else
            return std::make_shared<AggregateFunctionNothingNull>(arguments, params);
        }

@ -137,22 +136,17 @@ public:
            {
                return std::make_shared<AggregateFunctionNullUnary<true, true>>(nested_function, arguments, params);
            }
-            else
-            {
+
            if (serialize_flag)
                return std::make_shared<AggregateFunctionNullUnary<false, true>>(nested_function, arguments, params);
-                else
            return std::make_shared<AggregateFunctionNullUnary<false, false>>(nested_function, arguments, params);
        }
-        }
-        else
-        {
+
        if (return_type_is_nullable)
        {
            return std::make_shared<AggregateFunctionNullVariadic<true, true>>(nested_function, arguments, params);
        }
-            else
-            {
+
        return std::make_shared<AggregateFunctionNullVariadic<false, true>>(nested_function, arguments, params);
 #if 0
                if (serialize_flag)
@ -165,8 +159,6 @@ public:
            }
 #endif
    }
-        }
-    }
 };

 }
--- a/src/AggregateFunctions/Combinators/AggregateFunctionOrFill.cpp
+++ b/src/AggregateFunctions/Combinators/AggregateFunctionOrFill.cpp
@ -37,7 +37,6 @@ public:
    {
        if (kind == Kind::OrNull)
            return std::make_shared<AggregateFunctionOrFill<true>>(nested_function, arguments, params);
-        else
        return std::make_shared<AggregateFunctionOrFill<false>>(nested_function, arguments, params);
    }
 };
--- a/src/AggregateFunctions/DDSketch.h
+++ b/src/AggregateFunctions/DDSketch.h
@ -120,12 +120,10 @@ public:
                this->merge(new_sketch);
                return;
            }
-            else
-            {
+
            DDSketchDenseLogarithmic new_sketch = changeMapping(other.mapping->getGamma());
            copy(new_sketch);
        }
-        }

        // If the other sketch is empty, do nothing
        if (other.count == 0)
--- a/src/AggregateFunctions/QuantileExact.h
+++ b/src/AggregateFunctions/QuantileExact.h
@ -146,7 +146,7 @@ struct QuantileExactExclusive : public QuantileExact<Value>

            if (n >= array.size())
                return static_cast<Float64>(*std::max_element(array.begin(), array.end()));
-            else if (n < 1)
+            if (n < 1)
                return static_cast<Float64>(*std::min_element(array.begin(), array.end()));

            ::nth_element(array.begin(), array.begin() + n - 1, array.end());
@ -211,7 +211,7 @@ struct QuantileExactInclusive : public QuantileExact<Value>

            if (n >= array.size())
                return static_cast<Float64>(*std::max_element(array.begin(), array.end()));
-            else if (n < 1)
+            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());
--- a/src/AggregateFunctions/QuantileTDigest.h
+++ b/src/AggregateFunctions/QuantileTDigest.h
@ -416,15 +416,10 @@ public:

                if (x <= left)
                    return checkOverflow<ResultType>(prev_mean);
-                else if (x >= right)
+                if (x >= right)
                    return checkOverflow<ResultType>(c.mean);
-                else
-                    return checkOverflow<ResultType>(interpolate(
-                        static_cast<Value>(x),
-                        static_cast<Value>(left),
-                        prev_mean,
-                        static_cast<Value>(right),
-                        c.mean));
+                return checkOverflow<ResultType>(
+                    interpolate(static_cast<Value>(x), static_cast<Value>(left), prev_mean, static_cast<Value>(right), c.mean));
            }

            sum += c.count;
--- a/src/AggregateFunctions/QuantileTiming.h
+++ b/src/AggregateFunctions/QuantileTiming.h
@ -736,15 +736,13 @@ public:
            tiny.prepare();
            return tiny.get(level);
        }
-        else if (kind == Kind::Medium)
+        if (kind == Kind::Medium)
        {
            return medium.get(level);
        }
-        else
-        {
+
        return large->get(level);
    }
-    }

    /// Get the size values of the quantiles of the `levels` levels. Record `size` results starting with `result` address.
    template <typename ResultType>
--- a/src/AggregateFunctions/ReservoirSampler.h
+++ b/src/AggregateFunctions/ReservoirSampler.h
@ -260,7 +260,6 @@ private:
        /// With a large number of values, we will generate random numbers several times slower.
        if (limit <= static_cast<UInt64>(pcg32_fast::max()))
            return rng() % limit;
-        else
        return (static_cast<UInt64>(rng()) * (static_cast<UInt64>(pcg32_fast::max()) + 1ULL) + static_cast<UInt64>(rng())) % limit;
    }

@ -277,7 +276,6 @@ private:
    {
        if (OnEmpty == ReservoirSamplerOnEmpty::THROW)
            throw DB::Exception(DB::ErrorCodes::LOGICAL_ERROR, "Quantile of empty ReservoirSampler");
-        else
        return NanLikeValueConstructor<ResultType, std::is_floating_point_v<ResultType>>::getValue();
    }
 };
--- a/src/AggregateFunctions/ReservoirSamplerDeterministic.h
+++ b/src/AggregateFunctions/ReservoirSamplerDeterministic.h
@ -271,7 +271,6 @@ private:
    {
        if (OnEmpty == ReservoirSamplerDeterministicOnEmpty::THROW)
            throw DB::Exception(DB::ErrorCodes::LOGICAL_ERROR, "Quantile of empty ReservoirSamplerDeterministic");
-        else
        return NanLikeValueConstructor<ResultType, std::is_floating_point_v<ResultType>>::getValue();
    }
 };
--- a/src/AggregateFunctions/SingleValueData.cpp
+++ b/src/AggregateFunctions/SingleValueData.cpp
@ -50,8 +50,7 @@ std::optional<size_t> SingleValueDataBase::getSmallestIndex(const IColumn & colu
                index = i;
        return {index};
    }
-    else
-    {
+
    constexpr IColumn::PermutationSortDirection direction = IColumn::PermutationSortDirection::Ascending;
    constexpr IColumn::PermutationSortStability stability = IColumn::PermutationSortStability::Unstable;
    IColumn::Permutation permutation;
@ -59,7 +58,6 @@ std::optional<size_t> SingleValueDataBase::getSmallestIndex(const IColumn & colu
    column.getPermutation(direction, stability, limit, nan_null_direction_hint, permutation);
    return {permutation[0]};
 }
-}

 std::optional<size_t> SingleValueDataBase::getGreatestIndex(const IColumn & column, size_t row_begin, size_t row_end) const
 {
@ -77,8 +75,7 @@ std::optional<size_t> SingleValueDataBase::getGreatestIndex(const IColumn & colu
                index = i;
        return {index};
    }
-    else
-    {
+
    constexpr IColumn::PermutationSortDirection direction = IColumn::PermutationSortDirection::Descending;
    constexpr IColumn::PermutationSortStability stability = IColumn::PermutationSortStability::Unstable;
    IColumn::Permutation permutation;
@ -86,7 +83,6 @@ std::optional<size_t> SingleValueDataBase::getGreatestIndex(const IColumn & colu
    column.getPermutation(direction, stability, limit, nan_null_direction_hint, permutation);
    return {permutation[0]};
 }
-}

 std::optional<size_t> SingleValueDataBase::getSmallestIndexNotNullIf(
    const IColumn & column, const UInt8 * __restrict null_map, const UInt8 * __restrict if_map, size_t row_begin, size_t row_end) const
@ -247,7 +243,6 @@ bool SingleValueDataFixed<T>::setIfSmaller(const SingleValueDataFixed<T> & to, A
        set(to, arena);
        return true;
    }
-    else
    return false;
 }

@ -259,7 +254,6 @@ bool SingleValueDataFixed<T>::setIfGreater(const SingleValueDataFixed<T> & to, A
        set(to, arena);
        return true;
    }
-    else
    return false;
 }

@ -271,7 +265,6 @@ bool SingleValueDataFixed<T>::setIfSmaller(const IColumn & column, size_t row_nu
        set(column, row_num, arena);
        return true;
    }
-    else
    return false;
 }

@ -283,7 +276,6 @@ bool SingleValueDataFixed<T>::setIfGreater(const IColumn & column, size_t row_nu
        set(column, row_num, arena);
        return true;
    }
-    else
    return false;
 }

@ -544,7 +536,7 @@ std::optional<size_t> SingleValueDataFixed<T>::getGreatestIndexNotNullIf(
            }
            return opt;
        }
-        else if (!null_map)
+        if (!null_map)
        {
            opt = findExtremeMaxIf(vec.getData().data(), if_map, row_begin, row_end);
            if (!opt.has_value())
@ -556,8 +548,7 @@ std::optional<size_t> SingleValueDataFixed<T>::getGreatestIndexNotNullIf(
            }
            return opt;
        }
-        else
-        {
+
        auto final_flags = mergeIfAndNullFlags(null_map, if_map, row_begin, row_end);
        opt = findExtremeMaxIf(vec.getData().data(), final_flags.get(), row_begin, row_end);
        if (!opt.has_value())
@ -567,7 +558,7 @@ std::optional<size_t> SingleValueDataFixed<T>::getGreatestIndexNotNullIf(
            if (final_flags[i] && vec[i] == *opt)
                return {i};
        }
-        }
+
        UNREACHABLE();
    }
    else
@ -1218,7 +1209,6 @@ bool SingleValueDataString::setIfSmaller(const IColumn & column, size_t row_num,
        set(column, row_num, arena);
        return true;
    }
-    else
    return false;
 }

@ -1230,7 +1220,6 @@ bool SingleValueDataString::setIfSmaller(const SingleValueDataBase & other, Aren
        changeImpl(to.getStringRef(), arena);
        return true;
    }
-    else
    return false;
 }

@ -1243,7 +1232,6 @@ bool SingleValueDataString::setIfGreater(const IColumn & column, size_t row_num,
        set(column, row_num, arena);
        return true;
    }
-    else
    return false;
 }

@ -1255,7 +1243,6 @@ bool SingleValueDataString::setIfGreater(const SingleValueDataBase & other, Aren
        changeImpl(to.getStringRef(), arena);
        return true;
    }
-    else
    return false;
 }

@ -1317,8 +1304,7 @@ bool SingleValueDataGeneric::setIfSmaller(const IColumn & column, size_t row_num
        set(column, row_num, arena);
        return true;
    }
-    else
-    {
+
    Field new_value;
    column.get(row_num, new_value);
    if (new_value < value)
@ -1326,10 +1312,8 @@ bool SingleValueDataGeneric::setIfSmaller(const IColumn & column, size_t row_num
        value = new_value;
        return true;
    }
-        else
    return false;
 }
-}

 bool SingleValueDataGeneric::setIfSmaller(const SingleValueDataBase & other, Arena *)
 {
@ -1339,7 +1323,6 @@ bool SingleValueDataGeneric::setIfSmaller(const SingleValueDataBase & other, Are
        value = to.value;
        return true;
    }
-    else
    return false;
 }

@ -1350,8 +1333,7 @@ bool SingleValueDataGeneric::setIfGreater(const IColumn & column, size_t row_num
        set(column, row_num, arena);
        return true;
    }
-    else
-    {
+
    Field new_value;
    column.get(row_num, new_value);
    if (new_value > value)
@ -1359,10 +1341,8 @@ bool SingleValueDataGeneric::setIfGreater(const IColumn & column, size_t row_num
        value = new_value;
        return true;
    }
-        else
    return false;
 }
-}

 bool SingleValueDataGeneric::setIfGreater(const SingleValueDataBase & other, Arena *)
 {
@ -1372,7 +1352,6 @@ bool SingleValueDataGeneric::setIfGreater(const SingleValueDataBase & other, Are
        value = to.value;
        return true;
    }
-    else
    return false;
 }

--- a/src/AggregateFunctions/ThetaSketchData.h
+++ b/src/AggregateFunctions/ThetaSketchData.h
@ -60,9 +60,8 @@ public:
    {
        if (sk_union)
            return static_cast<UInt64>(sk_union->get_result().get_estimate());
-        else if (sk_update)
+        if (sk_update)
            return static_cast<UInt64>(sk_update->get_estimate());
-        else
        return 0;
    }

--- a/src/AggregateFunctions/UniqVariadicHash.cpp
+++ b/src/AggregateFunctions/UniqVariadicHash.cpp
@ -26,7 +26,6 @@ bool isAllArgumentsContiguousInMemory(const DataTypes & argument_types)

    if (single_argument_as_tuple)
        return check_all_arguments_are_contiguous_in_memory(single_argument_as_tuple->getElements());
-    else
    return check_all_arguments_are_contiguous_in_memory(argument_types);
 }

--- a/src/Analyzer/ColumnTransformers.cpp
+++ b/src/Analyzer/ColumnTransformers.cpp
@ -163,8 +163,7 @@ void ExceptColumnTransformerNode::dumpTreeImpl(WriteBuffer & buffer, FormatState
        buffer << ", pattern: " << column_matcher->pattern();
        return;
    }
-    else
-    {
+
    buffer << ", identifiers: ";

    size_t except_column_names_size = except_column_names.size();
@ -176,7 +175,6 @@ void ExceptColumnTransformerNode::dumpTreeImpl(WriteBuffer & buffer, FormatState
            buffer << ", ";
    }
 }
-}

 bool ExceptColumnTransformerNode::isEqualImpl(const IQueryTreeNode & rhs, CompareOptions) const
 {
@ -190,9 +188,9 @@ bool ExceptColumnTransformerNode::isEqualImpl(const IQueryTreeNode & rhs, Compar

    if (!column_matcher && !rhs_column_matcher)
        return true;
-    else if (column_matcher && !rhs_column_matcher)
+    if (column_matcher && !rhs_column_matcher)
        return false;
-    else if (!column_matcher && rhs_column_matcher)
+    if (!column_matcher && rhs_column_matcher)
        return false;

    return column_matcher->pattern() == rhs_column_matcher->pattern();
--- a/src/Analyzer/FunctionNode.cpp
+++ b/src/Analyzer/FunctionNode.cpp
@ -173,9 +173,9 @@ bool FunctionNode::isEqualImpl(const IQueryTreeNode & rhs, CompareOptions compar

    if (lhs_result_type && rhs_result_type && !lhs_result_type->equals(*rhs_result_type))
        return false;
-    else if (lhs_result_type && !rhs_result_type)
+    if (lhs_result_type && !rhs_result_type)
        return false;
-    else if (!lhs_result_type && rhs_result_type)
+    if (!lhs_result_type && rhs_result_type)
        return false;

    return true;
--- a/Show More
+++ b/Show More