Merge branch 'master' into keeper-batch-flushes

2024-09-20 00:30:49 +00:00 · 2023-08-24 09:08:47 +00:00 · 2023-08-24 09:08:47 +00:00 · 322b53dd62
commit 322b53dd62
parent 625be86dc0 fdfefe58f3
101 changed files with 868 additions and 450 deletions
--- a/cmake/dbms_glob_sources.cmake
+++ b/cmake/dbms_glob_sources.cmake
@ -4,10 +4,19 @@ macro(add_glob cur_list)
 endmacro()

 macro(add_headers_and_sources prefix common_path)
-    add_glob(${prefix}_headers ${CMAKE_CURRENT_SOURCE_DIR} ${common_path}/*.h)
-    add_glob(${prefix}_sources ${common_path}/*.cpp ${common_path}/*.c ${common_path}/*.h)
+    add_glob(${prefix}_headers ${common_path}/*.h)
+    add_glob(${prefix}_sources ${common_path}/*.cpp ${common_path}/*.c)
 endmacro()

 macro(add_headers_only prefix common_path)
-    add_glob(${prefix}_headers ${CMAKE_CURRENT_SOURCE_DIR} ${common_path}/*.h)
+    add_glob(${prefix}_headers ${common_path}/*.h)
+endmacro()
+
+macro(extract_into_parent_list src_list dest_list)
+    list(REMOVE_ITEM ${src_list} ${ARGN})
+    get_filename_component(__dir_name ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+    foreach(file IN ITEMS ${ARGN})
+        list(APPEND ${dest_list} ${__dir_name}/${file})
+    endforeach()
+    set(${dest_list} "${${dest_list}}" PARENT_SCOPE)
 endmacro()
--- a/cmake/target.cmake
+++ b/cmake/target.cmake
@ -19,6 +19,19 @@ else ()
    message (FATAL_ERROR "Platform ${CMAKE_SYSTEM_NAME} is not supported")
 endif ()

+# Since we always use toolchain files to generate hermetic builds, cmake will
+# always think it's a cross-compilation, See
+# https://cmake.org/cmake/help/latest/variable/CMAKE_CROSSCOMPILING.html
+#
+# This will slow down cmake configuration and compilation. For instance, LLVM
+# will try to configure NATIVE LLVM targets with all tests enabled (You'll see
+# Building native llvm-tblgen...).
+#
+# Here, we set it manually by checking the system name and processor.
+if (${CMAKE_SYSTEM_NAME} STREQUAL ${CMAKE_HOST_SYSTEM_NAME} AND ${CMAKE_SYSTEM_PROCESSOR} STREQUAL ${CMAKE_HOST_SYSTEM_PROCESSOR})
+    set (CMAKE_CROSSCOMPILING 0)
+endif ()
+
 if (CMAKE_CROSSCOMPILING)
    if (OS_DARWIN)
        # FIXME: broken dependencies
--- a/contrib/krb5
+++ b/contrib/krb5
@ -1 +1 @@
-Subproject commit 1d5c970e9369f444caf81d1d06a231a6bad8581f
+Subproject commit 71b06c2276009ae649c7703019f3b4605f66fd3d
--- a/contrib/openldap
+++ b/contrib/openldap
@ -1 +1 @@
-Subproject commit 8688afe6bc95ebcd20edf4578c536362218cb70a
+Subproject commit 5671b80e369df2caf5f34e02924316205a43c895
--- a/contrib/openldap-cmake/CMakeLists.txt
+++ b/contrib/openldap-cmake/CMakeLists.txt
@ -96,71 +96,82 @@ target_compile_definitions(_lber
 )

 set(_ldap_srcs
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/bind.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/open.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/result.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/error.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/compare.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/search.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/controls.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/messages.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/references.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/extended.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/cyrus.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/modify.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/add.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/modrdn.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/delete.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/abandon.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/sasl.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/sbind.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/unbind.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/add.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/addentry.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/assertion.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/avl.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/bind.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/cancel.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/charray.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/compare.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/controls.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/cyrus.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/dds.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/delete.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/deref.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/dnssrv.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/error.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/extended.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/fetch.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/filter.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/free.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/sort.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/passwd.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/whoami.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/vc.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/getattr.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/getdn.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/getentry.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/getattr.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/getvalues.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/addentry.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/request.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/os-ip.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/url.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/pagectrl.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/sortctrl.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/vlvctrl.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/init.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/options.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/print.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/string.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/util-int.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/schema.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/charray.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/os-local.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/dnssrv.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/utf-8.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/utf-8-conv.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/tls2.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/tls_o.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/tls_g.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/turn.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/ppolicy.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/dds.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/txn.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/ldap_sync.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/stctrl.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/assertion.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/deref.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/ldifutil.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/ldif.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/fetch.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/lbase64.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/ldap_sync.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/ldif.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/ldifutil.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/messages.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/modify.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/modrdn.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/msctrl.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/open.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/options.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/os-ip.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/os-local.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/pagectrl.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/passwd.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/ppolicy.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/print.c"
    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/psearchctrl.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/rdwr.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/references.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/request.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/result.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/rq.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/sasl.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/sbind.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/schema.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/search.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/sort.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/sortctrl.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/stctrl.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/string.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/tavl.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/thr_debug.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/thr_nt.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/thr_posix.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/thr_pth.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/thr_thr.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/threads.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/tls2.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/tls_g.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/tls_o.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/tpool.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/turn.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/txn.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/unbind.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/url.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/utf-8-conv.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/utf-8.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/util-int.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/vc.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/vlvctrl.c"
+    "${OPENLDAP_SOURCE_DIR}/libraries/libldap/whoami.c"
 )

 mkversion(ldap)
@ -185,43 +196,5 @@ target_compile_definitions(_ldap
    PRIVATE LDAP_LIBRARY
 )

-set(_ldap_r_specific_srcs
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r/threads.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r/rdwr.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r/tpool.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r/rq.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r/thr_posix.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r/thr_thr.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r/thr_nt.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r/thr_pth.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r/thr_stub.c"
-    "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r/thr_debug.c"
-)
-
-mkversion(ldap_r)
-
-add_library(_ldap_r
-    ${_ldap_r_specific_srcs}
-    ${_ldap_srcs}
-    "${CMAKE_CURRENT_BINARY_DIR}/ldap_r-version.c"
-)
-
-target_link_libraries(_ldap_r
-    PRIVATE _lber
-    PRIVATE OpenSSL::Crypto OpenSSL::SSL
-)
-
-target_include_directories(_ldap_r SYSTEM
-    PUBLIC ${_extra_build_dir}/include
-    PUBLIC "${OPENLDAP_SOURCE_DIR}/include"
-    PRIVATE "${OPENLDAP_SOURCE_DIR}/libraries/libldap_r"
-    PRIVATE "${OPENLDAP_SOURCE_DIR}/libraries/libldap"
-)
-
-target_compile_definitions(_ldap_r
-    PRIVATE LDAP_R_COMPILE
-    PRIVATE LDAP_LIBRARY
-)
-
-add_library(ch_contrib::ldap ALIAS _ldap_r)
+add_library(ch_contrib::ldap ALIAS _ldap)
 add_library(ch_contrib::lber ALIAS _lber)
--- a/contrib/snappy
+++ b/contrib/snappy
@ -1 +1 @@
-Subproject commit fb057edfed820212076239fd32cb2ff23e9016bf
+Subproject commit 6ebb5b1ab8801ea3fde103c5c29f5ab86df5fe7a
--- a/docker/test/integration/runner/compose/docker_compose_keeper.yml
+++ b/docker/test/integration/runner/compose/docker_compose_keeper.yml
@ -20,6 +20,9 @@ services:
            - type: ${keeper_fs:-tmpfs}
              source: ${keeper_db_dir1:-}
              target: /var/lib/clickhouse-keeper
+            - type: ${keeper_fs:-tmpfs}
+              source: ${keeper_db_dir1:-}
+              target: /var/lib/clickhouse
        entrypoint: "${keeper_cmd_prefix:-clickhouse keeper} --config=/etc/clickhouse-keeper/keeper_config1.xml --log-file=/var/log/clickhouse-keeper/clickhouse-keeper.log --errorlog-file=/var/log/clickhouse-keeper/clickhouse-keeper.err.log"
        cap_add:
            - SYS_PTRACE
@ -53,6 +56,9 @@ services:
            - type: ${keeper_fs:-tmpfs}
              source: ${keeper_db_dir2:-}
              target: /var/lib/clickhouse-keeper
+            - type: ${keeper_fs:-tmpfs}
+              source: ${keeper_db_dir1:-}
+              target: /var/lib/clickhouse
        entrypoint: "${keeper_cmd_prefix:-clickhouse keeper} --config=/etc/clickhouse-keeper/keeper_config2.xml --log-file=/var/log/clickhouse-keeper/clickhouse-keeper.log --errorlog-file=/var/log/clickhouse-keeper/clickhouse-keeper.err.log"
        cap_add:
            - SYS_PTRACE
@ -86,6 +92,9 @@ services:
            - type: ${keeper_fs:-tmpfs}
              source: ${keeper_db_dir3:-}
              target: /var/lib/clickhouse-keeper
+            - type: ${keeper_fs:-tmpfs}
+              source: ${keeper_db_dir1:-}
+              target: /var/lib/clickhouse
        entrypoint: "${keeper_cmd_prefix:-clickhouse keeper} --config=/etc/clickhouse-keeper/keeper_config3.xml --log-file=/var/log/clickhouse-keeper/clickhouse-keeper.log --errorlog-file=/var/log/clickhouse-keeper/clickhouse-keeper.err.log"
        cap_add:
            - SYS_PTRACE
--- a/docker/test/performance-comparison/compare.sh
+++ b/docker/test/performance-comparison/compare.sh
@ -644,7 +644,7 @@ function report
 rm -r report ||:
 mkdir report report/tmp ||:

-rm ./*.{rep,svg} test-times.tsv test-dump.tsv unstable.tsv unstable-query-ids.tsv unstable-query-metrics.tsv changed-perf.tsv unstable-tests.tsv unstable-queries.tsv bad-tests.tsv slow-on-client.tsv all-queries.tsv run-errors.tsv ||:
+rm ./*.{rep,svg} test-times.tsv test-dump.tsv unstable.tsv unstable-query-ids.tsv unstable-query-metrics.tsv changed-perf.tsv unstable-tests.tsv unstable-queries.tsv bad-tests.tsv all-queries.tsv run-errors.tsv ||:

 cat analyze/errors.log >> report/errors.log ||:
 cat profile-errors.log >> report/errors.log ||:
@ -810,12 +810,6 @@ create view total_client_time_per_query as select *
    from file('analyze/client-times.tsv', TSV,
        'test text, query_index int, client float, server float');

-create table slow_on_client_report engine File(TSV, 'report/slow-on-client.tsv')
-    as select client, server, round(client/server, 3) p,
-        test, query_display_name
-    from total_client_time_per_query left join query_display_names using (test, query_index)
-    where p > round(1.02, 3) order by p desc;
-
 create table wall_clock_time_per_test engine Memory as select *
    from file('wall-clock-times.tsv', TSV, 'test text, real float, user float, system float');

--- a/docker/test/performance-comparison/report.py
+++ b/docker/test/performance-comparison/report.py
@ -364,20 +364,6 @@ if args.report == "main":
            ]
        )

-    slow_on_client_rows = tsvRows("report/slow-on-client.tsv")
-    error_tests += len(slow_on_client_rows)
-    addSimpleTable(
-        "Slow on Client",
-        ["Client time,&nbsp;s", "Server time,&nbsp;s", "Ratio", "Test", "Query"],
-        slow_on_client_rows,
-    )
-    if slow_on_client_rows:
-        errors_explained.append(
-            [
-                f'<a href="#{currentTableAnchor()}">Some queries are taking noticeable time client-side (missing `FORMAT Null`?)</a>'
-            ]
-        )
-
    def add_backward_incompatible():
        rows = tsvRows("report/partial-queries-report.tsv")
        if not rows:
--- a/docker/test/upgrade/run.sh
+++ b/docker/test/upgrade/run.sh
@ -63,6 +63,7 @@ configure
 # it contains some new settings, but we can safely remove it
 rm /etc/clickhouse-server/config.d/merge_tree.xml
 rm /etc/clickhouse-server/config.d/enable_wait_for_shutdown_replicated_tables.xml
+rm /etc/clickhouse-server/config.d/filesystem_caches_path.xml
 rm /etc/clickhouse-server/users.d/nonconst_timezone.xml

 start
@ -93,6 +94,7 @@ sudo chgrp clickhouse /etc/clickhouse-server/config.d/s3_storage_policy_by_defau
 # it contains some new settings, but we can safely remove it
 rm /etc/clickhouse-server/config.d/merge_tree.xml
 rm /etc/clickhouse-server/config.d/enable_wait_for_shutdown_replicated_tables.xml
+rm /etc/clickhouse-server/config.d/filesystem_caches_path.xml
 rm /etc/clickhouse-server/users.d/nonconst_timezone.xml

 start
--- a/docs/changelogs/v23.3.10.5-lts.md
+++ b/docs/changelogs/v23.3.10.5-lts.md
@ -0,0 +1,14 @@
+---
+sidebar_position: 1
+sidebar_label: 2023
+---
+
+# 2023 Changelog
+
+### ClickHouse release v23.3.10.5-lts (d8737007f9e) FIXME as compared to v23.3.9.55-lts (b9c5c8622d3)
+
+#### Bug Fix (user-visible misbehavior in an official stable release)
+
+* Not-ready Set [#53162](https://github.com/ClickHouse/ClickHouse/pull/53162) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Correctly handle totals and extremes with `DelayedSource` [#53644](https://github.com/ClickHouse/ClickHouse/pull/53644) ([Antonio Andelic](https://github.com/antonio2368)).
+
--- a/docs/en/operations/storing-data.md
+++ b/docs/en/operations/storing-data.md
@ -114,7 +114,11 @@ Example of disk configuration:

 ## Using local cache {#using-local-cache}

-It is possible to configure local cache over disks in storage configuration starting from version 22.3. For versions 22.3 - 22.7 cache is supported only for `s3` disk type. For versions >= 22.8 cache is supported for any disk type: S3, Azure, Local, Encrypted, etc. Cache uses `LRU` cache policy.
+It is possible to configure local cache over disks in storage configuration starting from version 22.3. 
+For versions 22.3 - 22.7 cache is supported only for `s3` disk type. For versions >= 22.8 cache is supported for any disk type: S3, Azure, Local, Encrypted, etc.
+For versions >= 23.5 cache is supported only for remote disk types: S3, Azure, HDFS.
+Cache uses `LRU` cache policy.
+

 Example of configuration for versions later or equal to 22.8:

--- a/docs/en/operations/system-tables/clusters.md
+++ b/docs/en/operations/system-tables/clusters.md
@ -23,6 +23,7 @@ Columns:
 - `database_shard_name` ([String](../../sql-reference/data-types/string.md)) — The name of the `Replicated` database shard (for clusters that belong to a `Replicated` database).
 - `database_replica_name` ([String](../../sql-reference/data-types/string.md)) — The name of the `Replicated` database replica (for clusters that belong to a `Replicated` database).
 - `is_active` ([Nullable(UInt8)](../../sql-reference/data-types/int-uint.md)) — The status of the `Replicated` database replica (for clusters that belong to a `Replicated` database): 1 means "replica is online", 0 means "replica is offline", `NULL` means "unknown".
+- `name` ([String](../../sql-reference/data-types/string.md)) - An alias to cluster.

 **Example**

--- a/programs/obfuscator/Obfuscator.cpp
+++ b/programs/obfuscator/Obfuscator.cpp
@ -390,7 +390,10 @@ static void transformFixedString(const UInt8 * src, UInt8 * dst, size_t size, UI

 static void transformUUID(const UUID & src_uuid, UUID & dst_uuid, UInt64 seed)
 {
-    const UInt128 & src = src_uuid.toUnderType();
+    auto src_copy = src_uuid;
+    transformEndianness<std::endian::little, std::endian::native>(src_copy);
+
+    const UInt128 & src = src_copy.toUnderType();
    UInt128 & dst = dst_uuid.toUnderType();

    SipHash hash;
@ -400,8 +403,9 @@ static void transformUUID(const UUID & src_uuid, UUID & dst_uuid, UInt64 seed)
    /// Saving version and variant from an old UUID
    dst = hash.get128();

-    dst.items[1] = (dst.items[1] & 0x1fffffffffffffffull) | (src.items[1] & 0xe000000000000000ull);
-    dst.items[0] = (dst.items[0] & 0xffffffffffff0fffull) | (src.items[0] & 0x000000000000f000ull);
+    const UInt64 trace[2] = {0x000000000000f000ull, 0xe000000000000000ull};
+    UUIDHelpers::getLowBytes(dst_uuid) = (UUIDHelpers::getLowBytes(dst_uuid) & (0xffffffffffffffffull - trace[1])) | (UUIDHelpers::getLowBytes(src_uuid) & trace[1]);
+    UUIDHelpers::getHighBytes(dst_uuid) = (UUIDHelpers::getHighBytes(dst_uuid) & (0xffffffffffffffffull - trace[0])) | (UUIDHelpers::getHighBytes(src_uuid) & trace[0]);
 }

 class FixedStringModel : public IModel
--- a/src/Access/UsersConfigAccessStorage.cpp
+++ b/src/Access/UsersConfigAccessStorage.cpp
@ -11,6 +11,7 @@
 #include <Common/Config/ConfigReloader.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/quoteString.h>
+#include <Common/TransformEndianness.hpp>
 #include <Core/Settings.h>
 #include <Interpreters/executeQuery.h>
 #include <Parsers/Access/ASTGrantQuery.h>
@ -49,6 +50,7 @@ namespace
        md5.update(type_storage_chars, strlen(type_storage_chars));
        UUID result;
        memcpy(&result, md5.digest().data(), md5.digestLength());
+        transformEndianness<std::endian::native, std::endian::little>(result);
        return result;
    }

--- a/src/AggregateFunctions/AggregateFunctionAvg.h
+++ b/src/AggregateFunctions/AggregateFunctionAvg.h
@ -109,7 +109,7 @@ public:

    void serialize(ConstAggregateDataPtr __restrict place, WriteBuffer & buf, std::optional<size_t> /* version */) const override
    {
-        writeBinary(this->data(place).numerator, buf);
+        writeBinaryLittleEndian(this->data(place).numerator, buf);

        if constexpr (std::is_unsigned_v<Denominator>)
            writeVarUInt(this->data(place).denominator, buf);
@ -119,7 +119,7 @@ public:

    void deserialize(AggregateDataPtr __restrict place, ReadBuffer & buf, std::optional<size_t> /* version */, Arena *) const override
    {
-        readBinary(this->data(place).numerator, buf);
+        readBinaryLittleEndian(this->data(place).numerator, buf);

        if constexpr (std::is_unsigned_v<Denominator>)
            readVarUInt(this->data(place).denominator, buf);
--- a/src/AggregateFunctions/AggregateFunctionBoundingRatio.h
+++ b/src/AggregateFunctions/AggregateFunctionBoundingRatio.h
@ -100,6 +100,17 @@ void AggregateFunctionBoundingRatioData::deserialize(ReadBuffer & buf)
    }
 }

+inline void writeBinary(const AggregateFunctionBoundingRatioData::Point & p, WriteBuffer & buf)
+{
+    writePODBinary(p, buf);
+}
+
+inline void readBinary(AggregateFunctionBoundingRatioData::Point & p, ReadBuffer & buf)
+{
+    readPODBinary(p, buf);
+}
+
+
 class AggregateFunctionBoundingRatio final : public IAggregateFunctionDataHelper<AggregateFunctionBoundingRatioData, AggregateFunctionBoundingRatio>
 {
 private:
--- a/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
+++ b/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
@ -547,7 +547,7 @@ public:

        /// For serialization we use signed Int32 (for historical reasons), -1 means "no value"
        Int32 size_to_write = size ? size : -1;
-        writeBinary(size_to_write, buf);
+        writeBinaryLittleEndian(size_to_write, buf);
        if (has())
            buf.write(getData(), size);
    }
@ -573,7 +573,7 @@ public:
    {
        /// For serialization we use signed Int32 (for historical reasons), -1 means "no value"
        Int32 rhs_size_signed;
-        readBinary(rhs_size_signed, buf);
+        readBinaryLittleEndian(rhs_size_signed, buf);

        if (rhs_size_signed < 0)
        {
--- a/src/AggregateFunctions/AggregateFunctionSum.h
+++ b/src/AggregateFunctions/AggregateFunctionSum.h
@ -258,12 +258,12 @@ struct AggregateFunctionSumData

    void write(WriteBuffer & buf) const
    {
-        writeBinary(sum, buf);
+        writeBinaryLittleEndian(sum, buf);
    }

    void read(ReadBuffer & buf)
    {
-        readBinary(sum, buf);
+        readBinaryLittleEndian(sum, buf);
    }

    T get() const
--- a/src/AggregateFunctions/CMakeLists.txt
+++ b/src/AggregateFunctions/CMakeLists.txt
@ -1,28 +1,26 @@
 include("${ClickHouse_SOURCE_DIR}/cmake/dbms_glob_sources.cmake")
 add_headers_and_sources(clickhouse_aggregate_functions .)

-list(REMOVE_ITEM clickhouse_aggregate_functions_sources
+extract_into_parent_list(clickhouse_aggregate_functions_sources dbms_sources
    IAggregateFunction.cpp
    AggregateFunctionFactory.cpp
    AggregateFunctionCombinatorFactory.cpp
-    AggregateFunctionCount.cpp
    AggregateFunctionState.cpp
+    AggregateFunctionCount.cpp
    parseAggregateFunctionParameters.cpp
-    FactoryHelpers.cpp
 )
-
-list(REMOVE_ITEM clickhouse_aggregate_functions_headers
+extract_into_parent_list(clickhouse_aggregate_functions_headers dbms_headers
    IAggregateFunction.h
    IAggregateFunctionCombinator.h
    AggregateFunctionFactory.h
    AggregateFunctionCombinatorFactory.h
-    AggregateFunctionCount.h
    AggregateFunctionState.h
-    parseAggregateFunctionParameters.h
+    AggregateFunctionCount.cpp
    FactoryHelpers.h
+    parseAggregateFunctionParameters.h
 )

-add_library(clickhouse_aggregate_functions ${clickhouse_aggregate_functions_sources})
+add_library(clickhouse_aggregate_functions ${clickhouse_aggregate_functions_headers} ${clickhouse_aggregate_functions_sources})
 target_link_libraries(clickhouse_aggregate_functions PRIVATE dbms PUBLIC ch_contrib::cityhash)

 if(ENABLE_EXAMPLES)
--- a/src/AggregateFunctions/QuantileTiming.h
+++ b/src/AggregateFunctions/QuantileTiming.h
@ -783,6 +783,16 @@ public:
            for (size_t i = 0; i < size; ++i)
                result[i] = std::numeric_limits<float>::quiet_NaN();
    }
+
+    friend void writeBinary(const Kind & x, WriteBuffer & buf)
+    {
+        writePODBinary(x, buf);
+    }
+
+    friend void readBinary(Kind & x, ReadBuffer & buf)
+    {
+        readPODBinary(x, buf);
+    }
 };

 #undef SMALL_THRESHOLD
--- a/src/AggregateFunctions/ReservoirSamplerDeterministic.h
+++ b/src/AggregateFunctions/ReservoirSamplerDeterministic.h
@ -276,3 +276,12 @@ private:
            return NanLikeValueConstructor<ResultType, std::is_floating_point_v<ResultType>>::getValue();
    }
 };
+
+namespace DB
+{
+template <typename T>
+void readBinary(std::pair<T, UInt32> & x, ReadBuffer & buf)
+{
+    readPODBinary(x, buf);
+}
+}
--- a/src/Backups/BackupsWorker.cpp
+++ b/src/Backups/BackupsWorker.cpp
@ -563,8 +563,13 @@ void BackupsWorker::writeBackupEntries(BackupMutablePtr backup, BackupEntries &&
            }
        };

-        if (always_single_threaded || !backups_thread_pool->trySchedule([job] { job(true); }))
+        if (always_single_threaded)
+        {
            job(false);
+            continue;
+        }
+
+        backups_thread_pool->scheduleOrThrowOnError([job] { job(true); });
    }

    {
@ -854,8 +859,7 @@ void BackupsWorker::restoreTablesData(const OperationID & restore_id, BackupPtr
            }
        };

-        if (!thread_pool.trySchedule([job] { job(true); }))
-            job(false);
+        thread_pool.scheduleOrThrowOnError([job] { job(true); });
    }

    {
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -49,6 +49,8 @@ else()
    add_definitions(-DENABLE_MULTITARGET_CODE=0)
 endif()

+set(dbms_headers)
+set(dbms_sources)

 add_subdirectory (Access)
 add_subdirectory (Backups)
@ -78,10 +80,6 @@ add_subdirectory (Daemon)
 add_subdirectory (Loggers)
 add_subdirectory (Formats)

-
-set(dbms_headers)
-set(dbms_sources)
-
 add_headers_and_sources(clickhouse_common_io Common)
 add_headers_and_sources(clickhouse_common_io Common/HashTable)
 add_headers_and_sources(clickhouse_common_io IO)
@ -151,47 +149,7 @@ else()
    message(STATUS "StorageFileLog is only supported on Linux")
 endif ()

-list (APPEND clickhouse_common_io_sources ${CONFIG_INCLUDE_PATH}/config_version.cpp)
-
-list (APPEND dbms_sources Functions/IFunction.cpp Functions/FunctionFactory.cpp Functions/FunctionHelpers.cpp Functions/extractTimeZoneFromFunctionArguments.cpp Functions/FunctionsLogical.cpp Functions/indexHint.cpp)
-list (APPEND dbms_headers Functions/IFunction.h Functions/FunctionFactory.h Functions/FunctionHelpers.h Functions/extractTimeZoneFromFunctionArguments.h Functions/FunctionsLogical.h Functions/indexHint.h)
-
-list (APPEND dbms_sources
-    AggregateFunctions/IAggregateFunction.cpp
-    AggregateFunctions/AggregateFunctionFactory.cpp
-    AggregateFunctions/AggregateFunctionCombinatorFactory.cpp
-    AggregateFunctions/AggregateFunctionState.cpp
-    AggregateFunctions/AggregateFunctionCount.cpp
-    AggregateFunctions/parseAggregateFunctionParameters.cpp)
-list (APPEND dbms_headers
-    AggregateFunctions/IAggregateFunction.h
-    AggregateFunctions/IAggregateFunctionCombinator.h
-    AggregateFunctions/AggregateFunctionFactory.h
-    AggregateFunctions/AggregateFunctionCombinatorFactory.h
-    AggregateFunctions/AggregateFunctionState.h
-    AggregateFunctions/AggregateFunctionCount.cpp
-    AggregateFunctions/FactoryHelpers.h
-    AggregateFunctions/parseAggregateFunctionParameters.h)
-
-list (APPEND dbms_sources
-    TableFunctions/ITableFunction.cpp
-    TableFunctions/TableFunctionView.cpp
-    TableFunctions/TableFunctionFactory.cpp)
-list (APPEND dbms_headers
-    TableFunctions/ITableFunction.h
-    TableFunctions/TableFunctionView.h
-    TableFunctions/TableFunctionFactory.h)
-
-list (APPEND dbms_sources
-    Dictionaries/DictionaryFactory.cpp
-    Dictionaries/DictionarySourceFactory.cpp
-    Dictionaries/DictionaryStructure.cpp
-    Dictionaries/getDictionaryConfigurationFromAST.cpp)
-list (APPEND dbms_headers
-    Dictionaries/DictionaryFactory.h
-    Dictionaries/DictionarySourceFactory.h
-    Dictionaries/DictionaryStructure.h
-    Dictionaries/getDictionaryConfigurationFromAST.h)
+list(APPEND clickhouse_common_io_sources ${CONFIG_INCLUDE_PATH}/config_version.cpp)

 if (NOT ENABLE_SSL)
    list (REMOVE_ITEM clickhouse_common_io_sources Common/OpenSSLHelpers.cpp)
--- a/src/Columns/ColumnNullable.cpp
+++ b/src/Columns/ColumnNullable.cpp
@ -865,10 +865,14 @@ ColumnPtr ColumnNullable::getNestedColumnWithDefaultOnNull() const
        if (next_null_index != start)
            res->insertRangeFrom(*nested_column, start, next_null_index - start);

-        if (next_null_index < end)
-            res->insertDefault();
+        size_t next_none_null_index = next_null_index;
+        while (next_none_null_index < end && null_map_data[next_none_null_index])
+            ++next_none_null_index;

-        start = next_null_index + 1;
+        if (next_null_index != next_none_null_index)
+            res->insertManyDefaults(next_none_null_index - next_null_index);
+
+        start = next_none_null_index;
    }
    return res;
 }
--- a/src/Common/FailPoint.cpp
+++ b/src/Common/FailPoint.cpp
@ -33,6 +33,7 @@ static struct InitFiu

 #define APPLY_FOR_FAILPOINTS(ONCE, REGULAR, PAUSEABLE_ONCE, PAUSEABLE) \
    ONCE(replicated_merge_tree_commit_zk_fail_after_op) \
+    REGULAR(use_delayed_remote_source) \
    REGULAR(dummy_failpoint) \
    PAUSEABLE_ONCE(dummy_pausable_failpoint_once) \
    PAUSEABLE(dummy_pausable_failpoint)
--- a/src/Common/HashTable/Hash.h
+++ b/src/Common/HashTable/Hash.h
@ -2,9 +2,10 @@

 #include <city.h>
 #include <Core/Types.h>
+#include <Core/UUID.h>
+#include <base/StringRef.h>
 #include <base/types.h>
 #include <base/unaligned.h>
-#include <base/StringRef.h>

 #include <type_traits>

@ -406,7 +407,7 @@ struct UInt128TrivialHash

 struct UUIDTrivialHash
 {
-    size_t operator()(DB::UUID x) const { return x.toUnderType().items[0]; }
+    size_t operator()(DB::UUID x) const { return DB::UUIDHelpers::getHighBytes(x); }
 };

 struct UInt256Hash
--- a/src/Common/HashTable/HashTable.h
+++ b/src/Common/HashTable/HashTable.h
@ -201,11 +201,11 @@ struct HashTableCell
    void setMapped(const value_type & /*value*/) {}

    /// Serialization, in binary and text form.
-    void write(DB::WriteBuffer & wb) const         { DB::writeBinary(key, wb); }
+    void write(DB::WriteBuffer & wb) const         { DB::writeBinaryLittleEndian(key, wb); }
    void writeText(DB::WriteBuffer & wb) const     { DB::writeDoubleQuoted(key, wb); }

    /// Deserialization, in binary and text form.
-    void read(DB::ReadBuffer & rb)        { DB::readBinary(key, rb); }
+    void read(DB::ReadBuffer & rb)        { DB::readBinaryLittleEndian(key, rb); }
    void readText(DB::ReadBuffer & rb)    { DB::readDoubleQuoted(key, rb); }

    /// When cell pointer is moved during erase, reinsert or resize operations
--- a/src/Common/OpenTelemetryTraceContext.cpp
+++ b/src/Common/OpenTelemetryTraceContext.cpp
@ -5,6 +5,7 @@
 #include <Common/Exception.h>
 #include <base/hex.h>
 #include <Core/Settings.h>
+#include <Core/UUID.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>

@ -227,8 +228,8 @@ bool TracingContext::parseTraceparentHeader(std::string_view traceparent, String

    ++data;
    this->trace_flags = unhex2(data);
-    this->trace_id.toUnderType().items[0] = trace_id_higher_64;
-    this->trace_id.toUnderType().items[1] = trace_id_lower_64;
+    UUIDHelpers::getHighBytes(this->trace_id) = trace_id_higher_64;
+    UUIDHelpers::getLowBytes(this->trace_id) = trace_id_lower_64;
    this->span_id = span_id_64;
    return true;
 }
@ -239,8 +240,8 @@ String TracingContext::composeTraceparentHeader() const
    // parent id.
    return fmt::format(
        "00-{:016x}{:016x}-{:016x}-{:02x}",
-        trace_id.toUnderType().items[0],
-        trace_id.toUnderType().items[1],
+        UUIDHelpers::getHighBytes(trace_id),
+        UUIDHelpers::getLowBytes(trace_id),
        span_id,
        // This cast is needed because fmt is being weird and complaining that
        // "mixing character types is not allowed".
@ -335,8 +336,8 @@ TracingContextHolder::TracingContextHolder(
            while (_parent_trace_context.trace_id == UUID())
            {
                // Make sure the random generated trace_id is not 0 which is an invalid id.
-                _parent_trace_context.trace_id.toUnderType().items[0] = thread_local_rng();
-                _parent_trace_context.trace_id.toUnderType().items[1] = thread_local_rng();
+                UUIDHelpers::getHighBytes(_parent_trace_context.trace_id) = thread_local_rng();
+                UUIDHelpers::getLowBytes(_parent_trace_context.trace_id) = thread_local_rng();
            }
            _parent_trace_context.span_id = 0;
        }
--- a/src/Common/ShellCommand.cpp
+++ b/src/Common/ShellCommand.cpp
@ -101,6 +101,12 @@ bool ShellCommand::tryWaitProcessWithTimeout(size_t timeout_in_seconds)
    out.close();
    err.close();

+    for (auto & [_, fd] : write_fds)
+        fd.close();
+
+    for (auto & [_, fd] : read_fds)
+        fd.close();
+
    return waitForPid(pid, timeout_in_seconds);
 }

@ -287,6 +293,12 @@ int ShellCommand::tryWait()
    out.close();
    err.close();

+    for (auto & [_, fd] : write_fds)
+        fd.close();
+
+    for (auto & [_, fd] : read_fds)
+        fd.close();
+
    LOG_TRACE(getLogger(), "Will wait for shell command pid {}", pid);

    int status = 0;
--- a/src/Common/ZooKeeper/ZooKeeper.cpp
+++ b/src/Common/ZooKeeper/ZooKeeper.cpp
@ -18,7 +18,6 @@
 #include <Common/DNSResolver.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/Exception.h>
-#include <Common/logger_useful.h>

 #include <Poco/Net/NetException.h>
 #include <Poco/Net/DNS.h>
--- a/src/Common/ZooKeeper/ZooKeeper.h
+++ b/src/Common/ZooKeeper/ZooKeeper.h
@ -7,6 +7,7 @@
 #include <memory>
 #include <mutex>
 #include <string>
+#include <Common/logger_useful.h>
 #include <Common/ProfileEvents.h>
 #include <Common/CurrentMetrics.h>
 #include <Common/Stopwatch.h>
@ -668,7 +669,13 @@ public:
            return;
        try
        {
-            zookeeper.tryRemove(path);
+            if (!zookeeper.expired())
+                zookeeper.tryRemove(path);
+            else
+            {
+                ProfileEvents::increment(ProfileEvents::CannotRemoveEphemeralNode);
+                LOG_DEBUG(&Poco::Logger::get("EphemeralNodeHolder"), "Cannot remove {} since session has been expired", path);
+            }
        }
        catch (...)
        {
--- a/src/Common/tests/gtest_makeRegexpPatternFromGlobs.cpp
+++ b/src/Common/tests/gtest_makeRegexpPatternFromGlobs.cpp
@ -41,7 +41,7 @@ TEST(Common, makeRegexpPatternFromGlobs)
    EXPECT_EQ(makeRegexpPatternFromGlobs("f{1..2}{1..2}"), "f(1|2)(1|2)");
    EXPECT_EQ(makeRegexpPatternFromGlobs("f{1..1}{1..1}"), "f(1)(1)");
    EXPECT_EQ(makeRegexpPatternFromGlobs("f{0..0}{0..0}"), "f(0)(0)");
-    EXPECT_EQ(makeRegexpPatternFromGlobs("file{1..5}"),"file(1|2|3|4|5)");
-    EXPECT_EQ(makeRegexpPatternFromGlobs("file{1,2,3}"),"file(1|2|3)");
+    EXPECT_EQ(makeRegexpPatternFromGlobs("file{1..5}"), "file(1|2|3|4|5)");
+    EXPECT_EQ(makeRegexpPatternFromGlobs("file{1,2,3}"), "file(1|2|3)");
    EXPECT_EQ(makeRegexpPatternFromGlobs("{1,2,3}blabla{a.x,b.x,c.x}smth[]_else{aa,bb}?*"), "(1|2|3)blabla(a\\.x|b\\.x|c\\.x)smth\\[\\]_else(aa|bb)[^/][^/]*");
 }
--- a/src/Core/MySQL/MySQLGtid.cpp
+++ b/src/Core/MySQL/MySQLGtid.cpp
@ -174,8 +174,8 @@ String GTIDSets::toPayload() const
    for (const auto & set : sets)
    {
        // MySQL UUID is big-endian.
-        writeBinaryBigEndian(set.uuid.toUnderType().items[0], buffer);
-        writeBinaryBigEndian(set.uuid.toUnderType().items[1], buffer);
+        writeBinaryBigEndian(UUIDHelpers::getHighBytes(set.uuid), buffer);
+        writeBinaryBigEndian(UUIDHelpers::getLowBytes(set.uuid), buffer);

        UInt64 intervals_size = set.intervals.size();
        buffer.write(reinterpret_cast<const char *>(&intervals_size), 8);
--- a/src/Core/MySQL/MySQLReplication.cpp
+++ b/src/Core/MySQL/MySQLReplication.cpp
@ -940,13 +940,8 @@ namespace MySQLReplication
        payload.readStrict(reinterpret_cast<char *>(&commit_flag), 1);

        // MySQL UUID is big-endian.
-        UInt64 high = 0UL;
-        UInt64 low = 0UL;
-        readBigEndianStrict(payload, reinterpret_cast<char *>(&low), 8);
-        gtid.uuid.toUnderType().items[0] = low;
-
-        readBigEndianStrict(payload, reinterpret_cast<char *>(&high), 8);
-        gtid.uuid.toUnderType().items[1] = high;
+        readBinaryBigEndian(UUIDHelpers::getHighBytes(gtid.uuid), payload);
+        readBinaryBigEndian(UUIDHelpers::getLowBytes(gtid.uuid), payload);

        payload.readStrict(reinterpret_cast<char *>(&gtid.seq_no), 8);

--- a/src/Core/MySQL/MySQLReplication.h
+++ b/src/Core/MySQL/MySQLReplication.h
@ -33,8 +33,10 @@ namespace MySQLReplication
    inline void readBigEndianStrict(ReadBuffer & payload, char * to, size_t n)
    {
        payload.readStrict(to, n);
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
        char *start = to, *end = to + n;
        std::reverse(start, end);
+#endif
    }

    inline void readTimeFractionalPart(ReadBuffer & payload, UInt32 & factional, UInt16 meta)
--- a/src/Core/UUID.cpp
+++ b/src/Core/UUID.cpp
@ -9,10 +9,11 @@ namespace UUIDHelpers
 {
    UUID generateV4()
    {
-        UInt128 res{thread_local_rng(), thread_local_rng()};
-        res.items[0] = (res.items[0] & 0xffffffffffff0fffull) | 0x0000000000004000ull;
-        res.items[1] = (res.items[1] & 0x3fffffffffffffffull) | 0x8000000000000000ull;
-        return UUID{res};
+        UUID uuid;
+        getHighBytes(uuid) = (thread_local_rng() & 0xffffffffffff0fffull) | 0x0000000000004000ull;
+        getLowBytes(uuid) = (thread_local_rng() & 0x3fffffffffffffffull) | 0x8000000000000000ull;
+
+        return uuid;
    }
 }

--- a/src/Core/UUID.h
+++ b/src/Core/UUID.h
@ -2,6 +2,59 @@

 #include <Core/Types.h>

+/**
+ * Implementation Details
+ * ^^^^^^^^^^^^^^^^^^^^^^
+ * The underlying implementation for a UUID has it represented as a 128-bit unsigned integer. Underlying this, a wide
+ * integer with a 64-bit unsigned integer as its base is utilized. This wide integer can be interfaced with as an array
+ * to access different components of the base. For example, on a Little Endian platform, accessing at index 0 will give
+ * you the 8 higher bytes, and index 1 will give you the 8 lower bytes. On a Big Endian platform, this is reversed where
+ * index 0 will give you the 8 lower bytes, and index 1 will give you the 8 higher bytes.
+ *
+ *    uuid.toUnderType().items[0]
+ *
+ *    //  uint64_t   uint64_t
+ *    // [xxxxxxxx] [        ]
+ *
+ *    uuid.toUnderType().items[1]
+ *
+ *    //  uint64_t   uint64_t
+ *    // [        ] [xxxxxxxx]
+ *
+ * The way that data is stored in the underlying wide integer treats the data as two 64-bit chunks sequenced in the
+ * array. On a Little Endian platform, this results in the following layout
+ *
+ *    // Suppose uuid contains 61f0c404-5cb3-11e7-907b-a6006ad3dba0
+ *
+ *    uuid.toUnderType().items[0]
+ *
+ *    //  uint64_t as HEX
+ *    // [E7 11 B3 5C 04 C4 F0 61] [A0 DB D3 6A 00 A6 7B 90]
+ *    //  ^^^^^^^^^^^^^^^^^^^^^^^
+ *
+ *    uuid.toUnderType().items[1]
+ *
+ *    //  uint64_t as HEX
+ *    // [E7 11 B3 5C 04 C4 F0 61] [A0 DB D3 6A 00 A6 7B 90]
+ *    //                            ^^^^^^^^^^^^^^^^^^^^^^^
+ *
+ * while on a Big Endian platform this would be
+ *
+ *    // Suppose uuid contains 61f0c404-5cb3-11e7-907b-a6006ad3dba0
+ *
+ *    uuid.toUnderType().items[0]
+ *
+ *    //  uint64_t as HEX
+ *    // [90 7B A6 00 6A D3 DB A0] [61 F0 C4 04 5C B3 11 E7]
+ *    //  ^^^^^^^^^^^^^^^^^^^^^^^
+ *
+ *    uuid.toUnderType().items[1]
+ *
+ *    //  uint64_t as HEX
+ *    // [90 7B A6 00 6A D3 DB A0] [61 F0 C4 04 5C B3 11 E7]
+ *    //                            ^^^^^^^^^^^^^^^^^^^^^^^
+*/
+

 namespace DB
 {
@ -11,6 +64,29 @@ namespace UUIDHelpers
    /// Generate random UUID.
    UUID generateV4();

+    constexpr size_t HighBytes = (std::endian::native == std::endian::little) ? 0 : 1;
+    constexpr size_t LowBytes = (std::endian::native == std::endian::little) ? 1 : 0;
+
+    inline uint64_t getHighBytes(const UUID & uuid)
+    {
+        return uuid.toUnderType().items[HighBytes];
+    }
+
+    inline uint64_t & getHighBytes(UUID & uuid)
+    {
+        return uuid.toUnderType().items[HighBytes];
+    }
+
+    inline uint64_t getLowBytes(const UUID & uuid)
+    {
+        return uuid.toUnderType().items[LowBytes];
+    }
+
+    inline uint64_t & getLowBytes(UUID & uuid)
+    {
+        return uuid.toUnderType().items[LowBytes];
+    }
+
    const UUID Nil{};
 }

--- a/src/DataTypes/Serializations/SerializationUUID.cpp
+++ b/src/DataTypes/Serializations/SerializationUUID.cpp
@ -111,25 +111,25 @@ void SerializationUUID::deserializeTextCSV(IColumn & column, ReadBuffer & istr,
 void SerializationUUID::serializeBinary(const Field & field, WriteBuffer & ostr, const FormatSettings &) const
 {
    UUID x = field.get<UUID>();
-    writeBinary(x, ostr);
+    writeBinaryLittleEndian(x, ostr);
 }

 void SerializationUUID::deserializeBinary(Field & field, ReadBuffer & istr, const FormatSettings &) const
 {
    UUID x;
-    readBinary(x, istr);
+    readBinaryLittleEndian(x, istr);
    field = NearestFieldType<UUID>(x);
 }

 void SerializationUUID::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeBinary(assert_cast<const ColumnVector<UUID> &>(column).getData()[row_num], ostr);
+    writeBinaryLittleEndian(assert_cast<const ColumnVector<UUID> &>(column).getData()[row_num], ostr);
 }

 void SerializationUUID::deserializeBinary(IColumn & column, ReadBuffer & istr, const FormatSettings &) const
 {
    UUID x;
-    readBinary(x, istr);
+    readBinaryLittleEndian(x, istr);
    assert_cast<ColumnVector<UUID> &>(column).getData().push_back(x);
 }

--- a/src/Dictionaries/CMakeLists.txt
+++ b/src/Dictionaries/CMakeLists.txt
@ -16,10 +16,20 @@ if (OMIT_HEAVY_DEBUG_SYMBOLS)
        PROPERTIES COMPILE_FLAGS -g0)
 endif()

-list(REMOVE_ITEM clickhouse_dictionaries_sources DictionaryFactory.cpp DictionarySourceFactory.cpp DictionaryStructure.cpp getDictionaryConfigurationFromAST.cpp)
-list(REMOVE_ITEM clickhouse_dictionaries_headers DictionaryFactory.h DictionarySourceFactory.h DictionaryStructure.h getDictionaryConfigurationFromAST.h)
+extract_into_parent_list(clickhouse_dictionaries_sources dbms_sources
+    DictionaryFactory.cpp
+    DictionarySourceFactory.cpp
+    DictionaryStructure.cpp
+    getDictionaryConfigurationFromAST.cpp
+)
+extract_into_parent_list(clickhouse_dictionaries_headers dbms_headers
+    DictionaryFactory.h
+    DictionarySourceFactory.h
+    DictionaryStructure.h
+    getDictionaryConfigurationFromAST.h
+)

-add_library(clickhouse_dictionaries ${clickhouse_dictionaries_sources})
+add_library(clickhouse_dictionaries ${clickhouse_dictionaries_headers} ${clickhouse_dictionaries_sources})

 target_link_libraries(clickhouse_dictionaries
    PRIVATE
--- a/src/Disks/IO/AsynchronousBoundedReadBuffer.cpp
+++ b/src/Disks/IO/AsynchronousBoundedReadBuffer.cpp
@ -114,6 +114,26 @@ void AsynchronousBoundedReadBuffer::setReadUntilPosition(size_t position)
 {
    if (!read_until_position || position != *read_until_position)
    {
+        if (position < file_offset_of_buffer_end)
+        {
+            /// file has been read beyond new read until position already
+            if (working_buffer.size() >= file_offset_of_buffer_end - position)
+            {
+                /// new read until position is inside working buffer
+                file_offset_of_buffer_end = position;
+            }
+            else
+            {
+                /// new read until position is before working buffer begin
+                throw Exception(
+                    ErrorCodes::LOGICAL_ERROR,
+                    "Attempt to set read until position before already read data ({} > {}, info: {})",
+                    position,
+                    getPosition(),
+                    impl->getInfoForLog());
+            }
+        }
+
        read_until_position = position;

        /// We must wait on future and reset the prefetch here, because otherwise there might be
@ -248,7 +268,6 @@ off_t AsynchronousBoundedReadBuffer::seek(off_t offset, int whence)
        {
            /// Position is still inside the buffer.
            /// Probably it is at the end of the buffer - then we will load data on the following 'next' call.
-
            pos = working_buffer.end() - file_offset_of_buffer_end + new_pos;
            assert(pos >= working_buffer.begin());
            assert(pos <= working_buffer.end());
--- a/src/Disks/IO/AsynchronousBoundedReadBuffer.h
+++ b/src/Disks/IO/AsynchronousBoundedReadBuffer.h
@ -46,6 +46,8 @@ public:

    void setReadUntilEnd() override { return setReadUntilPosition(getFileSize()); }

+    size_t getFileOffsetOfBufferEnd() const override  { return file_offset_of_buffer_end; }
+
    off_t getPosition() override { return file_offset_of_buffer_end - available() + bytes_to_ignore; }

 private:
--- a/src/Functions/CMakeLists.txt
+++ b/src/Functions/CMakeLists.txt
@ -3,10 +3,22 @@ add_subdirectory(divide)
 include("${ClickHouse_SOURCE_DIR}/cmake/dbms_glob_sources.cmake")
 add_headers_and_sources(clickhouse_functions .)

-list(REMOVE_ITEM clickhouse_functions_sources IFunction.cpp FunctionFactory.cpp FunctionHelpers.cpp extractTimeZoneFromFunctionArguments.cpp FunctionsLogical.cpp)
-list(REMOVE_ITEM clickhouse_functions_headers IFunction.h FunctionFactory.h FunctionHelpers.h extractTimeZoneFromFunctionArguments.h FunctionsLogical.h)
+extract_into_parent_list(clickhouse_functions_sources dbms_sources
+    IFunction.cpp
+    FunctionFactory.cpp
+    FunctionHelpers.cpp
+    extractTimeZoneFromFunctionArguments.cpp
+    FunctionsLogical.cpp
+)
+extract_into_parent_list(clickhouse_functions_headers dbms_headers
+    IFunction.h
+    FunctionFactory.h
+    FunctionHelpers.h
+    extractTimeZoneFromFunctionArguments.h
+    FunctionsLogical.h
+)

-add_library(clickhouse_functions_obj OBJECT ${clickhouse_functions_sources})
+add_library(clickhouse_functions_obj OBJECT ${clickhouse_functions_headers} ${clickhouse_functions_sources})

 list (APPEND OBJECT_LIBS $<TARGET_OBJECTS:clickhouse_functions_obj>)

--- a/src/Functions/FunctionsBinaryRepresentation.cpp
+++ b/src/Functions/FunctionsBinaryRepresentation.cpp
@ -507,8 +507,8 @@ public:

                // use executeOnUInt instead of using executeOneString
                // because the latter one outputs the string in the memory order
-                Impl::executeOneUIntOrInt(uuid[i].toUnderType().items[0], end, false, false);
-                Impl::executeOneUIntOrInt(uuid[i].toUnderType().items[1], end, false, true);
+                Impl::executeOneUIntOrInt(UUIDHelpers::getHighBytes(uuid[i]), end, false, false);
+                Impl::executeOneUIntOrInt(UUIDHelpers::getLowBytes(uuid[i]), end, false, true);

                pos += end - begin;
                out_offsets[i] = pos;
--- a/src/Functions/FunctionsConversion.h
+++ b/src/Functions/FunctionsConversion.h
@ -203,18 +203,15 @@ struct ConvertImpl
                    }
                }

-                if constexpr (std::is_same_v<FromDataType, DataTypeUUID> && std::is_same_v<ToDataType,DataTypeUInt128>)
+                if constexpr (std::is_same_v<FromDataType, DataTypeUUID> && std::is_same_v<ToDataType, DataTypeUInt128>)
                {
-                    static_assert(std::is_same_v<DataTypeUInt128::FieldType, DataTypeUUID::FieldType::UnderlyingType>, "UInt128 and UUID types must be same");
-                    if constexpr (std::endian::native == std::endian::little)
-                    {
-                        vec_to[i].items[1] = vec_from[i].toUnderType().items[0];
-                        vec_to[i].items[0] = vec_from[i].toUnderType().items[1];
-                    }
-                    else
-                    {
-                        vec_to[i] = vec_from[i].toUnderType();
-                    }
+                    static_assert(
+                        std::is_same_v<DataTypeUInt128::FieldType, DataTypeUUID::FieldType::UnderlyingType>,
+                        "UInt128 and UUID types must be same");
+
+                    vec_to[i].items[1] = vec_from[i].toUnderType().items[0];
+                    vec_to[i].items[0] = vec_from[i].toUnderType().items[1];
+
                    continue;
                }

--- a/src/Functions/castTypeToEither.h
+++ b/src/Functions/castTypeToEither.h
@ -8,18 +8,12 @@ namespace DB
 template <typename... Ts, typename T, typename F>
 static bool castTypeToEither(const T * type, F && f)
 {
-    /// XXX can't use && here because gcc-7 complains about parentheses around && within ||
-    return ((typeid_cast<const Ts *>(type) ? f(*typeid_cast<const Ts *>(type)) : false) || ...);
+    return ((typeid_cast<const Ts *>(type) && f(*typeid_cast<const Ts *>(type))) || ...);
 }

 template <class ...Args>
 constexpr bool castTypeToEither(TypeList<Args...>, const auto * type, auto && f)
 {
-    return (
-        (typeid_cast<const Args *>(type) != nullptr
-            ? std::forward<decltype(f)>(f)(
-                *typeid_cast<const Args *>(type))
-            : false)
-        || ...);
+    return ((typeid_cast<const Args *>(type) != nullptr && std::forward<decltype(f)>(f)(*typeid_cast<const Args *>(type))) || ...);
 }
 }
--- a/src/Functions/currentDatabase.cpp
+++ b/src/Functions/currentDatabase.cpp
@ -55,6 +55,7 @@ REGISTER_FUNCTION(CurrentDatabase)
 {
    factory.registerFunction<FunctionCurrentDatabase>();
    factory.registerAlias("DATABASE", FunctionCurrentDatabase::name, FunctionFactory::CaseInsensitive);
+    factory.registerAlias("SCHEMA", FunctionCurrentDatabase::name, FunctionFactory::CaseInsensitive);
    factory.registerAlias("current_database", FunctionCurrentDatabase::name, FunctionFactory::CaseInsensitive);
 }

--- a/src/Functions/generateUUIDv4.cpp
+++ b/src/Functions/generateUUIDv4.cpp
@ -60,9 +60,8 @@ public:
        {
            /// https://tools.ietf.org/html/rfc4122#section-4.4

-            UInt128 & impl = uuid.toUnderType();
-            impl.items[0] = (impl.items[0] & 0xffffffffffff0fffull) | 0x0000000000004000ull;
-            impl.items[1] = (impl.items[1] & 0x3fffffffffffffffull) | 0x8000000000000000ull;
+            UUIDHelpers::getHighBytes(uuid) = (UUIDHelpers::getHighBytes(uuid) & 0xffffffffffff0fffull) | 0x0000000000004000ull;
+            UUIDHelpers::getLowBytes(uuid) = (UUIDHelpers::getLowBytes(uuid) & 0x3fffffffffffffffull) | 0x8000000000000000ull;
        }

        return col_res;
--- a/src/Functions/reinterpretAs.cpp
+++ b/src/Functions/reinterpretAs.cpp
@ -1,26 +1,27 @@
 #include <Functions/FunctionFactory.h>
-#include <Functions/castTypeToEither.h>
 #include <Functions/FunctionHelpers.h>
+#include <Functions/castTypeToEither.h>

 #include <Core/callOnTypeIndex.h>

-#include <DataTypes/DataTypesNumber.h>
-#include <DataTypes/DataTypeString.h>
-#include <DataTypes/DataTypeFixedString.h>
+#include <Columns/ColumnConst.h>
+#include <Columns/ColumnDecimal.h>
+#include <Columns/ColumnFixedString.h>
+#include <Columns/ColumnString.h>
+#include <Columns/ColumnVector.h>
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
-#include <DataTypes/DataTypeUUID.h>
-#include <DataTypes/DataTypeFactory.h>
-#include <DataTypes/DataTypesDecimal.h>
 #include <DataTypes/DataTypeDateTime64.h>
-#include <Columns/ColumnString.h>
-#include <Columns/ColumnFixedString.h>
-#include <Columns/ColumnConst.h>
-#include <Columns/ColumnVector.h>
-#include <Columns/ColumnDecimal.h>
+#include <DataTypes/DataTypeFactory.h>
+#include <DataTypes/DataTypeFixedString.h>
+#include <DataTypes/DataTypeString.h>
+#include <DataTypes/DataTypeUUID.h>
+#include <DataTypes/DataTypesDecimal.h>
+#include <DataTypes/DataTypesNumber.h>

-#include <Common/typeid_cast.h>
+#include <Common/TransformEndianness.hpp>
 #include <Common/memcpySmall.h>
+#include <Common/typeid_cast.h>

 #include <base/unaligned.h>

@ -261,8 +262,10 @@ public:
                            memcpy(static_cast<void*>(&to[i]), static_cast<const void*>(&from[i]), copy_size);
                        else
                        {
-                            size_t offset_to = sizeof(To) > sizeof(From) ? sizeof(To) - sizeof(From) : 0;
-                            memcpy(reinterpret_cast<char*>(&to[i]) + offset_to, static_cast<const void*>(&from[i]), copy_size);
+                            // Handle the cases of both 128-bit representation to 256-bit and 128-bit to 64-bit or lower.
+                            const size_t offset_from = sizeof(From) > sizeof(To) ? sizeof(From) - sizeof(To) : 0;
+                            const size_t offset_to = sizeof(To) > sizeof(From) ? sizeof(To) - sizeof(From) : 0;
+                            memcpy(reinterpret_cast<char *>(&to[i]) + offset_to, reinterpret_cast<const char *>(&from[i]) + offset_from, copy_size);
                        }

                    }
@ -315,7 +318,11 @@ private:
        {
            std::string_view data = src.getDataAt(i).toView();

+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
            memcpy(&data_to[offset], data.data(), std::min(n, data.size()));
+#else
+            reverseMemcpy(&data_to[offset], data.data(), std::min(n, data.size()));
+#endif
            offset += n;
        }
    }
@ -326,7 +333,11 @@ private:
        ColumnFixedString::Chars & data_to = dst.getChars();
        data_to.resize(n * rows);

+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
        memcpy(data_to.data(), src.getRawData().data(), data_to.size());
+#else
+        reverseMemcpy(data_to.data(), src.getRawData().data(), data_to.size());
+#endif
    }

    static void NO_INLINE executeToString(const IColumn & src, ColumnString & dst)
--- a/src/IO/ReadBufferFromS3.cpp
+++ b/src/IO/ReadBufferFromS3.cpp
@ -40,9 +40,15 @@ DB::PooledHTTPSessionPtr getSession(Aws::S3::Model::GetObjectResult & read_resul
 {
    if (auto * session_aware_stream = dynamic_cast<DB::S3::SessionAwareIOStream<DB::PooledHTTPSessionPtr> *>(&read_result.GetBody()))
        return static_cast<DB::PooledHTTPSessionPtr &>(session_aware_stream->getSession());
-    else if (!dynamic_cast<DB::S3::SessionAwareIOStream<DB::HTTPSessionPtr> *>(&read_result.GetBody()))
-        throw DB::Exception(DB::ErrorCodes::LOGICAL_ERROR, "Session of unexpected type encountered");
-    return {};
+
+    if (dynamic_cast<DB::S3::SessionAwareIOStream<DB::HTTPSessionPtr> *>(&read_result.GetBody()))
+        return {};
+
+    /// accept result from S# mock in gtest_writebuffer_s3.cpp
+    if (dynamic_cast<Aws::Utils::Stream::DefaultUnderlyingStream *>(&read_result.GetBody()))
+        return {};
+
+    throw DB::Exception(DB::ErrorCodes::LOGICAL_ERROR, "Session of unexpected type encountered");
 }

 void resetSession(Aws::S3::Model::GetObjectResult & read_result)
@ -260,6 +266,7 @@ bool ReadBufferFromS3::processException(Poco::Exception & e, size_t read_offset,
        "Attempt: {}, Message: {}",
        bucket, key, version_id.empty() ? "Latest" : version_id, read_offset, attempt, e.message());

+
    if (auto * s3_exception = dynamic_cast<S3Exception *>(&e))
    {
        /// It doesn't make sense to retry Access Denied or No Such Key
--- a/src/IO/ReadBufferFromS3.h
+++ b/src/IO/ReadBufferFromS3.h
@ -16,11 +16,6 @@

 #include <aws/s3/model/GetObjectResult.h>

-namespace Aws::S3
-{
-class Client;
-}
-
 namespace DB
 {
 /**
--- a/src/IO/ReadHelpers.cpp
+++ b/src/IO/ReadHelpers.cpp
@ -53,36 +53,25 @@ UUID parseUUID(std::span<const UInt8> src)
 {
    UUID uuid;
    const auto * src_ptr = src.data();
-    auto * dst = reinterpret_cast<UInt8 *>(&uuid);
    const auto size = src.size();

 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    const std::reverse_iterator dst_it(dst + sizeof(UUID));
+    const std::reverse_iterator dst(reinterpret_cast<UInt8 *>(&uuid) + sizeof(UUID));
+#else
+    auto * dst = reinterpret_cast<UInt8 *>(&uuid);
 #endif
    if (size == 36)
    {
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-        parseHex<4>(src_ptr, dst_it + 8);
-        parseHex<2>(src_ptr + 9, dst_it + 12);
-        parseHex<2>(src_ptr + 14, dst_it + 14);
-        parseHex<2>(src_ptr + 19, dst_it);
-        parseHex<6>(src_ptr + 24, dst_it + 2);
-#else
-        parseHex<4>(src_ptr, dst);
-        parseHex<2>(src_ptr + 9, dst + 4);
-        parseHex<2>(src_ptr + 14, dst + 6);
-        parseHex<2>(src_ptr + 19, dst + 8);
-        parseHex<6>(src_ptr + 24, dst + 10);
-#endif
+        parseHex<4>(src_ptr, dst + 8);
+        parseHex<2>(src_ptr + 9, dst + 12);
+        parseHex<2>(src_ptr + 14, dst + 14);
+        parseHex<2>(src_ptr + 19, dst);
+        parseHex<6>(src_ptr + 24, dst + 2);
    }
    else if (size == 32)
    {
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-        parseHex<8>(src_ptr, dst_it + 8);
-        parseHex<8>(src_ptr + 16, dst_it);
-#else
-        parseHex<16>(src_ptr, dst);
-#endif
+        parseHex<8>(src_ptr, dst + 8);
+        parseHex<8>(src_ptr + 16, dst);
    }
    else
        throw Exception(ErrorCodes::CANNOT_PARSE_UUID, "Unexpected length when trying to parse UUID ({})", size);
--- a/src/IO/ReadHelpers.h
+++ b/src/IO/ReadHelpers.h
@ -116,6 +116,13 @@ inline void readPODBinary(T & x, ReadBuffer & buf)
    buf.readStrict(reinterpret_cast<char *>(&x), sizeof(x)); /// NOLINT
 }

+inline void readUUIDBinary(UUID & x, ReadBuffer & buf)
+{
+    auto & uuid = x.toUnderType();
+    readPODBinary(uuid.items[0], buf);
+    readPODBinary(uuid.items[1], buf);
+}
+
 template <typename T>
 inline void readIntBinary(T & x, ReadBuffer & buf)
 {
@ -1106,16 +1113,26 @@ inline void readBinary(Decimal64 & x, ReadBuffer & buf) { readPODBinary(x, buf);
 inline void readBinary(Decimal128 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 inline void readBinary(Decimal256 & x, ReadBuffer & buf) { readPODBinary(x.value, buf); }
 inline void readBinary(LocalDate & x, ReadBuffer & buf) { readPODBinary(x, buf); }
-inline void readBinary(UUID & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 inline void readBinary(IPv4 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 inline void readBinary(IPv6 & x, ReadBuffer & buf) { readPODBinary(x, buf); }

+inline void readBinary(UUID & x, ReadBuffer & buf)
+{
+    readUUIDBinary(x, buf);
+}
+
+inline void readBinary(CityHash_v1_0_2::uint128 & x, ReadBuffer & buf)
+{
+    readPODBinary(x.low64, buf);
+    readPODBinary(x.high64, buf);
+}
+
 inline void readBinary(StackTrace::FramePointers & x, ReadBuffer & buf) { readPODBinary(x, buf); }

 template <std::endian endian, typename T>
 inline void readBinaryEndian(T & x, ReadBuffer & buf)
 {
-    readPODBinary(x, buf);
+    readBinary(x, buf);
    transformEndianness<endian>(x);
 }

--- a/src/IO/WriteHelpers.cpp
+++ b/src/IO/WriteHelpers.cpp
@ -23,30 +23,23 @@ void formatHex(IteratorSrc src, IteratorDst dst, size_t num_bytes)
 std::array<char, 36> formatUUID(const UUID & uuid)
 {
    std::array<char, 36> dst;
-    const auto * src_ptr = reinterpret_cast<const UInt8 *>(&uuid);
    auto * dst_ptr = dst.data();
+
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    const std::reverse_iterator src_it(src_ptr + 16);
-    formatHex(src_it + 8, dst_ptr, 4);
-    dst[8] = '-';
-    formatHex(src_it + 12, dst_ptr + 9, 2);
-    dst[13] = '-';
-    formatHex(src_it + 14, dst_ptr + 14, 2);
-    dst[18] = '-';
-    formatHex(src_it, dst_ptr + 19, 2);
-    dst[23] = '-';
-    formatHex(src_it + 2, dst_ptr + 24, 6);
+    const auto * src_ptr = reinterpret_cast<const UInt8 *>(&uuid);
+    const std::reverse_iterator src(src_ptr + 16);
 #else
-    formatHex(src_ptr, dst_ptr, 4);
-    dst[8] = '-';
-    formatHex(src_ptr + 4, dst_ptr + 9, 2);
-    dst[13] = '-';
-    formatHex(src_ptr + 6, dst_ptr + 14, 2);
-    dst[18] = '-';
-    formatHex(src_ptr + 8, dst_ptr + 19, 2);
-    dst[23] = '-';
-    formatHex(src_ptr + 10, dst_ptr + 24, 6);
+    const auto * src = reinterpret_cast<const UInt8 *>(&uuid);
 #endif
+    formatHex(src + 8, dst_ptr, 4);
+    dst[8] = '-';
+    formatHex(src + 12, dst_ptr + 9, 2);
+    dst[13] = '-';
+    formatHex(src + 14, dst_ptr + 14, 2);
+    dst[18] = '-';
+    formatHex(src, dst_ptr + 19, 2);
+    dst[23] = '-';
+    formatHex(src + 2, dst_ptr + 24, 6);

    return dst;
 }
--- a/src/IO/WriteHelpers.h
+++ b/src/IO/WriteHelpers.h
@ -88,6 +88,13 @@ inline void writePODBinary(const T & x, WriteBuffer & buf)
    buf.write(reinterpret_cast<const char *>(&x), sizeof(x)); /// NOLINT
 }

+inline void writeUUIDBinary(const UUID & x, WriteBuffer & buf)
+{
+    const auto & uuid = x.toUnderType();
+    writePODBinary(uuid.items[0], buf);
+    writePODBinary(uuid.items[1], buf);
+}
+
 template <typename T>
 inline void writeIntBinary(const T & x, WriteBuffer & buf)
 {
@ -882,10 +889,20 @@ inline void writeBinary(const Decimal128 & x, WriteBuffer & buf) { writePODBinar
 inline void writeBinary(const Decimal256 & x, WriteBuffer & buf) { writePODBinary(x.value, buf); }
 inline void writeBinary(const LocalDate & x, WriteBuffer & buf) { writePODBinary(x, buf); }
 inline void writeBinary(const LocalDateTime & x, WriteBuffer & buf) { writePODBinary(x, buf); }
-inline void writeBinary(const UUID & x, WriteBuffer & buf) { writePODBinary(x, buf); }
 inline void writeBinary(const IPv4 & x, WriteBuffer & buf) { writePODBinary(x, buf); }
 inline void writeBinary(const IPv6 & x, WriteBuffer & buf) { writePODBinary(x, buf); }

+inline void writeBinary(const UUID & x, WriteBuffer & buf)
+{
+    writeUUIDBinary(x, buf);
+}
+
+inline void writeBinary(const CityHash_v1_0_2::uint128 & x, WriteBuffer & buf)
+{
+    writePODBinary(x.low64, buf);
+    writePODBinary(x.high64, buf);
+}
+
 inline void writeBinary(const StackTrace::FramePointers & x, WriteBuffer & buf) { writePODBinary(x, buf); }

 /// Methods for outputting the value in text form for a tab-separated format.
@ -1208,7 +1225,7 @@ template <std::endian endian, typename T>
 inline void writeBinaryEndian(T x, WriteBuffer & buf)
 {
    transformEndianness<endian>(x);
-    writePODBinary(x, buf);
+    writeBinary(x, buf);
 }

 template <typename T>
--- a/src/IO/tests/gtest_writebuffer_s3.cpp
+++ b/src/IO/tests/gtest_writebuffer_s3.cpp
@ -23,11 +23,21 @@

 #include <IO/WriteBufferFromS3.h>
 #include <IO/S3Common.h>
+#include <IO/FileEncryptionCommon.h>
+#include <IO/WriteBufferFromEncryptedFile.h>
+#include <IO/ReadBufferFromEncryptedFile.h>
+#include <IO/AsyncReadCounters.h>
+#include <IO/ReadBufferFromS3.h>
+#include <IO/S3/Client.h>
+
+#include <Disks/IO/ThreadPoolReader.h>
+#include <Disks/IO/ReadBufferFromRemoteFSGather.h>
+#include <Disks/IO/AsynchronousBoundedReadBuffer.h>

 #include <Common/filesystemHelpers.h>
-#include <IO/S3/Client.h>
 #include <Core/Settings.h>

+
 namespace DB
 {

@ -258,10 +268,22 @@ struct Client : DB::S3::Client
        ++counters.getObject;

        auto & bStore = store->GetBucketStore(request.GetBucket());
+        const String data = bStore.objects[request.GetKey()];
+
+        size_t begin = 0;
+        size_t end = data.size() - 1;
+
+        const String & range = request.GetRange();
+        const String prefix = "bytes=";
+        if (range.starts_with(prefix))
+        {
+            int ret = sscanf(range.c_str(), "bytes=%zu-%zu", &begin, &end); /// NOLINT
+            chassert(ret == 2);
+        }

        auto factory = request.GetResponseStreamFactory();
        Aws::Utils::Stream::ResponseStream responseStream(factory);
-        responseStream.GetUnderlyingStream() << std::stringstream(bStore.objects[request.GetKey()]).rdbuf();
+        responseStream.GetUnderlyingStream() << std::stringstream(data.substr(begin, end - begin + 1)).rdbuf();

        Aws::AmazonWebServiceResult<Aws::Utils::Stream::ResponseStream> awsStream(std::move(responseStream), Aws::Http::HeaderValueCollection());
        Aws::S3::Model::GetObjectResult getObjectResult(std::move(awsStream));
@ -1148,4 +1170,108 @@ TEST_P(SyncAsync, StrictUploadPartSize) {
    }
 }

+String fillStringWithPattern(String pattern, int n)
+{
+    String data;
+    for (int i = 0; i < n; ++i)
+    {
+        data += pattern;
+    }
+    return data;
+}
+
+TEST_F(WBS3Test, ReadBeyondLastOffset) {
+    const String remote_file = "ReadBeyondLastOffset";
+
+    const String key = "1234567812345678";
+    const String data = fillStringWithPattern("0123456789", 10);
+
+    ReadSettings disk_read_settings;
+    disk_read_settings.enable_filesystem_cache = false;
+    disk_read_settings.local_fs_buffer_size = 70;
+    disk_read_settings.remote_fs_buffer_size = FileEncryption::Header::kSize + 60;
+
+    {
+        /// write encrypted file
+
+        FileEncryption::Header header;
+        header.algorithm = FileEncryption::Algorithm::AES_128_CTR;
+        header.key_fingerprint = FileEncryption::calculateKeyFingerprint(key);
+        header.init_vector = FileEncryption::InitVector::random();
+
+        auto wbs3 = getWriteBuffer(remote_file);
+        getAsyncPolicy().setAutoExecute(true);
+
+        WriteBufferFromEncryptedFile wb(10, std::move(wbs3), key, header);
+        wb.write(data.data(), data.size());
+        wb.finalize();
+    }
+
+    std::unique_ptr<ReadBufferFromEncryptedFile> encrypted_read_buffer;
+
+    {
+        /// create encrypted file reader
+
+        auto cache_log = std::shared_ptr<FilesystemCacheLog>();
+        const StoredObjects objects = { StoredObject(remote_file, data.size() + FileEncryption::Header::kSize) };
+        auto reader = std::make_unique<ThreadPoolReader>(1, 1);
+        auto async_read_counters = std::make_shared<AsyncReadCounters>();
+        auto prefetch_log = std::shared_ptr<FilesystemReadPrefetchesLog>();
+
+        auto rb_creator = [this, disk_read_settings] (const std::string & path, size_t read_until_position) -> std::unique_ptr<ReadBufferFromFileBase>
+        {
+            S3Settings::RequestSettings request_settings;
+            return std::make_unique<ReadBufferFromS3>(
+                client,
+                bucket,
+                path,
+                "Latest",
+                request_settings,
+                disk_read_settings,
+                /* use_external_buffer */true,
+                /* offset */0,
+                read_until_position,
+                /* restricted_seek */true);
+        };
+
+        auto rb_remote_fs = std::make_unique<ReadBufferFromRemoteFSGather>(
+            std::move(rb_creator),
+            objects,
+            disk_read_settings,
+            cache_log,
+            true);
+
+        auto rb_async = std::make_unique<AsynchronousBoundedReadBuffer>(
+            std::move(rb_remote_fs), *reader, disk_read_settings, async_read_counters, prefetch_log);
+
+        /// read the header from the buffer
+        /// as a result AsynchronousBoundedReadBuffer consists some data from the file inside working buffer
+        FileEncryption::Header header;
+        header.read(*rb_async);
+
+        ASSERT_EQ(rb_async->available(), disk_read_settings.remote_fs_buffer_size - FileEncryption::Header::kSize);
+        ASSERT_EQ(rb_async->getPosition(), FileEncryption::Header::kSize);
+        ASSERT_EQ(rb_async->getFileOffsetOfBufferEnd(), disk_read_settings.remote_fs_buffer_size);
+
+        /// ReadBufferFromEncryptedFile is constructed over an ReadBuffer which was already in use.
+        /// The 'FileEncryption::Header' has been read from `rb_async`.
+        /// 'rb_async' will read the data from `rb_async` working buffer
+        encrypted_read_buffer = std::make_unique<ReadBufferFromEncryptedFile>(
+            disk_read_settings.local_fs_buffer_size, std::move(rb_async), key, header);
+    }
+
+    /// When header is read, file is read into working buffer till some position. Tn the test the file is read until remote_fs_buffer_size (124) position.
+    /// Set the right border before that position and make sure that encrypted_read_buffer does not have access to it
+    ASSERT_GT(disk_read_settings.remote_fs_buffer_size, 50);
+    encrypted_read_buffer->setReadUntilPosition(50);
+
+    /// encrypted_read_buffer reads the data with buffer size `local_fs_buffer_size`
+    /// If the impl file has read the data beyond the ReadUntilPosition, encrypted_read_buffer does not read it
+    /// getFileOffsetOfBufferEnd should read data till `ReadUntilPosition`
+    String res;
+    readStringUntilEOF(res, *encrypted_read_buffer);
+    ASSERT_EQ(res, data.substr(0, 50));
+    ASSERT_TRUE(encrypted_read_buffer->eof());
+}
+
 #endif
--- a/src/Interpreters/ClusterProxy/SelectStreamFactory.cpp
+++ b/src/Interpreters/ClusterProxy/SelectStreamFactory.cpp
@ -14,6 +14,7 @@

 #include <Client/IConnections.h>
 #include <Common/logger_useful.h>
+#include <Common/FailPoint.h>
 #include <Processors/QueryPlan/QueryPlan.h>
 #include <Processors/QueryPlan/ReadFromRemote.h>
 #include <Processors/QueryPlan/ExpressionStep.h>
@ -35,6 +36,11 @@ namespace ErrorCodes
    extern const int ALL_REPLICAS_ARE_STALE;
 }

+namespace FailPoints
+{
+    extern const char use_delayed_remote_source[];
+}
+
 namespace ClusterProxy
 {

@ -134,6 +140,12 @@ void SelectStreamFactory::createForShard(

    const auto & settings = context->getSettingsRef();

+    fiu_do_on(FailPoints::use_delayed_remote_source,
+    {
+        emplace_remote_stream(/*lazy=*/true, /*local_delay=*/999999);
+        return;
+    });
+
    if (settings.prefer_localhost_replica && shard_info.isLocal())
    {
        StoragePtr main_table_storage;
--- a/src/Interpreters/ConcurrentHashJoin.h
+++ b/src/Interpreters/ConcurrentHashJoin.h
@ -3,7 +3,6 @@
 #include <condition_variable>
 #include <memory>
 #include <optional>
-#include <Functions/FunctionsLogical.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/ExpressionActions.h>
 #include <Interpreters/HashJoin.h>
@ -33,7 +32,13 @@ class ConcurrentHashJoin : public IJoin
 {

 public:
-    explicit ConcurrentHashJoin(ContextPtr context_, std::shared_ptr<TableJoin> table_join_, size_t slots_, const Block & right_sample_block, bool any_take_last_row_ = false);
+    explicit ConcurrentHashJoin(
+        ContextPtr context_,
+        std::shared_ptr<TableJoin> table_join_,
+        size_t slots_,
+        const Block & right_sample_block,
+        bool any_take_last_row_ = false);
+
    ~ConcurrentHashJoin() override = default;

    std::string getName() const override { return "ConcurrentHashJoin"; }
@ -67,7 +72,6 @@ private:

    IColumn::Selector selectDispatchBlock(const Strings & key_columns_names, const Block & from_block);
    Blocks dispatchBlock(const Strings & key_columns_names, const Block & from_block);
-
 };

 }
--- a/src/Interpreters/DatabaseCatalog.h
+++ b/src/Interpreters/DatabaseCatalog.h
@ -308,7 +308,7 @@ private:

    static inline size_t getFirstLevelIdx(const UUID & uuid)
    {
-        return uuid.toUnderType().items[0] >> (64 - bits_for_first_level);
+        return UUIDHelpers::getHighBytes(uuid) >> (64 - bits_for_first_level);
    }

    void dropTableDataTask();
--- a/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp
+++ b/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp
@ -326,8 +326,8 @@ static void insertUUID(IColumn & column, DataTypePtr type, const char * value, s
        throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Cannot insert MessagePack UUID into column with type {}.", type->getName());
    ReadBufferFromMemory buf(value, size);
    UUID uuid;
-    readBinaryBigEndian(uuid.toUnderType().items[0], buf);
-    readBinaryBigEndian(uuid.toUnderType().items[1], buf);
+    readBinaryBigEndian(UUIDHelpers::getHighBytes(uuid), buf);
+    readBinaryBigEndian(UUIDHelpers::getLowBytes(uuid), buf);
    assert_cast<ColumnUUID &>(column).insertValue(uuid);
 }

--- a/src/Processors/Formats/Impl/MsgPackRowOutputFormat.cpp
+++ b/src/Processors/Formats/Impl/MsgPackRowOutputFormat.cpp
@ -270,8 +270,8 @@ void MsgPackRowOutputFormat::serializeField(const IColumn & column, DataTypePtr
                {
                    WriteBufferFromOwnString buf;
                    UUID value = uuid_column.getElement(row_num);
-                    writeBinaryBigEndian(value.toUnderType().items[0], buf);
-                    writeBinaryBigEndian(value.toUnderType().items[1], buf);
+                    writeBinaryBigEndian(UUIDHelpers::getHighBytes(value), buf);
+                    writeBinaryBigEndian(UUIDHelpers::getLowBytes(value), buf);
                    std::string_view uuid_ext = buf.stringView();
                    packer.pack_ext(sizeof(UUID), int8_t(MsgPackExtensionTypes::UUIDType));
                    packer.pack_ext_body(uuid_ext.data(), static_cast<unsigned>(uuid_ext.size()));
--- a/src/Processors/Formats/Impl/ODBCDriver2BlockOutputFormat.cpp
+++ b/src/Processors/Formats/Impl/ODBCDriver2BlockOutputFormat.cpp
@ -16,7 +16,7 @@ ODBCDriver2BlockOutputFormat::ODBCDriver2BlockOutputFormat(

 static void writeODBCString(WriteBuffer & out, const std::string & str)
 {
-    writeIntBinary(Int32(str.size()), out);
+    writeBinaryLittleEndian(Int32(str.size()), out);
    out.write(str.data(), str.size());
 }

@ -30,7 +30,7 @@ void ODBCDriver2BlockOutputFormat::writeRow(const Columns & columns, size_t row_

        if (column->isNullAt(row_idx))
        {
-            writeIntBinary(Int32(-1), out);
+            writeBinaryLittleEndian(Int32(-1), out);
        }
        else
        {
@ -69,11 +69,11 @@ void ODBCDriver2BlockOutputFormat::writePrefix()
    const size_t columns = header.columns();

    /// Number of header rows.
-    writeIntBinary(Int32(2), out);
+    writeBinaryLittleEndian(Int32(2), out);

    /// Names of columns.
    /// Number of columns + 1 for first name column.
-    writeIntBinary(Int32(columns + 1), out);
+    writeBinaryLittleEndian(Int32(columns + 1), out);
    writeODBCString(out, "name");
    for (size_t i = 0; i < columns; ++i)
    {
@ -82,7 +82,7 @@ void ODBCDriver2BlockOutputFormat::writePrefix()
    }

    /// Types of columns.
-    writeIntBinary(Int32(columns + 1), out);
+    writeBinaryLittleEndian(Int32(columns + 1), out);
    writeODBCString(out, "type");
    for (size_t i = 0; i < columns; ++i)
    {
--- a/src/Processors/Sources/DelayedSource.cpp
+++ b/src/Processors/Sources/DelayedSource.cpp
@ -148,7 +148,9 @@ Processors DelayedSource::expandPipeline()
        inputs.emplace_back(outputs.front().getHeader(), this);
        /// Connect checks that header is same for ports.
        connect(*output, inputs.back());
-        inputs.back().setNeeded();
+
+        if (output == main_output)
+            inputs.back().setNeeded();
    }

    /// Executor will check that all processors are connected.
--- a/src/Processors/Sources/ShellCommandSource.cpp
+++ b/src/Processors/Sources/ShellCommandSource.cpp
@ -439,11 +439,7 @@ namespace
                }

                if (!executor->pull(chunk))
-                {
-                    if (check_exit_code)
-                        command->wait();
                    return {};
-                }

                current_read_rows += chunk.getNumRows();
            }
@ -466,6 +462,21 @@ namespace
                    if (thread.joinable())
                        thread.join();

+                if (check_exit_code)
+                {
+                    if (process_pool)
+                    {
+                        bool valid_command
+                            = configuration.read_fixed_number_of_rows && current_read_rows >= configuration.number_of_rows_to_read;
+
+                        // We can only wait for pooled commands when they are invalid.
+                        if (!valid_command)
+                            command->wait();
+                    }
+                    else
+                        command->wait();
+                }
+
                rethrowExceptionDuringSendDataIfNeeded();
            }

--- a/src/Processors/Transforms/DistinctSortedChunkTransform.cpp
+++ b/src/Processors/Transforms/DistinctSortedChunkTransform.cpp
@ -205,6 +205,8 @@ void DistinctSortedChunkTransform::transform(Chunk & chunk)
    if (unlikely(0 == chunk_rows))
        return;

+    convertToFullIfSparse(chunk);
+
    Columns input_columns = chunk.detachColumns();
    /// split input columns into sorted and other("non-sorted") columns
    initChunkProcessing(input_columns);
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@ -1217,10 +1217,10 @@ MergeTreeData::LoadPartResult MergeTreeData::loadDataPart(
        auto part_size_str = res.size_of_part ? formatReadableSizeWithBinarySuffix(*res.size_of_part) : "failed to calculate size";

        LOG_ERROR(log,
-            "Detaching broken part {}{} (size: {}). "
+            "Detaching broken part {} (size: {}). "
            "If it happened after update, it is likely because of backward incompatibility. "
            "You need to resolve this manually",
-            getFullPathOnDisk(part_disk_ptr), part_name, part_size_str);
+            fs::path(getFullPathOnDisk(part_disk_ptr)) / part_name, part_size_str);
    };

    try
--- a/src/Storages/MergeTree/MergeTreePartition.cpp
+++ b/src/Storages/MergeTree/MergeTreePartition.cpp
@ -84,15 +84,7 @@ namespace
        }
        void operator() (const UUID & x) const
        {
-#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-            auto tmp_x = x.toUnderType();
-            char * start = reinterpret_cast<char *>(&tmp_x);
-            char * end = start + sizeof(tmp_x);
-            std::reverse(start, end);
-            operator()(tmp_x);
-#else
            operator()(x.toUnderType());
-#endif
        }
        void operator() (const IPv4 & x) const
        {
--- a/src/Storages/StorageGenerateRandom.cpp
+++ b/src/Storages/StorageGenerateRandom.cpp
@ -360,7 +360,7 @@ ColumnPtr fillColumnWithRandomData(
            auto column = ColumnUUID::create();
            column->getData().resize(limit);
            /// NOTE This is slightly incorrect as random UUIDs should have fixed version 4.
-            fillBufferWithRandomData(reinterpret_cast<char *>(column->getData().data()), limit, sizeof(UUID), rng);
+            fillBufferWithRandomData(reinterpret_cast<char *>(column->getData().data()), limit, sizeof(UUID), rng, true);
            return column;
        }
        case TypeIndex::Int8:
--- a/src/Storages/StorageS3.cpp
+++ b/src/Storages/StorageS3.cpp
@ -527,7 +527,7 @@ StorageS3Source::StorageS3Source(
    const String & bucket_,
    const String & version_id_,
    std::shared_ptr<IIterator> file_iterator_,
-    const size_t download_thread_num_,
+    const size_t max_parsing_threads_,
    std::optional<SelectQueryInfo> query_info_)
    : ISource(info.source_header, false)
    , WithContext(context_)
@ -546,7 +546,7 @@ StorageS3Source::StorageS3Source(
    , query_info(std::move(query_info_))
    , requested_virtual_columns(info.requested_virtual_columns)
    , file_iterator(file_iterator_)
-    , download_thread_num(download_thread_num_)
+    , max_parsing_threads(max_parsing_threads_)
    , create_reader_pool(CurrentMetrics::StorageS3Threads, CurrentMetrics::StorageS3ThreadsActive, 1)
    , create_reader_scheduler(threadPoolCallbackRunner<ReaderHolder>(create_reader_pool, "CreateS3Reader"))
 {
@ -573,9 +573,17 @@ StorageS3Source::ReaderHolder StorageS3Source::createReader()

    auto read_buf = createS3ReadBuffer(key_with_info.key, object_size);
    auto input_format = FormatFactory::instance().getInput(
-            format, *read_buf, sample_block, getContext(), max_block_size,
-            format_settings, std::nullopt, std::nullopt,
-            /* is_remote_fs */ true, compression_method);
+        format,
+        *read_buf,
+        sample_block,
+        getContext(),
+        max_block_size,
+        format_settings,
+        max_parsing_threads,
+        /* max_download_threads= */ std::nullopt,
+        /* is_remote_fs */ true,
+        compression_method);
+
    if (query_info.has_value())
        input_format->setQueryInfo(query_info.value(), getContext());

@ -1035,7 +1043,9 @@ Pipe StorageS3::read(

    auto read_from_format_info = prepareReadingFromFormat(column_names, storage_snapshot, supportsSubsetOfColumns(), getVirtuals());

-    const size_t max_download_threads = local_context->getSettingsRef().max_download_threads;
+    const size_t max_threads = local_context->getSettingsRef().max_threads;
+    const size_t max_parsing_threads = num_streams >= max_threads ? 1 : (max_threads / num_streams);
+
    for (size_t i = 0; i < num_streams; ++i)
    {
        pipes.emplace_back(std::make_shared<StorageS3Source>(
@ -1051,7 +1061,7 @@ Pipe StorageS3::read(
            query_configuration.url.bucket,
            query_configuration.url.version_id,
            iterator_wrapper,
-            max_download_threads,
+            max_parsing_threads,
            query_info));
    }

--- a/src/Storages/StorageS3.h
+++ b/src/Storages/StorageS3.h
@ -130,7 +130,7 @@ public:
        const String & bucket,
        const String & version_id,
        std::shared_ptr<IIterator> file_iterator_,
-        size_t download_thread_num,
+        size_t max_parsing_threads,
        std::optional<SelectQueryInfo> query_info);

    ~StorageS3Source() override;
@ -218,7 +218,7 @@ private:

    NamesAndTypesList requested_virtual_columns;
    std::shared_ptr<IIterator> file_iterator;
-    size_t download_thread_num = 1;
+    size_t max_parsing_threads = 1;

    Poco::Logger * log = &Poco::Logger::get("StorageS3Source");

--- a/src/Storages/StorageURL.cpp
+++ b/src/Storages/StorageURL.cpp
@ -221,7 +221,7 @@ StorageURLSource::StorageURLSource(
    UInt64 max_block_size,
    const ConnectionTimeouts & timeouts,
    CompressionMethod compression_method,
-    size_t download_threads,
+    size_t max_parsing_threads,
    const SelectQueryInfo & query_info,
    const HTTPHeaderEntries & headers_,
    const URIParams & params,
@ -275,7 +275,6 @@ StorageURLSource::StorageURLSource(
            file_progress_callback(FileProgress(0, file_size));
        }

-        // TODO: Pass max_parsing_threads and max_download_threads adjusted for num_streams.
        input_format = FormatFactory::instance().getInput(
            format,
            *read_buf,
@ -283,9 +282,9 @@ StorageURLSource::StorageURLSource(
            context,
            max_block_size,
            format_settings,
-            download_threads,
-            /*max_download_threads*/ std::nullopt,
-            /* is_remote_fs */ true,
+            max_parsing_threads,
+            /* max_download_threads= */ std::nullopt,
+            /* is_remote_fs= */ true,
            compression_method);
        input_format->setQueryInfo(query_info, context);

@ -706,8 +705,6 @@ Pipe IStorageURLBase::read(
 {
    auto params = getReadURIParams(column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size);

-    size_t max_download_threads = local_context->getSettingsRef().max_download_threads;
-
    std::shared_ptr<StorageURLSource::IteratorWrapper> iterator_wrapper{nullptr};
    bool is_url_with_globs = urlWithGlobs(uri);
    size_t max_addresses = local_context->getSettingsRef().glob_expansion_max_elements;
@ -754,7 +751,9 @@ Pipe IStorageURLBase::read(
    Pipes pipes;
    pipes.reserve(num_streams);

-    size_t download_threads = num_streams >= max_download_threads ? 1 : (max_download_threads / num_streams);
+    const size_t max_threads = local_context->getSettingsRef().max_threads;
+    const size_t max_parsing_threads = num_streams >= max_threads ? 1 : (max_threads / num_streams);
+
    for (size_t i = 0; i < num_streams; ++i)
    {
        pipes.emplace_back(std::make_shared<StorageURLSource>(
@ -775,7 +774,7 @@ Pipe IStorageURLBase::read(
            max_block_size,
            getHTTPTimeouts(local_context),
            compression_method,
-            download_threads,
+            max_parsing_threads,
            query_info,
            headers,
            params,
@ -793,7 +792,7 @@ Pipe StorageURLWithFailover::read(
    ContextPtr local_context,
    QueryProcessingStage::Enum processed_stage,
    size_t max_block_size,
-    size_t /*num_streams*/)
+    size_t num_streams)
 {
    auto params = getReadURIParams(column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size);

@ -807,6 +806,9 @@ Pipe StorageURLWithFailover::read(

    auto read_from_format_info = prepareReadingFromFormat(column_names, storage_snapshot, supportsSubsetOfColumns(), getVirtuals());

+    const size_t max_threads = local_context->getSettingsRef().max_threads;
+    const size_t max_parsing_threads = num_streams >= max_threads ? 1 : (max_threads / num_streams);
+
    auto pipe = Pipe(std::make_shared<StorageURLSource>(
        read_from_format_info,
        iterator_wrapper,
@ -819,7 +821,7 @@ Pipe StorageURLWithFailover::read(
        max_block_size,
        getHTTPTimeouts(local_context),
        compression_method,
-        local_context->getSettingsRef().max_download_threads,
+        max_parsing_threads,
        query_info,
        headers,
        params));
--- a/src/Storages/StorageURL.h
+++ b/src/Storages/StorageURL.h
@ -170,7 +170,7 @@ public:
        UInt64 max_block_size,
        const ConnectionTimeouts & timeouts,
        CompressionMethod compression_method,
-        size_t download_threads,
+        size_t max_parsing_threads,
        const SelectQueryInfo & query_info,
        const HTTPHeaderEntries & headers_ = {},
        const URIParams & params = {},
--- a/src/Storages/System/StorageSystemClusters.cpp
+++ b/src/Storages/System/StorageSystemClusters.cpp
@ -32,6 +32,12 @@ NamesAndTypesList StorageSystemClusters::getNamesAndTypes()
    };
 }

+NamesAndAliases StorageSystemClusters::getNamesAndAliases()
+{
+    return {
+        {"name", std::make_shared<DataTypeString>(), "cluster"},
+    };
+}

 void StorageSystemClusters::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
--- a/src/Storages/System/StorageSystemClusters.h
+++ b/src/Storages/System/StorageSystemClusters.h
@ -22,6 +22,8 @@ public:

    static NamesAndTypesList getNamesAndTypes();

+    static NamesAndAliases getNamesAndAliases();
+
 protected:
    using IStorageSystemOneBlock::IStorageSystemOneBlock;
    using NameAndCluster = std::pair<String, std::shared_ptr<Cluster>>;
--- a/src/TableFunctions/CMakeLists.txt
+++ b/src/TableFunctions/CMakeLists.txt
@ -6,16 +6,18 @@ if (TARGET ch_contrib::hivemetastore)
    add_headers_and_sources(clickhouse_table_functions Hive)
 endif ()

-list(REMOVE_ITEM clickhouse_table_functions_sources
+extract_into_parent_list(clickhouse_table_functions_sources dbms_sources
    ITableFunction.cpp
    TableFunctionView.cpp
-    TableFunctionFactory.cpp)
-list(REMOVE_ITEM clickhouse_table_functions_headers
+    TableFunctionFactory.cpp
+)
+extract_into_parent_list(clickhouse_table_functions_headers dbms_headers
    ITableFunction.h
    TableFunctionView.h
-    TableFunctionFactory.h)
+    TableFunctionFactory.h
+)

-add_library(clickhouse_table_functions ${clickhouse_table_functions_sources})
+add_library(clickhouse_table_functions ${clickhouse_table_functions_headers} ${clickhouse_table_functions_sources})

 target_link_libraries(clickhouse_table_functions PRIVATE clickhouse_parsers clickhouse_storages_system dbms)

--- a/tests/clickhouse-test
+++ b/tests/clickhouse-test
@ -1467,7 +1467,7 @@ class TestSuite:
            else:
                raise Exception(f"Unknown file_extension: {filename}")

-        def parse_tags_from_line(line, comment_sign) -> set[str]:
+        def parse_tags_from_line(line, comment_sign) -> Set[str]:
            if not line.startswith(comment_sign):
                return set()
            tags_str = line[len(comment_sign) :].lstrip()  # noqa: ignore E203
--- a/tests/config/config.d/filesystem_caches_path.xml
+++ b/tests/config/config.d/filesystem_caches_path.xml
@ -0,0 +1,3 @@
+<clickhouse>
+    <filesystem_caches_path>/var/lib/clickhouse/filesystem_caches/</filesystem_caches_path>
+</clickhouse>
--- a/tests/config/config.d/storage_conf.xml
+++ b/tests/config/config.d/storage_conf.xml
@ -1,5 +1,4 @@
 <clickhouse>
-    <filesystem_caches_path>/var/lib/clickhouse/filesystem_caches/</filesystem_caches_path>
    <storage_configuration>
        <disks>
            <s3_disk>
--- a/tests/config/install.sh
+++ b/tests/config/install.sh
@ -60,6 +60,7 @@ ln -sf $SRC_PATH/config.d/compressed_marks_and_index.xml $DEST_SERVER_PATH/confi
 ln -sf $SRC_PATH/config.d/disable_s3_env_credentials.xml $DEST_SERVER_PATH/config.d/
 ln -sf $SRC_PATH/config.d/enable_wait_for_shutdown_replicated_tables.xml $DEST_SERVER_PATH/config.d/
 ln -sf $SRC_PATH/config.d/backups.xml $DEST_SERVER_PATH/config.d/
+ln -sf $SRC_PATH/config.d/filesystem_caches_path.xml $DEST_SERVER_PATH/config.d/

 # Not supported with fasttest.
 if [ "${DEST_SERVER_PATH}" = "/etc/clickhouse-server" ]
--- a/tests/integration/helpers/client.py
+++ b/tests/integration/helpers/client.py
@ -144,6 +144,7 @@ class Client:
        user=None,
        password=None,
        database=None,
+        query_id=None,
    ):
        return self.get_query_request(
            sql,
@ -153,6 +154,7 @@ class Client:
            user=user,
            password=password,
            database=database,
+            query_id=query_id,
        ).get_answer_and_error()


--- a/tests/integration/helpers/cluster.py
+++ b/tests/integration/helpers/cluster.py
@ -3476,6 +3476,7 @@ class ClickHouseInstance:
        user=None,
        password=None,
        database=None,
+        query_id=None,
    ):
        logging.debug(f"Executing query {sql} on {self.name}")
        return self.client.query_and_get_answer_with_error(
@ -3486,6 +3487,7 @@ class ClickHouseInstance:
            user=user,
            password=password,
            database=database,
+            query_id=query_id,
        )

    # Connects to the instance via HTTP interface, sends a query and returns the answer
--- a/tests/integration/test_mysql_protocol/test.py
+++ b/tests/integration/test_mysql_protocol/test.py
@ -371,6 +371,22 @@ def test_mysql_replacement_query(started_cluster):
        "database()\ndefault\n",
    ]

+    # SELECT SCHEMA().
+    code, (stdout, stderr) = started_cluster.mysql_client_container.exec_run(
+        """
+        mysql --protocol tcp -h {host} -P {port} default -u default
+        --password=123 -e "select schema();"
+    """.format(
+            host=started_cluster.get_instance_ip("node"), port=server_port
+        ),
+        demux=True,
+    )
+    assert code == 0
+    assert stdout.decode().lower() in [
+        "currentdatabase()\ndefault\n",
+        "schema()\ndefault\n",
+    ]
+
    code, (stdout, stderr) = started_cluster.mysql_client_container.exec_run(
        """
        mysql --protocol tcp -h {host} -P {port} default -u default
--- a/tests/integration/test_shutdown_wait_unfinished_queries/test.py
+++ b/tests/integration/test_shutdown_wait_unfinished_queries/test.py
@ -2,7 +2,9 @@ import pytest

 import threading
 import time
+import uuid
 from helpers.cluster import ClickHouseCluster
+from helpers.test_tools import assert_eq_with_retry

 cluster = ClickHouseCluster(__file__)
 node_wait_queries = cluster.add_instance(
@ -30,32 +32,55 @@ def start_cluster():
        cluster.shutdown()


-def do_long_query(node):
+def do_long_query(node, query_id):
    global result

    result = node.query_and_get_answer_with_error(
        "SELECT sleepEachRow(1) FROM system.numbers LIMIT 10",
        settings={"send_logs_level": "trace"},
+        query_id=query_id,
    )


 def test_shutdown_wait_unfinished_queries(start_cluster):
    global result

-    long_query = threading.Thread(target=do_long_query, args=(node_wait_queries,))
+    query_id = uuid.uuid4().hex
+    long_query = threading.Thread(
+        target=do_long_query,
+        args=(
+            node_wait_queries,
+            query_id,
+        ),
+    )
    long_query.start()

-    time.sleep(1)
+    assert_eq_with_retry(
+        node_wait_queries,
+        f"SELECT query_id FROM system.processes WHERE query_id = '{query_id}'",
+        query_id,
+    )
    node_wait_queries.stop_clickhouse(kill=False)

    long_query.join()

    assert result[0].count("0") == 10

-    long_query = threading.Thread(target=do_long_query, args=(node_kill_queries,))
+    query_id = uuid.uuid4().hex
+    long_query = threading.Thread(
+        target=do_long_query,
+        args=(
+            node_kill_queries,
+            query_id,
+        ),
+    )
    long_query.start()

-    time.sleep(1)
+    assert_eq_with_retry(
+        node_kill_queries,
+        f"SELECT query_id FROM system.processes WHERE query_id = '{query_id}'",
+        query_id,
+    )
    node_kill_queries.stop_clickhouse(kill=False)

    long_query.join()
--- a/tests/integration/test_ssl_cert_authentication/test.py
+++ b/tests/integration/test_ssl_cert_authentication/test.py
@ -160,6 +160,10 @@ def get_ssl_context(cert_name):
        )
        context.verify_mode = ssl.CERT_REQUIRED
    context.check_hostname = True
+    # Python 3.10 has removed many ciphers from the cipher suite.
+    # Hence based on https://github.com/urllib3/urllib3/issues/3100#issuecomment-1671106236
+    # we are expanding the list of cipher suites.
+    context.set_ciphers("DEFAULT")
    return context


--- a/tests/performance/encrypt_decrypt_empty_string_slow.xml
+++ b/tests/performance/encrypt_decrypt_empty_string_slow.xml
@ -1,55 +0,0 @@
-<test>
-  <!-- "Strict" mode (key and iv length checks), empty plaintext.
-  Ciphers that produce non-empty ciphertext on empty plaintext, and hence can't be optimized.-->
-
-    <substitutions>
-        <substitution>
-          <name>func</name>
-          <values>
-              <!-- materialize(plaitext) is to avoid all-args-are-const optimization, resulting in executing function exactly once. -->
-              <value>encrypt('aes-128-cbc', materialize(plaintext), key16, iv16)</value>
-              <value>encrypt('aes-128-ecb', materialize(plaintext), key16)</value>
-              <value>encrypt('aes-128-gcm', materialize(plaintext), key16, iv12, 'aadaadaadaad')</value>
-
-              <value>encrypt('aes-192-cbc', materialize(plaintext), key24, iv16)</value>
-              <value>encrypt('aes-192-ecb', materialize(plaintext), key24)</value>
-              <value>encrypt('aes-192-gcm', materialize(plaintext), key24, iv12, 'aadaadaadaad')</value>
-
-              <value>encrypt('aes-256-cbc', materialize(plaintext), key32, iv16)</value>
-              <value>encrypt('aes-256-ecb', materialize(plaintext), key32)</value>
-              <value>encrypt('aes-256-gcm', materialize(plaintext), key32, iv12, 'aadaadaadaad')</value>
-
-              <!-- decrypt + encrypt since it is really hard to compose decrypt-only case -->
-              <value>decrypt('aes-128-cbc', encrypt('aes-128-cbc', materialize(plaintext), key16, iv16), key16, iv16)</value>
-              <value>decrypt('aes-128-ecb', encrypt('aes-128-ecb', materialize(plaintext), key16), key16)</value>
-              <value>decrypt('aes-128-gcm', encrypt('aes-128-gcm', materialize(plaintext), key16, iv12, 'aadaadaadaad'), key16, iv12, 'aadaadaadaad')</value>
-
-              <value>decrypt('aes-192-cbc', encrypt('aes-192-cbc', materialize(plaintext), key24, iv16), key24, iv16)</value>
-              <value>decrypt('aes-192-ecb', encrypt('aes-192-ecb', materialize(plaintext), key24), key24)</value>
-              <value>decrypt('aes-192-gcm', encrypt('aes-192-gcm', materialize(plaintext), key24, iv12, 'aadaadaadaad'), key24, iv12, 'aadaadaadaad')</value>
-
-              <value>decrypt('aes-256-cbc', encrypt('aes-256-cbc', materialize(plaintext), key32, iv16), key32, iv16)</value>
-              <value>decrypt('aes-256-ecb', encrypt('aes-256-ecb', materialize(plaintext), key32), key32)</value>
-              <value>decrypt('aes-256-gcm', encrypt('aes-256-gcm', materialize(plaintext), key32, iv12, 'aadaadaadaad'), key32, iv12, 'aadaadaadaad')</value>
-
-           </values>
-        </substitution>
-        <substitution>
-           <name>table</name>
-           <values>
-               <value>numbers(2000000)</value>
-           </values>
-        </substitution>
-        <substitution>
-           <name>plaintext</name>
-           <values>
-              <value>''</value>
-           </values>
-        </substitution>
-    </substitutions>
-
-    <!-- allow OpenSSL-related code load ciphers and warm-up -->
-    <fill_query>WITH {plaintext} as plaintext, repeat('k', 32) as key32, substring(key32, 1, 24) as key24, substring(key32, 1, 16) as key16, repeat('iv', 8) as iv16, substring(iv16, 1, 12) as iv12 SELECT count() FROM {table} WHERE NOT ignore({func}) LIMIT 1</fill_query>
-
-    <query>WITH {plaintext} as plaintext, repeat('k', 32) as key32, substring(key32, 1, 24) as key24, substring(key32, 1, 16) as key16, repeat('iv', 8) as iv16, substring(iv16, 1, 12) as iv12 SELECT count() FROM {table} WHERE NOT ignore({func})</query>
-</test>
--- a/tests/queries/0_stateless/00304_http_external_data.sh
+++ b/tests/queries/0_stateless/00304_http_external_data.sh
@ -6,10 +6,4 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)

 echo -ne '1,Hello\n2,World\n' | ${CLICKHOUSE_CURL} -sSF 'file=@-' "${CLICKHOUSE_URL}&query=SELECT+*+FROM+file&file_format=CSV&file_types=UInt8,String";
 echo -ne '1@Hello\n2@World\n' | ${CLICKHOUSE_CURL} -sSF 'file=@-' "${CLICKHOUSE_URL}&query=SELECT+*+FROM+file&file_format=CSV&file_types=UInt8,String&format_csv_delimiter=@";
-
-# use big-endian version of binary data for s390x
-if [[ $(uname -a | grep s390x) ]]; then
-    echo -ne '\x00\x00\x00\x01\x00\x00\x00\x02' | ${CLICKHOUSE_CURL} -sSF "tmp=@-" "${CLICKHOUSE_URL}&query=SELECT+*+FROM+tmp&tmp_structure=TaskID+UInt32&tmp_format=RowBinary";
-else
-    echo -ne '\x01\x00\x00\x00\x02\x00\x00\x00' | ${CLICKHOUSE_CURL} -sSF "tmp=@-" "${CLICKHOUSE_URL}&query=SELECT+*+FROM+tmp&tmp_structure=TaskID+UInt32&tmp_format=RowBinary";
-fi
+echo -ne '\x01\x00\x00\x00\x02\x00\x00\x00' | ${CLICKHOUSE_CURL} -sSF "tmp=@-" "${CLICKHOUSE_URL}&query=SELECT+*+FROM+tmp&tmp_structure=TaskID+UInt32&tmp_format=RowBinary";
--- a/tests/queries/0_stateless/01472_obfuscator_uuid.sh
+++ b/tests/queries/0_stateless/01472_obfuscator_uuid.sh
@ -4,9 +4,10 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 # shellcheck source=../shell_config.sh
 . "$CURDIR"/../shell_config.sh

+$CLICKHOUSE_CLIENT --query="DROP TABLE IF EXISTS t_uuid"
 $CLICKHOUSE_CLIENT --query="CREATE TABLE t_uuid(Id UUID) ENGINE=MergeTree ORDER BY (Id)"
 $CLICKHOUSE_CLIENT --query="INSERT INTO t_uuid VALUES ('3f5ffba3-19ff-4f3d-8861-60ae6e1fc1aa'),('4bd62524-e33c-43e5-882d-f1d96cf5561e'),('7a8b45d2-c18b-4e8c-89eb-abf5bee88931'),('45bb7333-965b-4526-870e-4f941edb025b'),('a4e72d0e-f9fa-465e-8d9d-151b9ced94df'),('cb5818ab-83b5-48a8-94b0-5177e30176d9'),('701e8006-fc9f-4496-80ba-efa6817b917b'),('e0936acf-6e8f-42aa-8f56-d1363476eece'),('239bb790-5293-40df-92ae-472294b6e178'),('508d0e80-729f-4e3b-9336-4c5c8792f6be'),('94abef70-f2d6-4f7b-ad60-3889409f1dac'),('b6f1ec08-8473-4fa2-b134-73db040b0d82'),('7e54dcae-0bb4-4c4f-a636-54a705fb8b40'),('d1d258c2-a35f-4c00-abfa-8addbcbc5471'),('7c74fbd8-bf79-46ee-adfe-96271040a4f7'),('41e3a274-eea9-41d8-a128-de5a6658fcfd'),('a72dc048-f72f-470e-b0f9-60cfad6e1157'),('40634f4f-37bf-44e4-ac7c-6f024ad19990')"
-$CLICKHOUSE_CLIENT --query="SELECT Id FROM t_uuid FORMAT TSV" > "${CLICKHOUSE_TMP}"/data.tsv
+$CLICKHOUSE_CLIENT --query="SELECT Id FROM t_uuid ORDER BY (Id) FORMAT TSV" > "${CLICKHOUSE_TMP}"/data.tsv

 echo FROM RAW DATA && cat "${CLICKHOUSE_TMP}"/data.tsv
 echo TRANSFORMED TO && $CLICKHOUSE_OBFUSCATOR --structure "Id UUID" --input-format TSV --output-format TSV --seed dsrub < "${CLICKHOUSE_TMP}"/data.tsv 2>/dev/null
--- a/tests/queries/0_stateless/01705_normalize_case_insensitive_function_names.reference
+++ b/tests/queries/0_stateless/01705_normalize_case_insensitive_function_names.reference
@ -13,6 +13,7 @@ SELECT
    covarPop(1, 1),
    covarSamp(1, 1),
    currentDatabase(),
+    currentDatabase(),
    dateDiff('DAY', toDate('2020-10-24'), toDate('2019-10-24')),
    exp(1),
    arrayFlatten([[1]]),
--- a/tests/queries/0_stateless/01705_normalize_case_insensitive_function_names.sql
+++ b/tests/queries/0_stateless/01705_normalize_case_insensitive_function_names.sql
@ -1 +1 @@
-EXPLAIN SYNTAX SELECT CAST(1 AS INT), CEIL(1), CEILING(1), CHAR(49), CHAR_LENGTH('1'), CHARACTER_LENGTH('1'), COALESCE(1), CONCAT('1', '1'), CORR(1, 1), COS(1), COUNT(1), COVAR_POP(1, 1), COVAR_SAMP(1, 1), DATABASE(), DATEDIFF('DAY', toDate('2020-10-24'), toDate('2019-10-24')), EXP(1), FLATTEN([[1]]), FLOOR(1), FQDN(), GREATEST(1), IF(1, 1, 1), IFNULL(1, 1), LCASE('A'), LEAST(1), LENGTH('1'), LN(1), LOCATE('1', '1'), LOG(1), LOG10(1), LOG2(1), LOWER('A'), MAX(1), MID('123', 1, 1), MIN(1), MOD(1, 1), NOT(1), NOW(), NOW64(), NULLIF(1, 1), PI(), POSITION('123', '2'), POW(1, 1), POWER(1, 1), RAND(), REPLACE('1', '1', '2'), REVERSE('123'), ROUND(1), SIN(1), SQRT(1), STDDEV_POP(1), STDDEV_SAMP(1), SUBSTR('123', 2), SUBSTRING('123', 2), SUM(1), TAN(1), TANH(1), TRUNC(1), TRUNCATE(1), UCASE('A'), UPPER('A'), USER(), VAR_POP(1), VAR_SAMP(1), WEEK(toDate('2020-10-24')), YEARWEEK(toDate('2020-10-24')) format TSVRaw;
+EXPLAIN SYNTAX SELECT CAST(1 AS INT), CEIL(1), CEILING(1), CHAR(49), CHAR_LENGTH('1'), CHARACTER_LENGTH('1'), COALESCE(1), CONCAT('1', '1'), CORR(1, 1), COS(1), COUNT(1), COVAR_POP(1, 1), COVAR_SAMP(1, 1), DATABASE(), SCHEMA(), DATEDIFF('DAY', toDate('2020-10-24'), toDate('2019-10-24')), EXP(1), FLATTEN([[1]]), FLOOR(1), FQDN(), GREATEST(1), IF(1, 1, 1), IFNULL(1, 1), LCASE('A'), LEAST(1), LENGTH('1'), LN(1), LOCATE('1', '1'), LOG(1), LOG10(1), LOG2(1), LOWER('A'), MAX(1), MID('123', 1, 1), MIN(1), MOD(1, 1), NOT(1), NOW(), NOW64(), NULLIF(1, 1), PI(), POSITION('123', '2'), POW(1, 1), POWER(1, 1), RAND(), REPLACE('1', '1', '2'), REVERSE('123'), ROUND(1), SIN(1), SQRT(1), STDDEV_POP(1), STDDEV_SAMP(1), SUBSTR('123', 2), SUBSTRING('123', 2), SUM(1), TAN(1), TANH(1), TRUNC(1), TRUNCATE(1), UCASE('A'), UPPER('A'), USER(), VAR_POP(1), VAR_SAMP(1), WEEK(toDate('2020-10-24')), YEARWEEK(toDate('2020-10-24')) format TSVRaw;
--- a/tests/queries/0_stateless/02117_show_create_table_system.reference
+++ b/tests/queries/0_stateless/02117_show_create_table_system.reference
@ -50,7 +50,8 @@ CREATE TABLE system.clusters
    `estimated_recovery_time` UInt32,
    `database_shard_name` String,
    `database_replica_name` String,
-    `is_active` Nullable(UInt8)
+    `is_active` Nullable(UInt8),
+    `name` String
 )
 ENGINE = SystemClusters
 COMMENT 'SYSTEM TABLE is built on the fly.'
--- a/tests/queries/0_stateless/02354_distributed_with_external_aggregation_memory_usage.sql
+++ b/tests/queries/0_stateless/02354_distributed_with_external_aggregation_memory_usage.sql
@ -16,13 +16,13 @@ set max_bytes_before_external_group_by = '2G',
    max_block_size = 65505;

 -- whole aggregation state of local aggregation uncompressed is 5.8G
-- it is hard to provide an accurate estimation for memory usage, so 4G is just the actual value taken from the logs + delta
+-- it is hard to provide an accurate estimation for memory usage, so 5G is just the actual value taken from the logs + delta
 -- also avoid using localhost, so the queries will go over separate connections
 -- (otherwise the memory usage for merge will be counted together with the localhost query)
 select a, b, c, sum(a) as s
 from remote('127.0.0.{2,3}', currentDatabase(), t_2354_dist_with_external_aggr)
 group by a, b, c
 format Null
-settings max_memory_usage = '4Gi';
+settings max_memory_usage = '5Gi';

 DROP TABLE t_2354_dist_with_external_aggr;
--- a/tests/queries/0_stateless/02784_projections_read_in_order_bug.sql
+++ b/tests/queries/0_stateless/02784_projections_read_in_order_bug.sql
@ -1,3 +1,5 @@
+DROP TABLE IF EXISTS events;
+
 create table events (
    `organisation_id` UUID,
    `session_id` UUID,
--- a/tests/queries/0_stateless/02861_uuid_format_serialization.reference
+++ b/tests/queries/0_stateless/02861_uuid_format_serialization.reference
--- a/tests/queries/0_stateless/02861_uuid_format_serialization.sql
+++ b/tests/queries/0_stateless/02861_uuid_format_serialization.sql
@ -0,0 +1,9 @@
+DROP TABLE IF EXISTS t_uuid;
+CREATE TABLE t_uuid (x UUID) ENGINE=MergeTree ORDER BY x;
+
+INSERT INTO t_uuid VALUES ('61f0c404-5cb3-11e7-907b-a6006ad3dba0'), ('992f6910-42b2-43cd-98bc-c812fbf9b683'), ('417ddc5d-e556-4d27-95dd-a34d84e46a50');
+
+SELECT * FROM t_uuid ORDER BY x LIMIT 1 FORMAT RowBinary;
+SELECT * FROM t_uuid ORDER BY x FORMAT RowBinary;
+
+DROP TABLE IF EXISTS t_uuid;
--- a/tests/queries/0_stateless/02862_sorted_distinct_sparse_fix.reference
+++ b/tests/queries/0_stateless/02862_sorted_distinct_sparse_fix.reference
@ -0,0 +1,12 @@
+-- { echoOn }
+SELECT name, column, serialization_kind
+FROM system.parts_columns
+WHERE table = 't_sparse_distinct' AND database = currentDatabase() AND column = 'v'
+ORDER BY name;
+all_1_1_0	v	Default
+all_2_2_0	v	Sparse
+set optimize_distinct_in_order=1;
+set max_threads=1;
+select trimLeft(explain) from (explain pipeline SELECT DISTINCT id, v FROM t_sparse_distinct) where explain ilike '%DistinctSortedChunkTransform%';
+DistinctSortedChunkTransform
+SELECT DISTINCT id, v FROM t_sparse_distinct format Null;
--- a/tests/queries/0_stateless/02862_sorted_distinct_sparse_fix.sql
+++ b/tests/queries/0_stateless/02862_sorted_distinct_sparse_fix.sql
@ -0,0 +1,25 @@
+DROP TABLE IF EXISTS t_sparse_distinct;
+
+CREATE TABLE t_sparse_distinct (id UInt32, v String)
+ENGINE = MergeTree
+ORDER BY id
+SETTINGS ratio_of_defaults_for_sparse_serialization = 0.9;
+
+SYSTEM STOP MERGES t_sparse_distinct;
+
+INSERT INTO t_sparse_distinct SELECT number % 10, toString(number % 100 = 0) FROM numbers(100);
+INSERT INTO t_sparse_distinct(id) SELECT number % 10 FROM numbers(100);
+
+-- { echoOn }
+SELECT name, column, serialization_kind
+FROM system.parts_columns
+WHERE table = 't_sparse_distinct' AND database = currentDatabase() AND column = 'v'
+ORDER BY name;
+
+set optimize_distinct_in_order=1;
+set max_threads=1;
+
+select trimLeft(explain) from (explain pipeline SELECT DISTINCT id, v FROM t_sparse_distinct) where explain ilike '%DistinctSortedChunkTransform%';
+SELECT DISTINCT id, v FROM t_sparse_distinct format Null;
+
+DROP TABLE t_sparse_distinct;
--- a/tests/queries/0_stateless/02862_uuid_reinterpret_as_numeric.reference
+++ b/tests/queries/0_stateless/02862_uuid_reinterpret_as_numeric.reference
@ -0,0 +1,5 @@
+61f0c404-5cb3-11e7-907b-a6006ad3dba0
+403229640000000000	6.034192082918747e163
+-25	4583	1555239399	7057356139103719911	-148231516101255056243829344033567469081	192050850819683407219545263398200742375
+231	4583	1555239399	7057356139103719911	192050850819683407219545263398200742375	192050850819683407219545263398200742375
+00000000-5cb3-11e7-0000-000000000000
--- a/tests/queries/0_stateless/02862_uuid_reinterpret_as_numeric.sql
+++ b/tests/queries/0_stateless/02862_uuid_reinterpret_as_numeric.sql
@ -0,0 +1,13 @@
+DROP TABLE IF EXISTS t_uuid;
+CREATE TABLE t_uuid (x UUID) ENGINE=MergeTree ORDER BY x;
+
+INSERT INTO t_uuid VALUES ('61f0c404-5cb3-11e7-907b-a6006ad3dba0');
+
+SELECT reinterpretAsUUID(x) FROM t_uuid;
+SELECT reinterpretAsFloat32(x), reinterpretAsFloat64(x) FROM t_uuid;
+SELECT reinterpretAsInt8(x), reinterpretAsInt16(x), reinterpretAsInt32(x), reinterpretAsInt64(x), reinterpretAsInt128(x), reinterpretAsInt256(x) FROM t_uuid;
+SELECT reinterpretAsUInt8(x), reinterpretAsUInt16(x), reinterpretAsUInt32(x), reinterpretAsUInt64(x), reinterpretAsUInt128(x), reinterpretAsUInt256(x) FROM t_uuid;
+
+SELECT reinterpretAsUUID(reinterpretAsUInt128(reinterpretAsUInt32(reinterpretAsUInt256(x)))) FROM t_uuid;
+
+DROP TABLE IF EXISTS t_uuid;
--- a/tests/queries/0_stateless/02863_delayed_source_with_totals_and_extremes.reference
+++ b/tests/queries/0_stateless/02863_delayed_source_with_totals_and_extremes.reference
@ -0,0 +1,7 @@
+3
+
+3
+
+3
+3
+1
--- a/tests/queries/0_stateless/02863_delayed_source_with_totals_and_extremes.sql
+++ b/tests/queries/0_stateless/02863_delayed_source_with_totals_and_extremes.sql
@ -0,0 +1,16 @@
+-- Tags: no-parallel
+-- Tag no-parallel: failpoint is used which can force DelayedSource on other tests
+
+DROP TABLE IF EXISTS 02863_delayed_source;
+
+CREATE TABLE 02863_delayed_source(a Int64) ENGINE = ReplicatedMergeTree('/clickhouse/tables/{database}/02863_delayed_source/{replica}', 'r1') ORDER BY a;
+INSERT INTO 02863_delayed_source VALUES (1), (2);
+
+SYSTEM ENABLE FAILPOINT use_delayed_remote_source;
+
+SELECT sum(a) FROM remote('127.0.0.4', currentDatabase(), '02863_delayed_source') WITH TOTALS SETTINGS extremes = 1;
+SELECT max(explain like '%Delayed%') FROM (EXPLAIN PIPELINE graph=1 SELECT sum(a) FROM remote('127.0.0.4', currentDatabase(), '02863_delayed_source') WITH TOTALS SETTINGS extremes = 1);
+
+SYSTEM DISABLE FAILPOINT use_delayed_remote_source;
+
+DROP TABLE 02863_delayed_source;
--- a/Show More
+++ b/Show More