Merge branch 'master' into hanfei/stats_uniq

2024-11-23 16:12:01 +00:00 · 2024-04-09 12:15:31 +02:00 · 2024-04-09 12:15:31 +02:00 · e5aa439ca0
commit e5aa439ca0
parent 1979ea5e8f f3e1132136
312 changed files with 2090 additions and 893 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@ -96,7 +96,6 @@ Checks: [
  '-modernize-use-default-member-init',
  '-modernize-use-emplace',
  '-modernize-use-nodiscard',
-  '-modernize-use-override',
  '-modernize-use-trailing-return-type',

  '-performance-inefficient-string-concatenation',
--- a/base/base/wide_integer_impl.h
+++ b/base/base/wide_integer_impl.h
@ -13,8 +13,6 @@
 #include <tuple>
 #include <limits>

-#include <boost/math/special_functions/fpclassify.hpp>
-
 // NOLINTBEGIN(*)

 /// Use same extended double for all platforms
@ -22,6 +20,7 @@
 #define CONSTEXPR_FROM_DOUBLE constexpr
 using FromDoubleIntermediateType = long double;
 #else
+#include <boost/math/special_functions/fpclassify.hpp>
 #include <boost/multiprecision/cpp_bin_float.hpp>
 /// `wide_integer_from_builtin` can't be constexpr with non-literal `cpp_bin_float_double_extended`
 #define CONSTEXPR_FROM_DOUBLE
@ -309,6 +308,13 @@ struct integer<Bits, Signed>::_impl
        constexpr uint64_t max_int = std::numeric_limits<uint64_t>::max();
        static_assert(std::is_same_v<T, double> || std::is_same_v<T, FromDoubleIntermediateType>);
        /// Implementation specific behaviour on overflow (if we don't check here, stack overflow will triggered in bigint_cast).
+#if (LDBL_MANT_DIG == 64)
+        if (!std::isfinite(t))
+        {
+            self = 0;
+            return;
+        }
+#else
        if constexpr (std::is_same_v<T, double>)
        {
            if (!std::isfinite(t))
@ -325,6 +331,7 @@ struct integer<Bits, Signed>::_impl
                return;
            }
        }
+#endif

        const T alpha = t / static_cast<T>(max_int);

--- a/contrib/NuRaft
+++ b/contrib/NuRaft
@ -1 +1 @@
-Subproject commit 08ac76ea80a37f89b12109c805eafe9f1dc9b991
+Subproject commit cb5dc3c906e80f253e9ce9535807caef827cc2e0
--- a/contrib/nuraft-cmake/CMakeLists.txt
+++ b/contrib/nuraft-cmake/CMakeLists.txt
@ -51,6 +51,12 @@ else()
    target_compile_definitions(_nuraft PRIVATE USE_BOOST_ASIO=1 BOOST_ASIO_STANDALONE=1)
 endif()

+target_link_libraries (_nuraft PRIVATE clickhouse_common_io)
+# We must have it PUBLIC here because some headers which depend on it directly
+# included in clickhouse
+target_compile_definitions(_nuraft PUBLIC USE_CLICKHOUSE_THREADS=1)
+MESSAGE(STATUS "Will use clickhouse threads for NuRaft")
+
 target_include_directories (_nuraft SYSTEM PRIVATE "${LIBRARY_DIR}/include/libnuraft")
 # for some reason include "asio.h" directly without "boost/" prefix.
 target_include_directories (_nuraft SYSTEM PRIVATE "${ClickHouse_SOURCE_DIR}/contrib/boost/boost")
--- a/docker/test/stateless/run.sh
+++ b/docker/test/stateless/run.sh
@ -16,6 +16,8 @@ ln -snf "/usr/share/zoneinfo/$TZ" /etc/localtime && echo "$TZ" > /etc/timezone

 dpkg -i package_folder/clickhouse-common-static_*.deb
 dpkg -i package_folder/clickhouse-common-static-dbg_*.deb
+dpkg -i package_folder/clickhouse-odbc-bridge_*.deb
+dpkg -i package_folder/clickhouse-library-bridge_*.deb
 dpkg -i package_folder/clickhouse-server_*.deb
 dpkg -i package_folder/clickhouse-client_*.deb

--- a/docs/en/interfaces/formats.md
+++ b/docs/en/interfaces/formats.md
@ -79,7 +79,7 @@ The supported formats are:
 | [RowBinary](#rowbinary)                                                                   | ✔    | ✔     |
 | [RowBinaryWithNames](#rowbinarywithnamesandtypes)                                         | ✔    | ✔     |
 | [RowBinaryWithNamesAndTypes](#rowbinarywithnamesandtypes)                                 | ✔    | ✔     |
-| [RowBinaryWithDefaults](#rowbinarywithdefaults)                                           | ✔    | ✔     |
+| [RowBinaryWithDefaults](#rowbinarywithdefaults)                                           | ✔    | ✗     |
 | [Native](#native)                                                                         | ✔    | ✔     |
 | [Null](#null)                                                                             | ✗    | ✔     |
 | [XML](#xml)                                                                               | ✗    | ✔     |
@ -1487,7 +1487,7 @@ Differs from [PrettySpaceNoEscapes](#prettyspacenoescapes) in that up to 10,000
 - [output_format_pretty_max_value_width](/docs/en/operations/settings/settings-formats.md/#output_format_pretty_max_value_width) - Maximum width of value to display in Pretty formats. If greater - it will be cut. Default value - `10000`.
 - [output_format_pretty_color](/docs/en/operations/settings/settings-formats.md/#output_format_pretty_color) - use ANSI escape sequences to paint colors in Pretty formats. Default value - `true`.
 - [output_format_pretty_grid_charset](/docs/en/operations/settings/settings-formats.md/#output_format_pretty_grid_charset) - Charset for printing grid borders. Available charsets: ASCII, UTF-8. Default value - `UTF-8`.
- [output_format_pretty_row_numbers](/docs/en/operations/settings/settings-formats.md/#output_format_pretty_row_numbers) - Add row numbers before each row for pretty output format. Default value - `false`.
+- [output_format_pretty_row_numbers](/docs/en/operations/settings/settings-formats.md/#output_format_pretty_row_numbers) - Add row numbers before each row for pretty output format. Default value - `true`.

 ## RowBinary {#rowbinary}

@ -2465,7 +2465,7 @@ Result:

 ## Npy {#data-format-npy}

-This function is designed to load a NumPy array from a .npy file into ClickHouse. The NumPy file format is a binary format used for efficiently storing arrays of numerical data. During import, ClickHouse treats top level dimension as an array of rows with single column. Supported Npy data types and their corresponding type in ClickHouse: 
+This function is designed to load a NumPy array from a .npy file into ClickHouse. The NumPy file format is a binary format used for efficiently storing arrays of numerical data. During import, ClickHouse treats top level dimension as an array of rows with single column. Supported Npy data types and their corresponding type in ClickHouse:
 | Npy type | ClickHouse type |
 |:--------:|:---------------:|
 | b1       |    UInt8        |
--- a/docs/en/interfaces/http.md
+++ b/docs/en/interfaces/http.md
@ -507,16 +507,18 @@ Example:
 ``` xml
 <http_handlers>
    <rule>
-        <url><![CDATA[/query_param_with_url/\w+/(?P<name_1>[^/]+)(/(?P<name_2>[^/]+))?]]></url>
+        <url><![CDATA[regex:/query_param_with_url/(?P<name_1>[^/]+)]]></url>
        <methods>GET</methods>
        <headers>
            <XXX>TEST_HEADER_VALUE</XXX>
-            <PARAMS_XXX><![CDATA[(?P<name_1>[^/]+)(/(?P<name_2>[^/]+))?]]></PARAMS_XXX>
+            <PARAMS_XXX><![CDATA[regex:(?P<name_2>[^/]+)]]></PARAMS_XXX>
        </headers>
        <handler>
            <type>predefined_query_handler</type>
-            <query>SELECT value FROM system.settings WHERE name = {name_1:String}</query>
-            <query>SELECT name, value FROM system.settings WHERE name = {name_2:String}</query>
+            <query>
+                SELECT name, value FROM system.settings
+                WHERE name IN ({name_1:String}, {name_2:String})
+            </query>
        </handler>
    </rule>
    <defaults/>
@ -524,13 +526,13 @@ Example:
 ```

 ``` bash
-$ curl -H 'XXX:TEST_HEADER_VALUE' -H 'PARAMS_XXX:max_threads' 'http://localhost:8123/query_param_with_url/1/max_threads/max_final_threads?max_threads=1&max_final_threads=2'
-1
-max_final_threads   2
+$ curl -H 'XXX:TEST_HEADER_VALUE' -H 'PARAMS_XXX:max_final_threads' 'http://localhost:8123/query_param_with_url/max_threads?max_threads=1&max_final_threads=2'
+max_final_threads	2
+max_threads	1
 ```

 :::note
-In one `predefined_query_handler` only supports one `query` of an insert type.
+In one `predefined_query_handler` only one `query` is supported.
 :::

 ### dynamic_query_handler {#dynamic_query_handler}
--- a/docs/en/operations/server-configuration-parameters/settings.md
+++ b/docs/en/operations/server-configuration-parameters/settings.md
@ -436,7 +436,7 @@ Default: 0
 Restriction on dropping partitions.

 If the size of a [MergeTree](../../engines/table-engines/mergetree-family/mergetree.md) table exceeds `max_partition_size_to_drop` (in bytes), you can’t drop a partition using a [DROP PARTITION](../../sql-reference/statements/alter/partition.md#drop-partitionpart) query.
-This setting does not require a restart of the Clickhouse server to apply. Another way to disable the restriction is to create the `<clickhouse-path>/flags/force_drop_table` file.
+This setting does not require a restart of the ClickHouse server to apply. Another way to disable the restriction is to create the `<clickhouse-path>/flags/force_drop_table` file.
 Default value: 50 GB.
 The value 0 means that you can drop partitions without any restrictions.

@ -518,7 +518,7 @@ Restriction on deleting tables.

 If the size of a [MergeTree](../../engines/table-engines/mergetree-family/mergetree.md) table exceeds `max_table_size_to_drop` (in bytes), you can’t delete it using a [DROP](../../sql-reference/statements/drop.md) query or [TRUNCATE](../../sql-reference/statements/truncate.md) query.

-This setting does not require a restart of the Clickhouse server to apply. Another way to disable the restriction is to create the `<clickhouse-path>/flags/force_drop_table` file.
+This setting does not require a restart of the ClickHouse server to apply. Another way to disable the restriction is to create the `<clickhouse-path>/flags/force_drop_table` file.

 Default value: 50 GB.
 The value 0 means that you can delete all tables without any restrictions.
@ -1570,7 +1570,7 @@ Restriction on deleting tables.

 If the size of a [MergeTree](../../engines/table-engines/mergetree-family/mergetree.md) table exceeds `max_table_size_to_drop` (in bytes), you can’t delete it using a [DROP](../../sql-reference/statements/drop.md) query or [TRUNCATE](../../sql-reference/statements/truncate.md) query.

-This setting does not require a restart of the Clickhouse server to apply. Another way to disable the restriction is to create the `<clickhouse-path>/flags/force_drop_table` file.
+This setting does not require a restart of the ClickHouse server to apply. Another way to disable the restriction is to create the `<clickhouse-path>/flags/force_drop_table` file.

 Default value: 50 GB.

@ -1588,7 +1588,7 @@ Restriction on dropping partitions.

 If the size of a [MergeTree](../../engines/table-engines/mergetree-family/mergetree.md) table exceeds `max_partition_size_to_drop` (in bytes), you can’t drop a partition using a [DROP PARTITION](../../sql-reference/statements/alter/partition.md#drop-partitionpart) query.

-This setting does not require a restart of the Clickhouse server to apply. Another way to disable the restriction is to create the `<clickhouse-path>/flags/force_drop_table` file.
+This setting does not require a restart of the ClickHouse server to apply. Another way to disable the restriction is to create the `<clickhouse-path>/flags/force_drop_table` file.

 Default value: 50 GB.

--- a/docs/en/operations/settings/settings-formats.md
+++ b/docs/en/operations/settings/settings-formats.md
@ -1642,7 +1642,7 @@ Possible values:
 - 0 — Output without row numbers.
 - 1 — Output with row numbers.

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

 **Example**

--- a/docs/en/operations/storing-data.md
+++ b/docs/en/operations/storing-data.md
@ -36,7 +36,7 @@ E.g. configuration option
 <s3>
    <type>s3</type>
    <endpoint>https://s3.eu-west-1.amazonaws.com/clickhouse-eu-west-1.clickhouse.com/data/</endpoint>
-    <use_invironment_credentials>1</use_invironment_credentials>
+    <use_environment_credentials>1</use_environment_credentials>
 </s3>
 ```

@ -47,7 +47,7 @@ is equal to configuration (from `24.1`):
    <object_storage_type>s3</object_storage_type>
    <metadata_type>local</metadata_type>
    <endpoint>https://s3.eu-west-1.amazonaws.com/clickhouse-eu-west-1.clickhouse.com/data/</endpoint>
-    <use_invironment_credentials>1</use_invironment_credentials>
+    <use_environment_credentials>1</use_environment_credentials>
 </s3>
 ```

@ -56,7 +56,7 @@ Configuration
 <s3_plain>
    <type>s3_plain</type>
    <endpoint>https://s3.eu-west-1.amazonaws.com/clickhouse-eu-west-1.clickhouse.com/data/</endpoint>
-    <use_invironment_credentials>1</use_invironment_credentials>
+    <use_environment_credentials>1</use_environment_credentials>
 </s3_plain>
 ```

@ -67,7 +67,7 @@ is equal to
    <object_storage_type>s3</object_storage_type>
    <metadata_type>plain</metadata_type>
    <endpoint>https://s3.eu-west-1.amazonaws.com/clickhouse-eu-west-1.clickhouse.com/data/</endpoint>
-    <use_invironment_credentials>1</use_invironment_credentials>
+    <use_environment_credentials>1</use_environment_credentials>
 </s3_plain>
 ```

@ -79,7 +79,7 @@ Example of full storage configuration will look like:
            <s3>
                <type>s3</type>
                <endpoint>https://s3.eu-west-1.amazonaws.com/clickhouse-eu-west-1.clickhouse.com/data/</endpoint>
-                <use_invironment_credentials>1</use_invironment_credentials>
+                <use_environment_credentials>1</use_environment_credentials>
            </s3>
        </disks>
        <policies>
@ -105,7 +105,7 @@ Starting with 24.1 clickhouse version, it can also look like:
                <object_storage_type>s3</object_storage_type>
                <metadata_type>local</metadata_type>
                <endpoint>https://s3.eu-west-1.amazonaws.com/clickhouse-eu-west-1.clickhouse.com/data/</endpoint>
-                <use_invironment_credentials>1</use_invironment_credentials>
+                <use_environment_credentials>1</use_environment_credentials>
            </s3>
        </disks>
        <policies>
@ -324,7 +324,7 @@ Configuration:
 <s3_plain>
    <type>s3_plain</type>
    <endpoint>https://s3.eu-west-1.amazonaws.com/clickhouse-eu-west-1.clickhouse.com/data/</endpoint>
-    <use_invironment_credentials>1</use_invironment_credentials>
+    <use_environment_credentials>1</use_environment_credentials>
 </s3_plain>
 ```

@ -337,7 +337,7 @@ Configuration:
    <object_storage_type>azure</object_storage_type>
    <metadata_type>plain</metadata_type>
    <endpoint>https://s3.eu-west-1.amazonaws.com/clickhouse-eu-west-1.clickhouse.com/data/</endpoint>
-    <use_invironment_credentials>1</use_invironment_credentials>
+    <use_environment_credentials>1</use_environment_credentials>
 </s3_plain>
 ```

--- a/docs/en/sql-reference/aggregate-functions/reference/cramersv.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/cramersv.md
@ -7,26 +7,33 @@ sidebar_position: 351

 [Cramer's V](https://en.wikipedia.org/wiki/Cram%C3%A9r%27s_V) (sometimes referred to as Cramer's phi) is a measure of association between two columns in a table. The result of the `cramersV` function ranges from 0 (corresponding to no association between the variables) to 1 and can reach 1 only when each value is completely determined by the other. It may be viewed as the association between two variables as a percentage of their maximum possible variation.

+:::note
+For a bias corrected version of Cramer's V see: [cramersVBiasCorrected](./cramersvbiascorrected.md)
+:::
+
 **Syntax**

 ``` sql
 cramersV(column1, column2)
 ```

-**Arguments**
+**Parameters**

- `column1` and `column2` are the columns to be compared
+- `column1`: first column to be compared.
+- `column2`: second column to be compared.

 **Returned value**

 - a value between 0 (corresponding to no association between the columns' values) to 1 (complete association).

-**Return type** is always [Float64](../../../sql-reference/data-types/float.md).
+Type: always [Float64](../../../sql-reference/data-types/float.md).

 **Example**

 The following two columns being compared below have no association with each other, so the result of `cramersV` is 0:

+Query:
+
 ``` sql
 SELECT
    cramersV(a, b)
--- a/docs/en/sql-reference/aggregate-functions/reference/cramersvbiascorrected.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/cramersvbiascorrected.md
@ -5,31 +5,31 @@ sidebar_position: 352

 # cramersVBiasCorrected

-
 Cramer's V is a measure of association between two columns in a table. The result of the [`cramersV` function](./cramersv.md) ranges from 0 (corresponding to no association between the variables) to 1 and can reach 1 only when each value is completely determined by the other. The function can be heavily biased, so this version of Cramer's V uses the [bias correction](https://en.wikipedia.org/wiki/Cram%C3%A9r%27s_V#Bias_correction).

-
-
 **Syntax**

 ``` sql
 cramersVBiasCorrected(column1, column2)
 ```

-**Arguments**
+**Parameters**

- `column1` and `column2` are the columns to be compared
+- `column1`: first column to be compared.
+- `column2`: second column to be compared.

 **Returned value**

 - a value between 0 (corresponding to no association between the columns' values) to 1 (complete association).

-**Return type** is always [Float64](../../../sql-reference/data-types/float.md).
+Type: always [Float64](../../../sql-reference/data-types/float.md).

 **Example**

 The following two columns being compared below have a small association with each other. Notice the result of `cramersVBiasCorrected` is smaller than the result of `cramersV`:

+Query:
+
 ``` sql
 SELECT
    cramersV(a, b),
--- a/docs/en/sql-reference/data-types/datetime.md
+++ b/docs/en/sql-reference/data-types/datetime.md
@ -36,9 +36,9 @@ You can explicitly set a time zone for `DateTime`-type columns when creating a t

 The [clickhouse-client](../../interfaces/cli.md) applies the server time zone by default if a time zone isn’t explicitly set when initializing the data type. To use the client time zone, run `clickhouse-client` with the `--use_client_time_zone` parameter.

-ClickHouse outputs values depending on the value of the [date_time_output_format](../../operations/settings/settings.md#settings-date_time_output_format) setting. `YYYY-MM-DD hh:mm:ss` text format by default. Additionally, you can change the output with the [formatDateTime](../../sql-reference/functions/date-time-functions.md#formatdatetime) function.
+ClickHouse outputs values depending on the value of the [date_time_output_format](../../operations/settings/settings-formats.md#date_time_output_format) setting. `YYYY-MM-DD hh:mm:ss` text format by default. Additionally, you can change the output with the [formatDateTime](../../sql-reference/functions/date-time-functions.md#formatdatetime) function.

-When inserting data into ClickHouse, you can use different formats of date and time strings, depending on the value of the [date_time_input_format](../../operations/settings/settings.md#settings-date_time_input_format) setting.
+When inserting data into ClickHouse, you can use different formats of date and time strings, depending on the value of the [date_time_input_format](../../operations/settings/settings-formats.md#date_time_input_format) setting.

 ## Examples

@ -147,8 +147,8 @@ Time shifts for multiple days. Some pacific islands changed their timezone offse
 - [Type conversion functions](../../sql-reference/functions/type-conversion-functions.md)
 - [Functions for working with dates and times](../../sql-reference/functions/date-time-functions.md)
 - [Functions for working with arrays](../../sql-reference/functions/array-functions.md)
- [The `date_time_input_format` setting](../../operations/settings/settings-formats.md#settings-date_time_input_format)
- [The `date_time_output_format` setting](../../operations/settings/settings-formats.md#settings-date_time_output_format)
+- [The `date_time_input_format` setting](../../operations/settings/settings-formats.md#date_time_input_format)
+- [The `date_time_output_format` setting](../../operations/settings/settings-formats.md#date_time_output_format)
 - [The `timezone` server configuration parameter](../../operations/server-configuration-parameters/settings.md#server_configuration_parameters-timezone)
 - [The `session_timezone` setting](../../operations/settings/settings.md#session_timezone)
 - [Operators for working with dates and times](../../sql-reference/operators/index.md#operators-datetime)
--- a/docs/en/sql-reference/data-types/variant.md
+++ b/docs/en/sql-reference/data-types/variant.md
@ -190,22 +190,67 @@ SELECT toTypeName(variantType(v)) FROM test LIMIT 1;
 └─────────────────────────────────────────────────────────────────────┘
 ```

-## Conversion between Variant column and other columns
+## Conversion between a Variant column and other columns

-There are 3 possible conversions that can be performed with Variant column.
+There are 4 possible conversions that can be performed with a column of type `Variant`.

-### Converting an ordinary column to a Variant column
+### Converting a String column to a Variant column

-It is possible to convert ordinary column with type `T` to a `Variant` column containing this type:
+Conversion from `String` to `Variant` is performed by parsing a value of `Variant` type from the string value:

 ```sql
-SELECT toTypeName(variant) as type_name, 'Hello, World!'::Variant(UInt64, String, Array(UInt64)) as variant;
+SELECT '42'::Variant(String, UInt64) as variant, variantType(variant) as variant_type
 ```

 ```text
-┌─type_name──────────────────────────────┬─variant───────┐
-│ Variant(Array(UInt64), String, UInt64) │ Hello, World! │
-└────────────────────────────────────────┴───────────────┘
+┌─variant─┬─variant_type─┐
+│ 42      │ UInt64       │
+└─────────┴──────────────┘
+```
+
+```sql
+SELECT '[1, 2, 3]'::Variant(String, Array(UInt64)) as variant, variantType(variant) as variant_type
+```
+
+```text
+┌─variant─┬─variant_type──┐
+│ [1,2,3] │ Array(UInt64) │
+└─────────┴───────────────┘
+```
+
+```sql
+SELECT CAST(map('key1', '42', 'key2', 'true', 'key3', '2020-01-01'), 'Map(String, Variant(UInt64, Bool, Date))') as map_of_variants, mapApply((k, v) -> (k, variantType(v)), map_of_variants) as map_of_variant_types```
+```
+
+```text
+┌─map_of_variants─────────────────────────────┬─map_of_variant_types──────────────────────────┐
+│ {'key1':42,'key2':true,'key3':'2020-01-01'} │ {'key1':'UInt64','key2':'Bool','key3':'Date'} │
+└─────────────────────────────────────────────┴───────────────────────────────────────────────┘
+```
+
+### Converting an ordinary column to a Variant column
+
+It is possible to convert an ordinary column with type `T` to a `Variant` column containing this type:
+
+```sql
+SELECT toTypeName(variant) as type_name, [1,2,3]::Array(UInt64)::Variant(UInt64, String, Array(UInt64)) as variant, variantType(variant) as variant_name
+ ```
+
+```text
+┌─type_name──────────────────────────────┬─variant─┬─variant_name──┐
+│ Variant(Array(UInt64), String, UInt64) │ [1,2,3] │ Array(UInt64) │
+└────────────────────────────────────────┴─────────┴───────────────┘
+```
+
+Note: converting from `String` type is always performed through parsing, if you need to convert `String` column to `String` variant of a `Variant` without parsing, you can do the following:
+```sql
+SELECT '[1, 2, 3]'::Variant(String)::Variant(String, Array(UInt64), UInt64) as variant, variantType(variant) as variant_type
+```
+
+```sql
+┌─variant───┬─variant_type─┐
+│ [1, 2, 3] │ String       │
+└───────────┴──────────────┘
 ```

 ### Converting a Variant column to an ordinary column
--- a/docs/ru/interfaces/http.md
+++ b/docs/ru/interfaces/http.md
@ -434,16 +434,18 @@ $ curl -v 'http://localhost:8123/predefined_query'
 ``` xml
 <http_handlers>
    <rule>
-        <url><![CDATA[regex:/query_param_with_url/\w+/(?P<name_1>[^/]+)(/(?P<name_2>[^/]+))?]]></url>
+        <url><![CDATA[regex:/query_param_with_url/(?P<name_1>[^/]+)]]></url>
        <methods>GET</methods>
        <headers>
            <XXX>TEST_HEADER_VALUE</XXX>
-            <PARAMS_XXX><![CDATA[(?P<name_1>[^/]+)(/(?P<name_2>[^/]+))?]]></PARAMS_XXX>
+            <PARAMS_XXX><![CDATA[regex:(?P<name_2>[^/]+)]]></PARAMS_XXX>
        </headers>
        <handler>
            <type>predefined_query_handler</type>
-            <query>SELECT value FROM system.settings WHERE name = {name_1:String}</query>
-            <query>SELECT name, value FROM system.settings WHERE name = {name_2:String}</query>
+            <query>
+                SELECT name, value FROM system.settings
+                WHERE name IN ({name_1:String}, {name_2:String})
+            </query>
        </handler>
    </rule>
    <defaults/>
@ -451,13 +453,13 @@ $ curl -v 'http://localhost:8123/predefined_query'
 ```

 ``` bash
-$ curl -H 'XXX:TEST_HEADER_VALUE' -H 'PARAMS_XXX:max_threads' 'http://localhost:8123/query_param_with_url/1/max_threads/max_final_threads?max_threads=1&max_final_threads=2'
-1
-max_final_threads   2
+$ curl -H 'XXX:TEST_HEADER_VALUE' -H 'PARAMS_XXX:max_final_threads' 'http://localhost:8123/query_param_with_url/max_threads?max_threads=1&max_final_threads=2'
+max_final_threads	2
+max_threads	1
 ```

 :::note Предупреждение
-В одном `predefined_query_handler` поддерживается только один запрос типа `INSERT`.
+В одном `predefined_query_handler` поддерживается только один запрос.
 :::
 ### dynamic_query_handler {#dynamic_query_handler}

--- a/docs/ru/operations/settings/settings.md
+++ b/docs/ru/operations/settings/settings.md
@ -2776,7 +2776,7 @@ SELECT range(number) FROM system.numbers LIMIT 5 FORMAT PrettyCompactNoEscapes;
 -   0 — номера строк не выводятся.
 -   1 — номера строк выводятся.

-Значение по умолчанию: `0`.
+Значение по умолчанию: `1`.

 **Пример**

@ -2798,7 +2798,7 @@ SELECT TOP 3 name, value FROM system.settings;
 ```
 ### output_format_pretty_color {#output_format_pretty_color}

-Включает/выключает управляющие последовательности ANSI в форматах Pretty. 
+Включает/выключает управляющие последовательности ANSI в форматах Pretty.

 Возможные значения:

@ -4123,7 +4123,7 @@ SELECT sum(number) FROM numbers(10000000000) SETTINGS partial_result_on_first_ca
 ## session_timezone {#session_timezone}

 Задаёт значение часового пояса (session_timezone) по умолчанию для текущей сессии вместо [часового пояса сервера](../server-configuration-parameters/settings.md#server_configuration_parameters-timezone). То есть, все значения DateTime/DateTime64, для которых явно не задан часовой пояс, будут интерпретированы как относящиеся к указанной зоне.
-При значении настройки `''` (пустая строка), будет совпадать с часовым поясом сервера. 
+При значении настройки `''` (пустая строка), будет совпадать с часовым поясом сервера.

 Функции `timeZone()` and `serverTimezone()` возвращают часовой пояс текущей сессии и сервера соответственно.

--- a/docs/ru/sql-reference/data-types/datetime.md
+++ b/docs/ru/sql-reference/data-types/datetime.md
@ -120,7 +120,7 @@ FROM dt
 -   [Функции для работы с датой и временем](../../sql-reference/functions/date-time-functions.md)
 -   [Функции для работы с массивами](../../sql-reference/functions/array-functions.md)
 -   [Настройка `date_time_input_format`](../../operations/settings/index.md#settings-date_time_input_format)
-   [Настройка `date_time_output_format`](../../operations/settings/index.md)
+-   [Настройка `date_time_output_format`](../../operations/settings/index.md#settings-date_time_output_format)
 -   [Конфигурационный параметр сервера `timezone`](../../operations/server-configuration-parameters/settings.md#server_configuration_parameters-timezone)
 -   [Параметр `session_timezone`](../../operations/settings/settings.md#session_timezone)
 -   [Операторы для работы с датой и временем](../../sql-reference/operators/index.md#operators-datetime)
--- a/docs/zh/interfaces/http.md
+++ b/docs/zh/interfaces/http.md
@ -427,29 +427,32 @@ $ curl -v 'http://localhost:8123/predefined_query'
 ``` xml
 <http_handlers>
    <rule>
-        <url><![CDATA[/query_param_with_url/\w+/(?P<name_1>[^/]+)(/(?P<name_2>[^/]+))?]]></url>
-        <method>GET</method>
+        <url><![CDATA[regex:/query_param_with_url/(?P<name_1>[^/]+)]]></url>
+        <methods>GET</methods>
        <headers>
            <XXX>TEST_HEADER_VALUE</XXX>
-            <PARAMS_XXX><![CDATA[(?P<name_1>[^/]+)(/(?P<name_2>[^/]+))?]]></PARAMS_XXX>
+            <PARAMS_XXX><![CDATA[regex:(?P<name_2>[^/]+)]]></PARAMS_XXX>
        </headers>
        <handler>
            <type>predefined_query_handler</type>
-            <query>SELECT value FROM system.settings WHERE name = {name_1:String}</query>
-            <query>SELECT name, value FROM system.settings WHERE name = {name_2:String}</query>
+            <query>
+                SELECT name, value FROM system.settings
+                WHERE name IN ({name_1:String}, {name_2:String})
+            </query>
        </handler>
    </rule>
+    <defaults/>
 </http_handlers>
 ```

 ``` bash
-$ curl -H 'XXX:TEST_HEADER_VALUE' -H 'PARAMS_XXX:max_threads' 'http://localhost:8123/query_param_with_url/1/max_threads/max_final_threads?max_threads=1&max_final_threads=2'
-1
-max_final_threads   2
+$ curl -H 'XXX:TEST_HEADER_VALUE' -H 'PARAMS_XXX:max_final_threads' 'http://localhost:8123/query_param_with_url/max_threads?max_threads=1&max_final_threads=2'
+max_final_threads	2
+max_threads	1
 ```

 :::warning
-在一个`predefined_query_handler`中，只支持insert类型的一个`查询`。
+在一个`predefined_query_handler`中，只支持的一个`查询`。
 :::

 ### 动态查询 {#dynamic_query_handler}
--- a/packages/clickhouse-common-static-dbg.yaml
+++ b/packages/clickhouse-common-static-dbg.yaml
@ -30,10 +30,6 @@ conflicts:
 contents:
 - src: root/usr/lib/debug/usr/bin/clickhouse.debug
  dst: /usr/lib/debug/usr/bin/clickhouse.debug
- src: root/usr/lib/debug/usr/bin/clickhouse-odbc-bridge.debug
-  dst: /usr/lib/debug/usr/bin/clickhouse-odbc-bridge.debug
- src: root/usr/lib/debug/usr/bin/clickhouse-library-bridge.debug
-  dst: /usr/lib/debug/usr/bin/clickhouse-library-bridge.debug
 # docs
 - src: ../AUTHORS
  dst: /usr/share/doc/clickhouse-common-static-dbg/AUTHORS
--- a/packages/clickhouse-common-static.yaml
+++ b/packages/clickhouse-common-static.yaml
@ -36,10 +36,6 @@ contents:
  dst: /usr/bin/clickhouse
 - src: root/usr/bin/clickhouse-extract-from-config
  dst: /usr/bin/clickhouse-extract-from-config
- src: root/usr/bin/clickhouse-library-bridge
-  dst: /usr/bin/clickhouse-library-bridge
- src: root/usr/bin/clickhouse-odbc-bridge
-  dst: /usr/bin/clickhouse-odbc-bridge
 - src: root/usr/share/bash-completion/completions
  dst: /usr/share/bash-completion/completions
 - src: root/usr/share/clickhouse
--- a/packages/clickhouse-library-bridge.yaml
+++ b/packages/clickhouse-library-bridge.yaml
@ -0,0 +1,35 @@
+# package sources should be placed in ${PWD}/root
+# nfpm should run from the same directory with a config
+name: "clickhouse-library-bridge"
+description: |
+  ClickHouse Library Bridge - is a separate process for loading libraries for the 'library' dictionary sources and the CatBoost library.
+    ClickHouse is a column-oriented database management system
+    that allows generating analytical data reports in real time.
+
+# Common packages config
+arch: "${DEB_ARCH}" # amd64, arm64
+platform: "linux"
+version: "${CLICKHOUSE_VERSION_STRING}"
+vendor: "ClickHouse Inc."
+homepage: "https://clickhouse.com"
+license: "Apache"
+section: "database"
+priority: "optional"
+maintainer: "ClickHouse Dev Team <packages+linux@clickhouse.com>"
+deb:
+  fields:
+    Source: clickhouse
+
+# Package specific content
+contents:
+- src: root/usr/bin/clickhouse-library-bridge
+  dst: /usr/bin/clickhouse-library-bridge
+# docs
+- src: ../AUTHORS
+  dst: /usr/share/doc/clickhouse-library-bridge/AUTHORS
+- src: ../CHANGELOG.md
+  dst: /usr/share/doc/clickhouse-library-bridge/CHANGELOG.md
+- src: ../LICENSE
+  dst: /usr/share/doc/clickhouse-library-bridge/LICENSE
+- src: ../README.md
+  dst: /usr/share/doc/clickhouse-library-bridge/README.md
--- a/packages/clickhouse-odbc-bridge.yaml
+++ b/packages/clickhouse-odbc-bridge.yaml
@ -0,0 +1,35 @@
+# package sources should be placed in ${PWD}/root
+# nfpm should run from the same directory with a config
+name: "clickhouse-odbc-bridge"
+description: |
+  ClickHouse ODBC Bridge - is a separate process for loading ODBC drivers and interacting with external databases using the ODBC protocol.
+    ClickHouse is a column-oriented database management system
+    that allows generating analytical data reports in real time.
+
+# Common packages config
+arch: "${DEB_ARCH}" # amd64, arm64
+platform: "linux"
+version: "${CLICKHOUSE_VERSION_STRING}"
+vendor: "ClickHouse Inc."
+homepage: "https://clickhouse.com"
+license: "Apache"
+section: "database"
+priority: "optional"
+maintainer: "ClickHouse Dev Team <packages+linux@clickhouse.com>"
+deb:
+  fields:
+    Source: clickhouse
+
+# Package specific content
+contents:
+- src: root/usr/bin/clickhouse-odbc-bridge
+  dst: /usr/bin/clickhouse-odbc-bridge
+# docs
+- src: ../AUTHORS
+  dst: /usr/share/doc/clickhouse-odbc-bridge/AUTHORS
+- src: ../CHANGELOG.md
+  dst: /usr/share/doc/clickhouse-odbc-bridge/CHANGELOG.md
+- src: ../LICENSE
+  dst: /usr/share/doc/clickhouse-odbc-bridge/LICENSE
+- src: ../README.md
+  dst: /usr/share/doc/clickhouse-odbc-bridge/README.md
--- a/programs/format/Format.cpp
+++ b/programs/format/Format.cpp
@ -237,7 +237,7 @@ int mainEntryClickHouseFormat(int argc, char ** argv)
                ASTPtr res = parseQueryAndMovePosition(
                    parser, pos, end, "query", multiple, cmd_settings.max_query_size, cmd_settings.max_parser_depth, cmd_settings.max_parser_backtracks);

-                std::unique_ptr<ReadBuffer> insert_query_payload = nullptr;
+                std::unique_ptr<ReadBuffer> insert_query_payload;
                /// If the query is INSERT ... VALUES, then we will try to parse the data.
                if (auto * insert_query = res->as<ASTInsertQuery>(); insert_query && insert_query->data)
                {
--- a/programs/install/Install.cpp
+++ b/programs/install/Install.cpp
@ -662,7 +662,6 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
                    "        <server>\n"
                    "            <certificateFile>" << (config_dir / "server.crt").string() << "</certificateFile>\n"
                    "            <privateKeyFile>" << (config_dir / "server.key").string() << "</privateKeyFile>\n"
-                    "            <dhParamsFile>" << (config_dir / "dhparam.pem").string() << "</dhParamsFile>\n"
                    "        </server>\n"
                    "    </openSSL>\n"
                    "</clickhouse>\n";
--- a/programs/library-bridge/CMakeLists.txt
+++ b/programs/library-bridge/CMakeLists.txt
@ -24,9 +24,4 @@ target_link_libraries(clickhouse-library-bridge PRIVATE

 set_target_properties(clickhouse-library-bridge PROPERTIES RUNTIME_OUTPUT_DIRECTORY ..)

-if (SPLIT_DEBUG_SYMBOLS)
-    clickhouse_split_debug_symbols(TARGET clickhouse-library-bridge DESTINATION_DIR ${CMAKE_CURRENT_BINARY_DIR}/../${SPLITTED_DEBUG_SYMBOLS_DIR} BINARY_PATH ../clickhouse-library-bridge)
-else()
-    clickhouse_make_empty_debug_info_for_nfpm(TARGET clickhouse-library-bridge DESTINATION_DIR ${CMAKE_CURRENT_BINARY_DIR}/../${SPLITTED_DEBUG_SYMBOLS_DIR})
-    install(TARGETS clickhouse-library-bridge RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-endif()
+install(TARGETS clickhouse-library-bridge RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
--- a/programs/library-bridge/ExternalDictionaryLibraryUtils.h
+++ b/programs/library-bridge/ExternalDictionaryLibraryUtils.h
@ -35,7 +35,7 @@ public:
    ExternalDictionaryLibraryAPI::CStrings strings; // will pass pointer to lib

 private:
-    std::unique_ptr<ExternalDictionaryLibraryAPI::CString[]> ptr_holder = nullptr;
+    std::unique_ptr<ExternalDictionaryLibraryAPI::CString[]> ptr_holder;
    Container strings_holder;
 };

--- a/programs/odbc-bridge/CMakeLists.txt
+++ b/programs/odbc-bridge/CMakeLists.txt
@ -30,12 +30,7 @@ target_link_libraries(clickhouse-odbc-bridge PRIVATE
 set_target_properties(clickhouse-odbc-bridge PROPERTIES RUNTIME_OUTPUT_DIRECTORY ..)
 target_compile_options (clickhouse-odbc-bridge PRIVATE -Wno-reserved-id-macro -Wno-keyword-macro)

-if (SPLIT_DEBUG_SYMBOLS)
-    clickhouse_split_debug_symbols(TARGET clickhouse-odbc-bridge DESTINATION_DIR ${CMAKE_CURRENT_BINARY_DIR}/../${SPLITTED_DEBUG_SYMBOLS_DIR} BINARY_PATH ../clickhouse-odbc-bridge)
-else()
-    clickhouse_make_empty_debug_info_for_nfpm(TARGET clickhouse-odbc-bridge DESTINATION_DIR ${CMAKE_CURRENT_BINARY_DIR}/../${SPLITTED_DEBUG_SYMBOLS_DIR})
-    install(TARGETS clickhouse-odbc-bridge RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-endif()
+install(TARGETS clickhouse-odbc-bridge RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)

 if(ENABLE_TESTS)
    add_subdirectory(tests)
--- a/programs/odbc-bridge/ColumnInfoHandler.cpp
+++ b/programs/odbc-bridge/ColumnInfoHandler.cpp
@ -12,6 +12,7 @@
 #include <Poco/Net/HTTPServerRequest.h>
 #include <Poco/Net/HTTPServerResponse.h>
 #include <Poco/NumberParser.h>
+#include <Interpreters/Context.h>
 #include <Common/logger_useful.h>
 #include <Common/BridgeProtocolVersion.h>
 #include <Common/quoteString.h>
--- a/programs/odbc-bridge/ColumnInfoHandler.h
+++ b/programs/odbc-bridge/ColumnInfoHandler.h
@ -5,7 +5,6 @@
 #if USE_ODBC

 #include <Interpreters/Context_fwd.h>
-#include <Interpreters/Context.h>
 #include <Server/HTTP/HTTPRequestHandler.h>
 #include <Poco/Logger.h>

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

+    bool will_have_trace_collector = hasPHDRCache() && config().has("trace_log");
+
    // Initialize global thread pool. Do it before we fetch configs from zookeeper
    // nodes (`from_zk`), because ZooKeeper interface uses the pool. We will
    // ignore `max_thread_pool_size` in configs we fetch from ZK, but oh well.
    GlobalThreadPool::initialize(
        server_settings.max_thread_pool_size,
        server_settings.max_thread_pool_free_size,
-        server_settings.thread_pool_queue_size);
+        server_settings.thread_pool_queue_size,
+        will_have_trace_collector ? server_settings.global_profiler_real_time_period_ns : 0,
+        will_have_trace_collector ? server_settings.global_profiler_cpu_time_period_ns : 0);
    /// Wait for all threads to avoid possible use-after-free (for example logging objects can be already destroyed).
    SCOPE_EXIT({
        Stopwatch watch;
--- a/programs/server/config.xml
+++ b/programs/server/config.xml
@ -96,7 +96,7 @@
            <to>https://{bucket}.s3.amazonaws.com</to>
        </s3>
        <gs>
-            <to>https://{bucket}.storage.googleapis.com</to>
+            <to>https://storage.googleapis.com/{bucket}</to>
        </gs>
        <oss>
            <to>https://{bucket}.oss.aliyuncs.com</to>
--- a/src/Access/AccessBackup.cpp
+++ b/src/Access/AccessBackup.cpp
@ -16,6 +16,8 @@
 #include <IO/ReadBufferFromString.h>
 #include <Poco/UUIDGenerator.h>
 #include <base/insertAtEnd.h>
+
+#include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/copy.hpp>

 namespace fs = std::filesystem;
--- a/src/AggregateFunctions/AggregateFunctionAnyHeavy.cpp
+++ b/src/AggregateFunctions/AggregateFunctionAnyHeavy.cpp
@ -115,34 +115,34 @@ public:

    void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena * arena) const override
    {
-        this->data(place).add(*columns[0], row_num, arena);
+        data(place).add(*columns[0], row_num, arena);
    }

    void addManyDefaults(AggregateDataPtr __restrict place, const IColumn ** columns, size_t, Arena * arena) const override
    {
-        this->data(place).addManyDefaults(*columns[0], 0, arena);
+        data(place).addManyDefaults(*columns[0], 0, arena);
    }

    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena * arena) const override
    {
-        this->data(place).add(this->data(rhs), arena);
+        data(place).add(data(rhs), arena);
    }

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

    void deserialize(AggregateDataPtr place, ReadBuffer & buf, std::optional<size_t> /* version */, Arena * arena) const override
    {
-        this->data(place).read(buf, *serialization, arena);
+        data(place).read(buf, *serialization, arena);
    }

    bool allocatesMemoryInArena() const override { return singleValueTypeAllocatesMemoryInArena(value_type_index); }

    void insertResultInto(AggregateDataPtr __restrict place, IColumn & to, Arena *) const override
    {
-        this->data(place).insertResultInto(to);
+        data(place).insertResultInto(to);
    }
 };

--- a/src/AggregateFunctions/AggregateFunctionFlameGraph.cpp
+++ b/src/AggregateFunctions/AggregateFunctionFlameGraph.cpp
@ -559,7 +559,7 @@ public:
            ptr = ptrs[row_num];
        }

-        this->data(place).add(ptr, allocated, trace_values.data() + prev_offset, trace_size, arena);
+        data(place).add(ptr, allocated, trace_values.data() + prev_offset, trace_size, arena);
    }

    void addManyDefaults(
@ -572,7 +572,7 @@ public:

    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena * arena) const override
    {
-        this->data(place).merge(this->data(rhs), arena);
+        data(place).merge(data(rhs), arena);
    }

    void serialize(ConstAggregateDataPtr __restrict, WriteBuffer &, std::optional<size_t> /* version */) const override
@ -590,7 +590,7 @@ public:
        auto & array = assert_cast<ColumnArray &>(to);
        auto & str = assert_cast<ColumnString &>(array.getData());

-        this->data(place).dumpFlameGraph(str.getChars(), str.getOffsets(), 0, 0);
+        data(place).dumpFlameGraph(str.getChars(), str.getOffsets(), 0, 0);

        array.getOffsets().push_back(str.size());
    }
--- a/src/AggregateFunctions/AggregateFunctionGroupArray.cpp
+++ b/src/AggregateFunctions/AggregateFunctionGroupArray.cpp
@ -89,10 +89,10 @@ struct GroupArraySamplerData
        chassert(lim != 0);

        /// With a large number of values, we will generate random numbers several times slower.
-        if (lim <= static_cast<UInt64>(rng.max()))
+        if (lim <= static_cast<UInt64>(pcg32_fast::max()))
            return rng() % lim;
        else
-            return (static_cast<UInt64>(rng()) * (static_cast<UInt64>(rng.max()) + 1ULL) + static_cast<UInt64>(rng())) % lim;
+            return (static_cast<UInt64>(rng()) * (static_cast<UInt64>(pcg32::max()) + 1ULL) + static_cast<UInt64>(rng())) % lim;
    }

    void randomShuffle()
--- a/src/AggregateFunctions/AggregateFunctionLargestTriangleThreeBuckets.cpp
+++ b/src/AggregateFunctions/AggregateFunctionLargestTriangleThreeBuckets.cpp
@ -242,7 +242,7 @@ public:
    {
        Float64 x = getFloat64DataFromColumn(columns[0], row_num, this->x_type);
        Float64 y = getFloat64DataFromColumn(columns[1], row_num, this->y_type);
-        this->data(place).add(x, y, arena);
+        data(place).add(x, y, arena);
    }

    Float64 getFloat64DataFromColumn(const IColumn * column, size_t row_num, TypeIndex type_index) const
@ -264,25 +264,25 @@ public:

    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena * arena) const override
    {
-        auto & a = this->data(place);
-        const auto & b = this->data(rhs);
+        auto & a = data(place);
+        const auto & b = data(rhs);

        a.merge(b, arena);
    }

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

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

    void insertResultInto(AggregateDataPtr __restrict place, IColumn & to, Arena * arena) const override
    {
-        auto res = this->data(place).getResult(total_buckets, arena);
+        auto res = data(place).getResult(total_buckets, arena);

        auto & col = assert_cast<ColumnArray &>(to);
        auto & col_offsets = assert_cast<ColumnArray::ColumnOffsets &>(col.getOffsetsColumn());
--- a/src/AggregateFunctions/AggregateFunctionMannWhitney.cpp
+++ b/src/AggregateFunctions/AggregateFunctionMannWhitney.cpp
@ -205,35 +205,35 @@ public:
        UInt8 is_second = columns[1]->getUInt(row_num);

        if (is_second)
-            this->data(place).addY(value, arena);
+            data(place).addY(value, arena);
        else
-            this->data(place).addX(value, arena);
+            data(place).addX(value, arena);
    }

    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena * arena) const override
    {
-        auto & a = this->data(place);
-        const auto & b = this->data(rhs);
+        auto & a = data(place);
+        const auto & b = data(rhs);

        a.merge(b, arena);
    }

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

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

    void insertResultInto(AggregateDataPtr __restrict place, IColumn & to, Arena *) const override
    {
-        if (!this->data(place).size_x || !this->data(place).size_y)
+        if (!data(place).size_x || !data(place).size_y)
            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Aggregate function {} require both samples to be non empty", getName());

-        auto [u_statistic, p_value] = this->data(place).getResult(alternative, continuity_correction);
+        auto [u_statistic, p_value] = data(place).getResult(alternative, continuity_correction);

        /// Because p-value is a probability.
        p_value = std::min(1.0, std::max(0.0, p_value));
--- a/src/AggregateFunctions/AggregateFunctionRankCorrelation.cpp
+++ b/src/AggregateFunctions/AggregateFunctionRankCorrelation.cpp
@ -66,31 +66,31 @@ public:
    {
        Float64 new_x = columns[0]->getFloat64(row_num);
        Float64 new_y = columns[1]->getFloat64(row_num);
-        this->data(place).addX(new_x, arena);
-        this->data(place).addY(new_y, arena);
+        data(place).addX(new_x, arena);
+        data(place).addY(new_y, arena);
    }

    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena * arena) const override
    {
-        auto & a = this->data(place);
-        const auto & b = this->data(rhs);
+        auto & a = data(place);
+        const auto & b = data(rhs);

        a.merge(b, arena);
    }

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

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

    void insertResultInto(AggregateDataPtr __restrict place, IColumn & to, Arena *) const override
    {
-        auto answer = this->data(place).getResult();
+        auto answer = data(place).getResult();

        auto & column = static_cast<ColumnVector<Float64> &>(to);
        column.getData().push_back(answer);
--- a/src/AggregateFunctions/AggregateFunctionRetention.cpp
+++ b/src/AggregateFunctions/AggregateFunctionRetention.cpp
@ -102,24 +102,24 @@ public:
            auto event = assert_cast<const ColumnVector<UInt8> *>(columns[i])->getData()[row_num];
            if (event)
            {
-                this->data(place).add(i);
+                data(place).add(i);
            }
        }
    }

    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena *) const override
    {
-        this->data(place).merge(this->data(rhs));
+        data(place).merge(data(rhs));
    }

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

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

    void insertResultInto(AggregateDataPtr __restrict place, IColumn & to, Arena *) const override
@ -130,13 +130,13 @@ public:
        ColumnArray::Offset current_offset = data_to.size();
        data_to.resize(current_offset + events_size);

-        const bool first_flag = this->data(place).events.test(0);
+        const bool first_flag = data(place).events.test(0);
        data_to[current_offset] = first_flag;
        ++current_offset;

        for (size_t i = 1; i < events_size; ++i)
        {
-            data_to[current_offset] = (first_flag && this->data(place).events.test(i));
+            data_to[current_offset] = (first_flag && data(place).events.test(i));
            ++current_offset;
        }

--- a/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.cpp
+++ b/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.cpp
@ -123,22 +123,22 @@ public:
        Float64 x = columns[0]->getFloat64(row_num);
        Float64 y = columns[1]->getFloat64(row_num);

-        this->data(place).add(x, y);
+        data(place).add(x, y);
    }

    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena *) const override
    {
-        this->data(place).merge(this->data(rhs));
+        data(place).merge(data(rhs));
    }

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

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

    static DataTypePtr createResultType()
@ -168,8 +168,8 @@ public:
        IColumn & to,
        Arena *) const override
    {
-        Float64 k = this->data(place).getK();
-        Float64 b = this->data(place).getB(k);
+        Float64 k = data(place).getK();
+        Float64 b = data(place).getB(k);

        auto & col_tuple = assert_cast<ColumnTuple &>(to);
        auto & col_k = assert_cast<ColumnVector<Float64> &>(col_tuple.getColumn(0));
--- a/src/AggregateFunctions/AggregateFunctionSingleValueOrNull.cpp
+++ b/src/AggregateFunctions/AggregateFunctionSingleValueOrNull.cpp
@ -120,7 +120,7 @@ public:

    void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena * arena) const override
    {
-        this->data(place).add(*columns[0], row_num, arena);
+        data(place).add(*columns[0], row_num, arena);
    }

    void addBatchSinglePlace(
@ -131,7 +131,7 @@ public:
        Arena * arena,
        ssize_t if_argument_pos) const override
    {
-        if (this->data(place).isNull())
+        if (data(place).isNull())
            return;
        IAggregateFunctionDataHelper<Data, AggregateFunctionSingleValueOrNull>::addBatchSinglePlace(
            row_begin, row_end, place, columns, arena, if_argument_pos);
@ -146,7 +146,7 @@ public:
        Arena * arena,
        ssize_t if_argument_pos) const override
    {
-        if (this->data(place).isNull())
+        if (data(place).isNull())
            return;
        IAggregateFunctionDataHelper<Data, AggregateFunctionSingleValueOrNull>::addBatchSinglePlaceNotNull(
            row_begin, row_end, place, columns, null_map, arena, if_argument_pos);
@ -154,29 +154,29 @@ public:

    void addManyDefaults(AggregateDataPtr __restrict place, const IColumn ** columns, size_t, Arena * arena) const override
    {
-        this->data(place).add(*columns[0], 0, arena);
+        data(place).add(*columns[0], 0, arena);
    }

    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena * arena) const override
    {
-        this->data(place).add(this->data(rhs), arena);
+        data(place).add(data(rhs), arena);
    }

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

    void deserialize(AggregateDataPtr place, ReadBuffer & buf, std::optional<size_t> /* version */, Arena * arena) const override
    {
-        this->data(place).read(buf, *serialization, arena);
+        data(place).read(buf, *serialization, arena);
    }

    bool allocatesMemoryInArena() const override { return singleValueTypeAllocatesMemoryInArena(value_type_index); }

    void insertResultInto(AggregateDataPtr __restrict place, IColumn & to, Arena *) const override
    {
-        this->data(place).insertResultInto(to);
+        data(place).insertResultInto(to);
    }
 };

--- a/src/AggregateFunctions/AggregateFunctionStatistics.cpp
+++ b/src/AggregateFunctions/AggregateFunctionStatistics.cpp
@ -150,13 +150,13 @@ private:

    Float64 getResult(ConstAggregateDataPtr __restrict place) const
    {
-        const auto & data = this->data(place);
+        const auto & dt = data(place);
        switch (kind)
        {
-            case VarKind::varSampStable: return getVarSamp(data.m2, data.count);
-            case VarKind::stddevSampStable: return getStddevSamp(data.m2, data.count);
-            case VarKind::varPopStable: return getVarPop(data.m2, data.count);
-            case VarKind::stddevPopStable: return getStddevPop(data.m2, data.count);
+            case VarKind::varSampStable: return getVarSamp(dt.m2, dt.count);
+            case VarKind::stddevSampStable: return getStddevSamp(dt.m2, dt.count);
+            case VarKind::varPopStable: return getVarPop(dt.m2, dt.count);
+            case VarKind::stddevPopStable: return getStddevPop(dt.m2, dt.count);
        }
    }

@ -182,22 +182,22 @@ public:

    void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
    {
-        this->data(place).update(*columns[0], row_num);
+        data(place).update(*columns[0], row_num);
    }

    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena *) const override
    {
-        this->data(place).mergeWith(this->data(rhs));
+        data(place).mergeWith(data(rhs));
    }

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

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

    void insertResultInto(AggregateDataPtr __restrict place, IColumn & to, Arena *) const override
--- a/src/AggregateFunctions/Combinators/AggregateFunctionNull.h
+++ b/src/AggregateFunctions/Combinators/AggregateFunctionNull.h
@ -491,7 +491,7 @@ public:
        std::vector<const UInt8 *> nullable_filters;
        const IColumn * nested_columns[number_of_arguments];

-        std::unique_ptr<UInt8[]> final_flags = nullptr;
+        std::unique_ptr<UInt8[]> final_flags;
        const UInt8 * final_flags_ptr = nullptr;

        if (if_argument_pos >= 0)
--- a/src/AggregateFunctions/IAggregateFunction.h
+++ b/src/AggregateFunctions/IAggregateFunction.h
@ -1,17 +1,18 @@
 #pragma once

+#include <AggregateFunctions/IAggregateFunction_fwd.h>
 #include <Columns/ColumnSparse.h>
 #include <Columns/ColumnTuple.h>
 #include <Columns/ColumnsNumber.h>
 #include <Core/Block.h>
 #include <Core/ColumnNumbers.h>
 #include <Core/Field.h>
+#include <Core/IResolvedFunction.h>
 #include <Core/ValuesWithType.h>
 #include <Interpreters/Context_fwd.h>
 #include <base/types.h>
 #include <Common/Exception.h>
 #include <Common/ThreadPool_fwd.h>
-#include <Core/IResolvedFunction.h>

 #include "config.h"

@ -46,13 +47,6 @@ class IWindowFunction;
 using DataTypePtr = std::shared_ptr<const IDataType>;
 using DataTypes = std::vector<DataTypePtr>;

-using AggregateDataPtr = char *;
-using AggregateDataPtrs = std::vector<AggregateDataPtr>;
-using ConstAggregateDataPtr = const char *;
-
-class IAggregateFunction;
-using AggregateFunctionPtr = std::shared_ptr<const IAggregateFunction>;
-
 struct AggregateFunctionProperties;

 /** Aggregate functions interface.
--- a/src/AggregateFunctions/IAggregateFunction_fwd.h
+++ b/src/AggregateFunctions/IAggregateFunction_fwd.h
@ -0,0 +1,14 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+namespace DB
+{
+using AggregateDataPtr = char *;
+using AggregateDataPtrs = std::vector<AggregateDataPtr>;
+using ConstAggregateDataPtr = const char *;
+
+class IAggregateFunction;
+using AggregateFunctionPtr = std::shared_ptr<const IAggregateFunction>;
+}
--- a/src/AggregateFunctions/ReservoirSampler.h
+++ b/src/AggregateFunctions/ReservoirSampler.h
@ -258,10 +258,10 @@ private:
        chassert(limit > 0);

        /// With a large number of values, we will generate random numbers several times slower.
-        if (limit <= static_cast<UInt64>(rng.max()))
+        if (limit <= static_cast<UInt64>(pcg32_fast::max()))
            return rng() % limit;
        else
-            return (static_cast<UInt64>(rng()) * (static_cast<UInt64>(rng.max()) + 1ULL) + static_cast<UInt64>(rng())) % limit;
+            return (static_cast<UInt64>(rng()) * (static_cast<UInt64>(pcg32_fast::max()) + 1ULL) + static_cast<UInt64>(rng())) % limit;
    }

    void sortIfNeeded()
--- a/src/AggregateFunctions/SingleValueData.cpp
+++ b/src/AggregateFunctions/SingleValueData.cpp
@ -579,7 +579,7 @@ std::optional<size_t> SingleValueDataFixed<T>::getGreatestIndexNotNullIf(
            return std::nullopt;

        for (size_t i = index + 1; i < row_end; i++)
-            if ((!if_map || if_map[i] != 0) && (!null_map || null_map[i] == 0) && (vec[i] < vec[index]))
+            if ((!if_map || if_map[i] != 0) && (!null_map || null_map[i] == 0) && (vec[i] > vec[index]))
                index = i;
        return {index};
    }
--- a/src/Analyzer/ArrayJoinNode.cpp
+++ b/src/Analyzer/ArrayJoinNode.cpp
@ -1,14 +1,12 @@
 #include <Analyzer/ArrayJoinNode.h>
-
+#include <Analyzer/ColumnNode.h>
+#include <Analyzer/Utils.h>
+#include <IO/Operators.h>
 #include <IO/WriteBuffer.h>
 #include <IO/WriteHelpers.h>
-#include <IO/Operators.h>
-
-#include <Parsers/ASTTablesInSelectQuery.h>
 #include <Parsers/ASTExpressionList.h>
-
-#include <Analyzer/Utils.h>
-#include <Analyzer/ColumnNode.h>
+#include <Parsers/ASTTablesInSelectQuery.h>
+#include <Common/assert_cast.h>

 namespace DB
 {
--- a/src/Analyzer/ColumnNode.cpp
+++ b/src/Analyzer/ColumnNode.cpp
@ -1,14 +1,12 @@
 #include <Analyzer/ColumnNode.h>
-
-#include <Common/SipHash.h>
-
+#include <Analyzer/TableNode.h>
+#include <IO/Operators.h>
 #include <IO/WriteBuffer.h>
 #include <IO/WriteHelpers.h>
-#include <IO/Operators.h>
-
 #include <Parsers/ASTIdentifier.h>
+#include <Common/SipHash.h>
+#include <Common/assert_cast.h>

-#include <Analyzer/TableNode.h>

 namespace DB
 {
--- a/src/Analyzer/JoinNode.cpp
+++ b/src/Analyzer/JoinNode.cpp
@ -1,16 +1,14 @@
 #include <Analyzer/JoinNode.h>
 #include <Analyzer/ListNode.h>
-
+#include <Analyzer/Utils.h>
+#include <IO/Operators.h>
 #include <IO/WriteBuffer.h>
 #include <IO/WriteHelpers.h>
-#include <IO/Operators.h>
-
-#include <Parsers/ASTSubquery.h>
-#include <Parsers/ASTIdentifier.h>
 #include <Parsers/ASTFunction.h>
+#include <Parsers/ASTIdentifier.h>
+#include <Parsers/ASTSubquery.h>
 #include <Parsers/ASTTablesInSelectQuery.h>
-
-#include <Analyzer/Utils.h>
+#include <Common/assert_cast.h>

 namespace DB
 {
--- a/src/Analyzer/Passes/QueryAnalysisPass.cpp
+++ b/src/Analyzer/Passes/QueryAnalysisPass.cpp
@ -1940,8 +1940,7 @@ std::vector<String> QueryAnalyzer::collectIdentifierTypoHints(const Identifier &
    for (const auto & valid_identifier : valid_identifiers)
        prompting_strings.push_back(valid_identifier.getFullName());

-    NamePrompter<1> prompter;
-    return prompter.getHints(unresolved_identifier.getFullName(), prompting_strings);
+    return NamePrompter<1>::getHints(unresolved_identifier.getFullName(), prompting_strings);
 }

 /** Wrap expression node in tuple element function calls for nested paths.
@ -6083,7 +6082,9 @@ ProjectionNames QueryAnalyzer::resolveFunction(QueryTreeNodePtr & node, Identifi
              * Example: SELECT toTypeName(sum(number)) FROM numbers(10);
              */
            if (column && isColumnConst(*column) && !typeid_cast<const ColumnConst *>(column.get())->getDataColumn().isDummy() &&
-                (!hasAggregateFunctionNodes(node) && !hasFunctionNode(node, "arrayJoin")))
+                !hasAggregateFunctionNodes(node) && !hasFunctionNode(node, "arrayJoin") &&
+                /// Sanity check: do not convert large columns to constants
+                column->byteSize() < 1_MiB)
            {
                /// Replace function node with result constant node
                Field column_constant_value;
--- a/src/Analyzer/QueryTreeBuilder.cpp
+++ b/src/Analyzer/QueryTreeBuilder.cpp
@ -444,8 +444,8 @@ QueryTreeNodePtr QueryTreeBuilder::buildSortList(const ASTPtr & order_by_express
            nulls_sort_direction = order_by_element.nulls_direction == 1 ? SortDirection::ASCENDING : SortDirection::DESCENDING;

        std::shared_ptr<Collator> collator;
-        if (order_by_element.collation)
-            collator = std::make_shared<Collator>(order_by_element.collation->as<ASTLiteral &>().value.get<String &>());
+        if (order_by_element.getCollation())
+            collator = std::make_shared<Collator>(order_by_element.getCollation()->as<ASTLiteral &>().value.get<String &>());

        const auto & sort_expression_ast = order_by_element.children.at(0);
        auto sort_expression = buildExpression(sort_expression_ast, context);
@ -455,12 +455,12 @@ QueryTreeNodePtr QueryTreeBuilder::buildSortList(const ASTPtr & order_by_express
            std::move(collator),
            order_by_element.with_fill);

-        if (order_by_element.fill_from)
-            sort_node->getFillFrom() = buildExpression(order_by_element.fill_from, context);
-        if (order_by_element.fill_to)
-            sort_node->getFillTo() = buildExpression(order_by_element.fill_to, context);
-        if (order_by_element.fill_step)
-            sort_node->getFillStep() = buildExpression(order_by_element.fill_step, context);
+        if (order_by_element.getFillFrom())
+            sort_node->getFillFrom() = buildExpression(order_by_element.getFillFrom(), context);
+        if (order_by_element.getFillTo())
+            sort_node->getFillTo() = buildExpression(order_by_element.getFillTo(), context);
+        if (order_by_element.getFillStep())
+            sort_node->getFillStep() = buildExpression(order_by_element.getFillStep(), context);

        list_node->getNodes().push_back(std::move(sort_node));
    }
@ -558,7 +558,7 @@ QueryTreeNodePtr QueryTreeBuilder::buildExpression(const ASTPtr & expression, co
    }
    else if (const auto * function = expression->as<ASTFunction>())
    {
-        if (function->is_lambda_function)
+        if (function->is_lambda_function || isASTLambdaFunction(*function))
        {
            const auto & lambda_arguments_and_expression = function->arguments->as<ASTExpressionList &>().children;
            auto & lambda_arguments_tuple = lambda_arguments_and_expression.at(0)->as<ASTFunction &>();
--- a/src/Analyzer/SortNode.cpp
+++ b/src/Analyzer/SortNode.cpp
@ -120,17 +120,18 @@ ASTPtr SortNode::toASTImpl(const ConvertToASTOptions & options) const

    result->nulls_direction_was_explicitly_specified = nulls_sort_direction.has_value();

-    result->with_fill = with_fill;
-    result->fill_from = hasFillFrom() ? getFillFrom()->toAST(options) : nullptr;
-    result->fill_to = hasFillTo() ? getFillTo()->toAST(options) : nullptr;
-    result->fill_step = hasFillStep() ? getFillStep()->toAST(options) : nullptr;
    result->children.push_back(getExpression()->toAST(options));

    if (collator)
-    {
-        result->children.push_back(std::make_shared<ASTLiteral>(Field(collator->getLocale())));
-        result->collation = result->children.back();
-    }
+        result->setCollation(std::make_shared<ASTLiteral>(Field(collator->getLocale())));
+
+    result->with_fill = with_fill;
+    if (hasFillFrom())
+        result->setFillFrom(getFillFrom()->toAST(options));
+    if (hasFillTo())
+        result->setFillTo(getFillTo()->toAST(options));
+    if (hasFillStep())
+        result->setFillStep(getFillStep()->toAST(options));

    return result;
 }
--- a/src/Analyzer/WindowNode.cpp
+++ b/src/Analyzer/WindowNode.cpp
@ -1,11 +1,9 @@
 #include <Analyzer/WindowNode.h>
-
-#include <Common/SipHash.h>
-
-#include <IO/WriteBufferFromString.h>
 #include <IO/Operators.h>
-
+#include <IO/WriteBufferFromString.h>
 #include <Parsers/ASTWindowDefinition.h>
+#include <Common/SipHash.h>
+#include <Common/assert_cast.h>

 namespace DB
 {
--- a/src/Backups/BackupEntriesCollector.cpp
+++ b/src/Backups/BackupEntriesCollector.cpp
@ -1,22 +1,25 @@
+#include <Access/Common/AccessEntityType.h>
+#include <Backups/BackupCoordinationStage.h>
 #include <Backups/BackupEntriesCollector.h>
 #include <Backups/BackupEntryFromMemory.h>
-#include <Backups/IBackupCoordination.h>
-#include <Backups/BackupCoordinationStage.h>
 #include <Backups/BackupUtils.h>
 #include <Backups/DDLAdjustingForBackupVisitor.h>
+#include <Backups/IBackupCoordination.h>
 #include <Databases/IDatabase.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/DatabaseCatalog.h>
 #include <Parsers/ASTCreateQuery.h>
 #include <Parsers/formatAST.h>
 #include <Storages/IStorage.h>
-#include <Access/Common/AccessEntityType.h>
 #include <base/chrono_io.h>
 #include <base/insertAtEnd.h>
+#include <base/scope_guard.h>
 #include <base/sleep.h>
 #include <Common/escapeForFileName.h>
+
+#include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/copy.hpp>
-#include <base/scope_guard.h>
+
 #include <filesystem>

 namespace fs = std::filesystem;
--- a/src/Backups/BackupIO_S3.cpp
+++ b/src/Backups/BackupIO_S3.cpp
@ -124,11 +124,12 @@ BackupReaderS3::BackupReaderS3(
    bool allow_s3_native_copy,
    const ReadSettings & read_settings_,
    const WriteSettings & write_settings_,
-    const ContextPtr & context_)
+    const ContextPtr & context_,
+    bool is_internal_backup)
    : BackupReaderDefault(read_settings_, write_settings_, getLogger("BackupReaderS3"))
    , s3_uri(s3_uri_)
    , data_source_description{DataSourceType::ObjectStorage, ObjectStorageType::S3, MetadataStorageType::None, s3_uri.endpoint, false, false}
-    , s3_settings(context_->getStorageS3Settings().getSettings(s3_uri.uri.toString(), context_->getUserName()))
+    , s3_settings(context_->getStorageS3Settings().getSettings(s3_uri.uri.toString(), context_->getUserName(), /*ignore_user=*/is_internal_backup))
 {
    auto & request_settings = s3_settings.request_settings;
    request_settings.updateFromSettings(context_->getSettingsRef());
@ -214,11 +215,12 @@ BackupWriterS3::BackupWriterS3(
    const String & storage_class_name,
    const ReadSettings & read_settings_,
    const WriteSettings & write_settings_,
-    const ContextPtr & context_)
+    const ContextPtr & context_,
+    bool is_internal_backup)
    : BackupWriterDefault(read_settings_, write_settings_, getLogger("BackupWriterS3"))
    , s3_uri(s3_uri_)
    , data_source_description{DataSourceType::ObjectStorage, ObjectStorageType::S3, MetadataStorageType::None, s3_uri.endpoint, false, false}
-    , s3_settings(context_->getStorageS3Settings().getSettings(s3_uri.uri.toString(), context_->getUserName()))
+    , s3_settings(context_->getStorageS3Settings().getSettings(s3_uri.uri.toString(), context_->getUserName(), /*ignore_user=*/is_internal_backup))
 {
    auto & request_settings = s3_settings.request_settings;
    request_settings.updateFromSettings(context_->getSettingsRef());
--- a/src/Backups/BackupIO_S3.h
+++ b/src/Backups/BackupIO_S3.h
@ -18,7 +18,15 @@ namespace DB
 class BackupReaderS3 : public BackupReaderDefault
 {
 public:
-    BackupReaderS3(const S3::URI & s3_uri_, const String & access_key_id_, const String & secret_access_key_, bool allow_s3_native_copy, const ReadSettings & read_settings_, const WriteSettings & write_settings_, const ContextPtr & context_);
+    BackupReaderS3(
+        const S3::URI & s3_uri_,
+        const String & access_key_id_,
+        const String & secret_access_key_,
+        bool allow_s3_native_copy,
+        const ReadSettings & read_settings_,
+        const WriteSettings & write_settings_,
+        const ContextPtr & context_,
+        bool is_internal_backup);
    ~BackupReaderS3() override;

    bool fileExists(const String & file_name) override;
@ -41,7 +49,16 @@ private:
 class BackupWriterS3 : public BackupWriterDefault
 {
 public:
-    BackupWriterS3(const S3::URI & s3_uri_, const String & access_key_id_, const String & secret_access_key_, bool allow_s3_native_copy, const String & storage_class_name, const ReadSettings & read_settings_, const WriteSettings & write_settings_, const ContextPtr & context_);
+    BackupWriterS3(
+        const S3::URI & s3_uri_,
+        const String & access_key_id_,
+        const String & secret_access_key_,
+        bool allow_s3_native_copy,
+        const String & storage_class_name,
+        const ReadSettings & read_settings_,
+        const WriteSettings & write_settings_,
+        const ContextPtr & context_,
+        bool is_internal_backup);
    ~BackupWriterS3() override;

    bool fileExists(const String & file_name) override;
--- a/src/Backups/BackupsWorker.cpp
+++ b/src/Backups/BackupsWorker.cpp
@ -27,6 +27,8 @@
 #include <Common/scope_guard_safe.h>
 #include <Common/ThreadPool.h>

+#include <boost/range/adaptor/map.hpp>
+

 namespace CurrentMetrics
 {
@ -940,6 +942,7 @@ void BackupsWorker::doRestore(
    backup_open_params.use_same_s3_credentials_for_base_backup = restore_settings.use_same_s3_credentials_for_base_backup;
    backup_open_params.read_settings = getReadSettingsForRestore(context);
    backup_open_params.write_settings = getWriteSettingsForRestore(context);
+    backup_open_params.is_internal_backup = restore_settings.internal;
    BackupPtr backup = BackupFactory::instance().createBackup(backup_open_params);

    String current_database = context->getCurrentDatabase();
--- a/src/Backups/RestorerFromBackup.cpp
+++ b/src/Backups/RestorerFromBackup.cpp
@ -24,6 +24,9 @@
 #include <Common/escapeForFileName.h>
 #include <base/insertAtEnd.h>
 #include <boost/algorithm/string/join.hpp>
+
+#include <boost/range/adaptor/map.hpp>
+
 #include <filesystem>
 #include <ranges>

--- a/src/Backups/registerBackupEngineS3.cpp
+++ b/src/Backups/registerBackupEngineS3.cpp
@ -110,7 +110,8 @@ void registerBackupEngineS3(BackupFactory & factory)
                                                           params.allow_s3_native_copy,
                                                           params.read_settings,
                                                           params.write_settings,
-                                                           params.context);
+                                                           params.context,
+                                                           params.is_internal_backup);

            return std::make_unique<BackupImpl>(
                params.backup_info,
@ -129,7 +130,8 @@ void registerBackupEngineS3(BackupFactory & factory)
                                                           params.s3_storage_class,
                                                           params.read_settings,
                                                           params.write_settings,
-                                                           params.context);
+                                                           params.context,
+                                                           params.is_internal_backup);

            return std::make_unique<BackupImpl>(
                params.backup_info,
--- a/src/Columns/ColumnAggregateFunction.cpp
+++ b/src/Columns/ColumnAggregateFunction.cpp
@ -1,7 +1,13 @@
 #include <Columns/ColumnAggregateFunction.h>

+#include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnsCommon.h>
 #include <Columns/MaskOperations.h>
+#include <IO/Operators.h>
+#include <IO/ReadBufferFromString.h>
+#include <IO/WriteBufferFromArena.h>
+#include <IO/WriteBufferFromString.h>
+#include <Processors/Transforms/ColumnGathererTransform.h>
 #include <Common/AlignedBuffer.h>
 #include <Common/Arena.h>
 #include <Common/FieldVisitorToString.h>
@ -11,10 +17,6 @@
 #include <Common/assert_cast.h>
 #include <Common/iota.h>
 #include <Common/typeid_cast.h>
-#include <IO/Operators.h>
-#include <IO/WriteBufferFromArena.h>
-#include <IO/WriteBufferFromString.h>
-#include <Processors/Transforms/ColumnGathererTransform.h>


 namespace DB
@ -109,6 +111,11 @@ ConstArenas concatArenas(const ConstArenas & array, ConstArenaPtr arena)

 }

+std::string ColumnAggregateFunction::getName() const
+{
+    return "AggregateFunction(" + func->getName() + ")";
+}
+
 MutableColumnPtr ColumnAggregateFunction::convertToValues(MutableColumnPtr column)
 {
    /** If the aggregate function returns an unfinalized/unfinished state,
--- a/src/Columns/ColumnAggregateFunction.h
+++ b/src/Columns/ColumnAggregateFunction.h
@ -1,17 +1,9 @@
 #pragma once

-#include <AggregateFunctions/IAggregateFunction.h>
-
+#include <AggregateFunctions/IAggregateFunction_fwd.h>
 #include <Columns/IColumn.h>
-#include <Common/PODArray.h>
-
 #include <Core/Field.h>
-
-#include <IO/ReadBufferFromString.h>
-#include <IO/WriteBuffer.h>
-#include <IO/WriteHelpers.h>
-
-#include <Functions/FunctionHelpers.h>
+#include <Common/PODArray.h>

 namespace DB
 {
@ -26,6 +18,12 @@ using ArenaPtr = std::shared_ptr<Arena>;
 using ConstArenaPtr = std::shared_ptr<const Arena>;
 using ConstArenas = std::vector<ConstArenaPtr>;

+class Context;
+using ContextPtr = std::shared_ptr<const Context>;
+
+struct ColumnWithTypeAndName;
+using ColumnsWithTypeAndName = std::vector<ColumnWithTypeAndName>;
+

 /** Column of states of aggregate functions.
  * Presented as an array of pointers to the states of aggregate functions (data).
@ -121,7 +119,7 @@ public:
    /// This method is made static and receive MutableColumnPtr object to explicitly destroy it.
    static MutableColumnPtr convertToValues(MutableColumnPtr column);

-    std::string getName() const override { return "AggregateFunction(" + func->getName() + ")"; }
+    std::string getName() const override;
    const char * getFamilyName() const override { return "AggregateFunction"; }
    TypeIndex getDataType() const override { return TypeIndex::AggregateFunction; }

--- a/src/Columns/ColumnObject.h
+++ b/src/Columns/ColumnObject.h
@ -1,12 +1,10 @@
 #pragma once

+#include <Columns/IColumn.h>
 #include <Core/Field.h>
 #include <Core/Names.h>
-#include <Columns/IColumn.h>
-#include <Common/PODArray.h>
-#include <Common/HashTable/HashMap.h>
-#include <DataTypes/Serializations/JSONDataParser.h>
 #include <DataTypes/Serializations/SubcolumnsTree.h>
+#include <Common/PODArray.h>

 #include <DataTypes/IDataType.h>

--- a/src/Columns/ColumnSparse.cpp
+++ b/src/Columns/ColumnSparse.cpp
@ -346,7 +346,7 @@ ColumnPtr ColumnSparse::filter(const Filter & filt, ssize_t) const
    }

    auto res_values = values->filter(values_filter, values_result_size_hint);
-    return this->create(res_values, std::move(res_offsets), res_offset);
+    return create(res_values, std::move(res_offsets), res_offset);
 }

 void ColumnSparse::expand(const Filter & mask, bool inverted)
--- a/src/Common/AsynchronousMetrics.cpp
+++ b/src/Common/AsynchronousMetrics.cpp
@ -671,7 +671,7 @@ void AsynchronousMetrics::update(TimePoint update_time, bool force_update)
                    ReadableSize(rss),
                    ReadableSize(difference));

-            total_memory_tracker.setRSS(rss, free_memory_in_allocator_arenas);
+            MemoryTracker::setRSS(rss, free_memory_in_allocator_arenas);
        }
    }

--- a/src/Common/FileChecker.cpp
+++ b/src/Common/FileChecker.cpp
@ -10,6 +10,8 @@
 #include <IO/ReadHelpers.h>
 #include <base/JSON.h>

+#include <boost/range/adaptor/map.hpp>
+

 namespace fs = std::filesystem;

--- a/src/Common/HTTPConnectionPool.cpp
+++ b/src/Common/HTTPConnectionPool.cpp
@ -203,7 +203,7 @@ public:
        if (total_connections_in_group >= limits.warning_limit && total_connections_in_group >= mute_warning_until)
        {
            LOG_WARNING(log, "Too many active sessions in group {}, count {}, warning limit {}", type, total_connections_in_group, limits.warning_limit);
-            mute_warning_until = roundUp(total_connections_in_group, limits.warning_step);
+            mute_warning_until = roundUp(total_connections_in_group, HTTPConnectionPools::Limits::warning_step);
        }
    }

--- a/src/Common/HashTable/HashMap.h
+++ b/src/Common/HashTable/HashMap.h
@ -207,7 +207,7 @@ public:
    void ALWAYS_INLINE mergeToViaEmplace(Self & that, Func && func)
    {
        DB::PrefetchingHelper prefetching;
-        size_t prefetch_look_ahead = prefetching.getInitialLookAheadValue();
+        size_t prefetch_look_ahead = DB::PrefetchingHelper::getInitialLookAheadValue();

        size_t i = 0;
        auto prefetch_it = advanceIterator(this->begin(), prefetch_look_ahead);
@ -216,10 +216,10 @@ public:
        {
            if constexpr (prefetch)
            {
-                if (i == prefetching.iterationsToMeasure())
+                if (i == DB::PrefetchingHelper::iterationsToMeasure())
                {
                    prefetch_look_ahead = prefetching.calcPrefetchLookAhead();
-                    prefetch_it = advanceIterator(prefetch_it, prefetch_look_ahead - prefetching.getInitialLookAheadValue());
+                    prefetch_it = advanceIterator(prefetch_it, prefetch_look_ahead - DB::PrefetchingHelper::getInitialLookAheadValue());
                }

                if (prefetch_it != end)
--- a/src/Common/QueryProfiler.cpp
+++ b/src/Common/QueryProfiler.cpp
@ -211,23 +211,13 @@ void Timer::cleanup()
 #endif

 template <typename ProfilerImpl>
-QueryProfilerBase<ProfilerImpl>::QueryProfilerBase(UInt64 thread_id, int clock_type, UInt32 period, int pause_signal_)
+QueryProfilerBase<ProfilerImpl>::QueryProfilerBase([[maybe_unused]] UInt64 thread_id, [[maybe_unused]] int clock_type, [[maybe_unused]] UInt32 period, [[maybe_unused]] int pause_signal_)
    : log(getLogger("QueryProfiler"))
    , pause_signal(pause_signal_)
 {
 #if defined(SANITIZER)
-    UNUSED(thread_id);
-    UNUSED(clock_type);
-    UNUSED(period);
-    UNUSED(pause_signal);
-
    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "QueryProfiler disabled because they cannot work under sanitizers");
 #elif defined(__APPLE__)
-    UNUSED(thread_id);
-    UNUSED(clock_type);
-    UNUSED(period);
-    UNUSED(pause_signal);
-
    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "QueryProfiler cannot work on OSX");
 #else
    /// Sanity check.
@ -261,6 +251,20 @@ QueryProfilerBase<ProfilerImpl>::QueryProfilerBase(UInt64 thread_id, int clock_t
 #endif
 }

+
+template <typename ProfilerImpl>
+void QueryProfilerBase<ProfilerImpl>::setPeriod([[maybe_unused]] UInt32 period_)
+{
+#if defined(SANITIZER)
+    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "QueryProfiler disabled because they cannot work under sanitizers");
+#elif defined(__APPLE__)
+    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "QueryProfiler cannot work on OSX");
+#else
+    timer.set(period_);
+#endif
+
+}
+
 template <typename ProfilerImpl>
 QueryProfilerBase<ProfilerImpl>::~QueryProfilerBase()
 {
--- a/src/Common/QueryProfiler.h
+++ b/src/Common/QueryProfiler.h
@ -57,6 +57,8 @@ public:
    QueryProfilerBase(UInt64 thread_id, int clock_type, UInt32 period, int pause_signal_);
    ~QueryProfilerBase();

+    void setPeriod(UInt32 period_);
+
 private:
    void cleanup();

--- a/src/Common/StackTrace.cpp
+++ b/src/Common/StackTrace.cpp
@ -366,7 +366,7 @@ String demangleAndCollapseNames(std::optional<std::string_view> file, const char
    if (file.has_value())
    {
        std::string_view file_copy = file.value();
-        if (auto trim_pos = file_copy.find_last_of('/'); trim_pos != file_copy.npos)
+        if (auto trim_pos = file_copy.find_last_of('/'); trim_pos != std::string_view::npos)
            file_copy.remove_suffix(file_copy.size() - trim_pos);
        if (file_copy.ends_with("functional"))
            return "?";
--- a/src/Common/ThreadPool.cpp
+++ b/src/Common/ThreadPool.cpp
@ -490,8 +490,9 @@ void ThreadPoolImpl<Thread>::worker(typename std::list<Thread>::iterator thread_


 template class ThreadPoolImpl<std::thread>;
-template class ThreadPoolImpl<ThreadFromGlobalPoolImpl<false>>;
-template class ThreadFromGlobalPoolImpl<true>;
+template class ThreadPoolImpl<ThreadFromGlobalPoolImpl<false, true>>;
+template class ThreadFromGlobalPoolImpl<true, true>;
+template class ThreadFromGlobalPoolImpl<true, false>;

 std::unique_ptr<GlobalThreadPool> GlobalThreadPool::the_instance;

@ -500,7 +501,9 @@ GlobalThreadPool::GlobalThreadPool(
    size_t max_threads_,
    size_t max_free_threads_,
    size_t queue_size_,
-    const bool shutdown_on_exception_)
+    const bool shutdown_on_exception_,
+    UInt64 global_profiler_real_time_period_ns_,
+    UInt64 global_profiler_cpu_time_period_ns_)
    : FreeThreadPool(
        CurrentMetrics::GlobalThread,
        CurrentMetrics::GlobalThreadActive,
@ -509,10 +512,12 @@ GlobalThreadPool::GlobalThreadPool(
        max_free_threads_,
        queue_size_,
        shutdown_on_exception_)
+    , global_profiler_real_time_period_ns(global_profiler_real_time_period_ns_)
+    , global_profiler_cpu_time_period_ns(global_profiler_cpu_time_period_ns_)
 {
 }

-void GlobalThreadPool::initialize(size_t max_threads, size_t max_free_threads, size_t queue_size)
+void GlobalThreadPool::initialize(size_t max_threads, size_t max_free_threads, size_t queue_size, UInt64 global_profiler_real_time_period_ns, UInt64 global_profiler_cpu_time_period_ns)
 {
    if (the_instance)
    {
@ -520,7 +525,7 @@ void GlobalThreadPool::initialize(size_t max_threads, size_t max_free_threads, s
            "The global thread pool is initialized twice");
    }

-    the_instance.reset(new GlobalThreadPool(max_threads, max_free_threads, queue_size, false /*shutdown_on_exception*/));
+    the_instance.reset(new GlobalThreadPool(max_threads, max_free_threads, queue_size, false /*shutdown_on_exception*/, global_profiler_real_time_period_ns, global_profiler_cpu_time_period_ns));
 }

 GlobalThreadPool & GlobalThreadPool::instance()
--- a/src/Common/ThreadPool.h
+++ b/src/Common/ThreadPool.h
@ -172,10 +172,21 @@ class GlobalThreadPool : public FreeThreadPool, private boost::noncopyable
        size_t max_threads_,
        size_t max_free_threads_,
        size_t queue_size_,
-        bool shutdown_on_exception_);
+        bool shutdown_on_exception_,
+        UInt64 global_profiler_real_time_period_ns_,
+        UInt64 global_profiler_cpu_time_period_ns_);

 public:
-    static void initialize(size_t max_threads = 10000, size_t max_free_threads = 1000, size_t queue_size = 10000);
+    UInt64 global_profiler_real_time_period_ns;
+    UInt64 global_profiler_cpu_time_period_ns;
+
+    static void initialize(
+        size_t max_threads = 10000,
+        size_t max_free_threads = 1000,
+        size_t queue_size = 10000,
+        UInt64 global_profiler_real_time_period_ns_ = 0,
+        UInt64 global_profiler_cpu_time_period_ns_ = 0);
+
    static GlobalThreadPool & instance();
    static void shutdown();
 };
@ -187,7 +198,7 @@ public:
  * NOTE: User code should use 'ThreadFromGlobalPool' declared below instead of directly using this class.
  *
  */
-template <bool propagate_opentelemetry_context = true>
+template <bool propagate_opentelemetry_context = true, bool global_trace_collector_allowed = true>
 class ThreadFromGlobalPoolImpl : boost::noncopyable
 {
 public:
@ -197,11 +208,15 @@ public:
    explicit ThreadFromGlobalPoolImpl(Function && func, Args &&... args)
        : state(std::make_shared<State>())
    {
+        UInt64 global_profiler_real_time_period = GlobalThreadPool::instance().global_profiler_real_time_period_ns;
+        UInt64 global_profiler_cpu_time_period = GlobalThreadPool::instance().global_profiler_cpu_time_period_ns;
        /// NOTE:
        /// - If this will throw an exception, the destructor won't be called
        /// - this pointer cannot be passed in the lambda, since after detach() it will not be valid
        GlobalThreadPool::instance().scheduleOrThrow([
            my_state = state,
+            global_profiler_real_time_period,
+            global_profiler_cpu_time_period,
            my_func = std::forward<Function>(func),
            my_args = std::make_tuple(std::forward<Args>(args)...)]() mutable /// mutable is needed to destroy capture
        {
@ -220,6 +235,12 @@ public:
            /// Thread status holds raw pointer on query context, thus it always must be destroyed
            /// before sending signal that permits to join this thread.
            DB::ThreadStatus thread_status;
+            if constexpr (global_trace_collector_allowed)
+            {
+                if (unlikely(global_profiler_real_time_period != 0 || global_profiler_cpu_time_period != 0))
+                    thread_status.initGlobalProfiler(global_profiler_real_time_period, global_profiler_cpu_time_period);
+            }
+
            std::apply(function, arguments);
        },
        {}, // default priority
@ -305,11 +326,12 @@ protected:
 /// you need to use class, or you need to use ThreadFromGlobalPool below.
 ///
 /// See the comments of ThreadPool below to know how it works.
-using ThreadFromGlobalPoolNoTracingContextPropagation = ThreadFromGlobalPoolImpl<false>;
+using ThreadFromGlobalPoolNoTracingContextPropagation = ThreadFromGlobalPoolImpl<false, true>;

 /// An alias of thread that execute jobs/tasks on global thread pool by implicit passing tracing context on current thread to underlying worker as parent tracing context.
 /// If jobs/tasks are directly scheduled by using APIs of this class, you need to use this class or you need to use class above.
-using ThreadFromGlobalPool = ThreadFromGlobalPoolImpl<true>;
+using ThreadFromGlobalPool = ThreadFromGlobalPoolImpl<true, true>;
+using ThreadFromGlobalPoolWithoutTraceCollector = ThreadFromGlobalPoolImpl<true, false>;

 /// Recommended thread pool for the case when multiple thread pools are created and destroyed.
 ///
--- a/src/Common/ThreadPool_fwd.h
+++ b/src/Common/ThreadPool_fwd.h
@ -3,11 +3,12 @@
 template <typename Thread>
 class ThreadPoolImpl;

-template <bool propagate_opentelemetry_context>
+template <bool propagate_opentelemetry_context, bool global_trace_collector_allowed>
 class ThreadFromGlobalPoolImpl;

-using ThreadFromGlobalPoolNoTracingContextPropagation = ThreadFromGlobalPoolImpl<false>;
+using ThreadFromGlobalPoolNoTracingContextPropagation = ThreadFromGlobalPoolImpl<false, true>;

-using ThreadFromGlobalPool = ThreadFromGlobalPoolImpl<true>;
+using ThreadFromGlobalPool = ThreadFromGlobalPoolImpl<true, true>;
+using ThreadFromGlobalPoolWithoutTraceCollector = ThreadFromGlobalPoolImpl<true, false>;

 using ThreadPool = ThreadPoolImpl<ThreadFromGlobalPoolNoTracingContextPropagation>;
--- a/src/Common/ThreadStatus.cpp
+++ b/src/Common/ThreadStatus.cpp
@ -96,7 +96,7 @@ ThreadStatus::ThreadStatus(bool check_current_thread_on_destruction_)
        stack_t altstack_description{};
        altstack_description.ss_sp = alt_stack.getData();
        altstack_description.ss_flags = 0;
-        altstack_description.ss_size = alt_stack.getSize();
+        altstack_description.ss_size = ThreadStack::getSize();

        if (0 != sigaltstack(&altstack_description, nullptr))
        {
@ -124,6 +124,26 @@ ThreadStatus::ThreadStatus(bool check_current_thread_on_destruction_)
 #endif
 }

+void ThreadStatus::initGlobalProfiler([[maybe_unused]] UInt64 global_profiler_real_time_period, [[maybe_unused]] UInt64 global_profiler_cpu_time_period)
+{
+#if !defined(SANITIZER) && !defined(CLICKHOUSE_KEEPER_STANDALONE_BUILD) && !defined(__APPLE__)
+    try
+    {
+        if (global_profiler_real_time_period > 0)
+            query_profiler_real = std::make_unique<QueryProfilerReal>(thread_id,
+                /* period= */ static_cast<UInt32>(global_profiler_real_time_period));
+
+        if (global_profiler_cpu_time_period > 0)
+            query_profiler_cpu = std::make_unique<QueryProfilerCPU>(thread_id,
+                /* period= */ static_cast<UInt32>(global_profiler_cpu_time_period));
+    }
+    catch (...)
+    {
+        tryLogCurrentException("ThreadStatus", "Cannot initialize GlobalProfiler");
+    }
+#endif
+}
+
 ThreadGroupPtr ThreadStatus::getThreadGroup() const
 {
    chassert(current_thread == this);
--- a/src/Common/ThreadStatus.h
+++ b/src/Common/ThreadStatus.h
@ -307,6 +307,8 @@ public:

    void flushUntrackedMemory();

+    void initGlobalProfiler(UInt64 global_profiler_real_time_period, UInt64 global_profiler_cpu_time_period);
+
 private:
    void applyGlobalSettings();
    void applyQuerySettings();
--- a/src/Common/randomDelay.cpp
+++ b/src/Common/randomDelay.cpp
@ -0,0 +1,39 @@
+#include <Common/randomDelay.h>
+
+#include <Common/logger_useful.h>
+#include <Common/randomNumber.h>
+#include <base/sleep.h>
+
+
+void randomDelayForMaxMilliseconds(uint64_t milliseconds, LoggerPtr log, const char * start_of_message)
+{
+    if (milliseconds)
+    {
+        auto count = randomNumber() % milliseconds;
+
+        if (log)
+        {
+            if (start_of_message && !*start_of_message)
+                start_of_message = nullptr;
+
+            LOG_TEST(log, "{}{}Sleeping for {} milliseconds",
+                     (start_of_message ? start_of_message : ""),
+                     (start_of_message ? ": " : ""),
+                     count);
+        }
+
+        sleepForMilliseconds(count);
+
+        if (log)
+        {
+            LOG_TEST(log, "{}{}Awaking after sleeping",
+                     (start_of_message ? start_of_message : ""),
+                     (start_of_message ? ": " : ""));
+        }
+    }
+}
+
+void randomDelayForMaxSeconds(uint64_t seconds, LoggerPtr log, const char * start_of_message)
+{
+    randomDelayForMaxMilliseconds(seconds * 1000, log, start_of_message);
+}
--- a/src/Common/randomDelay.h
+++ b/src/Common/randomDelay.h
@ -0,0 +1,8 @@
+#pragma once
+
+#include <Common/Logger.h>
+
+/// Sleeps for random duration between 0 and a specified number of milliseconds, optionally outputs a logging message about that.
+/// This function can be used to add random delays in tests.
+void randomDelayForMaxMilliseconds(uint64_t milliseconds, LoggerPtr log = nullptr, const char * start_of_message = nullptr);
+void randomDelayForMaxSeconds(uint64_t seconds, LoggerPtr log = nullptr, const char * start_of_message = nullptr);
--- a/src/Compression/CachedCompressedReadBuffer.cpp
+++ b/src/Compression/CachedCompressedReadBuffer.cpp
@ -38,7 +38,7 @@ void CachedCompressedReadBuffer::prefetch(Priority priority)
 bool CachedCompressedReadBuffer::nextImpl()
 {
    /// Let's check for the presence of a decompressed block in the cache, grab the ownership of this block, if it exists.
-    UInt128 key = cache->hash(path, file_pos);
+    UInt128 key = UncompressedCache::hash(path, file_pos);

    owned_cell = cache->getOrSet(key, [&]()
    {
--- a/src/Coordination/FourLetterCommand.cpp
+++ b/src/Coordination/FourLetterCommand.cpp
@ -592,7 +592,7 @@ String RecalculateCommand::run()

 String CleanResourcesCommand::run()
 {
-    keeper_dispatcher.cleanResources();
+    KeeperDispatcher::cleanResources();
    return "ok";
 }

--- a/src/Core/Block.cpp
+++ b/src/Core/Block.cpp
@ -1,19 +1,17 @@
-#include <Common/Exception.h>
-#include <Common/FieldVisitorToString.h>
-
-#include <Core/Block.h>
-
-#include <IO/WriteBufferFromString.h>
-#include <IO/Operators.h>
-
-#include <Common/assert_cast.h>
-
+#include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnAggregateFunction.h>
 #include <Columns/ColumnConst.h>
 #include <Columns/ColumnSparse.h>
+#include <Core/Block.h>
+#include <IO/Operators.h>
+#include <IO/WriteBufferFromString.h>
+#include <base/sort.h>
+#include <Common/Exception.h>
+#include <Common/FieldVisitorToString.h>
+#include <Common/assert_cast.h>

 #include <iterator>
-#include <base/sort.h>
+
 #include <boost/algorithm/string.hpp>


--- a/src/Core/Field.cpp
+++ b/src/Core/Field.cpp
@ -22,6 +22,12 @@ namespace ErrorCodes
    extern const int DECIMAL_OVERFLOW;
 }

+template <is_decimal T>
+T DecimalField<T>::getScaleMultiplier() const
+{
+    return DecimalUtils::scaleMultiplier<T>(scale);
+}
+
 inline Field getBinaryValue(UInt8 type, ReadBuffer & buf)
 {
    switch (static_cast<Field::Types::Which>(type))
@ -627,5 +633,9 @@ std::string_view Field::getTypeName() const
    return fieldTypeToString(which);
 }

-
+template class DecimalField<Decimal32>;
+template class DecimalField<Decimal64>;
+template class DecimalField<Decimal128>;
+template class DecimalField<Decimal256>;
+template class DecimalField<DateTime64>;
 }
--- a/src/Core/Field.h
+++ b/src/Core/Field.h
@ -8,7 +8,6 @@
 #include <functional>

 #include <Core/CompareHelper.h>
-#include <Core/DecimalFunctions.h>
 #include <Core/Defines.h>
 #include <Core/Types.h>
 #include <Core/UUID.h>
@ -151,7 +150,7 @@ public:

    operator T() const { return dec; } /// NOLINT
    T getValue() const { return dec; }
-    T getScaleMultiplier() const { return DecimalUtils::scaleMultiplier<T>(scale); }
+    T getScaleMultiplier() const;
    UInt32 getScale() const { return scale; }

    template <typename U>
@ -200,6 +199,12 @@ private:
    UInt32 scale;
 };

+extern template class DecimalField<Decimal32>;
+extern template class DecimalField<Decimal64>;
+extern template class DecimalField<Decimal128>;
+extern template class DecimalField<Decimal256>;
+extern template class DecimalField<DateTime64>;
+
 template <typename T> constexpr bool is_decimal_field = false;
 template <> constexpr inline bool is_decimal_field<DecimalField<Decimal32>> = true;
 template <> constexpr inline bool is_decimal_field<DecimalField<Decimal64>> = true;
--- a/src/Core/ServerSettings.h
+++ b/src/Core/ServerSettings.h
@ -137,6 +137,8 @@ namespace DB
    M(UInt64, http_connections_soft_limit, 100, "Connections above this limit have significantly shorter time to live. The limit applies to the http connections which do not belong to any disk or storage.", 0) \
    M(UInt64, http_connections_warn_limit, 1000, "Warning massages are written to the logs if number of in-use connections are higher than this limit. The limit applies to the http connections which do not belong to any disk or storage.", 0) \
    M(UInt64, http_connections_store_limit, 5000, "Connections above this limit reset after use. Set to 0 to turn connection cache off. The limit applies to the http connections which do not belong to any disk or storage.", 0) \
+    M(UInt64, global_profiler_real_time_period_ns, 0, "Period for real clock timer of global profiler (in nanoseconds). Set 0 value to turn off the real clock global profiler. Recommended value is at least 10000000 (100 times a second) for single queries or 1000000000 (once a second) for cluster-wide profiling.", 0) \
+    M(UInt64, global_profiler_cpu_time_period_ns, 0, "Period for CPU clock timer of global profiler (in nanoseconds). Set 0 value to turn off the CPU clock global profiler. Recommended value is at least 10000000 (100 times a second) for single queries or 1000000000 (once a second) for cluster-wide profiling.", 0) \

 /// If you add a setting which can be updated at runtime, please update 'changeable_settings' map in StorageSystemServerSettings.cpp

--- a/src/Core/SettingsEnums.cpp
+++ b/src/Core/SettingsEnums.cpp
@ -2,6 +2,8 @@
 #include <magic_enum.hpp>
 #include <Access/Common/SQLSecurityDefs.h>

+#include <boost/range/adaptor/map.hpp>
+

 namespace DB
 {
--- a/src/Core/SettingsFields.h
+++ b/src/Core/SettingsFields.h
@ -1,13 +1,12 @@
 #pragma once

-#include <Poco/Timespan.h>
-#include <Poco/URI.h>
-#include <base/types.h>
-#include <Core/Field.h>
-#include <Core/MultiEnum.h>
-#include <boost/range/adaptor/map.hpp>
 #include <chrono>
 #include <string_view>
+#include <Core/Field.h>
+#include <Core/MultiEnum.h>
+#include <base/types.h>
+#include <Poco/Timespan.h>
+#include <Poco/URI.h>


 namespace DB
--- a/src/DataTypes/DataTypeAggregateFunction.cpp
+++ b/src/DataTypes/DataTypeAggregateFunction.cpp
@ -15,6 +15,7 @@
 #include <IO/Operators.h>

 #include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/IAggregateFunction.h>
 #include <Parsers/ASTFunction.h>
 #include <Parsers/ASTIdentifier_fwd.h>
 #include <Parsers/ASTLiteral.h>
@ -32,6 +33,11 @@ namespace ErrorCodes
    extern const int LOGICAL_ERROR;
 }

+String DataTypeAggregateFunction::getFunctionName() const
+{
+    return function->getName();
+}
+

 String DataTypeAggregateFunction::doGetName() const
 {
@ -52,6 +58,25 @@ size_t DataTypeAggregateFunction::getVersion() const
    return function->getDefaultVersion();
 }

+DataTypePtr DataTypeAggregateFunction::getReturnType() const
+{
+    return function->getResultType();
+}
+
+DataTypePtr DataTypeAggregateFunction::getReturnTypeToPredict() const
+{
+    return function->getReturnTypeToPredict();
+}
+
+bool DataTypeAggregateFunction::isVersioned() const
+{
+    return function->isVersioned();
+}
+
+void DataTypeAggregateFunction::updateVersionFromRevision(size_t revision, bool if_empty) const
+{
+    setVersion(function->getVersionFromRevision(revision), if_empty);
+}

 String DataTypeAggregateFunction::getNameImpl(bool with_version) const
 {
--- a/src/DataTypes/DataTypeAggregateFunction.h
+++ b/src/DataTypes/DataTypeAggregateFunction.h
@ -1,7 +1,7 @@
 #pragma once

-#include <AggregateFunctions/IAggregateFunction.h>
-
+#include <AggregateFunctions/IAggregateFunction_fwd.h>
+#include <Core/Field.h>
 #include <DataTypes/IDataType.h>


@ -39,7 +39,7 @@ public:
    {
    }

-    String getFunctionName() const { return function->getName(); }
+    String getFunctionName() const;
    AggregateFunctionPtr getFunction() const { return function; }

    String doGetName() const override;
@ -51,8 +51,8 @@ public:

    bool canBeInsideNullable() const override { return false; }

-    DataTypePtr getReturnType() const { return function->getResultType(); }
-    DataTypePtr getReturnTypeToPredict() const { return function->getReturnTypeToPredict(); }
+    DataTypePtr getReturnType() const;
+    DataTypePtr getReturnTypeToPredict() const;
    DataTypes getArgumentsDataTypes() const { return argument_types; }

    MutableColumnPtr createColumn() const override;
@ -69,7 +69,7 @@ public:
    SerializationPtr doGetDefaultSerialization() const override;
    bool supportsSparseSerialization() const override { return false; }

-    bool isVersioned() const { return function->isVersioned(); }
+    bool isVersioned() const;

    /// Version is not empty only if it was parsed from AST or implicitly cast to 0 or version according
    /// to server revision.
@ -84,10 +84,7 @@ public:
        version = version_;
    }

-    void updateVersionFromRevision(size_t revision, bool if_empty) const
-    {
-        setVersion(function->getVersionFromRevision(revision), if_empty);
-    }
+    void updateVersionFromRevision(size_t revision, bool if_empty) const;
 };

 void setVersionToAggregateFunctions(DataTypePtr & type, bool if_empty, std::optional<size_t> revision = std::nullopt);
--- a/src/DataTypes/DataTypeCustomSimpleAggregateFunction.cpp
+++ b/src/DataTypes/DataTypeCustomSimpleAggregateFunction.cpp
@ -7,6 +7,7 @@
 #include <DataTypes/DataTypeFactory.h>

 #include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/IAggregateFunction.h>
 #include <Parsers/ASTFunction.h>
 #include <Parsers/ASTIdentifier.h>
 #include <Parsers/ASTLiteral.h>
--- a/src/DataTypes/DataTypeCustomSimpleAggregateFunction.h
+++ b/src/DataTypes/DataTypeCustomSimpleAggregateFunction.h
@ -1,13 +1,18 @@
 #pragma once

+#include <AggregateFunctions/IAggregateFunction_fwd.h>
+#include <Core/Field.h>
 #include <DataTypes/DataTypeCustom.h>
-#include <AggregateFunctions/IAggregateFunction.h>

 #include <IO/ReadHelpers.h>

 namespace DB
 {

+class IDataType;
+using DataTypePtr = std::shared_ptr<const IDataType>;
+using DataTypes = std::vector<DataTypePtr>;
+
 /** The type SimpleAggregateFunction(fct, type) is meant to be used in an AggregatingMergeTree. It behaves like a standard
 * data type but when rows are merged, an aggregation function is applied.
 *
--- a/src/DataTypes/Serializations/SerializationAggregateFunction.cpp
+++ b/src/DataTypes/Serializations/SerializationAggregateFunction.cpp
@ -1,17 +1,15 @@
-#include <DataTypes/Serializations/SerializationAggregateFunction.h>
-
-#include <IO/WriteHelpers.h>
-
+#include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnAggregateFunction.h>
-
-#include <Common/typeid_cast.h>
-#include <Common/assert_cast.h>
-#include <Common/AlignedBuffer.h>
-#include <Common/Arena.h>
-
+#include <DataTypes/Serializations/SerializationAggregateFunction.h>
 #include <Formats/FormatSettings.h>
 #include <IO/Operators.h>
+#include <IO/ReadBufferFromString.h>
 #include <IO/WriteBufferFromString.h>
+#include <IO/WriteHelpers.h>
+#include <Common/AlignedBuffer.h>
+#include <Common/Arena.h>
+#include <Common/assert_cast.h>
+#include <Common/typeid_cast.h>

 namespace DB
 {
--- a/src/DataTypes/Serializations/SerializationAggregateFunction.h
+++ b/src/DataTypes/Serializations/SerializationAggregateFunction.h
@ -1,6 +1,6 @@
 #pragma once

-#include <AggregateFunctions/IAggregateFunction.h>
+#include <AggregateFunctions/IAggregateFunction_fwd.h>

 #include <DataTypes/Serializations/ISerialization.h>

--- a/src/DataTypes/Serializations/SerializationBool.cpp
+++ b/src/DataTypes/Serializations/SerializationBool.cpp
@ -194,12 +194,12 @@ ReturnType deserializeImpl(
        buf.dropCheckpoint();
        if (buf.hasUnreadData())
        {
+            restore_column_if_needed();
            if constexpr (throw_exception)
                throw Exception(
                    ErrorCodes::CANNOT_PARSE_BOOL,
                    "Cannot continue parsing after parsed bool value because it will result in the loss of some data. It may happen if "
                    "bool_true_representation or bool_false_representation contains some delimiters of input format");
-            restore_column_if_needed();
            return ReturnType(false);
        }
        return ReturnType(true);
--- a/src/DataTypes/getLeastSupertype.cpp
+++ b/src/DataTypes/getLeastSupertype.cpp
@ -463,6 +463,9 @@ DataTypePtr getLeastSupertype(const DataTypes & types)
            /// nested_type will be nullptr, we should return nullptr in this case.
            if (!nested_type)
                return nullptr;
+            /// Common type for Nullable(Nothing) and Variant(...) is Variant(...)
+            if (isVariant(nested_type))
+                return nested_type;
            return std::make_shared<DataTypeNullable>(nested_type);
        }
    }
--- a/src/Databases/DatabaseAtomic.cpp
+++ b/src/Databases/DatabaseAtomic.cpp
@ -417,9 +417,9 @@ void DatabaseAtomic::assertCanBeDetached(bool cleanup)
 }

 DatabaseTablesIteratorPtr
-DatabaseAtomic::getTablesIterator(ContextPtr local_context, const IDatabase::FilterByNameFunction & filter_by_table_name) const
+DatabaseAtomic::getTablesIterator(ContextPtr local_context, const IDatabase::FilterByNameFunction & filter_by_table_name, bool skip_not_loaded) const
 {
-    auto base_iter = DatabaseOrdinary::getTablesIterator(local_context, filter_by_table_name);
+    auto base_iter = DatabaseOrdinary::getTablesIterator(local_context, filter_by_table_name, skip_not_loaded);
    return std::make_unique<AtomicDatabaseTablesSnapshotIterator>(std::move(typeid_cast<DatabaseTablesSnapshotIterator &>(*base_iter)));
 }

--- a/src/Databases/DatabaseAtomic.h
+++ b/src/Databases/DatabaseAtomic.h
@ -46,7 +46,7 @@ public:

    void drop(ContextPtr /*context*/) override;

-    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name) const override;
+    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name, bool skip_not_loaded) const override;

    void beforeLoadingMetadata(ContextMutablePtr context, LoadingStrictnessLevel mode) override;

--- a/src/Databases/DatabaseDictionary.cpp
+++ b/src/Databases/DatabaseDictionary.cpp
@ -80,7 +80,7 @@ StoragePtr DatabaseDictionary::tryGetTable(const String & table_name, ContextPtr
    return createStorageDictionary(getDatabaseName(), load_result, getContext());
 }

-DatabaseTablesIteratorPtr DatabaseDictionary::getTablesIterator(ContextPtr, const FilterByNameFunction & filter_by_table_name) const
+DatabaseTablesIteratorPtr DatabaseDictionary::getTablesIterator(ContextPtr, const FilterByNameFunction & filter_by_table_name, bool /* skip_not_loaded */) const
 {
    return std::make_unique<DatabaseTablesSnapshotIterator>(listTables(filter_by_table_name), getDatabaseName());
 }
--- a/src/Databases/DatabaseDictionary.h
+++ b/src/Databases/DatabaseDictionary.h
@ -34,7 +34,7 @@ public:

    StoragePtr tryGetTable(const String & table_name, ContextPtr context) const override;

-    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name) const override;
+    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name, bool skip_not_loaded) const override;

    bool empty() const override;

--- a/src/Databases/DatabaseFilesystem.cpp
+++ b/src/Databases/DatabaseFilesystem.cpp
@ -229,7 +229,7 @@ std::vector<std::pair<ASTPtr, StoragePtr>> DatabaseFilesystem::getTablesForBacku
 * Returns an empty iterator because the database does not have its own tables
 * But only caches them for quick access
 */
-DatabaseTablesIteratorPtr DatabaseFilesystem::getTablesIterator(ContextPtr, const FilterByNameFunction &) const
+DatabaseTablesIteratorPtr DatabaseFilesystem::getTablesIterator(ContextPtr, const FilterByNameFunction &, bool) const
 {
    return std::make_unique<DatabaseTablesSnapshotIterator>(Tables{}, getDatabaseName());
 }
--- a/src/Databases/DatabaseFilesystem.h
+++ b/src/Databases/DatabaseFilesystem.h
@ -45,7 +45,7 @@ public:

    std::vector<std::pair<ASTPtr, StoragePtr>> getTablesForBackup(const FilterByNameFunction &, const ContextPtr &) const override;

-    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr, const FilterByNameFunction &) const override;
+    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr, const FilterByNameFunction &, bool) const override;

 protected:
    StoragePtr getTableImpl(const String & name, ContextPtr context, bool throw_on_error) const;
--- a/Show More
+++ b/Show More