diff --git a/.clang-tidy b/.clang-tidy
index f8622039f29..7f78143ec3d 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -110,6 +110,7 @@ Checks: '*,
     -misc-const-correctness,
     -misc-no-recursion,
     -misc-non-private-member-variables-in-classes,
+    -misc-confusable-identifiers, # useful but slooow
 
     -modernize-avoid-c-arrays,
     -modernize-concat-nested-namespaces,
@@ -148,19 +149,6 @@ Checks: '*,
     -readability-use-anyofallof,
 
     -zirkon-*,
-
-    -misc-*, # temporarily disabled due to being too slow
-    # also disable checks in other categories which are aliases of checks in misc-*:
-    # https://releases.llvm.org/15.0.0/tools/clang/tools/extra/docs/clang-tidy/checks/list.html
-    -cert-dcl54-cpp,                                            # alias of misc-new-delete-overloads
-    -hicpp-new-delete-operators,                                # alias of misc-new-delete-overloads
-    -cert-fio38-c,                                              # alias of misc-non-copyable-objects
-    -cert-dcl03-c,                                              # alias of misc-static-assert
-    -hicpp-static-assert,                                       # alias of misc-static-assert
-    -cert-err09-cpp,                                            # alias of misc-throw-by-value-catch-by-reference
-    -cert-err61-cpp,                                            # alias of misc-throw-by-value-catch-by-reference
-    -cppcoreguidelines-c-copy-assignment-signature,             # alias of misc-unconventional-assign-operator
-    -cppcoreguidelines-non-private-member-variables-in-classes, # alias of misc-non-private-member-variables-in-classes
 '
 
 WarningsAsErrors: '*'
diff --git a/base/base/find_symbols.h b/base/base/find_symbols.h
index 01efe7046bc..fe5d3bbadab 100644
--- a/base/base/find_symbols.h
+++ b/base/base/find_symbols.h
@@ -36,7 +36,7 @@
 
 namespace detail
 {
-template <char ...chars> constexpr bool is_in(char x) { return ((x == chars) || ...); }
+template <char ...chars> constexpr bool is_in(char x) { return ((x == chars) || ...); } // NOLINT(misc-redundant-expression)
 
 #if defined(__SSE2__)
 template <char s0>
diff --git a/docs/en/engines/table-engines/mergetree-family/replication.md b/docs/en/engines/table-engines/mergetree-family/replication.md
index e9ca87916a0..e14ba5699e4 100644
--- a/docs/en/engines/table-engines/mergetree-family/replication.md
+++ b/docs/en/engines/table-engines/mergetree-family/replication.md
@@ -8,11 +8,18 @@ sidebar_label: Data Replication
 
 :::note
 In ClickHouse Cloud replication is managed for you. Please create your tables without adding arguments.  For example, in the text below you would replace:
+
+```sql
+ENGINE = ReplicatedReplacingMergeTree(
+    '/clickhouse/tables/{shard}/table_name',
+    '{replica}',
+    ver
+)
 ```
-ENGINE = ReplicatedReplacingMergeTree('/clickhouse/tables/{shard}/table_name', '{replica}', ver)
-```
+
 with:
-```
+
+```sql
 ENGINE = ReplicatedReplacingMergeTree
 ```
 :::
diff --git a/docs/en/interfaces/formats.md b/docs/en/interfaces/formats.md
index 68ff1c50b19..03f0201e3e0 100644
--- a/docs/en/interfaces/formats.md
+++ b/docs/en/interfaces/formats.md
@@ -1235,8 +1235,8 @@ For output it uses the following correspondence between ClickHouse types and BSO
 | ClickHouse type                                                                                                       | BSON Type                                                                                                     |
 |-----------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
 | [Bool](/docs/en/sql-reference/data-types/boolean.md)                                                                  | `\x08` boolean                                                                                                |
-| [Int8/UInt8](/docs/en/sql-reference/data-types/int-uint.md)                                                           | `\x10` int32                                                                                                  |
-| [Int16UInt16](/docs/en/sql-reference/data-types/int-uint.md)                                                          | `\x10` int32                                                                                                  |
+| [Int8/UInt8](/docs/en/sql-reference/data-types/int-uint.md)/[Enum8](/docs/en/sql-reference/data-types/enum.md)        | `\x10` int32                                                                                                  |
+| [Int16/UInt16](/docs/en/sql-reference/data-types/int-uint.md)/[Enum16](/docs/en/sql-reference/data-types/enum.md)      | `\x10` int32                                                                                                  |
 | [Int32](/docs/en/sql-reference/data-types/int-uint.md)                                                                | `\x10` int32                                                                                                  |
 | [UInt32](/docs/en/sql-reference/data-types/int-uint.md)                                                               | `\x12` int64                                                                                                  |
 | [Int64/UInt64](/docs/en/sql-reference/data-types/int-uint.md)                                                         | `\x12` int64                                                                                                  |
@@ -1255,30 +1255,30 @@ For output it uses the following correspondence between ClickHouse types and BSO
 | [Array](/docs/en/sql-reference/data-types/array.md)                                                                   | `\x04` array                                                                                                  |
 | [Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                                   | `\x04` array                                                                                                  |
 | [Named Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                             | `\x03` document                                                                                               |
-| [Map](/docs/en/sql-reference/data-types/map.md) (with String keys)                                                    | `\x03` document                                                                                               |
+| [Map](/docs/en/sql-reference/data-types/map.md)                                                                       | `\x03` document                                                                                               |
 | [IPv4](/docs/en/sql-reference/data-types/domains/ipv4.md)                                                             | `\x10` int32                                                                                                  |
 | [IPv6](/docs/en/sql-reference/data-types/domains/ipv6.md)                                                             | `\x05` binary, `\x00` binary subtype                                                                          |
 
 For input it uses the following correspondence between BSON types and ClickHouse types:
 
-| BSON Type                                | ClickHouse Type                                                                                                                                                                       |
-|------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `\x01` double                            | [Float32/Float64](/docs/en/sql-reference/data-types/float.md)                                                                                                                         |
-| `\x02` string                            | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                                 |
-| `\x03` document                          | [Map](/docs/en/sql-reference/data-types/map.md)/[Named Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                                             |
-| `\x04` array                             | [Array](/docs/en/sql-reference/data-types/array.md)/[Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                                               |
-| `\x05` binary, `\x00` binary subtype     | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)/[IPv6](/docs/en/sql-reference/data-types/domains/ipv6.md)       |
-| `\x05` binary, `\x02` old binary subtype | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                                 |
-| `\x05` binary, `\x03` old uuid subtype   | [UUID](/docs/en/sql-reference/data-types/uuid.md)                                                                                                                                     |
-| `\x05` binary, `\x04` uuid subtype       | [UUID](/docs/en/sql-reference/data-types/uuid.md)                                                                                                                                     |
-| `\x07` ObjectId                          | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                                 |
-| `\x08` boolean                           | [Bool](/docs/en/sql-reference/data-types/boolean.md)                                                                                                                                  |
-| `\x09` datetime                          | [DateTime64](/docs/en/sql-reference/data-types/datetime64.md)                                                                                                                         |
-| `\x0A` null value                        | [NULL](/docs/en/sql-reference/data-types/nullable.md)                                                                                                                                 |
-| `\x0D` JavaScript code                   | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                                 |
-| `\x0E` symbol                            | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                                 |
-| `\x10` int32                             | [Int32/UInt32](/docs/en/sql-reference/data-types/int-uint.md)/[Decimal32](/docs/en/sql-reference/data-types/decimal.md)/[IPv4](/docs/en/sql-reference/data-types/domains/ipv4.md)     |
-| `\x12` int64                             | [Int64/UInt64](/docs/en/sql-reference/data-types/int-uint.md)/[Decimal64](/docs/en/sql-reference/data-types/decimal.md)/[DateTime64](/docs/en/sql-reference/data-types/datetime64.md) |
+| BSON Type                                | ClickHouse Type                                                                                                                                                                                                                             |
+|------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `\x01` double                            | [Float32/Float64](/docs/en/sql-reference/data-types/float.md)                                                                                                                                                                               |
+| `\x02` string                            | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                                                                                       |
+| `\x03` document                          | [Map](/docs/en/sql-reference/data-types/map.md)/[Named Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                                                                                                   |
+| `\x04` array                             | [Array](/docs/en/sql-reference/data-types/array.md)/[Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                                                                                                     |
+| `\x05` binary, `\x00` binary subtype     | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)/[IPv6](/docs/en/sql-reference/data-types/domains/ipv6.md)                                                             |
+| `\x05` binary, `\x02` old binary subtype | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                                                                                       |
+| `\x05` binary, `\x03` old uuid subtype   | [UUID](/docs/en/sql-reference/data-types/uuid.md)                                                                                                                                                                                           |
+| `\x05` binary, `\x04` uuid subtype       | [UUID](/docs/en/sql-reference/data-types/uuid.md)                                                                                                                                                                                           |
+| `\x07` ObjectId                          | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                                                                                       |
+| `\x08` boolean                           | [Bool](/docs/en/sql-reference/data-types/boolean.md)                                                                                                                                                                                        |
+| `\x09` datetime                          | [DateTime64](/docs/en/sql-reference/data-types/datetime64.md)                                                                                                                                                                               |
+| `\x0A` null value                        | [NULL](/docs/en/sql-reference/data-types/nullable.md)                                                                                                                                                                                       |
+| `\x0D` JavaScript code                   | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                                                                                       |
+| `\x0E` symbol                            | [String](/docs/en/sql-reference/data-types/string.md)/[FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                                                                                       |
+| `\x10` int32                             | [Int32/UInt32](/docs/en/sql-reference/data-types/int-uint.md)/[Decimal32](/docs/en/sql-reference/data-types/decimal.md)/[IPv4](/docs/en/sql-reference/data-types/domains/ipv4.md)/[Enum8/Enum16](/docs/en/sql-reference/data-types/enum.md) |
+| `\x12` int64                             | [Int64/UInt64](/docs/en/sql-reference/data-types/int-uint.md)/[Decimal64](/docs/en/sql-reference/data-types/decimal.md)/[DateTime64](/docs/en/sql-reference/data-types/datetime64.md)                                                       |
 
 Other BSON types are not supported. Also, it performs conversion between different integer types (for example, you can insert BSON int32 value into ClickHouse UInt8).
 Big integers and decimals (Int128/UInt128/Int256/UInt256/Decimal128/Decimal256) can be parsed from BSON Binary value with `\x00` binary subtype. In this case this format will validate that the size of binary data equals the size of expected value.
@@ -1610,29 +1610,34 @@ See also [Format Schema](#formatschema).
 
 The table below shows supported data types and how they match ClickHouse [data types](/docs/en/sql-reference/data-types/index.md) in `INSERT` and `SELECT` queries.
 
-| CapnProto data type (`INSERT`)   | ClickHouse data type                                                                                                   | CapnProto data type (`SELECT`) |
-|----------------------------------|------------------------------------------------------------------------------------------------------------------------|------------------------------|
-| `UINT8`, `BOOL`                  | [UInt8](/docs/en/sql-reference/data-types/int-uint.md)                                                                 | `UINT8`                      |
-| `INT8`                           | [Int8](/docs/en/sql-reference/data-types/int-uint.md)                                                                  | `INT8`                       |
-| `UINT16`                         | [UInt16](/docs/en/sql-reference/data-types/int-uint.md), [Date](/docs/en/sql-reference/data-types/date.md)             | `UINT16`                     |
-| `INT16`                          | [Int16](/docs/en/sql-reference/data-types/int-uint.md)                                                                 | `INT16`                      |
-| `UINT32`                         | [UInt32](/docs/en/sql-reference/data-types/int-uint.md), [DateTime](/docs/en/sql-reference/data-types/datetime.md)     | `UINT32`                     |
-| `INT32`                          | [Int32](/docs/en/sql-reference/data-types/int-uint.md)                                                                 | `INT32`                      |
-| `UINT64`                         | [UInt64](/docs/en/sql-reference/data-types/int-uint.md)                                                                | `UINT64`                     |
-| `INT64`                          | [Int64](/docs/en/sql-reference/data-types/int-uint.md), [DateTime64](/docs/en/sql-reference/data-types/datetime.md)    | `INT64`                      |
-| `FLOAT32`                        | [Float32](/docs/en/sql-reference/data-types/float.md)                                                                  | `FLOAT32`                    |
-| `FLOAT64`                        | [Float64](/docs/en/sql-reference/data-types/float.md)                                                                  | `FLOAT64`                    |
-| `TEXT, DATA`                     | [String](/docs/en/sql-reference/data-types/string.md), [FixedString](/docs/en/sql-reference/data-types/fixedstring.md) | `TEXT, DATA`                 |
-| `union(T, Void), union(Void, T)` | [Nullable(T)](/docs/en/sql-reference/data-types/date.md)                                                               | `union(T, Void), union(Void, T)`                 |
-| `ENUM`                           | [Enum(8\                                                                                                               |16)](/docs/en/sql-reference/data-types/enum.md)  | `ENUM`                         |
-| `LIST`                           | [Array](/docs/en/sql-reference/data-types/array.md)                                                                    | `LIST`                       |
-| `STRUCT`                         | [Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                                    | `STRUCT`                     |
-| `UINT32`                         | [IPv4](/docs/en/sql-reference/data-types/domains/ipv4.md)                                                              | `UINT32`                     |
-| `DATA`                           | [IPv6](/docs/en/sql-reference/data-types/domains/ipv6.md)                                                              | `DATA`                       |
+| CapnProto data type (`INSERT`)                       | ClickHouse data type                                                                                                                                                           | CapnProto data type (`SELECT`)                       |
+|------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------|
+| `UINT8`, `BOOL`                                      | [UInt8](/docs/en/sql-reference/data-types/int-uint.md)                                                                                                                         | `UINT8`                                              |
+| `INT8`                                               | [Int8](/docs/en/sql-reference/data-types/int-uint.md)                                                                                                                          | `INT8`                                               |
+| `UINT16`                                             | [UInt16](/docs/en/sql-reference/data-types/int-uint.md), [Date](/docs/en/sql-reference/data-types/date.md)                                                                     | `UINT16`                                             |
+| `INT16`                                              | [Int16](/docs/en/sql-reference/data-types/int-uint.md)                                                                                                                         | `INT16`                                              |
+| `UINT32`                                             | [UInt32](/docs/en/sql-reference/data-types/int-uint.md), [DateTime](/docs/en/sql-reference/data-types/datetime.md)                                                             | `UINT32`                                             |
+| `INT32`                                              | [Int32](/docs/en/sql-reference/data-types/int-uint.md), [Decimal32](/docs/en/sql-reference/data-types/decimal.md)                                                              | `INT32`                                              |
+| `UINT64`                                             | [UInt64](/docs/en/sql-reference/data-types/int-uint.md)                                                                                                                        | `UINT64`                                             |
+| `INT64`                                              | [Int64](/docs/en/sql-reference/data-types/int-uint.md), [DateTime64](/docs/en/sql-reference/data-types/datetime.md), [Decimal64](/docs/en/sql-reference/data-types/decimal.md) | `INT64`                                              |
+| `FLOAT32`                                            | [Float32](/docs/en/sql-reference/data-types/float.md)                                                                                                                          | `FLOAT32`                                            |
+| `FLOAT64`                                            | [Float64](/docs/en/sql-reference/data-types/float.md)                                                                                                                          | `FLOAT64`                                            |
+| `TEXT, DATA`                                         | [String](/docs/en/sql-reference/data-types/string.md), [FixedString](/docs/en/sql-reference/data-types/fixedstring.md)                                                         | `TEXT, DATA`                                         |
+| `union(T, Void), union(Void, T)`                     | [Nullable(T)](/docs/en/sql-reference/data-types/date.md)                                                                                                                       | `union(T, Void), union(Void, T)`                     |
+| `ENUM`                                               | [Enum(8/16)](/docs/en/sql-reference/data-types/enum.md)                                                                                                                        | `ENUM`                                               |
+| `LIST`                                               | [Array](/docs/en/sql-reference/data-types/array.md)                                                                                                                            | `LIST`                                               |
+| `STRUCT`                                             | [Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                                                                                            | `STRUCT`                                             |
+| `UINT32`                                             | [IPv4](/docs/en/sql-reference/data-types/domains/ipv4.md)                                                                                                                      | `UINT32`                                             |
+| `DATA`                                               | [IPv6](/docs/en/sql-reference/data-types/domains/ipv6.md)                                                                                                                      | `DATA`                                               |
+| `DATA`                                               | [Int128/UInt128/Int256/UInt256](/docs/en/sql-reference/data-types/int-uint.md)                                                                                                 | `DATA`                                               |
+| `DATA`                                               | [Decimal128/Decimal256](/docs/en/sql-reference/data-types/decimal.md)                                                                                                          | `DATA`                                               |
+| `STRUCT(entries LIST(STRUCT(key Key, value Value)))` | [Map](/docs/en/sql-reference/data-types/map.md)                                                                                                                                | `STRUCT(entries LIST(STRUCT(key Key, value Value)))` |
+
+Integer types can be converted into each other during input/output.
 
 For working with `Enum` in CapnProto format use the [format_capn_proto_enum_comparising_mode](/docs/en/operations/settings/settings-formats.md/#format_capn_proto_enum_comparising_mode) setting.
 
-Arrays can be nested and can have a value of the `Nullable` type as an argument. `Tuple` type also can be nested.
+Arrays can be nested and can have a value of the `Nullable` type as an argument. `Tuple` and `Map` types also can be nested.
 
 ### Inserting and Selecting Data {#inserting-and-selecting-data-capnproto}
 
diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md b/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
new file mode 100644
index 00000000000..21b9a3500c4
--- /dev/null
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantileApprox.md
@@ -0,0 +1,76 @@
+---
+slug: /en/sql-reference/aggregate-functions/reference/quantileApprox
+sidebar_position: 204
+---
+
+# quantileApprox
+
+Computes the [quantile](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [Greenwald-Khanna](http://infolab.stanford.edu/~datar/courses/cs361a/papers/quantiles.pdf) algorithm. The Greenwald-Khanna algorithm is an algorithm used to compute quantiles on a stream of data in a highly efficient manner. It was introduced by Michael Greenwald and Sanjeev Khanna in 2001. It is widely used in databases and big data systems where computing accurate quantiles on a large stream of data in real-time is necessary. The algorithm is highly efficient, taking only O(log n) space and O(log log n) time per item (where n is the size of the input). It is also highly accurate, providing an approximate quantile value with high probability. 
+
+`quantileApprox` is different from other quantile functions in ClickHouse, because it enables user to control the accuracy of the approximate quantile result.
+
+**Syntax**
+
+``` sql
+quantileApprox(accuracy, level)(expr)
+```
+
+Alias: `medianApprox`.
+
+**Arguments**
+
+-   `accuracy` — Accuracy of quantile. Constant positive integer. Larger accuracy value means less error. For example, if the accuracy argument is set to 100, the computed quantile will have an error no greater than 1% with high probability. There is a trade-off between the accuracy of the computed quantiles and the computational complexity of the algorithm. A larger accuracy requires more memory and computational resources to compute the quantile accurately, while a smaller accuracy argument allows for a faster and more memory-efficient computation but with a slightly lower accuracy.
+
+-   `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. Default value: 0.5. At `level=0.5` the function calculates [median](https://en.wikipedia.org/wiki/Median).
+
+-   `expr` — Expression over the column values resulting in numeric [data types](../../../sql-reference/data-types/index.md#data_types), [Date](../../../sql-reference/data-types/date.md) or [DateTime](../../../sql-reference/data-types/datetime.md).
+
+
+**Returned value**
+
+-   Quantile of the specified level and accuracy.
+
+
+Type:
+
+-   [Float64](../../../sql-reference/data-types/float.md) for numeric data type input.
+-   [Date](../../../sql-reference/data-types/date.md) if input values have the `Date` type.
+-   [DateTime](../../../sql-reference/data-types/datetime.md) if input values have the `DateTime` type.
+
+**Example**
+
+``` sql
+SELECT quantileApprox(1, 0.25)(number + 1)
+FROM numbers(1000)
+
+┌─quantileApprox(1, 0.25)(plus(number, 1))─┐
+│                                        1 │
+└──────────────────────────────────────────┘
+
+SELECT quantileApprox(10, 0.25)(number + 1)
+FROM numbers(1000)
+
+┌─quantileApprox(10, 0.25)(plus(number, 1))─┐
+│                                       156 │
+└───────────────────────────────────────────┘
+
+SELECT quantileApprox(100, 0.25)(number + 1)
+FROM numbers(1000)
+
+┌─quantileApprox(100, 0.25)(plus(number, 1))─┐
+│                                        251 │
+└────────────────────────────────────────────┘
+
+SELECT quantileApprox(1000, 0.25)(number + 1)
+FROM numbers(1000)
+
+┌─quantileApprox(1000, 0.25)(plus(number, 1))─┐
+│                                         249 │
+└─────────────────────────────────────────────┘
+```
+
+
+**See Also**
+
+-   [median](../../../sql-reference/aggregate-functions/reference/median.md#median)
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles)
diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
index 57151915336..fe22ad7b048 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantiles.md
@@ -114,3 +114,59 @@ Result:
 │ [249.75,499.5,749.25,899.1,949.05,989.01,998.001]                   │
 └─────────────────────────────────────────────────────────────────────┘
 ```
+
+## quantilesApprox
+
+`quantilesApprox` works similarly with `quantileApprox` but allows us to calculate quantities at different levels simultaneously and returns an array.
+
+**Syntax**
+
+``` sql
+quantilesApprox(accuracy, level1, level2, ...)(expr)
+```
+
+**Returned value**
+
+-   [Array](../../../sql-reference/data-types/array.md) of quantiles of the specified levels.
+
+Type of array values:
+
+-   [Float64](../../../sql-reference/data-types/float.md) for numeric data type input.
+-   [Date](../../../sql-reference/data-types/date.md) if input values have the `Date` type.
+-   [DateTime](../../../sql-reference/data-types/datetime.md) if input values have the `DateTime` type.
+
+**Example**
+
+Query:
+
+
+``` sql
+SELECT quantilesApprox(1, 0.25, 0.5, 0.75)(number + 1)
+FROM numbers(1000)
+
+┌─quantilesApprox(1, 0.25, 0.5, 0.75)(plus(number, 1))─┐
+│ [1,1,1]                                              │
+└──────────────────────────────────────────────────────┘
+
+SELECT quantilesApprox(10, 0.25, 0.5, 0.75)(number + 1)
+FROM numbers(1000)
+
+┌─quantilesApprox(10, 0.25, 0.5, 0.75)(plus(number, 1))─┐
+│ [156,413,659]                                         │
+└───────────────────────────────────────────────────────┘
+
+
+SELECT quantilesApprox(100, 0.25, 0.5, 0.75)(number + 1)
+FROM numbers(1000)
+
+┌─quantilesApprox(100, 0.25, 0.5, 0.75)(plus(number, 1))─┐
+│ [251,498,741]                                          │
+└────────────────────────────────────────────────────────┘
+
+SELECT quantilesApprox(1000, 0.25, 0.5, 0.75)(number + 1)
+FROM numbers(1000)
+
+┌─quantilesApprox(1000, 0.25, 0.5, 0.75)(plus(number, 1))─┐
+│ [249,499,749]                                           │
+└─────────────────────────────────────────────────────────┘
+```
diff --git a/docs/en/sql-reference/functions/date-time-functions.md b/docs/en/sql-reference/functions/date-time-functions.md
index 71b7fa07f18..11036d804dc 100644
--- a/docs/en/sql-reference/functions/date-time-functions.md
+++ b/docs/en/sql-reference/functions/date-time-functions.md
@@ -1276,16 +1276,16 @@ Using replacement fields, you can define a pattern for the resulting string. “
 | %k       | hour in 24h format (00-23)                              | 22         |
 | %l       | hour in 12h format (01-12)                              | 09         |
 | %m       | month as an integer number (01-12)                      | 01         |
-| %M       | minute (00-59)                                          | 33         |
+| %M       | full month name (January-December)                      | January    |
 | %n       | new-line character (‘’)                                 |            |
 | %p       | AM or PM designation                                    | PM         |
 | %Q       | Quarter (1-4)                                           | 1          |
-| %r       | 12-hour HH:MM AM/PM time, equivalent to %H:%M %p        | 10:30 PM   |
-| %R       | 24-hour HH:MM time, equivalent to %H:%M                 | 22:33      |
+| %r       | 12-hour HH:MM AM/PM time, equivalent to %H:%i %p        | 10:30 PM   |
+| %R       | 24-hour HH:MM time, equivalent to %H:%i                 | 22:33      |
 | %s       | second (00-59)                                          | 44         |
 | %S       | second (00-59)                                          | 44         |
 | %t       | horizontal-tab character (’)                            |            |
-| %T       | ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S | 22:33:44   |
+| %T       | ISO 8601 time format (HH:MM:SS), equivalent to %H:%i:%S | 22:33:44   |
 | %u       | ISO 8601 weekday as number with Monday as 1 (1-7)       | 2          |
 | %V       | ISO 8601 week number (01-53)                            | 01         |
 | %w       | weekday as a integer number with Sunday as 0 (0-6)      | 2          |
diff --git a/docs/en/sql-reference/functions/string-replace-functions.md b/docs/en/sql-reference/functions/string-replace-functions.md
index 50e15f70f5d..d4c7c451af2 100644
--- a/docs/en/sql-reference/functions/string-replace-functions.md
+++ b/docs/en/sql-reference/functions/string-replace-functions.md
@@ -13,17 +13,18 @@ Functions for [searching](../../sql-reference/functions/string-search-functions.
 ## replaceOne(haystack, pattern, replacement)
 
 Replaces the first occurrence of the substring ‘pattern’ (if it exists) in ‘haystack’ by the ‘replacement’ string.
-‘pattern’ and ‘replacement’ must be constants.
 
 ## replaceAll(haystack, pattern, replacement), replace(haystack, pattern, replacement)
 
 Replaces all occurrences of the substring ‘pattern’ in ‘haystack’ by the ‘replacement’ string.
 
+Alias: `replace`.
+
 ## replaceRegexpOne(haystack, pattern, replacement)
 
 Replaces the first occurrence of the substring matching the regular expression ‘pattern’ in ‘haystack‘ by the ‘replacement‘ string.
-‘pattern‘ must be a constant [re2 regular expression](https://github.com/google/re2/wiki/Syntax).
-‘replacement’ must be a plain constant string or a constant string containing substitutions `\0-\9`.
+‘pattern‘ must be a [re2 regular expression](https://github.com/google/re2/wiki/Syntax).
+‘replacement’ must be a plain string or a string containing substitutions `\0-\9`.
 Substitutions `\1-\9` correspond to the 1st to 9th capturing group (submatch), substitution `\0` corresponds to the entire match.
 To use a verbatim `\` character in the ‘pattern‘ or ‘replacement‘ string, escape it using `\`.
 Also keep in mind that string literals require an extra escaping.
@@ -88,6 +89,8 @@ SELECT replaceRegexpAll('Hello, World!', '^', 'here: ') AS res
 └─────────────────────┘
 ```
 
+Alias: `REGEXP_REPLACE`.
+
 ## regexpQuoteMeta(s)
 
 The function adds a backslash before some predefined characters in the string.
diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index 85eaf6ceba6..93cff6326ba 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -26,9 +26,11 @@ namespace ErrorCodes
 {
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int BAD_ARGUMENTS;
 }
 
 template <typename> class QuantileTiming;
+template <typename> class QuantileApprox;
 
 
 /** Generic aggregate function for calculation of quantiles.
@@ -60,6 +62,7 @@ private:
     using ColVecType = ColumnVectorOrDecimal<Value>;
 
     static constexpr bool returns_float = !(std::is_same_v<FloatReturnType, void>);
+    static constexpr bool is_quantile_approx = std::is_same_v<Data, QuantileApprox<Value>>;
     static_assert(!is_decimal<Value> || !returns_float);
 
     QuantileLevels<Float64> levels;
@@ -67,22 +70,57 @@ private:
     /// Used when there are single level to get.
     Float64 level = 0.5;
 
+    /// Used for the approximate version of the algorithm (Greenwald-Khanna)
+    ssize_t accuracy = 10000;
+
     DataTypePtr & argument_type;
 
 public:
     AggregateFunctionQuantile(const DataTypes & argument_types_, const Array & params)
         : IAggregateFunctionDataHelper<Data, AggregateFunctionQuantile<Value, Data, Name, has_second_arg, FloatReturnType, returns_many>>(
             argument_types_, params, createResultType(argument_types_))
-        , levels(params, returns_many)
+        , levels(is_quantile_approx && !params.empty() ? Array(params.begin() + 1, params.end()) : params, returns_many)
         , level(levels.levels[0])
         , argument_type(this->argument_types[0])
     {
         if (!returns_many && levels.size() > 1)
-            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} require one parameter or less", getName());
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires one level parameter or less", getName());
+
+        if constexpr (is_quantile_approx)
+        {
+            if (params.empty())
+                throw Exception(
+                    ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires at least one param", getName());
+
+            const auto & accuracy_field = params[0];
+            if (!isInt64OrUInt64FieldType(accuracy_field.getType()))
+                throw Exception(
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Aggregate function {} requires accuracy parameter with integer type", getName());
+
+            if (accuracy_field.getType() == Field::Types::Int64)
+                accuracy = accuracy_field.get<Int64>();
+            else
+                accuracy = accuracy_field.get<UInt64>();
+
+            if (accuracy <= 0)
+                throw Exception(
+                    ErrorCodes::BAD_ARGUMENTS,
+                    "Aggregate function {} requires accuracy parameter with positive value but is {}",
+                    getName(),
+                    accuracy);
+        }
     }
 
     String getName() const override { return Name::name; }
 
+    void create(AggregateDataPtr __restrict place) const override /// NOLINT
+    {
+        if constexpr (is_quantile_approx)
+            new (place) Data(accuracy);
+        else
+            new (place) Data;
+    }
+
     static DataTypePtr createResultType(const DataTypes & argument_types_)
     {
         DataTypePtr res;
@@ -257,4 +295,7 @@ struct NameQuantilesBFloat16 { static constexpr auto name = "quantilesBFloat16";
 struct NameQuantileBFloat16Weighted { static constexpr auto name = "quantileBFloat16Weighted"; };
 struct NameQuantilesBFloat16Weighted { static constexpr auto name = "quantilesBFloat16Weighted"; };
 
+struct NameQuantileApprox { static constexpr auto name = "quantileApprox"; };
+struct NameQuantilesApprox { static constexpr auto name = "quantilesApprox"; };
+
 }
diff --git a/src/AggregateFunctions/AggregateFunctionQuantileApprox.cpp b/src/AggregateFunctions/AggregateFunctionQuantileApprox.cpp
new file mode 100644
index 00000000000..2a913fdc956
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionQuantileApprox.cpp
@@ -0,0 +1,71 @@
+#include <AggregateFunctions/AggregateFunctionQuantile.h>
+#include <AggregateFunctions/QuantileApprox.h>
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/Helpers.h>
+#include <DataTypes/DataTypeDate.h>
+#include <DataTypes/DataTypeDateTime.h>
+#include <Core/Field.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+}
+
+namespace
+{
+
+template <typename Value, bool _> using FuncQuantileApprox = AggregateFunctionQuantile<Value, QuantileApprox<Value>, NameQuantileApprox, false, void, false>;
+template <typename Value, bool _> using FuncQuantilesApprox = AggregateFunctionQuantile<Value, QuantileApprox<Value>, NameQuantilesApprox, false, void, true>;
+
+template <template <typename, bool> class Function>
+AggregateFunctionPtr createAggregateFunctionQuantile(
+    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
+{
+    /// Second argument type check doesn't depend on the type of the first one.
+    Function<void, true>::assertSecondArg(argument_types);
+
+    const DataTypePtr & argument_type = argument_types[0];
+    WhichDataType which(argument_type);
+
+#define DISPATCH(TYPE) \
+    if (which.idx == TypeIndex::TYPE) \
+        return std::make_shared<Function<TYPE, true>>(argument_types, params);
+    FOR_BASIC_NUMERIC_TYPES(DISPATCH)
+#undef DISPATCH
+
+    if (which.idx == TypeIndex::Date) return std::make_shared<Function<DataTypeDate::FieldType, false>>(argument_types, params);
+    if (which.idx == TypeIndex::DateTime) return std::make_shared<Function<DataTypeDateTime::FieldType, false>>(argument_types, params);
+
+    if (which.idx == TypeIndex::Decimal32) return std::make_shared<Function<Decimal32, false>>(argument_types, params);
+    if (which.idx == TypeIndex::Decimal64) return std::make_shared<Function<Decimal64, false>>(argument_types, params);
+    if (which.idx == TypeIndex::Decimal128) return std::make_shared<Function<Decimal128, false>>(argument_types, params);
+    if (which.idx == TypeIndex::Decimal256) return std::make_shared<Function<Decimal256, false>>(argument_types, params);
+    if (which.idx == TypeIndex::DateTime64) return std::make_shared<Function<DateTime64, false>>(argument_types, params);
+
+    if (which.idx == TypeIndex::Int128) return std::make_shared<Function<Int128, true>>(argument_types, params);
+    if (which.idx == TypeIndex::UInt128) return std::make_shared<Function<UInt128, true>>(argument_types, params);
+    if (which.idx == TypeIndex::Int256) return std::make_shared<Function<Int256, true>>(argument_types, params);
+    if (which.idx == TypeIndex::UInt256) return std::make_shared<Function<UInt256, true>>(argument_types, params);
+
+    throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument for aggregate function {}",
+                    argument_type->getName(), name);
+}
+
+}
+
+void registerAggregateFunctionsQuantileApprox(AggregateFunctionFactory & factory)
+{
+    /// For aggregate functions returning array we cannot return NULL on empty set.
+    AggregateFunctionProperties properties = { .returns_default_when_only_null = true };
+
+    factory.registerFunction(NameQuantileApprox::name, createAggregateFunctionQuantile<FuncQuantileApprox>);
+    factory.registerFunction(NameQuantilesApprox::name, {createAggregateFunctionQuantile<FuncQuantilesApprox>, properties});
+
+    /// 'median' is an alias for 'quantile'
+    factory.registerAlias("medianApprox", NameQuantileApprox::name);
+}
+
+}
diff --git a/src/AggregateFunctions/QuantileApprox.h b/src/AggregateFunctions/QuantileApprox.h
new file mode 100644
index 00000000000..8a2d5e5705f
--- /dev/null
+++ b/src/AggregateFunctions/QuantileApprox.h
@@ -0,0 +1,477 @@
+#pragma once
+
+#include <cmath>
+#include <base/sort.h>
+#include <Common/RadixSort.h>
+#include <IO/WriteBuffer.h>
+#include <IO/ReadBuffer.h>
+#include <IO/WriteHelpers.h>
+#include <IO/ReadHelpers.h>
+
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+    extern const int NOT_IMPLEMENTED;
+}
+
+template <typename T>
+class ApproxSampler
+{
+public:
+    struct Stats
+    {
+        T value;      // the sampled value
+        Int64 g;      // the minimum rank jump from the previous value's minimum rank
+        Int64 delta;  // the maximum span of the rank
+
+        Stats() = default;
+        Stats(T value_, Int64 g_, Int64 delta_) : value(value_), g(g_), delta(delta_) {}
+    };
+
+    struct QueryResult
+    {
+        size_t index;
+        Int64 rank;
+        T value;
+
+        QueryResult(size_t index_, Int64 rank_, T value_) : index(index_), rank(rank_), value(value_) { }
+    };
+
+    ApproxSampler() = default;
+
+    explicit ApproxSampler(
+        double relative_error_,
+        size_t compress_threshold_ = default_compress_threshold,
+        size_t count_ = 0,
+        bool compressed_ = false)
+        : relative_error(relative_error_)
+        , compress_threshold(compress_threshold_)
+        , count(count_)
+        , compressed(compressed_)
+    {
+        sampled.reserve(compress_threshold);
+        backup_sampled.reserve(compress_threshold);
+
+        head_sampled.reserve(default_head_size);
+    }
+
+    bool isCompressed() const { return compressed; }
+    void setCompressed() { compressed = true; }
+
+    void insert(T x)
+    {
+        head_sampled.push_back(x);
+        compressed = false;
+        if (head_sampled.size() >= default_head_size)
+        {
+            withHeadBufferInserted();
+            if (sampled.size() >= compress_threshold)
+                compress();
+        }
+    }
+
+    void query(const Float64 * percentiles, const size_t * indices, size_t size, T * result) const
+    {
+        if (!head_sampled.empty())
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot operate on an uncompressed summary, call compress() first");
+
+        if (sampled.empty())
+        {
+            for (size_t i = 0; i < size; ++i)
+                result[i] = T();
+            return;
+        }
+
+        Int64 current_max = std::numeric_limits<Int64>::min();
+        for (const auto & stats : sampled)
+            current_max = std::max(stats.delta + stats.g, current_max);
+        Int64 target_error = current_max/2;
+
+        size_t index= 0;
+        auto min_rank = sampled[0].g;
+        for (size_t i = 0; i < size; ++i)
+        {
+            double percentile = percentiles[indices[i]];
+            if (percentile <= relative_error)
+            {
+                result[indices[i]] = sampled.front().value;
+            }
+            else if (percentile >= 1 - relative_error)
+            {
+                result[indices[i]] = sampled.back().value;
+            }
+            else
+            {
+                QueryResult res = findApproxQuantile(index, min_rank, target_error, percentile);
+                index = res.index;
+                min_rank = res.rank;
+                result[indices[i]] = res.value;
+            }
+        }
+
+    }
+
+    void compress()
+    {
+        if (compressed)
+            return;
+
+        withHeadBufferInserted();
+
+        doCompress(2 * relative_error * count);
+        compressed = true;
+    }
+
+
+    void merge(const ApproxSampler & other)
+    {
+        if (other.count == 0)
+            return;
+        else if (count == 0)
+        {
+            compress_threshold = other.compress_threshold;
+            relative_error = other.relative_error;
+            count = other.count;
+            compressed = other.compressed;
+
+            sampled.resize(other.sampled.size());
+            memcpy(sampled.data(), other.sampled.data(), sizeof(Stats) * other.sampled.size());
+            return;
+        }
+        else
+        {
+            // Merge the two buffers.
+            // The GK algorithm is a bit unclear about it, but we need to adjust the statistics during the
+            // merging. The main idea is that samples that come from one side will suffer from the lack of
+            // precision of the other.
+            // As a concrete example, take two QuantileSummaries whose samples (value, g, delta) are:
+            // `a = [(0, 1, 0), (20, 99, 0)]` and `b = [(10, 1, 0), (30, 49, 0)]`
+            // This means `a` has 100 values, whose minimum is 0 and maximum is 20,
+            // while `b` has 50 values, between 10 and 30.
+            // The resulting samples of the merge will be:
+            // a+b = [(0, 1, 0), (10, 1, ??), (20, 99, ??), (30, 49, 0)]
+            // The values of `g` do not change, as they represent the minimum number of values between two
+            // consecutive samples. The values of `delta` should be adjusted, however.
+            // Take the case of the sample `10` from `b`. In the original stream, it could have appeared
+            // right after `0` (as expressed by `g=1`) or right before `20`, so `delta=99+0-1=98`.
+            // In the GK algorithm's style of working in terms of maximum bounds, one can observe that the
+            // maximum additional uncertainty over samples coming from `b` is `max(g_a + delta_a) =
+            // floor(2 * eps_a * n_a)`. Likewise, additional uncertainty over samples from `a` is
+            // `floor(2 * eps_b * n_b)`.
+            // Only samples that interleave the other side are affected. That means that samples from
+            // one side that are lesser (or greater) than all samples from the other side are just copied
+            // unmodified.
+            // If the merging instances have different `relativeError`, the resulting instance will carry
+            // the largest one: `eps_ab = max(eps_a, eps_b)`.
+            // The main invariant of the GK algorithm is kept:
+            // `max(g_ab + delta_ab) <= floor(2 * eps_ab * (n_a + n_b))` since
+            // `max(g_ab + delta_ab) <= floor(2 * eps_a * n_a) + floor(2 * eps_b * n_b)`
+            // Finally, one can see how the `insert(x)` operation can be expressed as `merge([(x, 1, 0])`
+            compress();
+
+            backup_sampled.clear();
+            backup_sampled.reserve(sampled.size() + other.sampled.size());
+            double merged_relative_error = std::max(relative_error, other.relative_error);
+            size_t merged_count = count + other.count;
+            Int64 additional_self_delta = static_cast<Int64>(std::floor(2 * other.relative_error * other.count));
+            Int64 additional_other_delta = static_cast<Int64>(std::floor(2 * relative_error * count));
+
+            // Do a merge of two sorted lists until one of the lists is fully consumed
+            size_t self_idx = 0;
+            size_t other_idx = 0;
+            while (self_idx < sampled.size() && other_idx < other.sampled.size())
+            {
+                const Stats & self_sample = sampled[self_idx];
+                const Stats & other_sample = other.sampled[other_idx];
+
+                // Detect next sample
+                Stats next_sample;
+                Int64 additional_delta = 0;
+                if (self_sample.value < other_sample.value)
+                {
+                    ++self_idx;
+                    next_sample = self_sample;
+                    additional_delta = other_idx > 0 ? additional_self_delta : 0;
+                }
+                else
+                {
+                    ++other_idx;
+                    next_sample = other_sample;
+                    additional_delta = self_idx > 0 ? additional_other_delta : 0;
+                }
+
+                // Insert it
+                next_sample.delta += additional_delta;
+                backup_sampled.emplace_back(std::move(next_sample));
+            }
+
+            // Copy the remaining samples from the other list
+            // (by construction, at most one `while` loop will run)
+            while (self_idx < sampled.size())
+            {
+                backup_sampled.emplace_back(sampled[self_idx]);
+                ++self_idx;
+            }
+            while (other_idx < other.sampled.size())
+            {
+                backup_sampled.emplace_back(other.sampled[other_idx]);
+                ++other_idx;
+            }
+
+            std::swap(sampled, backup_sampled);
+            relative_error = merged_relative_error;
+            count = merged_count;
+            compress_threshold = other.compress_threshold;
+
+            doCompress(2 * merged_relative_error * merged_count);
+            compressed = true;
+        }
+    }
+
+    void write(WriteBuffer & buf) const
+    {
+        writeIntBinary<size_t>(compress_threshold, buf);
+        writeFloatBinary<double>(relative_error, buf);
+        writeIntBinary<size_t>(count, buf);
+        writeIntBinary<size_t>(sampled.size(), buf);
+
+        for (const auto & stats : sampled)
+        {
+            writeFloatBinary<T>(stats.value, buf);
+            writeIntBinary<Int64>(stats.g, buf);
+            writeIntBinary<Int64>(stats.delta, buf);
+        }
+    }
+
+    void read(ReadBuffer & buf)
+    {
+        readIntBinary<size_t>(compress_threshold, buf);
+        readFloatBinary<double>(relative_error, buf);
+        readIntBinary<size_t>(count, buf);
+
+        size_t sampled_len = 0;
+        readIntBinary<size_t>(sampled_len, buf);
+        sampled.resize(sampled_len);
+
+        for (size_t i = 0; i < sampled_len; ++i)
+        {
+            auto stats = sampled[i];
+            readFloatBinary<T>(stats.value, buf);
+            readIntBinary<Int64>(stats.g, buf);
+            readIntBinary<Int64>(stats.delta, buf);
+        }
+    }
+
+private:
+    QueryResult findApproxQuantile(size_t index, Int64 min_rank_at_index, double target_error, double percentile) const
+    {
+        Stats curr_sample = sampled[index];
+        Int64 rank = static_cast<Int64>(std::ceil(percentile * count));
+        size_t i = index;
+        Int64 min_rank = min_rank_at_index;
+        while (i < sampled.size() - 1)
+        {
+            Int64 max_rank = min_rank + curr_sample.delta;
+            if (max_rank - target_error <= rank && rank <= min_rank + target_error)
+                return {i, min_rank, curr_sample.value};
+            else
+            {
+                ++i;
+                curr_sample = sampled[i];
+                min_rank += curr_sample.g;
+            }
+        }
+        return {sampled.size()-1, 0, sampled.back().value};
+    }
+
+    void withHeadBufferInserted()
+    {
+        if (head_sampled.empty())
+            return;
+
+        bool use_radix_sort = head_sampled.size() >= 256 && (is_arithmetic_v<T> && !is_big_int_v<T>);
+        if (use_radix_sort)
+            RadixSort<RadixSortNumTraits<T>>::executeLSD(head_sampled.data(), head_sampled.size());
+        else
+            ::sort(head_sampled.begin(), head_sampled.end());
+
+        backup_sampled.clear();
+        backup_sampled.reserve(sampled.size() + head_sampled.size());
+
+        size_t sample_idx = 0;
+        size_t ops_idx = 0;
+        size_t current_count = count;
+        for (; ops_idx < head_sampled.size(); ++ops_idx)
+        {
+            T current_sample = head_sampled[ops_idx];
+
+            // Add all the samples before the next observation.
+            while (sample_idx < sampled.size() && sampled[sample_idx].value <= current_sample)
+            {
+                backup_sampled.emplace_back(sampled[sample_idx]);
+                ++sample_idx;
+            }
+
+            // If it is the first one to insert, of if it is the last one
+            ++current_count;
+            Int64 delta;
+            if (backup_sampled.empty() || (sample_idx == sampled.size() && ops_idx == (head_sampled.size() - 1)))
+                delta = 0;
+            else
+                delta = static_cast<Int64>(std::floor(2 * relative_error * current_count));
+
+            backup_sampled.emplace_back(current_sample, 1, delta);
+        }
+
+        // Add all the remaining existing samples
+        for (; sample_idx < sampled.size(); ++sample_idx)
+            backup_sampled.emplace_back(sampled[sample_idx]);
+
+        std::swap(sampled, backup_sampled);
+        head_sampled.clear();
+        count = current_count;
+    }
+
+
+    void doCompress(double merge_threshold)
+    {
+        if (sampled.empty())
+            return;
+
+        backup_sampled.clear();
+        // Start for the last element, which is always part of the set.
+        // The head contains the current new head, that may be merged with the current element.
+        Stats head = sampled.back();
+        ssize_t i = sampled.size() - 2;
+
+        // Do not compress the last element
+        while (i >= 1)
+        {
+            // The current sample:
+            const auto & sample1 = sampled[i];
+            // Do we need to compress?
+            if (sample1.g + head.g + head.delta < merge_threshold)
+            {
+                // Do not insert yet, just merge the current element into the head.
+                head.g += sample1.g;
+            }
+            else
+            {
+                // Prepend the current head, and keep the current sample as target for merging.
+                backup_sampled.push_back(head);
+                head = sample1;
+            }
+            --i;
+        }
+
+        backup_sampled.push_back(head);
+        // If necessary, add the minimum element:
+        auto curr_head = sampled.front();
+
+        // don't add the minimum element if `currentSamples` has only one element (both `currHead` and
+        // `head` point to the same element)
+        if (curr_head.value <= head.value && sampled.size() > 1)
+            backup_sampled.emplace_back(sampled.front());
+
+        std::reverse(backup_sampled.begin(), backup_sampled.end());
+        std::swap(sampled, backup_sampled);
+    }
+
+    double relative_error;
+    size_t compress_threshold;
+    size_t count = 0;
+    bool compressed;
+
+    PaddedPODArray<Stats> sampled;
+    PaddedPODArray<Stats> backup_sampled;
+
+    PaddedPODArray<T> head_sampled;
+
+    static constexpr size_t default_compress_threshold = 10000;
+    static constexpr size_t default_head_size = 50000;
+};
+
+template <typename Value>
+class QuantileApprox
+{
+private:
+    using Data = ApproxSampler<Value>;
+    mutable Data data;
+
+public:
+    QuantileApprox() = default;
+
+    explicit QuantileApprox(size_t accuracy) : data(1.0 / static_cast<double>(accuracy)) { }
+
+    void add(const Value & x)
+    {
+        data.insert(x);
+    }
+
+    template <typename Weight>
+    void add(const Value &, const Weight &)
+    {
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method add with weight is not implemented for GKSampler");
+    }
+
+    void merge(const QuantileApprox & rhs)
+    {
+        if (!data.isCompressed())
+            data.compress();
+
+        data.merge(rhs.data);
+    }
+
+    void serialize(WriteBuffer & buf) const
+    {
+        /// Always compress before serialization
+        if (!data.isCompressed())
+            data.compress();
+
+        data.write(buf);
+    }
+
+    void deserialize(ReadBuffer & buf)
+    {
+        data.read(buf);
+
+        data.setCompressed();
+    }
+
+    /// Get the value of the `level` quantile. The level must be between 0 and 1.
+    Value get(Float64 level)
+    {
+        if (!data.isCompressed())
+            data.compress();
+
+        Value res;
+        size_t indice = 0;
+        data.query(&level, &indice, 1, &res);
+        return res;
+    }
+
+    /// Get the `size` values of `levels` quantiles. Write `size` results starting with `result` address.
+    /// indices - an array of index levels such that the corresponding elements will go in ascending order.
+    void getMany(const Float64 * levels, const size_t * indices, size_t size, Value * result)
+    {
+        if (!data.isCompressed())
+            data.compress();
+
+        data.query(levels, indices, size, result);
+    }
+
+    Float64 getFloat64(Float64 /*level*/)
+    {
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method getFloat64 is not implemented for GKSampler");
+    }
+
+    void getManyFloat(const Float64 * /*levels*/, const size_t * /*indices*/, size_t /*size*/, Float64 * /*result*/)
+    {
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method getManyFloat is not implemented for GKSampler");
+    }
+};
+
+}
diff --git a/src/AggregateFunctions/registerAggregateFunctions.cpp b/src/AggregateFunctions/registerAggregateFunctions.cpp
index 2781d0662b0..91248a52ae9 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.cpp
+++ b/src/AggregateFunctions/registerAggregateFunctions.cpp
@@ -32,6 +32,7 @@ void registerAggregateFunctionsQuantileTDigest(AggregateFunctionFactory &);
 void registerAggregateFunctionsQuantileTDigestWeighted(AggregateFunctionFactory &);
 void registerAggregateFunctionsQuantileBFloat16(AggregateFunctionFactory &);
 void registerAggregateFunctionsQuantileBFloat16Weighted(AggregateFunctionFactory &);
+void registerAggregateFunctionsQuantileApprox(AggregateFunctionFactory &);
 void registerAggregateFunctionsSequenceMatch(AggregateFunctionFactory &);
 void registerAggregateFunctionWindowFunnel(AggregateFunctionFactory &);
 void registerAggregateFunctionRate(AggregateFunctionFactory &);
@@ -124,6 +125,7 @@ void registerAggregateFunctions()
         registerAggregateFunctionsQuantileTDigestWeighted(factory);
         registerAggregateFunctionsQuantileBFloat16(factory);
         registerAggregateFunctionsQuantileBFloat16Weighted(factory);
+        registerAggregateFunctionsQuantileApprox(factory);
         registerAggregateFunctionsSequenceMatch(factory);
         registerAggregateFunctionWindowFunnel(factory);
         registerAggregateFunctionRate(factory);
diff --git a/src/Backups/BackupCoordinationRemote.cpp b/src/Backups/BackupCoordinationRemote.cpp
index f885cd0e6b4..8e6b5db91b1 100644
--- a/src/Backups/BackupCoordinationRemote.cpp
+++ b/src/Backups/BackupCoordinationRemote.cpp
@@ -771,16 +771,19 @@ bool BackupCoordinationRemote::hasConcurrentBackups(const std::atomic<size_t> &)
                 String existing_backup_uuid = existing_backup_path;
                 existing_backup_uuid.erase(0, String("backup-").size());
 
-
                 if (existing_backup_uuid == toString(backup_uuid))
                     continue;
 
-                const auto status = zk->get(root_zookeeper_path + "/" + existing_backup_path + "/stage");
-                if (status != Stage::COMPLETED)
+                String status;
+                if (zk->tryGet(root_zookeeper_path + "/" + existing_backup_path + "/stage", status))
                 {
-                    LOG_WARNING(log, "Found a concurrent backup: {}, current backup: {}", existing_backup_uuid, toString(backup_uuid));
-                    result = true;
-                    return;
+                    /// If status is not COMPLETED it could be because the backup failed, check if 'error' exists
+                    if (status != Stage::COMPLETED && !zk->exists(root_zookeeper_path + "/" + existing_backup_path + "/error"))
+                    {
+                        LOG_WARNING(log, "Found a concurrent backup: {}, current backup: {}", existing_backup_uuid, toString(backup_uuid));
+                        result = true;
+                        return;
+                    }
                 }
             }
 
diff --git a/src/Backups/BackupEntryFromAppendOnlyFile.cpp b/src/Backups/BackupEntryFromAppendOnlyFile.cpp
index 9bab101bc35..5384a69d890 100644
--- a/src/Backups/BackupEntryFromAppendOnlyFile.cpp
+++ b/src/Backups/BackupEntryFromAppendOnlyFile.cpp
@@ -8,10 +8,11 @@ namespace DB
 BackupEntryFromAppendOnlyFile::BackupEntryFromAppendOnlyFile(
     const DiskPtr & disk_,
     const String & file_path_,
+    const ReadSettings & settings_,
     const std::optional<UInt64> & file_size_,
     const std::optional<UInt128> & checksum_,
     const std::shared_ptr<TemporaryFileOnDisk> & temporary_file_)
-    : BackupEntryFromImmutableFile(disk_, file_path_, file_size_, checksum_, temporary_file_)
+    : BackupEntryFromImmutableFile(disk_, file_path_, settings_, file_size_, checksum_, temporary_file_)
     , limit(BackupEntryFromImmutableFile::getSize())
 {
 }
diff --git a/src/Backups/BackupEntryFromAppendOnlyFile.h b/src/Backups/BackupEntryFromAppendOnlyFile.h
index c6055b86268..b0cee38c6be 100644
--- a/src/Backups/BackupEntryFromAppendOnlyFile.h
+++ b/src/Backups/BackupEntryFromAppendOnlyFile.h
@@ -16,6 +16,7 @@ public:
     BackupEntryFromAppendOnlyFile(
         const DiskPtr & disk_,
         const String & file_path_,
+        const ReadSettings & settings_,
         const std::optional<UInt64> & file_size_ = {},
         const std::optional<UInt128> & checksum_ = {},
         const std::shared_ptr<TemporaryFileOnDisk> & temporary_file_ = {});
diff --git a/src/Backups/BackupEntryFromImmutableFile.cpp b/src/Backups/BackupEntryFromImmutableFile.cpp
index 86b9c13fb9a..48783a3bb63 100644
--- a/src/Backups/BackupEntryFromImmutableFile.cpp
+++ b/src/Backups/BackupEntryFromImmutableFile.cpp
@@ -11,10 +11,16 @@ namespace DB
 BackupEntryFromImmutableFile::BackupEntryFromImmutableFile(
     const DiskPtr & disk_,
     const String & file_path_,
+    const ReadSettings & settings_,
     const std::optional<UInt64> & file_size_,
     const std::optional<UInt128> & checksum_,
     const std::shared_ptr<TemporaryFileOnDisk> & temporary_file_)
-    : disk(disk_), file_path(file_path_), file_size(file_size_), checksum(checksum_), temporary_file_on_disk(temporary_file_)
+    : disk(disk_)
+    , file_path(file_path_)
+    , settings(settings_)
+    , file_size(file_size_)
+    , checksum(checksum_)
+    , temporary_file_on_disk(temporary_file_)
 {
 }
 
@@ -30,7 +36,7 @@ UInt64 BackupEntryFromImmutableFile::getSize() const
 
 std::unique_ptr<SeekableReadBuffer> BackupEntryFromImmutableFile::getReadBuffer() const
 {
-    return disk->readFile(file_path);
+    return disk->readFile(file_path, settings);
 }
 
 
diff --git a/src/Backups/BackupEntryFromImmutableFile.h b/src/Backups/BackupEntryFromImmutableFile.h
index 99241c691cb..66f1fade294 100644
--- a/src/Backups/BackupEntryFromImmutableFile.h
+++ b/src/Backups/BackupEntryFromImmutableFile.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Backups/IBackupEntry.h>
+#include <IO/ReadSettings.h>
 #include <base/defines.h>
 #include <mutex>
 
@@ -19,6 +20,7 @@ public:
     BackupEntryFromImmutableFile(
         const DiskPtr & disk_,
         const String & file_path_,
+        const ReadSettings & settings_,
         const std::optional<UInt64> & file_size_ = {},
         const std::optional<UInt128> & checksum_ = {},
         const std::shared_ptr<TemporaryFileOnDisk> & temporary_file_ = {});
@@ -37,6 +39,7 @@ public:
 private:
     const DiskPtr disk;
     const String file_path;
+    ReadSettings settings;
     mutable std::optional<UInt64> file_size TSA_GUARDED_BY(get_file_size_mutex);
     mutable std::mutex get_file_size_mutex;
     const std::optional<UInt128> checksum;
diff --git a/src/Backups/BackupIO.cpp b/src/Backups/BackupIO.cpp
index cc252c2f1bd..f78e6df23a8 100644
--- a/src/Backups/BackupIO.cpp
+++ b/src/Backups/BackupIO.cpp
@@ -3,6 +3,7 @@
 #include <IO/copyData.h>
 #include <IO/WriteBufferFromFileBase.h>
 #include <IO/SeekableReadBuffer.h>
+#include <Interpreters/Context.h>
 
 
 namespace DB
@@ -22,6 +23,11 @@ void IBackupReader::copyFileToDisk(const String & file_name, size_t size, DiskPt
     write_buffer->finalize();
 }
 
+IBackupWriter::IBackupWriter(const ContextPtr & context_)
+    : read_settings(context_->getBackupReadSettings())
+    , has_throttling(static_cast<bool>(context_->getBackupsThrottler()))
+{}
+
 void IBackupWriter::copyDataToFile(const CreateReadBufferFunction & create_read_buffer, UInt64 offset, UInt64 size, const String & dest_file_name)
 {
     auto read_buffer = create_read_buffer();
diff --git a/src/Backups/BackupIO.h b/src/Backups/BackupIO.h
index cf3d29ee51e..aef9c14e83e 100644
--- a/src/Backups/BackupIO.h
+++ b/src/Backups/BackupIO.h
@@ -3,6 +3,8 @@
 #include <Core/Types.h>
 #include <Disks/DiskType.h>
 #include <Disks/IDisk.h>
+#include <IO/ReadSettings.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
@@ -28,6 +30,8 @@ class IBackupWriter /// BackupWriterFile, BackupWriterDisk
 public:
     using CreateReadBufferFunction = std::function<std::unique_ptr<SeekableReadBuffer>()>;
 
+    explicit IBackupWriter(const ContextPtr & context_);
+
     virtual ~IBackupWriter() = default;
     virtual bool fileExists(const String & file_name) = 0;
     virtual UInt64 getFileSize(const String & file_name) = 0;
@@ -38,7 +42,17 @@ public:
     virtual DataSourceDescription getDataSourceDescription() const = 0;
     virtual void copyDataToFile(const CreateReadBufferFunction & create_read_buffer, UInt64 offset, UInt64 size, const String & dest_file_name);
     virtual bool supportNativeCopy(DataSourceDescription /* data_source_description */) const { return false; }
+
+    /// Copy file using native copy (optimized for S3 to use CopyObject)
+    ///
+    /// NOTE: It still may fall back to copyDataToFile() if native copy is not possible:
+    /// - different buckets
+    /// - throttling had been requested
     virtual void copyFileNative(DiskPtr src_disk, const String & src_file_name, UInt64 src_offset, UInt64 src_size, const String & dest_file_name);
+
+protected:
+    const ReadSettings read_settings;
+    const bool has_throttling;
 };
 
 }
diff --git a/src/Backups/BackupIO_Disk.cpp b/src/Backups/BackupIO_Disk.cpp
index cc6076541d0..10d7a572f6b 100644
--- a/src/Backups/BackupIO_Disk.cpp
+++ b/src/Backups/BackupIO_Disk.cpp
@@ -50,7 +50,10 @@ void BackupReaderDisk::copyFileToDisk(const String & file_name, size_t size, Dis
 }
 
 
-BackupWriterDisk::BackupWriterDisk(const DiskPtr & disk_, const String & path_) : disk(disk_), path(path_)
+BackupWriterDisk::BackupWriterDisk(const DiskPtr & disk_, const String & path_, const ContextPtr & context_)
+    : IBackupWriter(context_)
+    , disk(disk_)
+    , path(path_)
 {
 }
 
@@ -127,9 +130,9 @@ void BackupWriterDisk::copyFileNative(DiskPtr src_disk, const String & src_file_
     if (!src_disk)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot natively copy data to disk without source disk");
 
-    if ((src_offset != 0) || (src_size != src_disk->getFileSize(src_file_name)))
+    if (has_throttling || (src_offset != 0) || (src_size != src_disk->getFileSize(src_file_name)))
     {
-        auto create_read_buffer = [src_disk, src_file_name] { return src_disk->readFile(src_file_name); };
+        auto create_read_buffer = [this, src_disk, src_file_name] { return src_disk->readFile(src_file_name, read_settings); };
         copyDataToFile(create_read_buffer, src_offset, src_size, dest_file_name);
         return;
     }
diff --git a/src/Backups/BackupIO_Disk.h b/src/Backups/BackupIO_Disk.h
index 600e4f8ff39..be34847000d 100644
--- a/src/Backups/BackupIO_Disk.h
+++ b/src/Backups/BackupIO_Disk.h
@@ -2,6 +2,7 @@
 
 #include <filesystem>
 #include <Backups/BackupIO.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
@@ -30,7 +31,7 @@ private:
 class BackupWriterDisk : public IBackupWriter
 {
 public:
-    BackupWriterDisk(const DiskPtr & disk_, const String & path_);
+    BackupWriterDisk(const DiskPtr & disk_, const String & path_, const ContextPtr & context_);
     ~BackupWriterDisk() override;
 
     bool fileExists(const String & file_name) override;
diff --git a/src/Backups/BackupIO_File.cpp b/src/Backups/BackupIO_File.cpp
index 5bf6d54928d..d4c9d0cb210 100644
--- a/src/Backups/BackupIO_File.cpp
+++ b/src/Backups/BackupIO_File.cpp
@@ -49,7 +49,9 @@ void BackupReaderFile::copyFileToDisk(const String & file_name, size_t size, Dis
 }
 
 
-BackupWriterFile::BackupWriterFile(const String & path_) : path(path_)
+BackupWriterFile::BackupWriterFile(const String & path_, const ContextPtr & context_)
+    : IBackupWriter(context_)
+    , path(path_)
 {
 }
 
@@ -152,9 +154,9 @@ void BackupWriterFile::copyFileNative(DiskPtr src_disk, const String & src_file_
     else
         abs_source_path = fs::absolute(src_file_name);
 
-    if ((src_offset != 0) || (src_size != fs::file_size(abs_source_path)))
+    if (has_throttling || (src_offset != 0) || (src_size != fs::file_size(abs_source_path)))
     {
-        auto create_read_buffer = [abs_source_path] { return createReadBufferFromFileBase(abs_source_path, {}); };
+        auto create_read_buffer = [this, abs_source_path] { return createReadBufferFromFileBase(abs_source_path, read_settings); };
         copyDataToFile(create_read_buffer, src_offset, src_size, dest_file_name);
         return;
     }
diff --git a/src/Backups/BackupIO_File.h b/src/Backups/BackupIO_File.h
index e1f4324a39f..d4b6e13d546 100644
--- a/src/Backups/BackupIO_File.h
+++ b/src/Backups/BackupIO_File.h
@@ -2,6 +2,7 @@
 
 #include <filesystem>
 #include <Backups/BackupIO.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
@@ -27,7 +28,7 @@ private:
 class BackupWriterFile : public IBackupWriter
 {
 public:
-    explicit BackupWriterFile(const String & path_);
+    explicit BackupWriterFile(const String & path_, const ContextPtr & context_);
     ~BackupWriterFile() override;
 
     bool fileExists(const String & file_name) override;
diff --git a/src/Backups/BackupIO_S3.cpp b/src/Backups/BackupIO_S3.cpp
index f7d518b064d..ba5ba170427 100644
--- a/src/Backups/BackupIO_S3.cpp
+++ b/src/Backups/BackupIO_S3.cpp
@@ -161,9 +161,9 @@ void BackupReaderS3::copyFileToDisk(const String & file_name, size_t size, DiskP
 
 BackupWriterS3::BackupWriterS3(
     const S3::URI & s3_uri_, const String & access_key_id_, const String & secret_access_key_, const ContextPtr & context_)
-    : s3_uri(s3_uri_)
+    : IBackupWriter(context_)
+    , s3_uri(s3_uri_)
     , client(makeS3Client(s3_uri_, access_key_id_, secret_access_key_, context_))
-    , read_settings(context_->getReadSettings())
     , request_settings(context_->getStorageS3Settings().getSettings(s3_uri.uri.toString()).request_settings)
     , log(&Poco::Logger::get("BackupWriterS3"))
 {
@@ -189,7 +189,7 @@ void BackupWriterS3::copyFileNative(DiskPtr src_disk, const String & src_file_na
     auto objects = src_disk->getStorageObjects(src_file_name);
     if (objects.size() > 1)
     {
-        auto create_read_buffer = [src_disk, src_file_name] { return src_disk->readFile(src_file_name); };
+        auto create_read_buffer = [this, src_disk, src_file_name] { return src_disk->readFile(src_file_name, read_settings); };
         copyDataToFile(create_read_buffer, src_offset, src_size, dest_file_name);
     }
     else
diff --git a/src/Backups/BackupIO_S3.h b/src/Backups/BackupIO_S3.h
index 94e61248428..c32a6b48660 100644
--- a/src/Backups/BackupIO_S3.h
+++ b/src/Backups/BackupIO_S3.h
@@ -7,6 +7,7 @@
 #include <IO/ReadSettings.h>
 #include <IO/S3Common.h>
 #include <Storages/StorageS3Settings.h>
+#include <Interpreters/Context_fwd.h>
 
 
 namespace DB
@@ -76,7 +77,6 @@ private:
 
     S3::URI s3_uri;
     std::shared_ptr<S3::Client> client;
-    ReadSettings read_settings;
     S3Settings::RequestSettings request_settings;
     Poco::Logger * log;
     std::optional<bool> supports_batch_delete;
diff --git a/src/Backups/RestoreCoordinationRemote.cpp b/src/Backups/RestoreCoordinationRemote.cpp
index 0187ad0e7e2..cc03f0c4a2a 100644
--- a/src/Backups/RestoreCoordinationRemote.cpp
+++ b/src/Backups/RestoreCoordinationRemote.cpp
@@ -279,12 +279,16 @@ bool RestoreCoordinationRemote::hasConcurrentRestores(const std::atomic<size_t>
                     if (existing_restore_uuid == toString(restore_uuid))
                         continue;
 
-                    const auto status = zk->get(root_zookeeper_path + "/" + existing_restore_path + "/stage");
-                    if (status != Stage::COMPLETED)
+                    String status;
+                    if (zk->tryGet(root_zookeeper_path + "/" + existing_restore_path + "/stage", status))
                     {
-                        LOG_WARNING(log, "Found a concurrent restore: {}, current restore: {}", existing_restore_uuid, toString(restore_uuid));
-                        result = true;
-                        return;
+                        /// If status is not COMPLETED it could be because the restore failed, check if 'error' exists
+                        if (status != Stage::COMPLETED && !zk->exists(root_zookeeper_path + "/" + existing_restore_path + "/error"))
+                        {
+                            LOG_WARNING(log, "Found a concurrent restore: {}, current restore: {}", existing_restore_uuid, toString(restore_uuid));
+                            result = true;
+                            return;
+                        }
                     }
                 }
 
diff --git a/src/Backups/registerBackupEnginesFileAndDisk.cpp b/src/Backups/registerBackupEnginesFileAndDisk.cpp
index 51b14fbc1d8..46f44471e6f 100644
--- a/src/Backups/registerBackupEnginesFileAndDisk.cpp
+++ b/src/Backups/registerBackupEnginesFileAndDisk.cpp
@@ -178,9 +178,9 @@ void registerBackupEnginesFileAndDisk(BackupFactory & factory)
         {
             std::shared_ptr<IBackupWriter> writer;
             if (engine_name == "File")
-                writer = std::make_shared<BackupWriterFile>(path);
+                writer = std::make_shared<BackupWriterFile>(path, params.context);
             else
-                writer = std::make_shared<BackupWriterDisk>(disk, path);
+                writer = std::make_shared<BackupWriterDisk>(disk, path, params.context);
             return std::make_unique<BackupImpl>(
                 backup_name_for_logging,
                 archive_params,
diff --git a/src/Common/Concepts.h b/src/Common/Concepts.h
index b1bf591024d..927f42aa4be 100644
--- a/src/Common/Concepts.h
+++ b/src/Common/Concepts.h
@@ -5,6 +5,10 @@
 namespace DB
 {
 
+template<typename T, typename ... U>
+concept is_any_of = (std::same_as<T, U> || ...);
+
+
 template <typename... T>
 concept OptionalArgument = requires(T &&...)
 {
diff --git a/src/Common/MemoryTracker.cpp b/src/Common/MemoryTracker.cpp
index e2129e1013e..e33a0736547 100644
--- a/src/Common/MemoryTracker.cpp
+++ b/src/Common/MemoryTracker.cpp
@@ -82,6 +82,26 @@ inline std::string_view toDescription(OvercommitResult result)
     }
 }
 
+inline void debugLogBigAllocationWithoutCheck(Int64 size [[maybe_unused]])
+{
+    /// Big allocations through allocNoThrow (without checking memory limits) may easily lead to OOM (and it's hard to debug).
+    /// Let's find them.
+#ifdef ABORT_ON_LOGICAL_ERROR
+    if (size < 0)
+        return;
+
+    constexpr Int64 threshold = 16 * 1024 * 1024;   /// The choice is arbitrary (maybe we should decrease it)
+    if (size < threshold)
+        return;
+
+    MemoryTrackerBlockerInThread blocker;
+    LOG_TEST(&Poco::Logger::get("MemoryTracker"), "Too big allocation ({} bytes) without checking memory limits, "
+                                                   "it may lead to OOM. Stack trace: {}", size, StackTrace().toString());
+#else
+    return;     /// Avoid trash logging in release builds
+#endif
+}
+
 }
 
 namespace ProfileEvents
@@ -235,7 +255,10 @@ void MemoryTracker::allocImpl(Int64 size, bool throw_if_memory_exceeded, MemoryT
                 formatReadableSizeWithBinarySuffix(current_hard_limit));
         }
         else
+        {
             memory_limit_exceeded_ignored = true;
+            debugLogBigAllocationWithoutCheck(size);
+        }
     }
 
     Int64 limit_to_check = current_hard_limit;
@@ -303,7 +326,10 @@ void MemoryTracker::allocImpl(Int64 size, bool throw_if_memory_exceeded, MemoryT
             }
         }
         else
+        {
             memory_limit_exceeded_ignored = true;
+            debugLogBigAllocationWithoutCheck(size);
+        }
     }
 
     bool peak_updated = false;
@@ -323,6 +349,7 @@ void MemoryTracker::allocImpl(Int64 size, bool throw_if_memory_exceeded, MemoryT
         {
             bool log_memory_usage = false;
             peak_updated = updatePeak(will_be, log_memory_usage);
+            debugLogBigAllocationWithoutCheck(size);
         }
     }
 
diff --git a/src/Common/ProfileEvents.cpp b/src/Common/ProfileEvents.cpp
index 1d035952f13..a17d73e1673 100644
--- a/src/Common/ProfileEvents.cpp
+++ b/src/Common/ProfileEvents.cpp
@@ -75,10 +75,14 @@
     M(S3GetRequestThrottlerSleepMicroseconds, "Total time a query was sleeping to conform S3 GET and SELECT request throttling.") \
     M(S3PutRequestThrottlerCount, "Number of S3 PUT, COPY, POST and LIST requests passed through throttler.") \
     M(S3PutRequestThrottlerSleepMicroseconds, "Total time a query was sleeping to conform S3 PUT, COPY, POST and LIST request throttling.") \
-    M(RemoteReadThrottlerBytes, "Bytes passed through 'max_remote_read_network_bandwidth_for_server' throttler.") \
-    M(RemoteReadThrottlerSleepMicroseconds, "Total time a query was sleeping to conform 'max_remote_read_network_bandwidth_for_server' throttling.") \
-    M(RemoteWriteThrottlerBytes, "Bytes passed through 'max_remote_write_network_bandwidth_for_server' throttler.") \
-    M(RemoteWriteThrottlerSleepMicroseconds, "Total time a query was sleeping to conform 'max_remote_write_network_bandwidth_for_server' throttling.") \
+    M(RemoteReadThrottlerBytes, "Bytes passed through 'max_remote_read_network_bandwidth_for_server'/'max_remote_read_network_bandwidth' throttler.") \
+    M(RemoteReadThrottlerSleepMicroseconds, "Total time a query was sleeping to conform 'max_remote_read_network_bandwidth_for_server'/'max_remote_read_network_bandwidth' throttling.") \
+    M(RemoteWriteThrottlerBytes, "Bytes passed through 'max_remote_write_network_bandwidth_for_server'/'max_remote_write_network_bandwidth' throttler.") \
+    M(RemoteWriteThrottlerSleepMicroseconds, "Total time a query was sleeping to conform 'max_remote_write_network_bandwidth_for_server'/'max_remote_write_network_bandwidth' throttling.") \
+    M(LocalReadThrottlerBytes, "Bytes passed through 'max_local_read_bandwidth_for_server'/'max_local_read_bandwidth' throttler.") \
+    M(LocalReadThrottlerSleepMicroseconds, "Total time a query was sleeping to conform 'max_local_read_bandwidth_for_server'/'max_local_read_bandwidth' throttling.") \
+    M(LocalWriteThrottlerBytes, "Bytes passed through 'max_local_write_bandwidth_for_server'/'max_local_write_bandwidth' throttler.") \
+    M(LocalWriteThrottlerSleepMicroseconds, "Total time a query was sleeping to conform 'max_local_write_bandwidth_for_server'/'max_local_write_bandwidth' throttling.") \
     M(ThrottlerSleepMicroseconds, "Total time a query was sleeping to conform all throttling settings.") \
     \
     M(QueryMaskingRulesMatch, "Number of times query masking rules was successfully matched.") \
diff --git a/src/Common/SpaceSaving.h b/src/Common/SpaceSaving.h
index 476e107067b..c83e836eb83 100644
--- a/src/Common/SpaceSaving.h
+++ b/src/Common/SpaceSaving.h
@@ -94,8 +94,8 @@ public:
         void write(WriteBuffer & wb) const
         {
             writeBinary(key, wb);
-            writeVarUInt(count, wb);
-            writeVarUInt(error, wb);
+            writeVarUIntOverflow(count, wb);
+            writeVarUIntOverflow(error, wb);
         }
 
         void read(ReadBuffer & rb)
diff --git a/src/Common/typeid_cast.h b/src/Common/typeid_cast.h
index 1568d380938..baee3aaf632 100644
--- a/src/Common/typeid_cast.h
+++ b/src/Common/typeid_cast.h
@@ -18,9 +18,6 @@ namespace DB
     }
 }
 
-template<typename T, typename ... U>
-concept is_any_of = (std::same_as<T, U> || ...);
-
 
 /** Checks type by comparing typeid.
   * The exact match of the type is checked. That is, cast to the ancestor will be unsuccessful.
diff --git a/src/Core/ProtocolDefines.h b/src/Core/ProtocolDefines.h
index f687145668a..ff9b1fae442 100644
--- a/src/Core/ProtocolDefines.h
+++ b/src/Core/ProtocolDefines.h
@@ -30,7 +30,7 @@
 
 #define DBMS_CLUSTER_PROCESSING_PROTOCOL_VERSION 1
 
-#define DBMS_PARALLEL_REPLICAS_PROTOCOL_VERSION 1
+#define DBMS_PARALLEL_REPLICAS_PROTOCOL_VERSION 2
 #define DBMS_MIN_REVISION_WITH_PARALLEL_REPLICAS 54453
 
 #define DBMS_MERGE_TREE_PART_INFO_VERSION 1
diff --git a/src/Core/ServerSettings.cpp b/src/Core/ServerSettings.cpp
index 0a94b0dffcc..2b4ee6485bc 100644
--- a/src/Core/ServerSettings.cpp
+++ b/src/Core/ServerSettings.cpp
@@ -19,7 +19,10 @@ void ServerSettings::loadSettingsFromConfig(const Poco::Util::AbstractConfigurat
         "background_buffer_flush_schedule_pool_size",
         "background_schedule_pool_size",
         "background_message_broker_schedule_pool_size",
-        "background_distributed_schedule_pool_size"
+        "background_distributed_schedule_pool_size",
+
+        "max_remote_read_network_bandwidth_for_server",
+        "max_remote_write_network_bandwidth_for_server",
     };
 
     for (auto setting : all())
diff --git a/src/Core/ServerSettings.h b/src/Core/ServerSettings.h
index 753a70a7c25..aabc89cc6d7 100644
--- a/src/Core/ServerSettings.h
+++ b/src/Core/ServerSettings.h
@@ -21,10 +21,15 @@ namespace DB
     M(UInt64, max_io_thread_pool_size, 100, "The maximum number of threads that would be used for IO operations", 0) \
     M(UInt64, max_io_thread_pool_free_size, 0, "Max free size for IO thread pool.", 0) \
     M(UInt64, io_thread_pool_queue_size, 10000, "Queue size for IO thread pool.", 0) \
+    M(UInt64, max_remote_read_network_bandwidth_for_server, 0, "The maximum speed of data exchange over the network in bytes per second for read. Zero means unlimited.", 0) \
+    M(UInt64, max_remote_write_network_bandwidth_for_server, 0, "The maximum speed of data exchange over the network in bytes per second for write. Zero means unlimited.", 0) \
+    M(UInt64, max_local_read_bandwidth_for_server, 0, "The maximum speed of local reads in bytes per second. Zero means unlimited.", 0) \
+    M(UInt64, max_local_write_bandwidth_for_server, 0, "The maximum speed of local writes in bytes per second. Zero means unlimited.", 0) \
     M(UInt64, max_backups_io_thread_pool_size, 1000, "The maximum number of threads that would be used for IO operations for BACKUP queries", 0) \
     M(UInt64, max_backups_io_thread_pool_free_size, 0, "Max free size for backups IO thread pool.", 0) \
     M(UInt64, backups_io_thread_pool_queue_size, 0, "Queue size for backups IO thread pool.", 0) \
     M(UInt64, backup_threads, 16, "The maximum number of threads to execute BACKUP requests.", 0) \
+    M(UInt64, max_backup_bandwidth_for_server, 0, "The maximum read speed in bytes per second for all backups on server. Zero means unlimited.", 0) \
     M(UInt64, restore_threads, 16, "The maximum number of threads to execute RESTORE requests.", 0) \
     M(Int32, max_connections, 1024, "Max server connections.", 0) \
     M(UInt32, asynchronous_metrics_update_period_s, 1, "Period in seconds for updating asynchronous metrics.", 0) \
diff --git a/src/Core/Settings.h b/src/Core/Settings.h
index 44b68f459bd..b6a149aa4ca 100644
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@@ -100,8 +100,10 @@ class IColumn;
     M(Bool, replace_running_query, false, "Whether the running request should be canceled with the same id as the new one.", 0) \
     M(UInt64, max_replicated_fetches_network_bandwidth_for_server, 0, "The maximum speed of data exchange over the network in bytes per second for replicated fetches. Zero means unlimited. Only has meaning at server startup.", 0) \
     M(UInt64, max_replicated_sends_network_bandwidth_for_server, 0, "The maximum speed of data exchange over the network in bytes per second for replicated sends. Zero means unlimited. Only has meaning at server startup.", 0) \
-    M(UInt64, max_remote_read_network_bandwidth_for_server, 0, "The maximum speed of data exchange over the network in bytes per second for read. Zero means unlimited. Only has meaning at server startup.", 0) \
-    M(UInt64, max_remote_write_network_bandwidth_for_server, 0, "The maximum speed of data exchange over the network in bytes per second for write. Zero means unlimited. Only has meaning at server startup.", 0) \
+    M(UInt64, max_remote_read_network_bandwidth, 0, "The maximum speed of data exchange over the network in bytes per second for read.", 0) \
+    M(UInt64, max_remote_write_network_bandwidth, 0, "The maximum speed of data exchange over the network in bytes per second for write.", 0) \
+    M(UInt64, max_local_read_bandwidth, 0, "The maximum speed of local reads in bytes per second.", 0) \
+    M(UInt64, max_local_write_bandwidth, 0, "The maximum speed of local writes in bytes per second.", 0) \
     M(Bool, stream_like_engine_allow_direct_select, false, "Allow direct SELECT query for Kafka, RabbitMQ, FileLog, Redis Streams and NATS engines. In case there are attached materialized views, SELECT query is not allowed even if this setting is enabled.", 0) \
     M(String, stream_like_engine_insert_queue, "", "When stream like engine reads from multiple queues, user will need to select one queue to insert into when writing. Used by Redis Streams and NATS.", 0) \
     \
@@ -422,6 +424,7 @@ class IColumn;
     M(UInt64, backup_restore_keeper_fault_injection_seed, 0, "0 - random seed, otherwise the setting value", 0) \
     M(UInt64, backup_restore_keeper_value_max_size, 1048576, "Maximum size of data of a [Zoo]Keeper's node during backup", 0) \
     M(UInt64, backup_restore_batch_size_for_keeper_multiread, 10000, "Maximum size of batch for multiread request to [Zoo]Keeper during backup or restore", 0) \
+    M(UInt64, max_backup_bandwidth, 0, "The maximum read speed in bytes per second for particular backup on server. Zero means unlimited.", 0) \
     \
     M(Bool, log_profile_events, true, "Log query performance statistics into the query_log, query_thread_log and query_views_log.", 0) \
     M(Bool, log_query_settings, true, "Log query settings into the query_log.", 0) \
@@ -464,6 +467,7 @@ class IColumn;
     M(Bool, allow_introspection_functions, false, "Allow functions for introspection of ELF and DWARF for query profiling. These functions are slow and may impose security considerations.", 0) \
     \
     M(Bool, allow_execute_multiif_columnar, true, "Allow execute multiIf function columnar", 0) \
+    M(Bool, formatdatetime_parsedatetime_m_is_month_name, true, "Formatter '%M' in function 'formatDateTime' produces the month name instead of minutes.", 0) \
     \
     M(UInt64, max_partitions_per_insert_block, 100, "Limit maximum number of partitions in single INSERTed block. Zero means unlimited. Throw exception if the block contains too many partitions. This setting is a safety threshold, because using large number of partitions is a common misconception.", 0) \
     M(Int64, max_partitions_to_read, -1, "Limit the max number of partitions that can be accessed in one query. <= 0 means unlimited.", 0) \
@@ -735,6 +739,7 @@ class IColumn;
 #define MAKE_OBSOLETE(M, TYPE, NAME, DEFAULT) \
     M(TYPE, NAME, DEFAULT, "Obsolete setting, does nothing.", BaseSettingsHelpers::Flags::OBSOLETE)
 
+/// NOTE: ServerSettings::loadSettingsFromConfig() should be updated to include this settings
 #define MAKE_DEPRECATED_BY_SERVER_CONFIG(M, TYPE, NAME, DEFAULT) \
     M(TYPE, NAME, DEFAULT, "User-level setting is deprecated, and it must be defined in the server configuration instead.", BaseSettingsHelpers::Flags::OBSOLETE)
 
@@ -768,6 +773,8 @@ class IColumn;
     MAKE_DEPRECATED_BY_SERVER_CONFIG(M, UInt64, background_schedule_pool_size, 128) \
     MAKE_DEPRECATED_BY_SERVER_CONFIG(M, UInt64, background_message_broker_schedule_pool_size, 16) \
     MAKE_DEPRECATED_BY_SERVER_CONFIG(M, UInt64, background_distributed_schedule_pool_size, 16) \
+    MAKE_DEPRECATED_BY_SERVER_CONFIG(M, UInt64, max_remote_read_network_bandwidth_for_server, 0) \
+    MAKE_DEPRECATED_BY_SERVER_CONFIG(M, UInt64, max_remote_write_network_bandwidth_for_server, 0) \
     /* ---- */ \
     MAKE_OBSOLETE(M, DefaultDatabaseEngine, default_database_engine, DefaultDatabaseEngine::Atomic) \
     MAKE_OBSOLETE(M, UInt64, max_pipeline_depth, 0)                                                                                 \
diff --git a/src/Core/SettingsChangesHistory.h b/src/Core/SettingsChangesHistory.h
index caf18cf8fb8..4f89397ed9d 100644
--- a/src/Core/SettingsChangesHistory.h
+++ b/src/Core/SettingsChangesHistory.h
@@ -101,6 +101,7 @@ static std::map<ClickHouseVersion, SettingsChangesHistory::SettingsChanges> sett
                {"query_plan_aggregation_in_order", 0, 1, "Enable some refactoring around query plan"},
                {"format_binary_max_string_size", 0, 1_GiB, "Prevent allocating large amount of memory"}}},
     {"22.11", {{"use_structure_from_insertion_table_in_table_functions", 0, 2, "Improve using structure from insertion table in table functions"}}},
+    {"23.4", {{"formatdatetime_parsedatetime_m_is_month_name", false, true, "Improved compatibility with MySQL DATE_FORMAT/STR_TO_DATE"}}},
     {"22.9", {{"force_grouping_standard_compatibility", false, true, "Make GROUPING function output the same as in SQL standard and other DBMS"}}},
     {"22.7", {{"cross_to_inner_join_rewrite", 1, 2, "Force rewrite comma join to inner"},
               {"enable_positional_arguments", false, true, "Enable positional arguments feature by default"},
diff --git a/src/Disks/DiskLocal.cpp b/src/Disks/DiskLocal.cpp
index a3b7e413014..160fcb5732c 100644
--- a/src/Disks/DiskLocal.cpp
+++ b/src/Disks/DiskLocal.cpp
@@ -1,4 +1,5 @@
 #include "DiskLocal.h"
+#include <Common/Throttler_fwd.h>
 #include <Common/createHardLink.h>
 #include "DiskFactory.h"
 
@@ -367,10 +368,11 @@ std::unique_ptr<ReadBufferFromFileBase> DiskLocal::readFile(const String & path,
 }
 
 std::unique_ptr<WriteBufferFromFileBase>
-DiskLocal::writeFile(const String & path, size_t buf_size, WriteMode mode, const WriteSettings &)
+DiskLocal::writeFile(const String & path, size_t buf_size, WriteMode mode, const WriteSettings & settings)
 {
     int flags = (mode == WriteMode::Append) ? (O_APPEND | O_CREAT | O_WRONLY) : -1;
-    return std::make_unique<WriteBufferFromFile>(fs::path(disk_path) / path, buf_size, flags);
+    return std::make_unique<WriteBufferFromFile>(
+        fs::path(disk_path) / path, buf_size, flags, settings.local_throttler);
 }
 
 void DiskLocal::removeFile(const String & path)
diff --git a/src/Disks/IO/createReadBufferFromFileBase.cpp b/src/Disks/IO/createReadBufferFromFileBase.cpp
index 04496e36826..8e9a1d86628 100644
--- a/src/Disks/IO/createReadBufferFromFileBase.cpp
+++ b/src/Disks/IO/createReadBufferFromFileBase.cpp
@@ -76,11 +76,25 @@ std::unique_ptr<ReadBufferFromFileBase> createReadBufferFromFileBase(
 
         if (settings.local_fs_method == LocalFSReadMethod::read)
         {
-            res = std::make_unique<ReadBufferFromFile>(filename, buffer_size, actual_flags, existing_memory, buffer_alignment, file_size);
+            res = std::make_unique<ReadBufferFromFile>(
+                filename,
+                buffer_size,
+                actual_flags,
+                existing_memory,
+                buffer_alignment,
+                file_size,
+                settings.local_throttler);
         }
         else if (settings.local_fs_method == LocalFSReadMethod::pread || settings.local_fs_method == LocalFSReadMethod::mmap)
         {
-            res = std::make_unique<ReadBufferFromFilePReadWithDescriptorsCache>(filename, buffer_size, actual_flags, existing_memory, buffer_alignment, file_size);
+            res = std::make_unique<ReadBufferFromFilePReadWithDescriptorsCache>(
+                filename,
+                buffer_size,
+                actual_flags,
+                existing_memory,
+                buffer_alignment,
+                file_size,
+                settings.local_throttler);
         }
         else if (settings.local_fs_method == LocalFSReadMethod::io_uring)
         {
@@ -90,7 +104,15 @@ std::unique_ptr<ReadBufferFromFileBase> createReadBufferFromFileBase(
                 throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "io_uring is not supported by this system");
 
             res = std::make_unique<AsynchronousReadBufferFromFileWithDescriptorsCache>(
-                *reader, settings.priority, filename, buffer_size, actual_flags, existing_memory, buffer_alignment, file_size);
+                *reader,
+                settings.priority,
+                filename,
+                buffer_size,
+                actual_flags,
+                existing_memory,
+                buffer_alignment,
+                file_size,
+                settings.local_throttler);
 #else
             throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "Read method io_uring is only supported in Linux");
 #endif
@@ -103,7 +125,15 @@ std::unique_ptr<ReadBufferFromFileBase> createReadBufferFromFileBase(
 
             auto & reader = context->getThreadPoolReader(Context::FilesystemReaderType::SYNCHRONOUS_LOCAL_FS_READER);
             res = std::make_unique<AsynchronousReadBufferFromFileWithDescriptorsCache>(
-                reader, settings.priority, filename, buffer_size, actual_flags, existing_memory, buffer_alignment, file_size);
+                reader,
+                settings.priority,
+                filename,
+                buffer_size,
+                actual_flags,
+                existing_memory,
+                buffer_alignment,
+                file_size,
+                settings.local_throttler);
         }
         else if (settings.local_fs_method == LocalFSReadMethod::pread_threadpool)
         {
@@ -113,7 +143,15 @@ std::unique_ptr<ReadBufferFromFileBase> createReadBufferFromFileBase(
 
             auto & reader = context->getThreadPoolReader(Context::FilesystemReaderType::ASYNCHRONOUS_LOCAL_FS_READER);
             res = std::make_unique<AsynchronousReadBufferFromFileWithDescriptorsCache>(
-                reader, settings.priority, filename, buffer_size, actual_flags, existing_memory, buffer_alignment, file_size);
+                reader,
+                settings.priority,
+                filename,
+                buffer_size,
+                actual_flags,
+                existing_memory,
+                buffer_alignment,
+                file_size,
+                settings.local_throttler);
         }
         else
             throw Exception(ErrorCodes::LOGICAL_ERROR, "Unknown read method");
diff --git a/src/Formats/CapnProtoUtils.cpp b/src/Formats/CapnProtoUtils.cpp
index a557b762672..d6c032408bb 100644
--- a/src/Formats/CapnProtoUtils.cpp
+++ b/src/Formats/CapnProtoUtils.cpp
@@ -9,6 +9,7 @@
 #include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeString.h>
+#include <DataTypes/DataTypeMap.h>
 #include <DataTypes/IDataType.h>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/join.hpp>
@@ -264,23 +265,25 @@ static bool checkTupleType(const capnp::Type & capnp_type, const DataTypePtr & d
         return false;
     }
 
-    if (!tuple_data_type->haveExplicitNames())
+    bool have_explicit_names = tuple_data_type->haveExplicitNames();
+    const auto & nested_names = tuple_data_type->getElementNames();
+    for (uint32_t i = 0; i != nested_names.size(); ++i)
     {
-        error_message += "Only named Tuple can be converted to CapnProto Struct";
-        return false;
-    }
-    for (const auto & name : tuple_data_type->getElementNames())
-    {
-        KJ_IF_MAYBE(field, struct_schema.findFieldByName(name))
+        if (have_explicit_names)
         {
-            if (!checkCapnProtoType(field->getType(), nested_types[tuple_data_type->getPositionByName(name)], mode, error_message, name))
+            KJ_IF_MAYBE (field, struct_schema.findFieldByName(nested_names[i]))
+            {
+                if (!checkCapnProtoType(field->getType(), nested_types[tuple_data_type->getPositionByName(nested_names[i])], mode, error_message, nested_names[i]))
+                    return false;
+            }
+            else
+            {
+                error_message += "CapnProto struct doesn't contain a field with name " + nested_names[i];
                 return false;
+            }
         }
-        else
-        {
-            error_message += "CapnProto struct doesn't contain a field with name " + name;
+        else if (!checkCapnProtoType(struct_schema.getFields()[i].getType(), nested_types[tuple_data_type->getPositionByName(nested_names[i])], mode, error_message, nested_names[i]))
             return false;
-        }
     }
 
     return true;
@@ -307,41 +310,129 @@ static bool checkArrayType(const capnp::Type & capnp_type, const DataTypePtr & d
     return checkCapnProtoType(list_schema.getElementType(), nested_type, mode, error_message, column_name);
 }
 
+static bool checkMapType(const capnp::Type & capnp_type, const DataTypePtr & data_type, FormatSettings::EnumComparingMode mode, String & error_message)
+{
+    /// We output/input Map type as follow CapnProto schema
+    ///
+    /// struct Map {
+    ///     struct Entry {
+    ///         key @0: Key;
+    ///         value @1: Value;
+    ///     }
+    ///     entries @0 :List(Entry);
+    /// }
+
+    if (!capnp_type.isStruct())
+        return false;
+    auto struct_schema = capnp_type.asStruct();
+
+    if (checkIfStructContainsUnnamedUnion(struct_schema))
+    {
+        error_message += "CapnProto struct contains unnamed union";
+        return false;
+    }
+
+    if (struct_schema.getFields().size() != 1)
+    {
+        error_message += "CapnProto struct that represents Map type can contain only one field";
+        return false;
+    }
+
+    const auto & field_type = struct_schema.getFields()[0].getType();
+    if (!field_type.isList())
+    {
+        error_message += "Field of CapnProto struct that represents Map is not a list";
+        return false;
+    }
+
+    auto list_element_type = field_type.asList().getElementType();
+    if (!list_element_type.isStruct())
+    {
+        error_message += "Field of CapnProto struct that represents Map is not a list of structs";
+        return false;
+    }
+
+    auto key_value_struct = list_element_type.asStruct();
+    if (checkIfStructContainsUnnamedUnion(key_value_struct))
+    {
+        error_message += "CapnProto struct contains unnamed union";
+        return false;
+    }
+
+    if (key_value_struct.getFields().size() != 2)
+    {
+        error_message += "Key-value structure for Map struct should have exactly 2 fields";
+        return false;
+    }
+
+    const auto & map_type = assert_cast<const DataTypeMap &>(*data_type);
+    DataTypes types = {map_type.getKeyType(), map_type.getValueType()};
+    Names names = {"key", "value"};
+
+    for (size_t i = 0; i != types.size(); ++i)
+    {
+        KJ_IF_MAYBE(field, key_value_struct.findFieldByName(names[i]))
+        {
+            if (!checkCapnProtoType(field->getType(), types[i], mode, error_message, names[i]))
+                return false;
+        }
+        else
+        {
+            error_message += R"(Key-value structure for Map struct should have exactly 2 fields with names "key" and "value")";
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool isCapnInteger(const capnp::Type & capnp_type)
+{
+    return capnp_type.isInt8() || capnp_type.isUInt8() || capnp_type.isInt16() || capnp_type.isUInt16() || capnp_type.isInt32()
+        || capnp_type.isUInt32() || capnp_type.isInt64() || capnp_type.isUInt64();
+}
+
 static bool checkCapnProtoType(const capnp::Type & capnp_type, const DataTypePtr & data_type, FormatSettings::EnumComparingMode mode, String & error_message, const String & column_name)
 {
     switch (data_type->getTypeId())
     {
         case TypeIndex::UInt8:
-            return capnp_type.isBool() || capnp_type.isUInt8();
-        case TypeIndex::Date: [[fallthrough]];
-        case TypeIndex::UInt16:
+            return capnp_type.isBool() || isCapnInteger(capnp_type);
+        case TypeIndex::Int8: [[fallthrough]];
+        case TypeIndex::Int16: [[fallthrough]];
+        case TypeIndex::UInt16: [[fallthrough]];
+        case TypeIndex::Int32: [[fallthrough]];
+        case TypeIndex::UInt32: [[fallthrough]];
+        case TypeIndex::Int64: [[fallthrough]];
+        case TypeIndex::UInt64:
+            /// Allow integer conversions durin input/output.
+            return isCapnInteger(capnp_type);
+        case TypeIndex::Date:
             return capnp_type.isUInt16();
         case TypeIndex::DateTime: [[fallthrough]];
-        case TypeIndex::IPv4: [[fallthrough]];
-        case TypeIndex::UInt32:
+        case TypeIndex::IPv4:
             return capnp_type.isUInt32();
-        case TypeIndex::UInt64:
-            return capnp_type.isUInt64();
-        case TypeIndex::Int8:
-            return capnp_type.isInt8();
-        case TypeIndex::Int16:
-            return capnp_type.isInt16();
         case TypeIndex::Date32: [[fallthrough]];
-        case TypeIndex::Decimal32: [[fallthrough]];
-        case TypeIndex::Int32:
-            return capnp_type.isInt32();
+        case TypeIndex::Decimal32:
+            return capnp_type.isInt32() || capnp_type.isUInt32();
         case TypeIndex::DateTime64: [[fallthrough]];
-        case TypeIndex::Decimal64: [[fallthrough]];
-        case TypeIndex::Int64:
-            return capnp_type.isInt64();
-        case TypeIndex::Float32:
-            return capnp_type.isFloat32();
+        case TypeIndex::Decimal64:
+            return capnp_type.isInt64() || capnp_type.isUInt64();
+        case TypeIndex::Float32:[[fallthrough]];
         case TypeIndex::Float64:
-            return capnp_type.isFloat64();
+            /// Allow converting between Float32 and isFloat64
+            return capnp_type.isFloat32() || capnp_type.isFloat64();
         case TypeIndex::Enum8:
             return checkEnums<Int8>(capnp_type, data_type, mode, INT8_MAX, error_message);
         case TypeIndex::Enum16:
             return checkEnums<Int16>(capnp_type, data_type, mode, INT16_MAX, error_message);
+        case TypeIndex::Int128: [[fallthrough]];
+        case TypeIndex::UInt128: [[fallthrough]];
+        case TypeIndex::Int256: [[fallthrough]];
+        case TypeIndex::UInt256: [[fallthrough]];
+        case TypeIndex::Decimal128: [[fallthrough]];
+        case TypeIndex::Decimal256:
+            return capnp_type.isData();
         case TypeIndex::Tuple:
             return checkTupleType(capnp_type, data_type, mode, error_message);
         case TypeIndex::Nullable:
@@ -359,6 +450,8 @@ static bool checkCapnProtoType(const capnp::Type & capnp_type, const DataTypePtr
         case TypeIndex::IPv6: [[fallthrough]];
         case TypeIndex::String:
             return capnp_type.isText() || capnp_type.isData();
+        case TypeIndex::Map:
+            return checkMapType(capnp_type, data_type, mode, error_message);
         default:
             return false;
     }
diff --git a/src/Formats/ProtobufSchemas.cpp b/src/Formats/ProtobufSchemas.cpp
index efc0a4e694f..86c81e1a3c3 100644
--- a/src/Formats/ProtobufSchemas.cpp
+++ b/src/Formats/ProtobufSchemas.cpp
@@ -41,8 +41,19 @@ public:
             return descriptor;
 
         const auto * file_descriptor = importer.Import(schema_path);
-        // If there are parsing errors, AddError() throws an exception and in this case the following line
-        // isn't executed.
+        if (error)
+        {
+            auto info = error.value();
+            error.reset();
+            throw Exception(
+                ErrorCodes::CANNOT_PARSE_PROTOBUF_SCHEMA,
+                "Cannot parse '{}' file, found an error at line {}, column {}, {}",
+                info.filename,
+                std::to_string(info.line),
+                std::to_string(info.column),
+                info.message);
+        }
+
         assert(file_descriptor);
 
         if (with_envelope == WithEnvelope::No)
@@ -74,14 +85,24 @@ private:
     // Overrides google::protobuf::compiler::MultiFileErrorCollector:
     void AddError(const String & filename, int line, int column, const String & message) override
     {
-        throw Exception(ErrorCodes::CANNOT_PARSE_PROTOBUF_SCHEMA,
-                        "Cannot parse '{}' file, found an error at line {}, column {}, {}",
-                        filename, std::to_string(line), std::to_string(column), message);
+        /// Protobuf library code is not exception safe, we should
+        /// remember the error and throw it later from our side.
+        error = ErrorInfo{filename, line, column, message};
     }
 
     google::protobuf::compiler::DiskSourceTree disk_source_tree;
     google::protobuf::compiler::Importer importer;
     const WithEnvelope with_envelope;
+
+    struct ErrorInfo
+    {
+        String filename;
+        int line;
+        int column;
+        String message;
+    };
+
+    std::optional<ErrorInfo> error;
 };
 
 
diff --git a/src/Formats/ProtobufSerializer.cpp b/src/Formats/ProtobufSerializer.cpp
index 4f3b19ac803..c712a1083d9 100644
--- a/src/Formats/ProtobufSerializer.cpp
+++ b/src/Formats/ProtobufSerializer.cpp
@@ -3453,15 +3453,35 @@ namespace
                     const auto & tuple_data_type = assert_cast<const DataTypeTuple &>(*data_type);
                     size_t size_of_tuple = tuple_data_type.getElements().size();
 
-                    if (tuple_data_type.haveExplicitNames() && field_descriptor.message_type())
+                    if (const auto * message_type = field_descriptor.message_type())
                     {
+                        bool have_explicit_names = tuple_data_type.haveExplicitNames();
+                        Names element_names;
+                        if (have_explicit_names)
+                        {
+                            element_names = tuple_data_type.getElementNames();
+                        }
+                        else
+                        {
+                            /// Match unnamed Tuple elements and Message fields by position.
+                            size_t field_count = message_type->field_count();
+                            if (field_count != size_of_tuple)
+                                throw Exception(
+                                    ErrorCodes::NO_COLUMNS_SERIALIZED_TO_PROTOBUF_FIELDS,
+                                    "The number of fields in Protobuf message ({}) is not equal to the number of elements in unnamed Tuple ({})",
+                                    field_count,
+                                    size_of_tuple);
+                            for (size_t i = 0; i != field_count; ++i)
+                                element_names.push_back(message_type->field(static_cast<int>(i))->name());
+                        }
+
                         /// Try to serialize as a nested message.
                         std::vector<size_t> used_column_indices;
                         auto message_serializer = buildMessageSerializerImpl(
                             size_of_tuple,
-                            tuple_data_type.getElementNames().data(),
+                            element_names.data(),
                             tuple_data_type.getElements().data(),
-                            *field_descriptor.message_type(),
+                            *message_type,
                             /* with_length_delimiter = */ false,
                             google_wrappers_special_treatment,
                             &field_descriptor,
diff --git a/src/Functions/FunctionStringReplace.h b/src/Functions/FunctionStringReplace.h
index f90eac2e7f3..6199e146210 100644
--- a/src/Functions/FunctionStringReplace.h
+++ b/src/Functions/FunctionStringReplace.h
@@ -5,6 +5,7 @@
 #include <Columns/ColumnConst.h>
 #include <DataTypes/DataTypeString.h>
 #include <Functions/FunctionFactory.h>
+#include <Functions/FunctionHelpers.h>
 
 
 namespace DB
@@ -13,16 +14,14 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int ILLEGAL_COLUMN;
-    extern const int ARGUMENT_OUT_OF_BOUND;
-    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
 }
 
-
 template <typename Impl, typename Name>
 class FunctionStringReplace : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
+
     static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionStringReplace>(); }
 
     String getName() const override { return name; }
@@ -32,65 +31,80 @@ public:
     bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
 
     bool useDefaultImplementationForConstants() const override { return true; }
-    ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1, 2}; }
 
-    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
+    DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
     {
-        if (!isStringOrFixedString(arguments[0]))
-            throw Exception(
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type {} of first argument of function {}",
-                arguments[0]->getName(), getName());
+        FunctionArgumentDescriptors args{
+            {"haystack", &isStringOrFixedString<IDataType>, nullptr, "String or FixedString"},
+            {"pattern", &isString<IDataType>, nullptr, "String"},
+            {"replacement", &isString<IDataType>, nullptr, "String"}
+        };
 
-        if (!isStringOrFixedString(arguments[1]))
-            throw Exception(
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type {} of second argument of function {}",
-                arguments[1]->getName(), getName());
-
-        if (!isStringOrFixedString(arguments[2]))
-            throw Exception(
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type {} of third argument of function {}",
-                arguments[2]->getName(), getName());
+        validateFunctionArgumentTypes(*this, arguments, args);
 
         return std::make_shared<DataTypeString>();
     }
 
     ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override
     {
-        const ColumnPtr column_src = arguments[0].column;
+        const ColumnPtr column_haystack = arguments[0].column;
         const ColumnPtr column_needle = arguments[1].column;
         const ColumnPtr column_replacement = arguments[2].column;
 
-        if (!isColumnConst(*column_needle) || !isColumnConst(*column_replacement))
-            throw Exception(
-                ErrorCodes::ILLEGAL_COLUMN,
-                "2nd and 3rd arguments of function {} must be constants.",
-                getName());
+        const ColumnString * col_haystack = checkAndGetColumn<ColumnString>(column_haystack.get());
+        const ColumnFixedString * col_haystack_fixed = checkAndGetColumn<ColumnFixedString>(column_haystack.get());
 
-        const IColumn * c1 = arguments[1].column.get();
-        const IColumn * c2 = arguments[2].column.get();
-        const ColumnConst * c1_const = typeid_cast<const ColumnConst *>(c1);
-        const ColumnConst * c2_const = typeid_cast<const ColumnConst *>(c2);
-        String needle = c1_const->getValue<String>();
-        String replacement = c2_const->getValue<String>();
+        const ColumnString * col_needle_vector = checkAndGetColumn<ColumnString>(column_needle.get());
+        const ColumnConst * col_needle_const = checkAndGetColumn<ColumnConst>(column_needle.get());
 
-        if (needle.empty())
-            throw Exception(
-                ErrorCodes::ARGUMENT_OUT_OF_BOUND,
-                "Length of the second argument of function replace must be greater than 0.");
+        const ColumnString * col_replacement_vector = checkAndGetColumn<ColumnString>(column_replacement.get());
+        const ColumnConst * col_replacement_const = checkAndGetColumn<ColumnConst>(column_replacement.get());
 
-        if (const ColumnString * col = checkAndGetColumn<ColumnString>(column_src.get()))
+        auto col_res = ColumnString::create();
+
+        if (col_haystack && col_needle_const && col_replacement_const)
         {
-            auto col_res = ColumnString::create();
-            Impl::vector(col->getChars(), col->getOffsets(), needle, replacement, col_res->getChars(), col_res->getOffsets());
+            Impl::vectorConstantConstant(
+                col_haystack->getChars(), col_haystack->getOffsets(),
+                col_needle_const->getValue<String>(),
+                col_replacement_const->getValue<String>(),
+                col_res->getChars(), col_res->getOffsets());
             return col_res;
         }
-        else if (const ColumnFixedString * col_fixed = checkAndGetColumn<ColumnFixedString>(column_src.get()))
+        else if (col_haystack && col_needle_vector && col_replacement_const)
         {
-            auto col_res = ColumnString::create();
-            Impl::vectorFixed(col_fixed->getChars(), col_fixed->getN(), needle, replacement, col_res->getChars(), col_res->getOffsets());
+            Impl::vectorVectorConstant(
+                col_haystack->getChars(), col_haystack->getOffsets(),
+                col_needle_vector->getChars(), col_needle_vector->getOffsets(),
+                col_replacement_const->getValue<String>(),
+                col_res->getChars(), col_res->getOffsets());
+            return col_res;
+        }
+        else if (col_haystack && col_needle_const && col_replacement_vector)
+        {
+            Impl::vectorConstantVector(
+                col_haystack->getChars(), col_haystack->getOffsets(),
+                col_needle_const->getValue<String>(),
+                col_replacement_vector->getChars(), col_replacement_vector->getOffsets(),
+                col_res->getChars(), col_res->getOffsets());
+            return col_res;
+        }
+        else if (col_haystack && col_needle_vector && col_replacement_vector)
+        {
+            Impl::vectorVectorVector(
+                col_haystack->getChars(), col_haystack->getOffsets(),
+                col_needle_vector->getChars(), col_needle_vector->getOffsets(),
+                col_replacement_vector->getChars(), col_replacement_vector->getOffsets(),
+                col_res->getChars(), col_res->getOffsets());
+            return col_res;
+        }
+        else if (col_haystack_fixed && col_needle_const && col_replacement_const)
+        {
+            Impl::vectorFixedConstantConstant(
+                col_haystack_fixed->getChars(), col_haystack_fixed->getN(),
+                col_needle_const->getValue<String>(),
+                col_replacement_const->getValue<String>(),
+                col_res->getChars(), col_res->getOffsets());
             return col_res;
         }
         else
diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h
index f832bf404a8..28002d34acc 100644
--- a/src/Functions/FunctionsConversion.h
+++ b/src/Functions/FunctionsConversion.h
@@ -41,6 +41,7 @@
 #include <Columns/ColumnsCommon.h>
 #include <Columns/ColumnStringHelpers.h>
 #include <Common/assert_cast.h>
+#include <Common/Concepts.h>
 #include <Common/quoteString.h>
 #include <Common/Exception.h>
 #include <Core/AccurateComparison.h>
diff --git a/src/Functions/FunctionsJSON.cpp b/src/Functions/FunctionsJSON.cpp
index 8bcb1f4d849..fbd987577e9 100644
--- a/src/Functions/FunctionsJSON.cpp
+++ b/src/Functions/FunctionsJSON.cpp
@@ -1,1624 +1,10 @@
-#include <type_traits>
-#include <boost/tti/has_member_function.hpp>
-
-#include <base/range.h>
-
-#include <Common/CpuId.h>
-#include <Common/typeid_cast.h>
-#include <Common/assert_cast.h>
-
-#include <Core/AccurateComparison.h>
-#include <Core/Settings.h>
-
-#include <Columns/ColumnConst.h>
-#include <Columns/ColumnLowCardinality.h>
-#include <Columns/ColumnDecimal.h>
-#include <Columns/ColumnString.h>
-#include <Columns/ColumnVector.h>
-#include <Columns/ColumnFixedString.h>
-#include <Columns/ColumnNullable.h>
-#include <Columns/ColumnArray.h>
-#include <Columns/ColumnTuple.h>
-
-#include <DataTypes/DataTypeArray.h>
-#include <DataTypes/DataTypeEnum.h>
-#include <DataTypes/DataTypeFactory.h>
-#include <DataTypes/DataTypeFixedString.h>
-#include <DataTypes/DataTypeLowCardinality.h>
-#include <DataTypes/DataTypeNothing.h>
-#include <DataTypes/DataTypeNullable.h>
-#include <DataTypes/DataTypeString.h>
-#include <DataTypes/DataTypeTuple.h>
-#include <DataTypes/DataTypeUUID.h>
-#include <DataTypes/DataTypesDecimal.h>
-#include <DataTypes/DataTypesNumber.h>
-#include <DataTypes/Serializations/SerializationDecimal.h>
-
+#include <Functions/FunctionsJSON.h>
 #include <Functions/FunctionFactory.h>
-#include <Functions/IFunction.h>
-#include <Common/JSONParsers/DummyJSONParser.h>
-#include <Common/JSONParsers/SimdJSONParser.h>
-#include <Common/JSONParsers/RapidJSONParser.h>
-#include <Functions/FunctionHelpers.h>
-
-#include <IO/readDecimalText.h>
-#include <Interpreters/Context.h>
-
-
-#include "config.h"
 
 
 namespace DB
 {
 
-namespace ErrorCodes
-{
-    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
-    extern const int ILLEGAL_COLUMN;
-    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
-}
-
-template <typename T>
-concept HasIndexOperator = requires (T t)
-{
-    t[0];
-};
-
-/// Functions to parse JSONs and extract values from it.
-/// The first argument of all these functions gets a JSON,
-/// after that there are any number of arguments specifying path to a desired part from the JSON's root.
-/// For example,
-/// select JSONExtractInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 1) = -100
-
-class FunctionJSONHelpers
-{
-public:
-    template <typename Name, template<typename> typename Impl, class JSONParser>
-    class Executor
-    {
-    public:
-        static ColumnPtr run(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count)
-        {
-            MutableColumnPtr to{result_type->createColumn()};
-            to->reserve(input_rows_count);
-
-            if (arguments.empty())
-                throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} requires at least one argument", String(Name::name));
-
-            const auto & first_column = arguments[0];
-            if (!isString(first_column.type))
-                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                                "The first argument of function {} should be a string containing JSON, illegal type: "
-                                "{}", String(Name::name), first_column.type->getName());
-
-            const ColumnPtr & arg_json = first_column.column;
-            const auto * col_json_const = typeid_cast<const ColumnConst *>(arg_json.get());
-            const auto * col_json_string
-                = typeid_cast<const ColumnString *>(col_json_const ? col_json_const->getDataColumnPtr().get() : arg_json.get());
-
-            if (!col_json_string)
-                throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {}", arg_json->getName());
-
-            const ColumnString::Chars & chars = col_json_string->getChars();
-            const ColumnString::Offsets & offsets = col_json_string->getOffsets();
-
-            size_t num_index_arguments = Impl<JSONParser>::getNumberOfIndexArguments(arguments);
-            std::vector<Move> moves = prepareMoves(Name::name, arguments, 1, num_index_arguments);
-
-            /// Preallocate memory in parser if necessary.
-            JSONParser parser;
-            if constexpr (has_member_function_reserve<void (JSONParser::*)(size_t)>::value)
-            {
-                size_t max_size = calculateMaxSize(offsets);
-                if (max_size)
-                    parser.reserve(max_size);
-            }
-
-            Impl<JSONParser> impl;
-
-            /// prepare() does Impl-specific preparation before handling each row.
-            if constexpr (has_member_function_prepare<void (Impl<JSONParser>::*)(const char *, const ColumnsWithTypeAndName &, const DataTypePtr &)>::value)
-                impl.prepare(Name::name, arguments, result_type);
-
-            using Element = typename JSONParser::Element;
-
-            Element document;
-            bool document_ok = false;
-            if (col_json_const)
-            {
-                std::string_view json{reinterpret_cast<const char *>(chars.data()), offsets[0] - 1};
-                document_ok = parser.parse(json, document);
-            }
-
-            for (const auto i : collections::range(0, input_rows_count))
-            {
-                if (!col_json_const)
-                {
-                    std::string_view json{reinterpret_cast<const char *>(&chars[offsets[i - 1]]), offsets[i] - offsets[i - 1] - 1};
-                    document_ok = parser.parse(json, document);
-                }
-
-                bool added_to_column = false;
-                if (document_ok)
-                {
-                    /// Perform moves.
-                    Element element;
-                    std::string_view last_key;
-                    bool moves_ok = performMoves<JSONParser>(arguments, i, document, moves, element, last_key);
-
-                    if (moves_ok)
-                        added_to_column = impl.insertResultToColumn(*to, element, last_key);
-                }
-
-                /// We add default value (=null or zero) if something goes wrong, we don't throw exceptions in these JSON functions.
-                if (!added_to_column)
-                    to->insertDefault();
-            }
-            return to;
-        }
-    };
-
-private:
-    BOOST_TTI_HAS_MEMBER_FUNCTION(reserve)
-    BOOST_TTI_HAS_MEMBER_FUNCTION(prepare)
-
-    /// Represents a move of a JSON iterator described by a single argument passed to a JSON function.
-    /// For example, the call JSONExtractInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 1)
-    /// contains two moves: {MoveType::ConstKey, "b"} and {MoveType::ConstIndex, 1}.
-    /// Keys and indices can be nonconst, in this case they are calculated for each row.
-    enum class MoveType
-    {
-        Key,
-        Index,
-        ConstKey,
-        ConstIndex,
-    };
-
-    struct Move
-    {
-        explicit Move(MoveType type_, size_t index_ = 0) : type(type_), index(index_) {}
-        Move(MoveType type_, const String & key_) : type(type_), key(key_) {}
-        MoveType type;
-        size_t index = 0;
-        String key;
-    };
-
-    static std::vector<FunctionJSONHelpers::Move> prepareMoves(
-        const char * function_name,
-        const ColumnsWithTypeAndName & columns,
-        size_t first_index_argument,
-        size_t num_index_arguments)
-    {
-        std::vector<Move> moves;
-        moves.reserve(num_index_arguments);
-        for (const auto i : collections::range(first_index_argument, first_index_argument + num_index_arguments))
-        {
-            const auto & column = columns[i];
-            if (!isString(column.type) && !isNativeInteger(column.type))
-                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                                "The argument {} of function {} should be a string specifying key "
-                                "or an integer specifying index, illegal type: {}",
-                                std::to_string(i + 1), String(function_name), column.type->getName());
-
-            if (column.column && isColumnConst(*column.column))
-            {
-                const auto & column_const = assert_cast<const ColumnConst &>(*column.column);
-                if (isString(column.type))
-                    moves.emplace_back(MoveType::ConstKey, column_const.getValue<String>());
-                else
-                    moves.emplace_back(MoveType::ConstIndex, column_const.getInt(0));
-            }
-            else
-            {
-                if (isString(column.type))
-                    moves.emplace_back(MoveType::Key, "");
-                else
-                    moves.emplace_back(MoveType::Index, 0);
-            }
-        }
-        return moves;
-    }
-
-
-    /// Performs moves of types MoveType::Index and MoveType::ConstIndex.
-    template <typename JSONParser>
-    static bool performMoves(const ColumnsWithTypeAndName & arguments, size_t row,
-                             const typename JSONParser::Element & document, const std::vector<Move> & moves,
-                             typename JSONParser::Element & element, std::string_view & last_key)
-    {
-        typename JSONParser::Element res_element = document;
-        std::string_view key;
-
-        for (size_t j = 0; j != moves.size(); ++j)
-        {
-            switch (moves[j].type)
-            {
-                case MoveType::ConstIndex:
-                {
-                    if (!moveToElementByIndex<JSONParser>(res_element, static_cast<int>(moves[j].index), key))
-                        return false;
-                    break;
-                }
-                case MoveType::ConstKey:
-                {
-                    key = moves[j].key;
-                    if (!moveToElementByKey<JSONParser>(res_element, key))
-                        return false;
-                    break;
-                }
-                case MoveType::Index:
-                {
-                    Int64 index = (*arguments[j + 1].column)[row].get<Int64>();
-                    if (!moveToElementByIndex<JSONParser>(res_element, static_cast<int>(index), key))
-                        return false;
-                    break;
-                }
-                case MoveType::Key:
-                {
-                    key = (*arguments[j + 1].column).getDataAt(row).toView();
-                    if (!moveToElementByKey<JSONParser>(res_element, key))
-                        return false;
-                    break;
-                }
-            }
-        }
-
-        element = res_element;
-        last_key = key;
-        return true;
-    }
-
-    template <typename JSONParser>
-    static bool moveToElementByIndex(typename JSONParser::Element & element, int index, std::string_view & out_key)
-    {
-        if (element.isArray())
-        {
-            auto array = element.getArray();
-            if (index >= 0)
-                --index;
-            else
-                index += array.size();
-
-            if (static_cast<size_t>(index) >= array.size())
-                return false;
-            element = array[index];
-            out_key = {};
-            return true;
-        }
-
-        if constexpr (HasIndexOperator<typename JSONParser::Object>)
-        {
-            if (element.isObject())
-            {
-                auto object = element.getObject();
-                if (index >= 0)
-                    --index;
-                else
-                    index += object.size();
-
-                if (static_cast<size_t>(index) >= object.size())
-                    return false;
-                std::tie(out_key, element) = object[index];
-                return true;
-            }
-        }
-
-        return {};
-    }
-
-    /// Performs moves of types MoveType::Key and MoveType::ConstKey.
-    template <typename JSONParser>
-    static bool moveToElementByKey(typename JSONParser::Element & element, std::string_view key)
-    {
-        if (!element.isObject())
-            return false;
-        auto object = element.getObject();
-        return object.find(key, element);
-    }
-
-    static size_t calculateMaxSize(const ColumnString::Offsets & offsets)
-    {
-        size_t max_size = 0;
-        for (const auto i : collections::range(0, offsets.size()))
-        {
-            size_t size = offsets[i] - offsets[i - 1];
-            if (max_size < size)
-                max_size = size;
-        }
-        if (max_size)
-            --max_size;
-        return max_size;
-    }
-
-};
-
-
-template <typename Name, template<typename> typename Impl>
-class ExecutableFunctionJSON : public IExecutableFunction, WithContext
-{
-
-public:
-    explicit ExecutableFunctionJSON(const NullPresence & null_presence_, bool allow_simdjson_, const DataTypePtr & json_return_type_)
-        : null_presence(null_presence_), allow_simdjson(allow_simdjson_), json_return_type(json_return_type_)
-    {
-    }
-
-    String getName() const override { return Name::name; }
-    bool useDefaultImplementationForNulls() const override { return false; }
-    bool useDefaultImplementationForConstants() const override { return true; }
-
-    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
-    {
-        if (null_presence.has_null_constant)
-            return result_type->createColumnConstWithDefaultValue(input_rows_count);
-
-        ColumnsWithTypeAndName temporary_columns = null_presence.has_nullable ? createBlockWithNestedColumns(arguments) : arguments;
-        ColumnPtr temporary_result = chooseAndRunJSONParser(temporary_columns, json_return_type, input_rows_count);
-        if (null_presence.has_nullable)
-            return wrapInNullable(temporary_result, arguments, result_type, input_rows_count);
-        return temporary_result;
-    }
-
-private:
-
-    ColumnPtr
-    chooseAndRunJSONParser(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const
-    {
-#if USE_SIMDJSON
-        if (allow_simdjson)
-            return FunctionJSONHelpers::Executor<Name, Impl, SimdJSONParser>::run(arguments, result_type, input_rows_count);
-#endif
-
-#if USE_RAPIDJSON
-        return FunctionJSONHelpers::Executor<Name, Impl, RapidJSONParser>::run(arguments, result_type, input_rows_count);
-#else
-        return FunctionJSONHelpers::Executor<Name, Impl, DummyJSONParser>::run(arguments, result_type, input_rows_count);
-#endif
-    }
-
-    NullPresence null_presence;
-    bool allow_simdjson;
-    DataTypePtr json_return_type;
-};
-
-
-template <typename Name, template<typename> typename Impl>
-class FunctionBaseFunctionJSON : public IFunctionBase
-{
-public:
-    explicit FunctionBaseFunctionJSON(
-        const NullPresence & null_presence_,
-        bool allow_simdjson_,
-        DataTypes argument_types_,
-        DataTypePtr return_type_,
-        DataTypePtr json_return_type_)
-        : null_presence(null_presence_)
-        , allow_simdjson(allow_simdjson_)
-        , argument_types(std::move(argument_types_))
-        , return_type(std::move(return_type_))
-        , json_return_type(std::move(json_return_type_))
-    {
-    }
-
-    String getName() const override { return Name::name; }
-
-    const DataTypes & getArgumentTypes() const override
-    {
-        return argument_types;
-    }
-
-    const DataTypePtr & getResultType() const override
-    {
-        return return_type;
-    }
-
-    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
-
-    ExecutableFunctionPtr prepare(const ColumnsWithTypeAndName &) const override
-    {
-        return std::make_unique<ExecutableFunctionJSON<Name, Impl>>(null_presence, allow_simdjson, json_return_type);
-    }
-
-private:
-    NullPresence null_presence;
-    bool allow_simdjson;
-    DataTypes argument_types;
-    DataTypePtr return_type;
-    DataTypePtr json_return_type;
-};
-
-
-/// We use IFunctionOverloadResolver instead of IFunction to handle non-default NULL processing.
-/// Both NULL and JSON NULL should generate NULL value. If any argument is NULL, return NULL.
-template <typename Name, template<typename> typename Impl>
-class JSONOverloadResolver : public IFunctionOverloadResolver, WithContext
-{
-public:
-    static constexpr auto name = Name::name;
-
-    String getName() const override { return name; }
-
-    static FunctionOverloadResolverPtr create(ContextPtr context_)
-    {
-        return std::make_unique<JSONOverloadResolver>(context_);
-    }
-
-    explicit JSONOverloadResolver(ContextPtr context_) : WithContext(context_) {}
-
-    bool isVariadic() const override { return true; }
-    size_t getNumberOfArguments() const override { return 0; }
-    bool useDefaultImplementationForNulls() const override { return false; }
-
-    FunctionBasePtr build(const ColumnsWithTypeAndName & arguments) const override
-    {
-        bool has_nothing_argument = false;
-        for (const auto & arg : arguments)
-            has_nothing_argument |= isNothing(arg.type);
-
-        DataTypePtr json_return_type = Impl<DummyJSONParser>::getReturnType(Name::name, createBlockWithNestedColumns(arguments));
-        NullPresence null_presence = getNullPresense(arguments);
-        DataTypePtr return_type;
-        if (has_nothing_argument)
-            return_type = std::make_shared<DataTypeNothing>();
-        else if (null_presence.has_null_constant)
-            return_type = makeNullable(std::make_shared<DataTypeNothing>());
-        else if (null_presence.has_nullable)
-            return_type = makeNullable(json_return_type);
-        else
-            return_type = json_return_type;
-
-        /// Top-level LowCardinality columns are processed outside JSON parser.
-        json_return_type = removeLowCardinality(json_return_type);
-
-        DataTypes argument_types;
-        argument_types.reserve(arguments.size());
-        for (const auto & argument : arguments)
-            argument_types.emplace_back(argument.type);
-        return std::make_unique<FunctionBaseFunctionJSON<Name, Impl>>(
-                null_presence, getContext()->getSettingsRef().allow_simdjson, argument_types, return_type, json_return_type);
-    }
-};
-
-
-struct NameJSONHas { static constexpr auto name{"JSONHas"}; };
-struct NameIsValidJSON { static constexpr auto name{"isValidJSON"}; };
-struct NameJSONLength { static constexpr auto name{"JSONLength"}; };
-struct NameJSONKey { static constexpr auto name{"JSONKey"}; };
-struct NameJSONType { static constexpr auto name{"JSONType"}; };
-struct NameJSONExtractInt { static constexpr auto name{"JSONExtractInt"}; };
-struct NameJSONExtractUInt { static constexpr auto name{"JSONExtractUInt"}; };
-struct NameJSONExtractFloat { static constexpr auto name{"JSONExtractFloat"}; };
-struct NameJSONExtractBool { static constexpr auto name{"JSONExtractBool"}; };
-struct NameJSONExtractString { static constexpr auto name{"JSONExtractString"}; };
-struct NameJSONExtract { static constexpr auto name{"JSONExtract"}; };
-struct NameJSONExtractKeysAndValues { static constexpr auto name{"JSONExtractKeysAndValues"}; };
-struct NameJSONExtractRaw { static constexpr auto name{"JSONExtractRaw"}; };
-struct NameJSONExtractArrayRaw { static constexpr auto name{"JSONExtractArrayRaw"}; };
-struct NameJSONExtractKeysAndValuesRaw { static constexpr auto name{"JSONExtractKeysAndValuesRaw"}; };
-struct NameJSONExtractKeys { static constexpr auto name{"JSONExtractKeys"}; };
-
-
-template <typename JSONParser>
-class JSONHasImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &) { return std::make_shared<DataTypeUInt8>(); }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    static bool insertResultToColumn(IColumn & dest, const Element &, std::string_view)
-    {
-        ColumnVector<UInt8> & col_vec = assert_cast<ColumnVector<UInt8> &>(dest);
-        col_vec.insertValue(1);
-        return true;
-    }
-};
-
-
-template <typename JSONParser>
-class IsValidJSONImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char * function_name, const ColumnsWithTypeAndName & arguments)
-    {
-        if (arguments.size() != 1)
-        {
-            /// IsValidJSON() shouldn't get parameters other than JSON.
-            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} needs exactly one argument",
-                            String(function_name));
-        }
-        return std::make_shared<DataTypeUInt8>();
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName &) { return 0; }
-
-    static bool insertResultToColumn(IColumn & dest, const Element &, std::string_view)
-    {
-        /// This function is called only if JSON is valid.
-        /// If JSON isn't valid then `FunctionJSON::Executor::run()` adds default value (=zero) to `dest` without calling this function.
-        ColumnVector<UInt8> & col_vec = assert_cast<ColumnVector<UInt8> &>(dest);
-        col_vec.insertValue(1);
-        return true;
-    }
-};
-
-
-template <typename JSONParser>
-class JSONLengthImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
-    {
-        return std::make_shared<DataTypeUInt64>();
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        size_t size;
-        if (element.isArray())
-            size = element.getArray().size();
-        else if (element.isObject())
-            size = element.getObject().size();
-        else
-            return false;
-
-        ColumnVector<UInt64> & col_vec = assert_cast<ColumnVector<UInt64> &>(dest);
-        col_vec.insertValue(size);
-        return true;
-    }
-};
-
-
-template <typename JSONParser>
-class JSONKeyImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
-    {
-        return std::make_shared<DataTypeString>();
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    static bool insertResultToColumn(IColumn & dest, const Element &, std::string_view last_key)
-    {
-        if (last_key.empty())
-            return false;
-        ColumnString & col_str = assert_cast<ColumnString &>(dest);
-        col_str.insertData(last_key.data(), last_key.size());
-        return true;
-    }
-};
-
-
-template <typename JSONParser>
-class JSONTypeImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
-    {
-        static const std::vector<std::pair<String, Int8>> values = {
-            {"Array", '['},
-            {"Object", '{'},
-            {"String", '"'},
-            {"Int64", 'i'},
-            {"UInt64", 'u'},
-            {"Double", 'd'},
-            {"Bool", 'b'},
-            {"Null", 0}, /// the default value for the column.
-        };
-        return std::make_shared<DataTypeEnum<Int8>>(values);
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        UInt8 type;
-        switch (element.type())
-        {
-            case ElementType::INT64:
-                type = 'i';
-                break;
-            case ElementType::UINT64:
-                type = 'u';
-                break;
-            case ElementType::DOUBLE:
-                type = 'd';
-                break;
-            case ElementType::STRING:
-                type = '"';
-                break;
-            case ElementType::ARRAY:
-                type = '[';
-                break;
-            case ElementType::OBJECT:
-                type = '{';
-                break;
-            case ElementType::BOOL:
-                type = 'b';
-                break;
-            case ElementType::NULL_VALUE:
-                type = 0;
-                break;
-        }
-
-        ColumnVector<Int8> & col_vec = assert_cast<ColumnVector<Int8> &>(dest);
-        col_vec.insertValue(type);
-        return true;
-    }
-};
-
-
-template <typename JSONParser, typename NumberType, bool convert_bool_to_integer = false>
-class JSONExtractNumericImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
-    {
-        return std::make_shared<DataTypeNumber<NumberType>>();
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        NumberType value;
-
-        switch (element.type())
-        {
-            case ElementType::DOUBLE:
-                if constexpr (std::is_floating_point_v<NumberType>)
-                {
-                    /// We permit inaccurate conversion of double to float.
-                    /// Example: double 0.1 from JSON is not representable in float.
-                    /// But it will be more convenient for user to perform conversion.
-                    value = static_cast<NumberType>(element.getDouble());
-                }
-                else if (!accurate::convertNumeric<Float64, NumberType, false>(element.getDouble(), value))
-                    return false;
-                break;
-            case ElementType::UINT64:
-                if (!accurate::convertNumeric<UInt64, NumberType, false>(element.getUInt64(), value))
-                    return false;
-                break;
-            case ElementType::INT64:
-                if (!accurate::convertNumeric<Int64, NumberType, false>(element.getInt64(), value))
-                    return false;
-                break;
-            case ElementType::BOOL:
-                if constexpr (is_integer<NumberType> && convert_bool_to_integer)
-                {
-                    value = static_cast<NumberType>(element.getBool());
-                    break;
-                }
-                return false;
-            case ElementType::STRING:
-            {
-                auto rb = ReadBufferFromMemory{element.getString()};
-                if constexpr (std::is_floating_point_v<NumberType>)
-                {
-                    if (!tryReadFloatText(value, rb) || !rb.eof())
-                        return false;
-                }
-                else
-                {
-                    if (tryReadIntText(value, rb) && rb.eof())
-                        break;
-
-                    /// Try to parse float and convert it to integer.
-                    Float64 tmp_float;
-                    rb.position() = rb.buffer().begin();
-                    if (!tryReadFloatText(tmp_float, rb) || !rb.eof())
-                        return false;
-
-                    if (!accurate::convertNumeric<Float64, NumberType, false>(tmp_float, value))
-                        return false;
-                }
-                break;
-            }
-            default:
-                return false;
-        }
-
-        if (dest.getDataType() == TypeIndex::LowCardinality)
-        {
-            ColumnLowCardinality & col_low = assert_cast<ColumnLowCardinality &>(dest);
-            col_low.insertData(reinterpret_cast<const char *>(&value), sizeof(value));
-        }
-        else
-        {
-            auto & col_vec = assert_cast<ColumnVector<NumberType> &>(dest);
-            col_vec.insertValue(value);
-        }
-        return true;
-    }
-};
-
-
-template <typename JSONParser>
-using JSONExtractInt64Impl = JSONExtractNumericImpl<JSONParser, Int64>;
-template <typename JSONParser>
-using JSONExtractUInt64Impl = JSONExtractNumericImpl<JSONParser, UInt64>;
-template <typename JSONParser>
-using JSONExtractFloat64Impl = JSONExtractNumericImpl<JSONParser, Float64>;
-
-
-template <typename JSONParser>
-class JSONExtractBoolImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
-    {
-        return std::make_shared<DataTypeUInt8>();
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        bool value;
-        switch (element.type())
-        {
-            case ElementType::BOOL:
-                value = element.getBool();
-                break;
-            case ElementType::INT64:
-                value = element.getInt64() != 0;
-                break;
-            case ElementType::UINT64:
-                value = element.getUInt64() != 0;
-                break;
-            default:
-                return false;
-        }
-
-        auto & col_vec = assert_cast<ColumnVector<UInt8> &>(dest);
-        col_vec.insertValue(static_cast<UInt8>(value));
-        return true;
-    }
-};
-
-template <typename JSONParser>
-class JSONExtractRawImpl;
-
-template <typename JSONParser>
-class JSONExtractStringImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
-    {
-        return std::make_shared<DataTypeString>();
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        if (element.isNull())
-            return false;
-
-        if (!element.isString())
-            return JSONExtractRawImpl<JSONParser>::insertResultToColumn(dest, element, {});
-
-        auto str = element.getString();
-
-        if (dest.getDataType() == TypeIndex::LowCardinality)
-        {
-            ColumnLowCardinality & col_low = assert_cast<ColumnLowCardinality &>(dest);
-            col_low.insertData(str.data(), str.size());
-        }
-        else
-        {
-            ColumnString & col_str = assert_cast<ColumnString &>(dest);
-            col_str.insertData(str.data(), str.size());
-        }
-        return true;
-    }
-};
-
-/// Nodes of the extract tree. We need the extract tree to extract from JSON complex values containing array, tuples or nullables.
-template <typename JSONParser>
-struct JSONExtractTree
-{
-    using Element = typename JSONParser::Element;
-
-    class Node
-    {
-    public:
-        Node() = default;
-        virtual ~Node() = default;
-        virtual bool insertResultToColumn(IColumn &, const Element &) = 0;
-    };
-
-    template <typename NumberType>
-    class NumericNode : public Node
-    {
-    public:
-        bool insertResultToColumn(IColumn & dest, const Element & element) override
-        {
-            return JSONExtractNumericImpl<JSONParser, NumberType, true>::insertResultToColumn(dest, element, {});
-        }
-    };
-
-    class LowCardinalityFixedStringNode : public Node
-    {
-    public:
-        explicit LowCardinalityFixedStringNode(const size_t fixed_length_) : fixed_length(fixed_length_) { }
-        bool insertResultToColumn(IColumn & dest, const Element & element) override
-        {
-            // If element is an object we delegate the insertion to JSONExtractRawImpl
-            if (element.isObject())
-                return JSONExtractRawImpl<JSONParser>::insertResultToLowCardinalityFixedStringColumn(dest, element, fixed_length);
-            else if (!element.isString())
-                return false;
-
-            auto str = element.getString();
-            if (str.size() > fixed_length)
-                return false;
-
-            // For the non low cardinality case of FixedString, the padding is done in the FixedString Column implementation.
-            // In order to avoid having to pass the data to a FixedString Column and read it back (which would slow down the execution)
-            // the data is padded here and written directly to the Low Cardinality Column
-            if (str.size() == fixed_length)
-            {
-                assert_cast<ColumnLowCardinality &>(dest).insertData(str.data(), str.size());
-            }
-            else
-            {
-                String padded_str(str);
-                padded_str.resize(fixed_length, '\0');
-
-                assert_cast<ColumnLowCardinality &>(dest).insertData(padded_str.data(), padded_str.size());
-            }
-            return true;
-        }
-
-    private:
-        const size_t fixed_length;
-    };
-
-    class UUIDNode : public Node
-    {
-    public:
-        bool insertResultToColumn(IColumn & dest, const Element & element) override
-        {
-            if (!element.isString())
-                return false;
-
-            auto uuid = parseFromString<UUID>(element.getString());
-            if (dest.getDataType() == TypeIndex::LowCardinality)
-            {
-                ColumnLowCardinality & col_low = assert_cast<ColumnLowCardinality &>(dest);
-                col_low.insertData(reinterpret_cast<const char *>(&uuid), sizeof(uuid));
-            }
-            else
-            {
-                assert_cast<ColumnUUID &>(dest).insert(uuid);
-            }
-            return true;
-        }
-    };
-
-    template <typename DecimalType>
-    class DecimalNode : public Node
-    {
-    public:
-        explicit DecimalNode(DataTypePtr data_type_) : data_type(data_type_) {}
-        bool insertResultToColumn(IColumn & dest, const Element & element) override
-        {
-            const auto * type = assert_cast<const DataTypeDecimal<DecimalType> *>(data_type.get());
-
-            DecimalType value{};
-
-            switch (element.type())
-            {
-                case ElementType::DOUBLE:
-                    value = convertToDecimal<DataTypeNumber<Float64>, DataTypeDecimal<DecimalType>>(
-                        element.getDouble(), type->getScale());
-                    break;
-                case ElementType::UINT64:
-                    value = convertToDecimal<DataTypeNumber<UInt64>, DataTypeDecimal<DecimalType>>(
-                        element.getUInt64(), type->getScale());
-                    break;
-                case ElementType::INT64:
-                    value = convertToDecimal<DataTypeNumber<Int64>, DataTypeDecimal<DecimalType>>(
-                        element.getInt64(), type->getScale());
-                    break;
-                case ElementType::STRING: {
-                    auto rb = ReadBufferFromMemory{element.getString()};
-                    if (!SerializationDecimal<DecimalType>::tryReadText(value, rb, DecimalUtils::max_precision<DecimalType>, type->getScale()))
-                        return false;
-                    break;
-                }
-                default:
-                    return false;
-            }
-
-            assert_cast<ColumnDecimal<DecimalType> &>(dest).insertValue(value);
-            return true;
-        }
-
-    private:
-        DataTypePtr data_type;
-    };
-
-    class StringNode : public Node
-    {
-    public:
-        bool insertResultToColumn(IColumn & dest, const Element & element) override
-        {
-            return JSONExtractStringImpl<JSONParser>::insertResultToColumn(dest, element, {});
-        }
-    };
-
-    class FixedStringNode : public Node
-    {
-    public:
-        bool insertResultToColumn(IColumn & dest, const Element & element) override
-        {
-            if (element.isNull())
-                return false;
-
-            if (!element.isString())
-                return JSONExtractRawImpl<JSONParser>::insertResultToFixedStringColumn(dest, element, {});
-
-            auto str = element.getString();
-            auto & col_str = assert_cast<ColumnFixedString &>(dest);
-            if (str.size() > col_str.getN())
-                return false;
-            col_str.insertData(str.data(), str.size());
-
-            return true;
-        }
-    };
-
-    template <typename Type>
-    class EnumNode : public Node
-    {
-    public:
-        explicit EnumNode(const std::vector<std::pair<String, Type>> & name_value_pairs_) : name_value_pairs(name_value_pairs_)
-        {
-            for (const auto & name_value_pair : name_value_pairs)
-            {
-                name_to_value_map.emplace(name_value_pair.first, name_value_pair.second);
-                only_values.emplace(name_value_pair.second);
-            }
-        }
-
-        bool insertResultToColumn(IColumn & dest, const Element & element) override
-        {
-            auto & col_vec = assert_cast<ColumnVector<Type> &>(dest);
-
-            if (element.isInt64())
-            {
-                Type value;
-                if (!accurate::convertNumeric(element.getInt64(), value) || !only_values.contains(value))
-                    return false;
-                col_vec.insertValue(value);
-                return true;
-            }
-
-            if (element.isUInt64())
-            {
-                Type value;
-                if (!accurate::convertNumeric(element.getUInt64(), value) || !only_values.contains(value))
-                    return false;
-                col_vec.insertValue(value);
-                return true;
-            }
-
-            if (element.isString())
-            {
-                auto value = name_to_value_map.find(element.getString());
-                if (value == name_to_value_map.end())
-                    return false;
-                col_vec.insertValue(value->second);
-                return true;
-            }
-
-            return false;
-        }
-
-    private:
-        std::vector<std::pair<String, Type>> name_value_pairs;
-        std::unordered_map<std::string_view, Type> name_to_value_map;
-        std::unordered_set<Type> only_values;
-    };
-
-    class NullableNode : public Node
-    {
-    public:
-        explicit NullableNode(std::unique_ptr<Node> nested_) : nested(std::move(nested_)) {}
-
-        bool insertResultToColumn(IColumn & dest, const Element & element) override
-        {
-            ColumnNullable & col_null = assert_cast<ColumnNullable &>(dest);
-            if (!nested->insertResultToColumn(col_null.getNestedColumn(), element))
-                return false;
-            col_null.getNullMapColumn().insertValue(0);
-            return true;
-        }
-
-    private:
-        std::unique_ptr<Node> nested;
-    };
-
-    class ArrayNode : public Node
-    {
-    public:
-        explicit ArrayNode(std::unique_ptr<Node> nested_) : nested(std::move(nested_)) {}
-
-        bool insertResultToColumn(IColumn & dest, const Element & element) override
-        {
-            if (!element.isArray())
-                return false;
-
-            auto array = element.getArray();
-
-            ColumnArray & col_arr = assert_cast<ColumnArray &>(dest);
-            auto & data = col_arr.getData();
-            size_t old_size = data.size();
-            bool were_valid_elements = false;
-
-            for (auto value : array)
-            {
-                if (nested->insertResultToColumn(data, value))
-                    were_valid_elements = true;
-                else
-                    data.insertDefault();
-            }
-
-            if (!were_valid_elements)
-            {
-                data.popBack(data.size() - old_size);
-                return false;
-            }
-
-            col_arr.getOffsets().push_back(data.size());
-            return true;
-        }
-
-    private:
-        std::unique_ptr<Node> nested;
-    };
-
-    class TupleNode : public Node
-    {
-    public:
-        TupleNode(std::vector<std::unique_ptr<Node>> nested_, const std::vector<String> & explicit_names_) : nested(std::move(nested_)), explicit_names(explicit_names_)
-        {
-            for (size_t i = 0; i != explicit_names.size(); ++i)
-                name_to_index_map.emplace(explicit_names[i], i);
-        }
-
-        bool insertResultToColumn(IColumn & dest, const Element & element) override
-        {
-            ColumnTuple & tuple = assert_cast<ColumnTuple &>(dest);
-            size_t old_size = dest.size();
-            bool were_valid_elements = false;
-
-            auto set_size = [&](size_t size)
-            {
-                for (size_t i = 0; i != tuple.tupleSize(); ++i)
-                {
-                    auto & col = tuple.getColumn(i);
-                    if (col.size() != size)
-                    {
-                        if (col.size() > size)
-                            col.popBack(col.size() - size);
-                        else
-                            while (col.size() < size)
-                                col.insertDefault();
-                    }
-                }
-            };
-
-            if (element.isArray())
-            {
-                auto array = element.getArray();
-                auto it = array.begin();
-
-                for (size_t index = 0; (index != nested.size()) && (it != array.end()); ++index)
-                {
-                    if (nested[index]->insertResultToColumn(tuple.getColumn(index), *it++))
-                        were_valid_elements = true;
-                    else
-                        tuple.getColumn(index).insertDefault();
-                }
-
-                set_size(old_size + static_cast<size_t>(were_valid_elements));
-                return were_valid_elements;
-            }
-
-            if (element.isObject())
-            {
-                auto object = element.getObject();
-                if (name_to_index_map.empty())
-                {
-                    auto it = object.begin();
-                    for (size_t index = 0; (index != nested.size()) && (it != object.end()); ++index)
-                    {
-                        if (nested[index]->insertResultToColumn(tuple.getColumn(index), (*it++).second))
-                            were_valid_elements = true;
-                        else
-                            tuple.getColumn(index).insertDefault();
-                    }
-                }
-                else
-                {
-                    for (const auto & [key, value] : object)
-                    {
-                        auto index = name_to_index_map.find(key);
-                        if (index != name_to_index_map.end())
-                        {
-                            if (nested[index->second]->insertResultToColumn(tuple.getColumn(index->second), value))
-                                were_valid_elements = true;
-                        }
-                    }
-                }
-
-                set_size(old_size + static_cast<size_t>(were_valid_elements));
-                return were_valid_elements;
-            }
-
-            return false;
-        }
-
-    private:
-        std::vector<std::unique_ptr<Node>> nested;
-        std::vector<String> explicit_names;
-        std::unordered_map<std::string_view, size_t> name_to_index_map;
-    };
-
-    static std::unique_ptr<Node> build(const char * function_name, const DataTypePtr & type)
-    {
-        switch (type->getTypeId())
-        {
-            case TypeIndex::UInt8: return std::make_unique<NumericNode<UInt8>>();
-            case TypeIndex::UInt16: return std::make_unique<NumericNode<UInt16>>();
-            case TypeIndex::UInt32: return std::make_unique<NumericNode<UInt32>>();
-            case TypeIndex::UInt64: return std::make_unique<NumericNode<UInt64>>();
-            case TypeIndex::UInt128: return std::make_unique<NumericNode<UInt128>>();
-            case TypeIndex::UInt256: return std::make_unique<NumericNode<UInt256>>();
-            case TypeIndex::Int8: return std::make_unique<NumericNode<Int8>>();
-            case TypeIndex::Int16: return std::make_unique<NumericNode<Int16>>();
-            case TypeIndex::Int32: return std::make_unique<NumericNode<Int32>>();
-            case TypeIndex::Int64: return std::make_unique<NumericNode<Int64>>();
-            case TypeIndex::Int128: return std::make_unique<NumericNode<Int128>>();
-            case TypeIndex::Int256: return std::make_unique<NumericNode<Int256>>();
-            case TypeIndex::Float32: return std::make_unique<NumericNode<Float32>>();
-            case TypeIndex::Float64: return std::make_unique<NumericNode<Float64>>();
-            case TypeIndex::String: return std::make_unique<StringNode>();
-            case TypeIndex::FixedString: return std::make_unique<FixedStringNode>();
-            case TypeIndex::UUID: return std::make_unique<UUIDNode>();
-            case TypeIndex::LowCardinality:
-            {
-                // The low cardinality case is treated in two different ways:
-                // For FixedString type, an especial class is implemented for inserting the data in the destination column,
-                // as the string length must be passed in order to check and pad the incoming data.
-                // For the rest of low cardinality types, the insertion is done in their corresponding class, adapting the data
-                // as needed for the insertData function of the ColumnLowCardinality.
-                auto dictionary_type = typeid_cast<const DataTypeLowCardinality *>(type.get())->getDictionaryType();
-                if ((*dictionary_type).getTypeId() == TypeIndex::FixedString)
-                {
-                    auto fixed_length = typeid_cast<const DataTypeFixedString *>(dictionary_type.get())->getN();
-                    return std::make_unique<LowCardinalityFixedStringNode>(fixed_length);
-                }
-                return build(function_name, dictionary_type);
-            }
-            case TypeIndex::Decimal256: return std::make_unique<DecimalNode<Decimal256>>(type);
-            case TypeIndex::Decimal128: return std::make_unique<DecimalNode<Decimal128>>(type);
-            case TypeIndex::Decimal64: return std::make_unique<DecimalNode<Decimal64>>(type);
-            case TypeIndex::Decimal32: return std::make_unique<DecimalNode<Decimal32>>(type);
-            case TypeIndex::Enum8:
-                return std::make_unique<EnumNode<Int8>>(static_cast<const DataTypeEnum8 &>(*type).getValues());
-            case TypeIndex::Enum16:
-                return std::make_unique<EnumNode<Int16>>(static_cast<const DataTypeEnum16 &>(*type).getValues());
-            case TypeIndex::Nullable:
-            {
-                return std::make_unique<NullableNode>(build(function_name, static_cast<const DataTypeNullable &>(*type).getNestedType()));
-            }
-            case TypeIndex::Array:
-            {
-                return std::make_unique<ArrayNode>(build(function_name, static_cast<const DataTypeArray &>(*type).getNestedType()));
-            }
-            case TypeIndex::Tuple:
-            {
-                const auto & tuple = static_cast<const DataTypeTuple &>(*type);
-                const auto & tuple_elements = tuple.getElements();
-                std::vector<std::unique_ptr<Node>> elements;
-                elements.reserve(tuple_elements.size());
-                for (const auto & tuple_element : tuple_elements)
-                    elements.emplace_back(build(function_name, tuple_element));
-                return std::make_unique<TupleNode>(std::move(elements), tuple.haveExplicitNames() ? tuple.getElementNames() : Strings{});
-            }
-            default:
-                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                                "Function {} doesn't support the return type schema: {}",
-                                String(function_name), type->getName());
-        }
-    }
-};
-
-
-template <typename JSONParser>
-class JSONExtractImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char * function_name, const ColumnsWithTypeAndName & arguments)
-    {
-        if (arguments.size() < 2)
-            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} requires at least two arguments", String(function_name));
-
-        const auto & col = arguments.back();
-        const auto * col_type_const = typeid_cast<const ColumnConst *>(col.column.get());
-        if (!col_type_const || !isString(col.type))
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN,
-                            "The last argument of function {} should "
-                            "be a constant string specifying the return data type, illegal value: {}",
-                            String(function_name), col.name);
-
-        return DataTypeFactory::instance().get(col_type_const->getValue<String>());
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 2; }
-
-    void prepare(const char * function_name, const ColumnsWithTypeAndName &, const DataTypePtr & result_type)
-    {
-        extract_tree = JSONExtractTree<JSONParser>::build(function_name, result_type);
-    }
-
-    bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        return extract_tree->insertResultToColumn(dest, element);
-    }
-
-protected:
-    std::unique_ptr<typename JSONExtractTree<JSONParser>::Node> extract_tree;
-};
-
-
-template <typename JSONParser>
-class JSONExtractKeysAndValuesImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char * function_name, const ColumnsWithTypeAndName & arguments)
-    {
-        if (arguments.size() < 2)
-            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} requires at least two arguments", String(function_name));
-
-        const auto & col = arguments.back();
-        const auto * col_type_const = typeid_cast<const ColumnConst *>(col.column.get());
-        if (!col_type_const || !isString(col.type))
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN,
-                            "The last argument of function {} should "
-                            "be a constant string specifying the values' data type, illegal value: {}",
-                            String(function_name), col.name);
-
-        DataTypePtr key_type = std::make_unique<DataTypeString>();
-        DataTypePtr value_type = DataTypeFactory::instance().get(col_type_const->getValue<String>());
-        DataTypePtr tuple_type = std::make_unique<DataTypeTuple>(DataTypes{key_type, value_type});
-        return std::make_unique<DataTypeArray>(tuple_type);
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 2; }
-
-    void prepare(const char * function_name, const ColumnsWithTypeAndName &, const DataTypePtr & result_type)
-    {
-        const auto tuple_type = typeid_cast<const DataTypeArray *>(result_type.get())->getNestedType();
-        const auto value_type = typeid_cast<const DataTypeTuple *>(tuple_type.get())->getElements()[1];
-        extract_tree = JSONExtractTree<JSONParser>::build(function_name, value_type);
-    }
-
-    bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        if (!element.isObject())
-            return false;
-
-        auto object = element.getObject();
-
-        auto & col_arr = assert_cast<ColumnArray &>(dest);
-        auto & col_tuple = assert_cast<ColumnTuple &>(col_arr.getData());
-        size_t old_size = col_tuple.size();
-        auto & col_key = assert_cast<ColumnString &>(col_tuple.getColumn(0));
-        auto & col_value = col_tuple.getColumn(1);
-
-        for (const auto & [key, value] : object)
-        {
-            if (extract_tree->insertResultToColumn(col_value, value))
-                col_key.insertData(key.data(), key.size());
-        }
-
-        if (col_tuple.size() == old_size)
-            return false;
-
-        col_arr.getOffsets().push_back(col_tuple.size());
-        return true;
-    }
-
-private:
-    std::unique_ptr<typename JSONExtractTree<JSONParser>::Node> extract_tree;
-};
-
-
-template <typename JSONParser>
-class JSONExtractRawImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
-    {
-        return std::make_shared<DataTypeString>();
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        if (dest.getDataType() == TypeIndex::LowCardinality)
-        {
-            ColumnString::Chars chars;
-            WriteBufferFromVector<ColumnString::Chars> buf(chars, AppendModeTag());
-            traverse(element, buf);
-            buf.finalize();
-            assert_cast<ColumnLowCardinality &>(dest).insertData(reinterpret_cast<const char *>(chars.data()), chars.size());
-        }
-        else
-        {
-            ColumnString & col_str = assert_cast<ColumnString &>(dest);
-            auto & chars = col_str.getChars();
-            WriteBufferFromVector<ColumnString::Chars> buf(chars, AppendModeTag());
-            traverse(element, buf);
-            buf.finalize();
-            chars.push_back(0);
-            col_str.getOffsets().push_back(chars.size());
-        }
-        return true;
-    }
-
-    // We use insertResultToFixedStringColumn in case we are inserting raw data in a FixedString column
-    static bool insertResultToFixedStringColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        ColumnFixedString::Chars chars;
-        WriteBufferFromVector<ColumnFixedString::Chars> buf(chars, AppendModeTag());
-        traverse(element, buf);
-        buf.finalize();
-
-        auto & col_str = assert_cast<ColumnFixedString &>(dest);
-
-        if (chars.size() > col_str.getN())
-            return false;
-
-        chars.resize_fill(col_str.getN());
-        col_str.insertData(reinterpret_cast<const char *>(chars.data()), chars.size());
-
-
-        return true;
-    }
-
-    // We use insertResultToLowCardinalityFixedStringColumn in case we are inserting raw data in a Low Cardinality FixedString column
-    static bool insertResultToLowCardinalityFixedStringColumn(IColumn & dest, const Element & element, size_t fixed_length)
-    {
-        if (element.getObject().size() > fixed_length)
-            return false;
-
-        ColumnFixedString::Chars chars;
-        WriteBufferFromVector<ColumnFixedString::Chars> buf(chars, AppendModeTag());
-        traverse(element, buf);
-        buf.finalize();
-
-        if (chars.size() > fixed_length)
-            return false;
-        chars.resize_fill(fixed_length);
-        assert_cast<ColumnLowCardinality &>(dest).insertData(reinterpret_cast<const char *>(chars.data()), chars.size());
-
-        return true;
-    }
-
-private:
-    static void traverse(const Element & element, WriteBuffer & buf)
-    {
-        if (element.isInt64())
-        {
-            writeIntText(element.getInt64(), buf);
-            return;
-        }
-        if (element.isUInt64())
-        {
-            writeIntText(element.getUInt64(), buf);
-            return;
-        }
-        if (element.isDouble())
-        {
-            writeFloatText(element.getDouble(), buf);
-            return;
-        }
-        if (element.isBool())
-        {
-            if (element.getBool())
-                writeCString("true", buf);
-            else
-                writeCString("false", buf);
-            return;
-        }
-        if (element.isString())
-        {
-            writeJSONString(element.getString(), buf, formatSettings());
-            return;
-        }
-        if (element.isArray())
-        {
-            writeChar('[', buf);
-            bool need_comma = false;
-            for (auto value : element.getArray())
-            {
-                if (std::exchange(need_comma, true))
-                    writeChar(',', buf);
-                traverse(value, buf);
-            }
-            writeChar(']', buf);
-            return;
-        }
-        if (element.isObject())
-        {
-            writeChar('{', buf);
-            bool need_comma = false;
-            for (auto [key, value] : element.getObject())
-            {
-                if (std::exchange(need_comma, true))
-                    writeChar(',', buf);
-                writeJSONString(key, buf, formatSettings());
-                writeChar(':', buf);
-                traverse(value, buf);
-            }
-            writeChar('}', buf);
-            return;
-        }
-        if (element.isNull())
-        {
-            writeCString("null", buf);
-            return;
-        }
-    }
-
-    static const FormatSettings & formatSettings()
-    {
-        static const FormatSettings the_instance = []
-        {
-            FormatSettings settings;
-            settings.json.escape_forward_slashes = false;
-            return settings;
-        }();
-        return the_instance;
-    }
-};
-
-
-template <typename JSONParser>
-class JSONExtractArrayRawImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
-    {
-        return std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>());
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        if (!element.isArray())
-            return false;
-
-        auto array = element.getArray();
-        ColumnArray & col_res = assert_cast<ColumnArray &>(dest);
-
-        for (auto value : array)
-            JSONExtractRawImpl<JSONParser>::insertResultToColumn(col_res.getData(), value, {});
-
-        col_res.getOffsets().push_back(col_res.getOffsets().back() + array.size());
-        return true;
-    }
-};
-
-
-template <typename JSONParser>
-class JSONExtractKeysAndValuesRawImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
-    {
-        DataTypePtr string_type = std::make_unique<DataTypeString>();
-        DataTypePtr tuple_type = std::make_unique<DataTypeTuple>(DataTypes{string_type, string_type});
-        return std::make_unique<DataTypeArray>(tuple_type);
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        if (!element.isObject())
-            return false;
-
-        auto object = element.getObject();
-
-        auto & col_arr = assert_cast<ColumnArray &>(dest);
-        auto & col_tuple = assert_cast<ColumnTuple &>(col_arr.getData());
-        auto & col_key = assert_cast<ColumnString &>(col_tuple.getColumn(0));
-        auto & col_value = assert_cast<ColumnString &>(col_tuple.getColumn(1));
-
-        for (const auto & [key, value] : object)
-        {
-            col_key.insertData(key.data(), key.size());
-            JSONExtractRawImpl<JSONParser>::insertResultToColumn(col_value, value, {});
-        }
-
-        col_arr.getOffsets().push_back(col_arr.getOffsets().back() + object.size());
-        return true;
-    }
-};
-
-template <typename JSONParser>
-class JSONExtractKeysImpl
-{
-public:
-    using Element = typename JSONParser::Element;
-
-    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
-    {
-        return std::make_unique<DataTypeArray>(std::make_shared<DataTypeString>());
-    }
-
-    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
-
-    bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
-    {
-        if (!element.isObject())
-            return false;
-
-        auto object = element.getObject();
-
-        ColumnArray & col_res = assert_cast<ColumnArray &>(dest);
-        auto & col_key = assert_cast<ColumnString &>(col_res.getData());
-
-        for (const auto & [key, value] : object)
-        {
-            col_key.insertData(key.data(), key.size());
-        }
-
-        col_res.getOffsets().push_back(col_res.getOffsets().back() + object.size());
-        return true;
-    }
-};
-
 REGISTER_FUNCTION(JSON)
 {
     factory.registerFunction<JSONOverloadResolver<NameJSONHas, JSONHasImpl>>();
diff --git a/src/Functions/FunctionsJSON.h b/src/Functions/FunctionsJSON.h
new file mode 100644
index 00000000000..20f3e9f185d
--- /dev/null
+++ b/src/Functions/FunctionsJSON.h
@@ -0,0 +1,1623 @@
+#pragma once
+
+#include <type_traits>
+#include <boost/tti/has_member_function.hpp>
+
+#include <base/range.h>
+
+#include <Common/CpuId.h>
+#include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
+
+#include <Core/AccurateComparison.h>
+#include <Core/Settings.h>
+
+#include <Columns/ColumnConst.h>
+#include <Columns/ColumnLowCardinality.h>
+#include <Columns/ColumnDecimal.h>
+#include <Columns/ColumnString.h>
+#include <Columns/ColumnVector.h>
+#include <Columns/ColumnFixedString.h>
+#include <Columns/ColumnNullable.h>
+#include <Columns/ColumnArray.h>
+#include <Columns/ColumnTuple.h>
+
+#include <DataTypes/DataTypeArray.h>
+#include <DataTypes/DataTypeEnum.h>
+#include <DataTypes/DataTypeFactory.h>
+#include <DataTypes/DataTypeFixedString.h>
+#include <DataTypes/DataTypeLowCardinality.h>
+#include <DataTypes/DataTypeNothing.h>
+#include <DataTypes/DataTypeNullable.h>
+#include <DataTypes/DataTypeString.h>
+#include <DataTypes/DataTypeTuple.h>
+#include <DataTypes/DataTypeUUID.h>
+#include <DataTypes/DataTypesDecimal.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/Serializations/SerializationDecimal.h>
+
+#include <Functions/IFunction.h>
+#include <Common/JSONParsers/DummyJSONParser.h>
+#include <Common/JSONParsers/SimdJSONParser.h>
+#include <Common/JSONParsers/RapidJSONParser.h>
+#include <Functions/FunctionHelpers.h>
+
+#include <IO/readDecimalText.h>
+#include <Interpreters/Context.h>
+
+
+#include "config.h"
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+    extern const int ILLEGAL_COLUMN;
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+}
+
+template <typename T>
+concept HasIndexOperator = requires (T t)
+{
+    t[0];
+};
+
+/// Functions to parse JSONs and extract values from it.
+/// The first argument of all these functions gets a JSON,
+/// after that there are any number of arguments specifying path to a desired part from the JSON's root.
+/// For example,
+/// select JSONExtractInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 1) = -100
+
+class FunctionJSONHelpers
+{
+public:
+    template <typename Name, template<typename> typename Impl, class JSONParser>
+    class Executor
+    {
+    public:
+        static ColumnPtr run(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count)
+        {
+            MutableColumnPtr to{result_type->createColumn()};
+            to->reserve(input_rows_count);
+
+            if (arguments.empty())
+                throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} requires at least one argument", String(Name::name));
+
+            const auto & first_column = arguments[0];
+            if (!isString(first_column.type))
+                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                                "The first argument of function {} should be a string containing JSON, illegal type: "
+                                "{}", String(Name::name), first_column.type->getName());
+
+            const ColumnPtr & arg_json = first_column.column;
+            const auto * col_json_const = typeid_cast<const ColumnConst *>(arg_json.get());
+            const auto * col_json_string
+                = typeid_cast<const ColumnString *>(col_json_const ? col_json_const->getDataColumnPtr().get() : arg_json.get());
+
+            if (!col_json_string)
+                throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {}", arg_json->getName());
+
+            const ColumnString::Chars & chars = col_json_string->getChars();
+            const ColumnString::Offsets & offsets = col_json_string->getOffsets();
+
+            size_t num_index_arguments = Impl<JSONParser>::getNumberOfIndexArguments(arguments);
+            std::vector<Move> moves = prepareMoves(Name::name, arguments, 1, num_index_arguments);
+
+            /// Preallocate memory in parser if necessary.
+            JSONParser parser;
+            if constexpr (has_member_function_reserve<void (JSONParser::*)(size_t)>::value)
+            {
+                size_t max_size = calculateMaxSize(offsets);
+                if (max_size)
+                    parser.reserve(max_size);
+            }
+
+            Impl<JSONParser> impl;
+
+            /// prepare() does Impl-specific preparation before handling each row.
+            if constexpr (has_member_function_prepare<void (Impl<JSONParser>::*)(const char *, const ColumnsWithTypeAndName &, const DataTypePtr &)>::value)
+                impl.prepare(Name::name, arguments, result_type);
+
+            using Element = typename JSONParser::Element;
+
+            Element document;
+            bool document_ok = false;
+            if (col_json_const)
+            {
+                std::string_view json{reinterpret_cast<const char *>(chars.data()), offsets[0] - 1};
+                document_ok = parser.parse(json, document);
+            }
+
+            for (const auto i : collections::range(0, input_rows_count))
+            {
+                if (!col_json_const)
+                {
+                    std::string_view json{reinterpret_cast<const char *>(&chars[offsets[i - 1]]), offsets[i] - offsets[i - 1] - 1};
+                    document_ok = parser.parse(json, document);
+                }
+
+                bool added_to_column = false;
+                if (document_ok)
+                {
+                    /// Perform moves.
+                    Element element;
+                    std::string_view last_key;
+                    bool moves_ok = performMoves<JSONParser>(arguments, i, document, moves, element, last_key);
+
+                    if (moves_ok)
+                        added_to_column = impl.insertResultToColumn(*to, element, last_key);
+                }
+
+                /// We add default value (=null or zero) if something goes wrong, we don't throw exceptions in these JSON functions.
+                if (!added_to_column)
+                    to->insertDefault();
+            }
+            return to;
+        }
+    };
+
+private:
+    BOOST_TTI_HAS_MEMBER_FUNCTION(reserve)
+    BOOST_TTI_HAS_MEMBER_FUNCTION(prepare)
+
+    /// Represents a move of a JSON iterator described by a single argument passed to a JSON function.
+    /// For example, the call JSONExtractInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 1)
+    /// contains two moves: {MoveType::ConstKey, "b"} and {MoveType::ConstIndex, 1}.
+    /// Keys and indices can be nonconst, in this case they are calculated for each row.
+    enum class MoveType
+    {
+        Key,
+        Index,
+        ConstKey,
+        ConstIndex,
+    };
+
+    struct Move
+    {
+        explicit Move(MoveType type_, size_t index_ = 0) : type(type_), index(index_) {}
+        Move(MoveType type_, const String & key_) : type(type_), key(key_) {}
+        MoveType type;
+        size_t index = 0;
+        String key;
+    };
+
+    static std::vector<FunctionJSONHelpers::Move> prepareMoves(
+        const char * function_name,
+        const ColumnsWithTypeAndName & columns,
+        size_t first_index_argument,
+        size_t num_index_arguments)
+    {
+        std::vector<Move> moves;
+        moves.reserve(num_index_arguments);
+        for (const auto i : collections::range(first_index_argument, first_index_argument + num_index_arguments))
+        {
+            const auto & column = columns[i];
+            if (!isString(column.type) && !isNativeInteger(column.type))
+                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                                "The argument {} of function {} should be a string specifying key "
+                                "or an integer specifying index, illegal type: {}",
+                                std::to_string(i + 1), String(function_name), column.type->getName());
+
+            if (column.column && isColumnConst(*column.column))
+            {
+                const auto & column_const = assert_cast<const ColumnConst &>(*column.column);
+                if (isString(column.type))
+                    moves.emplace_back(MoveType::ConstKey, column_const.getValue<String>());
+                else
+                    moves.emplace_back(MoveType::ConstIndex, column_const.getInt(0));
+            }
+            else
+            {
+                if (isString(column.type))
+                    moves.emplace_back(MoveType::Key, "");
+                else
+                    moves.emplace_back(MoveType::Index, 0);
+            }
+        }
+        return moves;
+    }
+
+
+    /// Performs moves of types MoveType::Index and MoveType::ConstIndex.
+    template <typename JSONParser>
+    static bool performMoves(const ColumnsWithTypeAndName & arguments, size_t row,
+                             const typename JSONParser::Element & document, const std::vector<Move> & moves,
+                             typename JSONParser::Element & element, std::string_view & last_key)
+    {
+        typename JSONParser::Element res_element = document;
+        std::string_view key;
+
+        for (size_t j = 0; j != moves.size(); ++j)
+        {
+            switch (moves[j].type)
+            {
+                case MoveType::ConstIndex:
+                {
+                    if (!moveToElementByIndex<JSONParser>(res_element, static_cast<int>(moves[j].index), key))
+                        return false;
+                    break;
+                }
+                case MoveType::ConstKey:
+                {
+                    key = moves[j].key;
+                    if (!moveToElementByKey<JSONParser>(res_element, key))
+                        return false;
+                    break;
+                }
+                case MoveType::Index:
+                {
+                    Int64 index = (*arguments[j + 1].column)[row].get<Int64>();
+                    if (!moveToElementByIndex<JSONParser>(res_element, static_cast<int>(index), key))
+                        return false;
+                    break;
+                }
+                case MoveType::Key:
+                {
+                    key = (*arguments[j + 1].column).getDataAt(row).toView();
+                    if (!moveToElementByKey<JSONParser>(res_element, key))
+                        return false;
+                    break;
+                }
+            }
+        }
+
+        element = res_element;
+        last_key = key;
+        return true;
+    }
+
+    template <typename JSONParser>
+    static bool moveToElementByIndex(typename JSONParser::Element & element, int index, std::string_view & out_key)
+    {
+        if (element.isArray())
+        {
+            auto array = element.getArray();
+            if (index >= 0)
+                --index;
+            else
+                index += array.size();
+
+            if (static_cast<size_t>(index) >= array.size())
+                return false;
+            element = array[index];
+            out_key = {};
+            return true;
+        }
+
+        if constexpr (HasIndexOperator<typename JSONParser::Object>)
+        {
+            if (element.isObject())
+            {
+                auto object = element.getObject();
+                if (index >= 0)
+                    --index;
+                else
+                    index += object.size();
+
+                if (static_cast<size_t>(index) >= object.size())
+                    return false;
+                std::tie(out_key, element) = object[index];
+                return true;
+            }
+        }
+
+        return {};
+    }
+
+    /// Performs moves of types MoveType::Key and MoveType::ConstKey.
+    template <typename JSONParser>
+    static bool moveToElementByKey(typename JSONParser::Element & element, std::string_view key)
+    {
+        if (!element.isObject())
+            return false;
+        auto object = element.getObject();
+        return object.find(key, element);
+    }
+
+    static size_t calculateMaxSize(const ColumnString::Offsets & offsets)
+    {
+        size_t max_size = 0;
+        for (const auto i : collections::range(0, offsets.size()))
+        {
+            size_t size = offsets[i] - offsets[i - 1];
+            if (max_size < size)
+                max_size = size;
+        }
+        if (max_size)
+            --max_size;
+        return max_size;
+    }
+
+};
+
+
+template <typename Name, template<typename> typename Impl>
+class ExecutableFunctionJSON : public IExecutableFunction, WithContext
+{
+
+public:
+    explicit ExecutableFunctionJSON(const NullPresence & null_presence_, bool allow_simdjson_, const DataTypePtr & json_return_type_)
+        : null_presence(null_presence_), allow_simdjson(allow_simdjson_), json_return_type(json_return_type_)
+    {
+    }
+
+    String getName() const override { return Name::name; }
+    bool useDefaultImplementationForNulls() const override { return false; }
+    bool useDefaultImplementationForConstants() const override { return true; }
+
+    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
+    {
+        if (null_presence.has_null_constant)
+            return result_type->createColumnConstWithDefaultValue(input_rows_count);
+
+        ColumnsWithTypeAndName temporary_columns = null_presence.has_nullable ? createBlockWithNestedColumns(arguments) : arguments;
+        ColumnPtr temporary_result = chooseAndRunJSONParser(temporary_columns, json_return_type, input_rows_count);
+        if (null_presence.has_nullable)
+            return wrapInNullable(temporary_result, arguments, result_type, input_rows_count);
+        return temporary_result;
+    }
+
+private:
+
+    ColumnPtr
+    chooseAndRunJSONParser(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const
+    {
+#if USE_SIMDJSON
+        if (allow_simdjson)
+            return FunctionJSONHelpers::Executor<Name, Impl, SimdJSONParser>::run(arguments, result_type, input_rows_count);
+#endif
+
+#if USE_RAPIDJSON
+        return FunctionJSONHelpers::Executor<Name, Impl, RapidJSONParser>::run(arguments, result_type, input_rows_count);
+#else
+        return FunctionJSONHelpers::Executor<Name, Impl, DummyJSONParser>::run(arguments, result_type, input_rows_count);
+#endif
+    }
+
+    NullPresence null_presence;
+    bool allow_simdjson;
+    DataTypePtr json_return_type;
+};
+
+
+template <typename Name, template<typename> typename Impl>
+class FunctionBaseFunctionJSON : public IFunctionBase
+{
+public:
+    explicit FunctionBaseFunctionJSON(
+        const NullPresence & null_presence_,
+        bool allow_simdjson_,
+        DataTypes argument_types_,
+        DataTypePtr return_type_,
+        DataTypePtr json_return_type_)
+        : null_presence(null_presence_)
+        , allow_simdjson(allow_simdjson_)
+        , argument_types(std::move(argument_types_))
+        , return_type(std::move(return_type_))
+        , json_return_type(std::move(json_return_type_))
+    {
+    }
+
+    String getName() const override { return Name::name; }
+
+    const DataTypes & getArgumentTypes() const override
+    {
+        return argument_types;
+    }
+
+    const DataTypePtr & getResultType() const override
+    {
+        return return_type;
+    }
+
+    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
+
+    ExecutableFunctionPtr prepare(const ColumnsWithTypeAndName &) const override
+    {
+        return std::make_unique<ExecutableFunctionJSON<Name, Impl>>(null_presence, allow_simdjson, json_return_type);
+    }
+
+private:
+    NullPresence null_presence;
+    bool allow_simdjson;
+    DataTypes argument_types;
+    DataTypePtr return_type;
+    DataTypePtr json_return_type;
+};
+
+
+/// We use IFunctionOverloadResolver instead of IFunction to handle non-default NULL processing.
+/// Both NULL and JSON NULL should generate NULL value. If any argument is NULL, return NULL.
+template <typename Name, template<typename> typename Impl>
+class JSONOverloadResolver : public IFunctionOverloadResolver, WithContext
+{
+public:
+    static constexpr auto name = Name::name;
+
+    String getName() const override { return name; }
+
+    static FunctionOverloadResolverPtr create(ContextPtr context_)
+    {
+        return std::make_unique<JSONOverloadResolver>(context_);
+    }
+
+    explicit JSONOverloadResolver(ContextPtr context_) : WithContext(context_) {}
+
+    bool isVariadic() const override { return true; }
+    size_t getNumberOfArguments() const override { return 0; }
+    bool useDefaultImplementationForNulls() const override { return false; }
+
+    FunctionBasePtr build(const ColumnsWithTypeAndName & arguments) const override
+    {
+        bool has_nothing_argument = false;
+        for (const auto & arg : arguments)
+            has_nothing_argument |= isNothing(arg.type);
+
+        DataTypePtr json_return_type = Impl<DummyJSONParser>::getReturnType(Name::name, createBlockWithNestedColumns(arguments));
+        NullPresence null_presence = getNullPresense(arguments);
+        DataTypePtr return_type;
+        if (has_nothing_argument)
+            return_type = std::make_shared<DataTypeNothing>();
+        else if (null_presence.has_null_constant)
+            return_type = makeNullable(std::make_shared<DataTypeNothing>());
+        else if (null_presence.has_nullable)
+            return_type = makeNullable(json_return_type);
+        else
+            return_type = json_return_type;
+
+        /// Top-level LowCardinality columns are processed outside JSON parser.
+        json_return_type = removeLowCardinality(json_return_type);
+
+        DataTypes argument_types;
+        argument_types.reserve(arguments.size());
+        for (const auto & argument : arguments)
+            argument_types.emplace_back(argument.type);
+        return std::make_unique<FunctionBaseFunctionJSON<Name, Impl>>(
+                null_presence, getContext()->getSettingsRef().allow_simdjson, argument_types, return_type, json_return_type);
+    }
+};
+
+
+struct NameJSONHas { static constexpr auto name{"JSONHas"}; };
+struct NameIsValidJSON { static constexpr auto name{"isValidJSON"}; };
+struct NameJSONLength { static constexpr auto name{"JSONLength"}; };
+struct NameJSONKey { static constexpr auto name{"JSONKey"}; };
+struct NameJSONType { static constexpr auto name{"JSONType"}; };
+struct NameJSONExtractInt { static constexpr auto name{"JSONExtractInt"}; };
+struct NameJSONExtractUInt { static constexpr auto name{"JSONExtractUInt"}; };
+struct NameJSONExtractFloat { static constexpr auto name{"JSONExtractFloat"}; };
+struct NameJSONExtractBool { static constexpr auto name{"JSONExtractBool"}; };
+struct NameJSONExtractString { static constexpr auto name{"JSONExtractString"}; };
+struct NameJSONExtract { static constexpr auto name{"JSONExtract"}; };
+struct NameJSONExtractKeysAndValues { static constexpr auto name{"JSONExtractKeysAndValues"}; };
+struct NameJSONExtractRaw { static constexpr auto name{"JSONExtractRaw"}; };
+struct NameJSONExtractArrayRaw { static constexpr auto name{"JSONExtractArrayRaw"}; };
+struct NameJSONExtractKeysAndValuesRaw { static constexpr auto name{"JSONExtractKeysAndValuesRaw"}; };
+struct NameJSONExtractKeys { static constexpr auto name{"JSONExtractKeys"}; };
+
+
+template <typename JSONParser>
+class JSONHasImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &) { return std::make_shared<DataTypeUInt8>(); }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    static bool insertResultToColumn(IColumn & dest, const Element &, std::string_view)
+    {
+        ColumnVector<UInt8> & col_vec = assert_cast<ColumnVector<UInt8> &>(dest);
+        col_vec.insertValue(1);
+        return true;
+    }
+};
+
+
+template <typename JSONParser>
+class IsValidJSONImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char * function_name, const ColumnsWithTypeAndName & arguments)
+    {
+        if (arguments.size() != 1)
+        {
+            /// IsValidJSON() shouldn't get parameters other than JSON.
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} needs exactly one argument",
+                            String(function_name));
+        }
+        return std::make_shared<DataTypeUInt8>();
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName &) { return 0; }
+
+    static bool insertResultToColumn(IColumn & dest, const Element &, std::string_view)
+    {
+        /// This function is called only if JSON is valid.
+        /// If JSON isn't valid then `FunctionJSON::Executor::run()` adds default value (=zero) to `dest` without calling this function.
+        ColumnVector<UInt8> & col_vec = assert_cast<ColumnVector<UInt8> &>(dest);
+        col_vec.insertValue(1);
+        return true;
+    }
+};
+
+
+template <typename JSONParser>
+class JSONLengthImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
+    {
+        return std::make_shared<DataTypeUInt64>();
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        size_t size;
+        if (element.isArray())
+            size = element.getArray().size();
+        else if (element.isObject())
+            size = element.getObject().size();
+        else
+            return false;
+
+        ColumnVector<UInt64> & col_vec = assert_cast<ColumnVector<UInt64> &>(dest);
+        col_vec.insertValue(size);
+        return true;
+    }
+};
+
+
+template <typename JSONParser>
+class JSONKeyImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
+    {
+        return std::make_shared<DataTypeString>();
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    static bool insertResultToColumn(IColumn & dest, const Element &, std::string_view last_key)
+    {
+        if (last_key.empty())
+            return false;
+        ColumnString & col_str = assert_cast<ColumnString &>(dest);
+        col_str.insertData(last_key.data(), last_key.size());
+        return true;
+    }
+};
+
+
+template <typename JSONParser>
+class JSONTypeImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
+    {
+        static const std::vector<std::pair<String, Int8>> values = {
+            {"Array", '['},
+            {"Object", '{'},
+            {"String", '"'},
+            {"Int64", 'i'},
+            {"UInt64", 'u'},
+            {"Double", 'd'},
+            {"Bool", 'b'},
+            {"Null", 0}, /// the default value for the column.
+        };
+        return std::make_shared<DataTypeEnum<Int8>>(values);
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        UInt8 type;
+        switch (element.type())
+        {
+            case ElementType::INT64:
+                type = 'i';
+                break;
+            case ElementType::UINT64:
+                type = 'u';
+                break;
+            case ElementType::DOUBLE:
+                type = 'd';
+                break;
+            case ElementType::STRING:
+                type = '"';
+                break;
+            case ElementType::ARRAY:
+                type = '[';
+                break;
+            case ElementType::OBJECT:
+                type = '{';
+                break;
+            case ElementType::BOOL:
+                type = 'b';
+                break;
+            case ElementType::NULL_VALUE:
+                type = 0;
+                break;
+        }
+
+        ColumnVector<Int8> & col_vec = assert_cast<ColumnVector<Int8> &>(dest);
+        col_vec.insertValue(type);
+        return true;
+    }
+};
+
+
+template <typename JSONParser, typename NumberType, bool convert_bool_to_integer = false>
+class JSONExtractNumericImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
+    {
+        return std::make_shared<DataTypeNumber<NumberType>>();
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        NumberType value;
+
+        switch (element.type())
+        {
+            case ElementType::DOUBLE:
+                if constexpr (std::is_floating_point_v<NumberType>)
+                {
+                    /// We permit inaccurate conversion of double to float.
+                    /// Example: double 0.1 from JSON is not representable in float.
+                    /// But it will be more convenient for user to perform conversion.
+                    value = static_cast<NumberType>(element.getDouble());
+                }
+                else if (!accurate::convertNumeric<Float64, NumberType, false>(element.getDouble(), value))
+                    return false;
+                break;
+            case ElementType::UINT64:
+                if (!accurate::convertNumeric<UInt64, NumberType, false>(element.getUInt64(), value))
+                    return false;
+                break;
+            case ElementType::INT64:
+                if (!accurate::convertNumeric<Int64, NumberType, false>(element.getInt64(), value))
+                    return false;
+                break;
+            case ElementType::BOOL:
+                if constexpr (is_integer<NumberType> && convert_bool_to_integer)
+                {
+                    value = static_cast<NumberType>(element.getBool());
+                    break;
+                }
+                return false;
+            case ElementType::STRING:
+            {
+                auto rb = ReadBufferFromMemory{element.getString()};
+                if constexpr (std::is_floating_point_v<NumberType>)
+                {
+                    if (!tryReadFloatText(value, rb) || !rb.eof())
+                        return false;
+                }
+                else
+                {
+                    if (tryReadIntText(value, rb) && rb.eof())
+                        break;
+
+                    /// Try to parse float and convert it to integer.
+                    Float64 tmp_float;
+                    rb.position() = rb.buffer().begin();
+                    if (!tryReadFloatText(tmp_float, rb) || !rb.eof())
+                        return false;
+
+                    if (!accurate::convertNumeric<Float64, NumberType, false>(tmp_float, value))
+                        return false;
+                }
+                break;
+            }
+            default:
+                return false;
+        }
+
+        if (dest.getDataType() == TypeIndex::LowCardinality)
+        {
+            ColumnLowCardinality & col_low = assert_cast<ColumnLowCardinality &>(dest);
+            col_low.insertData(reinterpret_cast<const char *>(&value), sizeof(value));
+        }
+        else
+        {
+            auto & col_vec = assert_cast<ColumnVector<NumberType> &>(dest);
+            col_vec.insertValue(value);
+        }
+        return true;
+    }
+};
+
+
+template <typename JSONParser>
+using JSONExtractInt64Impl = JSONExtractNumericImpl<JSONParser, Int64>;
+template <typename JSONParser>
+using JSONExtractUInt64Impl = JSONExtractNumericImpl<JSONParser, UInt64>;
+template <typename JSONParser>
+using JSONExtractFloat64Impl = JSONExtractNumericImpl<JSONParser, Float64>;
+
+
+template <typename JSONParser>
+class JSONExtractBoolImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
+    {
+        return std::make_shared<DataTypeUInt8>();
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        bool value;
+        switch (element.type())
+        {
+            case ElementType::BOOL:
+                value = element.getBool();
+                break;
+            case ElementType::INT64:
+                value = element.getInt64() != 0;
+                break;
+            case ElementType::UINT64:
+                value = element.getUInt64() != 0;
+                break;
+            default:
+                return false;
+        }
+
+        auto & col_vec = assert_cast<ColumnVector<UInt8> &>(dest);
+        col_vec.insertValue(static_cast<UInt8>(value));
+        return true;
+    }
+};
+
+template <typename JSONParser>
+class JSONExtractRawImpl;
+
+template <typename JSONParser>
+class JSONExtractStringImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
+    {
+        return std::make_shared<DataTypeString>();
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        if (element.isNull())
+            return false;
+
+        if (!element.isString())
+            return JSONExtractRawImpl<JSONParser>::insertResultToColumn(dest, element, {});
+
+        auto str = element.getString();
+
+        if (dest.getDataType() == TypeIndex::LowCardinality)
+        {
+            ColumnLowCardinality & col_low = assert_cast<ColumnLowCardinality &>(dest);
+            col_low.insertData(str.data(), str.size());
+        }
+        else
+        {
+            ColumnString & col_str = assert_cast<ColumnString &>(dest);
+            col_str.insertData(str.data(), str.size());
+        }
+        return true;
+    }
+};
+
+/// Nodes of the extract tree. We need the extract tree to extract from JSON complex values containing array, tuples or nullables.
+template <typename JSONParser>
+struct JSONExtractTree
+{
+    using Element = typename JSONParser::Element;
+
+    class Node
+    {
+    public:
+        Node() = default;
+        virtual ~Node() = default;
+        virtual bool insertResultToColumn(IColumn &, const Element &) = 0;
+    };
+
+    template <typename NumberType>
+    class NumericNode : public Node
+    {
+    public:
+        bool insertResultToColumn(IColumn & dest, const Element & element) override
+        {
+            return JSONExtractNumericImpl<JSONParser, NumberType, true>::insertResultToColumn(dest, element, {});
+        }
+    };
+
+    class LowCardinalityFixedStringNode : public Node
+    {
+    public:
+        explicit LowCardinalityFixedStringNode(const size_t fixed_length_) : fixed_length(fixed_length_) { }
+        bool insertResultToColumn(IColumn & dest, const Element & element) override
+        {
+            // If element is an object we delegate the insertion to JSONExtractRawImpl
+            if (element.isObject())
+                return JSONExtractRawImpl<JSONParser>::insertResultToLowCardinalityFixedStringColumn(dest, element, fixed_length);
+            else if (!element.isString())
+                return false;
+
+            auto str = element.getString();
+            if (str.size() > fixed_length)
+                return false;
+
+            // For the non low cardinality case of FixedString, the padding is done in the FixedString Column implementation.
+            // In order to avoid having to pass the data to a FixedString Column and read it back (which would slow down the execution)
+            // the data is padded here and written directly to the Low Cardinality Column
+            if (str.size() == fixed_length)
+            {
+                assert_cast<ColumnLowCardinality &>(dest).insertData(str.data(), str.size());
+            }
+            else
+            {
+                String padded_str(str);
+                padded_str.resize(fixed_length, '\0');
+
+                assert_cast<ColumnLowCardinality &>(dest).insertData(padded_str.data(), padded_str.size());
+            }
+            return true;
+        }
+
+    private:
+        const size_t fixed_length;
+    };
+
+    class UUIDNode : public Node
+    {
+    public:
+        bool insertResultToColumn(IColumn & dest, const Element & element) override
+        {
+            if (!element.isString())
+                return false;
+
+            auto uuid = parseFromString<UUID>(element.getString());
+            if (dest.getDataType() == TypeIndex::LowCardinality)
+            {
+                ColumnLowCardinality & col_low = assert_cast<ColumnLowCardinality &>(dest);
+                col_low.insertData(reinterpret_cast<const char *>(&uuid), sizeof(uuid));
+            }
+            else
+            {
+                assert_cast<ColumnUUID &>(dest).insert(uuid);
+            }
+            return true;
+        }
+    };
+
+    template <typename DecimalType>
+    class DecimalNode : public Node
+    {
+    public:
+        explicit DecimalNode(DataTypePtr data_type_) : data_type(data_type_) {}
+        bool insertResultToColumn(IColumn & dest, const Element & element) override
+        {
+            const auto * type = assert_cast<const DataTypeDecimal<DecimalType> *>(data_type.get());
+
+            DecimalType value{};
+
+            switch (element.type())
+            {
+                case ElementType::DOUBLE:
+                    value = convertToDecimal<DataTypeNumber<Float64>, DataTypeDecimal<DecimalType>>(
+                        element.getDouble(), type->getScale());
+                    break;
+                case ElementType::UINT64:
+                    value = convertToDecimal<DataTypeNumber<UInt64>, DataTypeDecimal<DecimalType>>(
+                        element.getUInt64(), type->getScale());
+                    break;
+                case ElementType::INT64:
+                    value = convertToDecimal<DataTypeNumber<Int64>, DataTypeDecimal<DecimalType>>(
+                        element.getInt64(), type->getScale());
+                    break;
+                case ElementType::STRING: {
+                    auto rb = ReadBufferFromMemory{element.getString()};
+                    if (!SerializationDecimal<DecimalType>::tryReadText(value, rb, DecimalUtils::max_precision<DecimalType>, type->getScale()))
+                        return false;
+                    break;
+                }
+                default:
+                    return false;
+            }
+
+            assert_cast<ColumnDecimal<DecimalType> &>(dest).insertValue(value);
+            return true;
+        }
+
+    private:
+        DataTypePtr data_type;
+    };
+
+    class StringNode : public Node
+    {
+    public:
+        bool insertResultToColumn(IColumn & dest, const Element & element) override
+        {
+            return JSONExtractStringImpl<JSONParser>::insertResultToColumn(dest, element, {});
+        }
+    };
+
+    class FixedStringNode : public Node
+    {
+    public:
+        bool insertResultToColumn(IColumn & dest, const Element & element) override
+        {
+            if (element.isNull())
+                return false;
+
+            if (!element.isString())
+                return JSONExtractRawImpl<JSONParser>::insertResultToFixedStringColumn(dest, element, {});
+
+            auto str = element.getString();
+            auto & col_str = assert_cast<ColumnFixedString &>(dest);
+            if (str.size() > col_str.getN())
+                return false;
+            col_str.insertData(str.data(), str.size());
+
+            return true;
+        }
+    };
+
+    template <typename Type>
+    class EnumNode : public Node
+    {
+    public:
+        explicit EnumNode(const std::vector<std::pair<String, Type>> & name_value_pairs_) : name_value_pairs(name_value_pairs_)
+        {
+            for (const auto & name_value_pair : name_value_pairs)
+            {
+                name_to_value_map.emplace(name_value_pair.first, name_value_pair.second);
+                only_values.emplace(name_value_pair.second);
+            }
+        }
+
+        bool insertResultToColumn(IColumn & dest, const Element & element) override
+        {
+            auto & col_vec = assert_cast<ColumnVector<Type> &>(dest);
+
+            if (element.isInt64())
+            {
+                Type value;
+                if (!accurate::convertNumeric(element.getInt64(), value) || !only_values.contains(value))
+                    return false;
+                col_vec.insertValue(value);
+                return true;
+            }
+
+            if (element.isUInt64())
+            {
+                Type value;
+                if (!accurate::convertNumeric(element.getUInt64(), value) || !only_values.contains(value))
+                    return false;
+                col_vec.insertValue(value);
+                return true;
+            }
+
+            if (element.isString())
+            {
+                auto value = name_to_value_map.find(element.getString());
+                if (value == name_to_value_map.end())
+                    return false;
+                col_vec.insertValue(value->second);
+                return true;
+            }
+
+            return false;
+        }
+
+    private:
+        std::vector<std::pair<String, Type>> name_value_pairs;
+        std::unordered_map<std::string_view, Type> name_to_value_map;
+        std::unordered_set<Type> only_values;
+    };
+
+    class NullableNode : public Node
+    {
+    public:
+        explicit NullableNode(std::unique_ptr<Node> nested_) : nested(std::move(nested_)) {}
+
+        bool insertResultToColumn(IColumn & dest, const Element & element) override
+        {
+            ColumnNullable & col_null = assert_cast<ColumnNullable &>(dest);
+            if (!nested->insertResultToColumn(col_null.getNestedColumn(), element))
+                return false;
+            col_null.getNullMapColumn().insertValue(0);
+            return true;
+        }
+
+    private:
+        std::unique_ptr<Node> nested;
+    };
+
+    class ArrayNode : public Node
+    {
+    public:
+        explicit ArrayNode(std::unique_ptr<Node> nested_) : nested(std::move(nested_)) {}
+
+        bool insertResultToColumn(IColumn & dest, const Element & element) override
+        {
+            if (!element.isArray())
+                return false;
+
+            auto array = element.getArray();
+
+            ColumnArray & col_arr = assert_cast<ColumnArray &>(dest);
+            auto & data = col_arr.getData();
+            size_t old_size = data.size();
+            bool were_valid_elements = false;
+
+            for (auto value : array)
+            {
+                if (nested->insertResultToColumn(data, value))
+                    were_valid_elements = true;
+                else
+                    data.insertDefault();
+            }
+
+            if (!were_valid_elements)
+            {
+                data.popBack(data.size() - old_size);
+                return false;
+            }
+
+            col_arr.getOffsets().push_back(data.size());
+            return true;
+        }
+
+    private:
+        std::unique_ptr<Node> nested;
+    };
+
+    class TupleNode : public Node
+    {
+    public:
+        TupleNode(std::vector<std::unique_ptr<Node>> nested_, const std::vector<String> & explicit_names_) : nested(std::move(nested_)), explicit_names(explicit_names_)
+        {
+            for (size_t i = 0; i != explicit_names.size(); ++i)
+                name_to_index_map.emplace(explicit_names[i], i);
+        }
+
+        bool insertResultToColumn(IColumn & dest, const Element & element) override
+        {
+            ColumnTuple & tuple = assert_cast<ColumnTuple &>(dest);
+            size_t old_size = dest.size();
+            bool were_valid_elements = false;
+
+            auto set_size = [&](size_t size)
+            {
+                for (size_t i = 0; i != tuple.tupleSize(); ++i)
+                {
+                    auto & col = tuple.getColumn(i);
+                    if (col.size() != size)
+                    {
+                        if (col.size() > size)
+                            col.popBack(col.size() - size);
+                        else
+                            while (col.size() < size)
+                                col.insertDefault();
+                    }
+                }
+            };
+
+            if (element.isArray())
+            {
+                auto array = element.getArray();
+                auto it = array.begin();
+
+                for (size_t index = 0; (index != nested.size()) && (it != array.end()); ++index)
+                {
+                    if (nested[index]->insertResultToColumn(tuple.getColumn(index), *it++))
+                        were_valid_elements = true;
+                    else
+                        tuple.getColumn(index).insertDefault();
+                }
+
+                set_size(old_size + static_cast<size_t>(were_valid_elements));
+                return were_valid_elements;
+            }
+
+            if (element.isObject())
+            {
+                auto object = element.getObject();
+                if (name_to_index_map.empty())
+                {
+                    auto it = object.begin();
+                    for (size_t index = 0; (index != nested.size()) && (it != object.end()); ++index)
+                    {
+                        if (nested[index]->insertResultToColumn(tuple.getColumn(index), (*it++).second))
+                            were_valid_elements = true;
+                        else
+                            tuple.getColumn(index).insertDefault();
+                    }
+                }
+                else
+                {
+                    for (const auto & [key, value] : object)
+                    {
+                        auto index = name_to_index_map.find(key);
+                        if (index != name_to_index_map.end())
+                        {
+                            if (nested[index->second]->insertResultToColumn(tuple.getColumn(index->second), value))
+                                were_valid_elements = true;
+                        }
+                    }
+                }
+
+                set_size(old_size + static_cast<size_t>(were_valid_elements));
+                return were_valid_elements;
+            }
+
+            return false;
+        }
+
+    private:
+        std::vector<std::unique_ptr<Node>> nested;
+        std::vector<String> explicit_names;
+        std::unordered_map<std::string_view, size_t> name_to_index_map;
+    };
+
+    static std::unique_ptr<Node> build(const char * function_name, const DataTypePtr & type)
+    {
+        switch (type->getTypeId())
+        {
+            case TypeIndex::UInt8: return std::make_unique<NumericNode<UInt8>>();
+            case TypeIndex::UInt16: return std::make_unique<NumericNode<UInt16>>();
+            case TypeIndex::UInt32: return std::make_unique<NumericNode<UInt32>>();
+            case TypeIndex::UInt64: return std::make_unique<NumericNode<UInt64>>();
+            case TypeIndex::UInt128: return std::make_unique<NumericNode<UInt128>>();
+            case TypeIndex::UInt256: return std::make_unique<NumericNode<UInt256>>();
+            case TypeIndex::Int8: return std::make_unique<NumericNode<Int8>>();
+            case TypeIndex::Int16: return std::make_unique<NumericNode<Int16>>();
+            case TypeIndex::Int32: return std::make_unique<NumericNode<Int32>>();
+            case TypeIndex::Int64: return std::make_unique<NumericNode<Int64>>();
+            case TypeIndex::Int128: return std::make_unique<NumericNode<Int128>>();
+            case TypeIndex::Int256: return std::make_unique<NumericNode<Int256>>();
+            case TypeIndex::Float32: return std::make_unique<NumericNode<Float32>>();
+            case TypeIndex::Float64: return std::make_unique<NumericNode<Float64>>();
+            case TypeIndex::String: return std::make_unique<StringNode>();
+            case TypeIndex::FixedString: return std::make_unique<FixedStringNode>();
+            case TypeIndex::UUID: return std::make_unique<UUIDNode>();
+            case TypeIndex::LowCardinality:
+            {
+                // The low cardinality case is treated in two different ways:
+                // For FixedString type, an especial class is implemented for inserting the data in the destination column,
+                // as the string length must be passed in order to check and pad the incoming data.
+                // For the rest of low cardinality types, the insertion is done in their corresponding class, adapting the data
+                // as needed for the insertData function of the ColumnLowCardinality.
+                auto dictionary_type = typeid_cast<const DataTypeLowCardinality *>(type.get())->getDictionaryType();
+                if ((*dictionary_type).getTypeId() == TypeIndex::FixedString)
+                {
+                    auto fixed_length = typeid_cast<const DataTypeFixedString *>(dictionary_type.get())->getN();
+                    return std::make_unique<LowCardinalityFixedStringNode>(fixed_length);
+                }
+                return build(function_name, dictionary_type);
+            }
+            case TypeIndex::Decimal256: return std::make_unique<DecimalNode<Decimal256>>(type);
+            case TypeIndex::Decimal128: return std::make_unique<DecimalNode<Decimal128>>(type);
+            case TypeIndex::Decimal64: return std::make_unique<DecimalNode<Decimal64>>(type);
+            case TypeIndex::Decimal32: return std::make_unique<DecimalNode<Decimal32>>(type);
+            case TypeIndex::Enum8:
+                return std::make_unique<EnumNode<Int8>>(static_cast<const DataTypeEnum8 &>(*type).getValues());
+            case TypeIndex::Enum16:
+                return std::make_unique<EnumNode<Int16>>(static_cast<const DataTypeEnum16 &>(*type).getValues());
+            case TypeIndex::Nullable:
+            {
+                return std::make_unique<NullableNode>(build(function_name, static_cast<const DataTypeNullable &>(*type).getNestedType()));
+            }
+            case TypeIndex::Array:
+            {
+                return std::make_unique<ArrayNode>(build(function_name, static_cast<const DataTypeArray &>(*type).getNestedType()));
+            }
+            case TypeIndex::Tuple:
+            {
+                const auto & tuple = static_cast<const DataTypeTuple &>(*type);
+                const auto & tuple_elements = tuple.getElements();
+                std::vector<std::unique_ptr<Node>> elements;
+                elements.reserve(tuple_elements.size());
+                for (const auto & tuple_element : tuple_elements)
+                    elements.emplace_back(build(function_name, tuple_element));
+                return std::make_unique<TupleNode>(std::move(elements), tuple.haveExplicitNames() ? tuple.getElementNames() : Strings{});
+            }
+            default:
+                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                                "Function {} doesn't support the return type schema: {}",
+                                String(function_name), type->getName());
+        }
+    }
+};
+
+
+template <typename JSONParser>
+class JSONExtractImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char * function_name, const ColumnsWithTypeAndName & arguments)
+    {
+        if (arguments.size() < 2)
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} requires at least two arguments", String(function_name));
+
+        const auto & col = arguments.back();
+        const auto * col_type_const = typeid_cast<const ColumnConst *>(col.column.get());
+        if (!col_type_const || !isString(col.type))
+            throw Exception(ErrorCodes::ILLEGAL_COLUMN,
+                            "The last argument of function {} should "
+                            "be a constant string specifying the return data type, illegal value: {}",
+                            String(function_name), col.name);
+
+        return DataTypeFactory::instance().get(col_type_const->getValue<String>());
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 2; }
+
+    void prepare(const char * function_name, const ColumnsWithTypeAndName &, const DataTypePtr & result_type)
+    {
+        extract_tree = JSONExtractTree<JSONParser>::build(function_name, result_type);
+    }
+
+    bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        return extract_tree->insertResultToColumn(dest, element);
+    }
+
+protected:
+    std::unique_ptr<typename JSONExtractTree<JSONParser>::Node> extract_tree;
+};
+
+
+template <typename JSONParser>
+class JSONExtractKeysAndValuesImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char * function_name, const ColumnsWithTypeAndName & arguments)
+    {
+        if (arguments.size() < 2)
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} requires at least two arguments", String(function_name));
+
+        const auto & col = arguments.back();
+        const auto * col_type_const = typeid_cast<const ColumnConst *>(col.column.get());
+        if (!col_type_const || !isString(col.type))
+            throw Exception(ErrorCodes::ILLEGAL_COLUMN,
+                            "The last argument of function {} should "
+                            "be a constant string specifying the values' data type, illegal value: {}",
+                            String(function_name), col.name);
+
+        DataTypePtr key_type = std::make_unique<DataTypeString>();
+        DataTypePtr value_type = DataTypeFactory::instance().get(col_type_const->getValue<String>());
+        DataTypePtr tuple_type = std::make_unique<DataTypeTuple>(DataTypes{key_type, value_type});
+        return std::make_unique<DataTypeArray>(tuple_type);
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 2; }
+
+    void prepare(const char * function_name, const ColumnsWithTypeAndName &, const DataTypePtr & result_type)
+    {
+        const auto tuple_type = typeid_cast<const DataTypeArray *>(result_type.get())->getNestedType();
+        const auto value_type = typeid_cast<const DataTypeTuple *>(tuple_type.get())->getElements()[1];
+        extract_tree = JSONExtractTree<JSONParser>::build(function_name, value_type);
+    }
+
+    bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        if (!element.isObject())
+            return false;
+
+        auto object = element.getObject();
+
+        auto & col_arr = assert_cast<ColumnArray &>(dest);
+        auto & col_tuple = assert_cast<ColumnTuple &>(col_arr.getData());
+        size_t old_size = col_tuple.size();
+        auto & col_key = assert_cast<ColumnString &>(col_tuple.getColumn(0));
+        auto & col_value = col_tuple.getColumn(1);
+
+        for (const auto & [key, value] : object)
+        {
+            if (extract_tree->insertResultToColumn(col_value, value))
+                col_key.insertData(key.data(), key.size());
+        }
+
+        if (col_tuple.size() == old_size)
+            return false;
+
+        col_arr.getOffsets().push_back(col_tuple.size());
+        return true;
+    }
+
+private:
+    std::unique_ptr<typename JSONExtractTree<JSONParser>::Node> extract_tree;
+};
+
+
+template <typename JSONParser>
+class JSONExtractRawImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
+    {
+        return std::make_shared<DataTypeString>();
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        if (dest.getDataType() == TypeIndex::LowCardinality)
+        {
+            ColumnString::Chars chars;
+            WriteBufferFromVector<ColumnString::Chars> buf(chars, AppendModeTag());
+            traverse(element, buf);
+            buf.finalize();
+            assert_cast<ColumnLowCardinality &>(dest).insertData(reinterpret_cast<const char *>(chars.data()), chars.size());
+        }
+        else
+        {
+            ColumnString & col_str = assert_cast<ColumnString &>(dest);
+            auto & chars = col_str.getChars();
+            WriteBufferFromVector<ColumnString::Chars> buf(chars, AppendModeTag());
+            traverse(element, buf);
+            buf.finalize();
+            chars.push_back(0);
+            col_str.getOffsets().push_back(chars.size());
+        }
+        return true;
+    }
+
+    // We use insertResultToFixedStringColumn in case we are inserting raw data in a FixedString column
+    static bool insertResultToFixedStringColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        ColumnFixedString::Chars chars;
+        WriteBufferFromVector<ColumnFixedString::Chars> buf(chars, AppendModeTag());
+        traverse(element, buf);
+        buf.finalize();
+
+        auto & col_str = assert_cast<ColumnFixedString &>(dest);
+
+        if (chars.size() > col_str.getN())
+            return false;
+
+        chars.resize_fill(col_str.getN());
+        col_str.insertData(reinterpret_cast<const char *>(chars.data()), chars.size());
+
+
+        return true;
+    }
+
+    // We use insertResultToLowCardinalityFixedStringColumn in case we are inserting raw data in a Low Cardinality FixedString column
+    static bool insertResultToLowCardinalityFixedStringColumn(IColumn & dest, const Element & element, size_t fixed_length)
+    {
+        if (element.getObject().size() > fixed_length)
+            return false;
+
+        ColumnFixedString::Chars chars;
+        WriteBufferFromVector<ColumnFixedString::Chars> buf(chars, AppendModeTag());
+        traverse(element, buf);
+        buf.finalize();
+
+        if (chars.size() > fixed_length)
+            return false;
+        chars.resize_fill(fixed_length);
+        assert_cast<ColumnLowCardinality &>(dest).insertData(reinterpret_cast<const char *>(chars.data()), chars.size());
+
+        return true;
+    }
+
+private:
+    static void traverse(const Element & element, WriteBuffer & buf)
+    {
+        if (element.isInt64())
+        {
+            writeIntText(element.getInt64(), buf);
+            return;
+        }
+        if (element.isUInt64())
+        {
+            writeIntText(element.getUInt64(), buf);
+            return;
+        }
+        if (element.isDouble())
+        {
+            writeFloatText(element.getDouble(), buf);
+            return;
+        }
+        if (element.isBool())
+        {
+            if (element.getBool())
+                writeCString("true", buf);
+            else
+                writeCString("false", buf);
+            return;
+        }
+        if (element.isString())
+        {
+            writeJSONString(element.getString(), buf, formatSettings());
+            return;
+        }
+        if (element.isArray())
+        {
+            writeChar('[', buf);
+            bool need_comma = false;
+            for (auto value : element.getArray())
+            {
+                if (std::exchange(need_comma, true))
+                    writeChar(',', buf);
+                traverse(value, buf);
+            }
+            writeChar(']', buf);
+            return;
+        }
+        if (element.isObject())
+        {
+            writeChar('{', buf);
+            bool need_comma = false;
+            for (auto [key, value] : element.getObject())
+            {
+                if (std::exchange(need_comma, true))
+                    writeChar(',', buf);
+                writeJSONString(key, buf, formatSettings());
+                writeChar(':', buf);
+                traverse(value, buf);
+            }
+            writeChar('}', buf);
+            return;
+        }
+        if (element.isNull())
+        {
+            writeCString("null", buf);
+            return;
+        }
+    }
+
+    static const FormatSettings & formatSettings()
+    {
+        static const FormatSettings the_instance = []
+        {
+            FormatSettings settings;
+            settings.json.escape_forward_slashes = false;
+            return settings;
+        }();
+        return the_instance;
+    }
+};
+
+
+template <typename JSONParser>
+class JSONExtractArrayRawImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
+    {
+        return std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>());
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    static bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        if (!element.isArray())
+            return false;
+
+        auto array = element.getArray();
+        ColumnArray & col_res = assert_cast<ColumnArray &>(dest);
+
+        for (auto value : array)
+            JSONExtractRawImpl<JSONParser>::insertResultToColumn(col_res.getData(), value, {});
+
+        col_res.getOffsets().push_back(col_res.getOffsets().back() + array.size());
+        return true;
+    }
+};
+
+
+template <typename JSONParser>
+class JSONExtractKeysAndValuesRawImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
+    {
+        DataTypePtr string_type = std::make_unique<DataTypeString>();
+        DataTypePtr tuple_type = std::make_unique<DataTypeTuple>(DataTypes{string_type, string_type});
+        return std::make_unique<DataTypeArray>(tuple_type);
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        if (!element.isObject())
+            return false;
+
+        auto object = element.getObject();
+
+        auto & col_arr = assert_cast<ColumnArray &>(dest);
+        auto & col_tuple = assert_cast<ColumnTuple &>(col_arr.getData());
+        auto & col_key = assert_cast<ColumnString &>(col_tuple.getColumn(0));
+        auto & col_value = assert_cast<ColumnString &>(col_tuple.getColumn(1));
+
+        for (const auto & [key, value] : object)
+        {
+            col_key.insertData(key.data(), key.size());
+            JSONExtractRawImpl<JSONParser>::insertResultToColumn(col_value, value, {});
+        }
+
+        col_arr.getOffsets().push_back(col_arr.getOffsets().back() + object.size());
+        return true;
+    }
+};
+
+template <typename JSONParser>
+class JSONExtractKeysImpl
+{
+public:
+    using Element = typename JSONParser::Element;
+
+    static DataTypePtr getReturnType(const char *, const ColumnsWithTypeAndName &)
+    {
+        return std::make_unique<DataTypeArray>(std::make_shared<DataTypeString>());
+    }
+
+    static size_t getNumberOfIndexArguments(const ColumnsWithTypeAndName & arguments) { return arguments.size() - 1; }
+
+    bool insertResultToColumn(IColumn & dest, const Element & element, std::string_view)
+    {
+        if (!element.isObject())
+            return false;
+
+        auto object = element.getObject();
+
+        ColumnArray & col_res = assert_cast<ColumnArray &>(dest);
+        auto & col_key = assert_cast<ColumnString &>(col_res.getData());
+
+        for (const auto & [key, value] : object)
+        {
+            col_key.insertData(key.data(), key.size());
+        }
+
+        col_res.getOffsets().push_back(col_res.getOffsets().back() + object.size());
+        return true;
+    }
+};
+
+}
diff --git a/src/Functions/ReplaceRegexpImpl.h b/src/Functions/ReplaceRegexpImpl.h
index 88d7a40d2dd..7e3af1e62d9 100644
--- a/src/Functions/ReplaceRegexpImpl.h
+++ b/src/Functions/ReplaceRegexpImpl.h
@@ -13,6 +13,7 @@ namespace DB
 
 namespace ErrorCodes
 {
+    extern const int ARGUMENT_OUT_OF_BOUND;
     extern const int BAD_ARGUMENTS;
 }
 
@@ -28,9 +29,11 @@ struct ReplaceRegexpTraits
 /** Replace all matches of regexp 'needle' to string 'replacement'. 'needle' and 'replacement' are constants.
   * 'replacement' can contain substitutions, for example: '\2-\3-\1'
   */
-template <ReplaceRegexpTraits::Replace replace>
+template <typename Name, ReplaceRegexpTraits::Replace replace>
 struct ReplaceRegexpImpl
 {
+    static constexpr auto name = Name::name;
+
     struct Instruction
     {
         /// If not negative, perform substitution of n-th subpattern from the regexp match.
@@ -162,18 +165,21 @@ struct ReplaceRegexpImpl
         ++res_offset;
     }
 
-    static void vector(
-        const ColumnString::Chars & data,
-        const ColumnString::Offsets & offsets,
+    static void vectorConstantConstant(
+        const ColumnString::Chars & haystack_data,
+        const ColumnString::Offsets & haystack_offsets,
         const String & needle,
         const String & replacement,
         ColumnString::Chars & res_data,
         ColumnString::Offsets & res_offsets)
     {
+        if (needle.empty())
+            throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Length of the pattern argument in function {} must be greater than 0.", name);
+
         ColumnString::Offset res_offset = 0;
-        res_data.reserve(data.size());
-        size_t size = offsets.size();
-        res_offsets.resize(size);
+        res_data.reserve(haystack_data.size());
+        size_t haystack_size = haystack_offsets.size();
+        res_offsets.resize(haystack_size);
 
         re2_st::RE2::Options regexp_options;
         /// Don't write error messages to stderr.
@@ -182,39 +188,89 @@ struct ReplaceRegexpImpl
         re2_st::RE2 searcher(needle, regexp_options);
 
         if (!searcher.ok())
-            throw Exception(
-                ErrorCodes::BAD_ARGUMENTS,
-                "The pattern argument is not a valid re2 pattern: {}",
-                searcher.error());
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "The pattern argument is not a valid re2 pattern: {}", searcher.error());
 
         int num_captures = std::min(searcher.NumberOfCapturingGroups() + 1, max_captures);
 
         Instructions instructions = createInstructions(replacement, num_captures);
 
         /// Cannot perform search for whole columns. Will process each string separately.
-        for (size_t i = 0; i < size; ++i)
+        for (size_t i = 0; i < haystack_size; ++i)
         {
-            size_t from = i > 0 ? offsets[i - 1] : 0;
-            const char * haystack_data = reinterpret_cast<const char *>(data.data() + from);
-            const size_t haystack_length = static_cast<unsigned>(offsets[i] - from - 1);
+            size_t from = i > 0 ? haystack_offsets[i - 1] : 0;
 
-            processString(haystack_data, haystack_length, res_data, res_offset, searcher, num_captures, instructions);
+            const char * hs_data = reinterpret_cast<const char *>(haystack_data.data() + from);
+            const size_t hs_length = static_cast<unsigned>(haystack_offsets[i] - from - 1);
+
+            processString(hs_data, hs_length, res_data, res_offset, searcher, num_captures, instructions);
             res_offsets[i] = res_offset;
         }
     }
 
-    static void vectorFixed(
-        const ColumnString::Chars & data,
-        size_t n,
-        const String & needle,
+    static void vectorVectorConstant(
+        const ColumnString::Chars & haystack_data,
+        const ColumnString::Offsets & haystack_offsets,
+        const ColumnString::Chars & needle_data,
+        const ColumnString::Offsets & needle_offsets,
         const String & replacement,
         ColumnString::Chars & res_data,
         ColumnString::Offsets & res_offsets)
     {
+        assert(haystack_offsets.size() == needle_offsets.size());
+
         ColumnString::Offset res_offset = 0;
-        size_t size = data.size() / n;
-        res_data.reserve(data.size());
-        res_offsets.resize(size);
+        res_data.reserve(haystack_data.size());
+        size_t haystack_size = haystack_offsets.size();
+        res_offsets.resize(haystack_size);
+
+        re2_st::RE2::Options regexp_options;
+        /// Don't write error messages to stderr.
+        regexp_options.set_log_errors(false);
+
+        /// Cannot perform search for whole columns. Will process each string separately.
+        for (size_t i = 0; i < haystack_size; ++i)
+        {
+            size_t hs_from = i > 0 ? haystack_offsets[i - 1] : 0;
+            const char * hs_data = reinterpret_cast<const char *>(haystack_data.data() + hs_from);
+            const size_t hs_length = static_cast<unsigned>(haystack_offsets[i] - hs_from - 1);
+
+            size_t ndl_from = i > 0 ? needle_offsets[i - 1] : 0;
+            const char * ndl_data = reinterpret_cast<const char *>(needle_data.data() + ndl_from);
+            const size_t ndl_length = static_cast<unsigned>(needle_offsets[i] - ndl_from - 1);
+            std::string_view needle(ndl_data, ndl_length);
+
+            if (needle.empty())
+                throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Length of the pattern argument in function {} must be greater than 0.", name);
+
+            re2_st::RE2 searcher(needle, regexp_options);
+            if (!searcher.ok())
+                throw Exception(ErrorCodes::BAD_ARGUMENTS, "The pattern argument is not a valid re2 pattern: {}", searcher.error());
+            int num_captures = std::min(searcher.NumberOfCapturingGroups() + 1, max_captures);
+            Instructions instructions = createInstructions(replacement, num_captures);
+
+            processString(hs_data, hs_length, res_data, res_offset, searcher, num_captures, instructions);
+            res_offsets[i] = res_offset;
+        }
+    }
+
+    static void vectorConstantVector(
+        const ColumnString::Chars & haystack_data,
+        const ColumnString::Offsets & haystack_offsets,
+        const String & needle,
+        const ColumnString::Chars & replacement_data,
+        const ColumnString::Offsets & replacement_offsets,
+        ColumnString::Chars & res_data,
+        ColumnString::Offsets & res_offsets)
+    {
+        assert(haystack_offsets.size() == replacement_offsets.size());
+
+        if (needle.empty())
+            throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Length of the pattern argument in function {} must be greater than 0.", name);
+
+        ColumnString::Offset res_offset = 0;
+        res_data.reserve(haystack_data.size());
+        size_t haystack_size = haystack_offsets.size();
+        res_offsets.resize(haystack_size);
 
         re2_st::RE2::Options regexp_options;
         /// Don't write error messages to stderr.
@@ -223,22 +279,116 @@ struct ReplaceRegexpImpl
         re2_st::RE2 searcher(needle, regexp_options);
 
         if (!searcher.ok())
-            throw Exception(
-                ErrorCodes::BAD_ARGUMENTS,
-                "The pattern argument is not a valid re2 pattern: {}",
-                searcher.error());
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "The pattern argument is not a valid re2 pattern: {}", searcher.error());
+
+        int num_captures = std::min(searcher.NumberOfCapturingGroups() + 1, max_captures);
+
+        /// Cannot perform search for whole columns. Will process each string separately.
+        for (size_t i = 0; i < haystack_size; ++i)
+        {
+            size_t hs_from = i > 0 ? haystack_offsets[i - 1] : 0;
+            const char * hs_data = reinterpret_cast<const char *>(haystack_data.data() + hs_from);
+            const size_t hs_length = static_cast<unsigned>(haystack_offsets[i] - hs_from - 1);
+
+            size_t repl_from = i > 0 ? replacement_offsets[i - 1] : 0;
+            const char * repl_data = reinterpret_cast<const char *>(replacement_data.data() + repl_from);
+            const size_t repl_length = static_cast<unsigned>(replacement_offsets[i] - repl_from - 1);
+
+            Instructions instructions = createInstructions(std::string_view(repl_data, repl_length), num_captures);
+
+            processString(hs_data, hs_length, res_data, res_offset, searcher, num_captures, instructions);
+            res_offsets[i] = res_offset;
+        }
+    }
+
+    static void vectorVectorVector(
+        const ColumnString::Chars & haystack_data,
+        const ColumnString::Offsets & haystack_offsets,
+        const ColumnString::Chars & needle_data,
+        const ColumnString::Offsets & needle_offsets,
+        const ColumnString::Chars & replacement_data,
+        const ColumnString::Offsets & replacement_offsets,
+        ColumnString::Chars & res_data,
+        ColumnString::Offsets & res_offsets)
+    {
+        assert(haystack_offsets.size() == needle_offsets.size());
+        assert(needle_offsets.size() == replacement_offsets.size());
+
+        ColumnString::Offset res_offset = 0;
+        res_data.reserve(haystack_data.size());
+        size_t haystack_size = haystack_offsets.size();
+        res_offsets.resize(haystack_size);
+
+        re2_st::RE2::Options regexp_options;
+        /// Don't write error messages to stderr.
+        regexp_options.set_log_errors(false);
+
+        /// Cannot perform search for whole columns. Will process each string separately.
+        for (size_t i = 0; i < haystack_size; ++i)
+        {
+            size_t hs_from = i > 0 ? haystack_offsets[i - 1] : 0;
+            const char * hs_data = reinterpret_cast<const char *>(haystack_data.data() + hs_from);
+            const size_t hs_length = static_cast<unsigned>(haystack_offsets[i] - hs_from - 1);
+
+            size_t ndl_from = i > 0 ? needle_offsets[i - 1] : 0;
+            const char * ndl_data = reinterpret_cast<const char *>(needle_data.data() + ndl_from);
+            const size_t ndl_length = static_cast<unsigned>(needle_offsets[i] - ndl_from - 1);
+            std::string_view needle(ndl_data, ndl_length);
+
+            if (needle.empty())
+                throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Length of the pattern argument in function {} must be greater than 0.", name);
+
+            size_t repl_from = i > 0 ? replacement_offsets[i - 1] : 0;
+            const char * repl_data = reinterpret_cast<const char *>(replacement_data.data() + repl_from);
+            const size_t repl_length = static_cast<unsigned>(replacement_offsets[i] - repl_from - 1);
+
+            re2_st::RE2 searcher(needle, regexp_options);
+            if (!searcher.ok())
+                throw Exception(ErrorCodes::BAD_ARGUMENTS, "The pattern argument is not a valid re2 pattern: {}", searcher.error());
+            int num_captures = std::min(searcher.NumberOfCapturingGroups() + 1, max_captures);
+            Instructions instructions = createInstructions(std::string_view(repl_data, repl_length), num_captures);
+
+            processString(hs_data, hs_length, res_data, res_offset, searcher, num_captures, instructions);
+            res_offsets[i] = res_offset;
+        }
+    }
+
+    static void vectorFixedConstantConstant(
+        const ColumnString::Chars & haystack_data,
+        size_t n,
+        const String & needle,
+        const String & replacement,
+        ColumnString::Chars & res_data,
+        ColumnString::Offsets & res_offsets)
+    {
+        if (needle.empty())
+            throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Length of the pattern argument in function {} must be greater than 0.", name);
+
+        ColumnString::Offset res_offset = 0;
+        size_t haystack_size = haystack_data.size() / n;
+        res_data.reserve(haystack_data.size());
+        res_offsets.resize(haystack_size);
+
+        re2_st::RE2::Options regexp_options;
+        /// Don't write error messages to stderr.
+        regexp_options.set_log_errors(false);
+
+        re2_st::RE2 searcher(needle, regexp_options);
+
+        if (!searcher.ok())
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "The pattern argument is not a valid re2 pattern: {}", searcher.error());
 
         int num_captures = std::min(searcher.NumberOfCapturingGroups() + 1, max_captures);
 
         Instructions instructions = createInstructions(replacement, num_captures);
 
-        for (size_t i = 0; i < size; ++i)
+        for (size_t i = 0; i < haystack_size; ++i)
         {
             size_t from = i * n;
-            const char * haystack_data = reinterpret_cast<const char *>(data.data() + from);
-            const size_t haystack_length = n;
+            const char * hs_data = reinterpret_cast<const char *>(haystack_data.data() + from);
+            const size_t hs_length = n;
 
-            processString(haystack_data, haystack_length, res_data, res_offset, searcher, num_captures, instructions);
+            processString(hs_data, hs_length, res_data, res_offset, searcher, num_captures, instructions);
             res_offsets[i] = res_offset;
         }
     }
diff --git a/src/Functions/ReplaceStringImpl.h b/src/Functions/ReplaceStringImpl.h
index 1a9ec49c58c..cd2dc1d3636 100644
--- a/src/Functions/ReplaceStringImpl.h
+++ b/src/Functions/ReplaceStringImpl.h
@@ -8,6 +8,11 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int ARGUMENT_OUT_OF_BOUND;
+}
+
 struct ReplaceStringTraits
 {
     enum class Replace
@@ -16,27 +21,33 @@ struct ReplaceStringTraits
         All
     };
 };
-/** Replace one or all occurencies of substring 'needle' to 'replacement'. 'needle' and 'replacement' are constants.
+
+/** Replace one or all occurencies of substring 'needle' to 'replacement'.
   */
-template <ReplaceStringTraits::Replace replace>
+template <typename Name, ReplaceStringTraits::Replace replace>
 struct ReplaceStringImpl
 {
-    static void vector(
-        const ColumnString::Chars & data,
-        const ColumnString::Offsets & offsets,
-        const std::string & needle,
-        const std::string & replacement,
+    static constexpr auto name = Name::name;
+
+    static void vectorConstantConstant(
+        const ColumnString::Chars & haystack_data,
+        const ColumnString::Offsets & haystack_offsets,
+        const String & needle,
+        const String & replacement,
         ColumnString::Chars & res_data,
         ColumnString::Offsets & res_offsets)
     {
-        const UInt8 * begin = data.data();
+        if (needle.empty())
+            throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Length of the pattern argument in function {} must be greater than 0.", name);
+
+        const UInt8 * const begin = haystack_data.data();
+        const UInt8 * const end = haystack_data.data() + haystack_data.size();
         const UInt8 * pos = begin;
-        const UInt8 * end = pos + data.size();
 
         ColumnString::Offset res_offset = 0;
-        res_data.reserve(data.size());
-        size_t size = offsets.size();
-        res_offsets.resize(size);
+        res_data.reserve(haystack_data.size());
+        const size_t haystack_size = haystack_offsets.size();
+        res_offsets.resize(haystack_size);
 
         /// The current index in the array of strings.
         size_t i = 0;
@@ -53,22 +64,22 @@ struct ReplaceStringImpl
             memcpy(&res_data[res_offset], pos, match - pos);
 
             /// Determine which index it belongs to.
-            while (i < offsets.size() && begin + offsets[i] <= match)
+            while (i < haystack_offsets.size() && begin + haystack_offsets[i] <= match)
             {
-                res_offsets[i] = res_offset + ((begin + offsets[i]) - pos);
+                res_offsets[i] = res_offset + ((begin + haystack_offsets[i]) - pos);
                 ++i;
             }
             res_offset += (match - pos);
 
             /// If you have reached the end, it's time to stop
-            if (i == offsets.size())
+            if (i == haystack_offsets.size())
                 break;
 
             /// Is it true that this string no longer needs to perform transformations.
             bool can_finish_current_string = false;
 
             /// We check that the entry does not go through the boundaries of strings.
-            if (match + needle.size() < begin + offsets[i])
+            if (match + needle.size() < begin + haystack_offsets[i])
             {
                 res_data.resize(res_data.size() + replacement.size());
                 memcpy(&res_data[res_offset], replacement.data(), replacement.size());
@@ -85,34 +96,268 @@ struct ReplaceStringImpl
 
             if (can_finish_current_string)
             {
-                res_data.resize(res_data.size() + (begin + offsets[i] - pos));
-                memcpy(&res_data[res_offset], pos, (begin + offsets[i] - pos));
-                res_offset += (begin + offsets[i] - pos);
+                res_data.resize(res_data.size() + (begin + haystack_offsets[i] - pos));
+                memcpy(&res_data[res_offset], pos, (begin + haystack_offsets[i] - pos));
+                res_offset += (begin + haystack_offsets[i] - pos);
                 res_offsets[i] = res_offset;
-                pos = begin + offsets[i];
+                pos = begin + haystack_offsets[i];
                 ++i;
             }
         }
     }
 
-    /// Note: this function converts fixed-length strings to variable-length strings
-    ///       and each variable-length string should ends with zero byte.
-    static void vectorFixed(
-        const ColumnString::Chars & data,
-        size_t n,
-        const std::string & needle,
-        const std::string & replacement,
+    template <typename CharT>
+    requires (sizeof(CharT) == 1)
+    static void copyToOutput(
+        const CharT * what_start, size_t what_size,
+        ColumnString::Chars & output, ColumnString::Offset & output_offset)
+    {
+        output.resize(output.size() + what_size);
+        memcpy(&output[output_offset], what_start, what_size);
+        output_offset += what_size;
+    }
+
+    static void vectorVectorConstant(
+        const ColumnString::Chars & haystack_data,
+        const ColumnString::Offsets & haystack_offsets,
+        const ColumnString::Chars & needle_data,
+        const ColumnString::Offsets & needle_offsets,
+        const String & replacement,
         ColumnString::Chars & res_data,
         ColumnString::Offsets & res_offsets)
     {
-        const UInt8 * begin = data.data();
-        const UInt8 * pos = begin;
-        const UInt8 * end = pos + data.size();
+        chassert(haystack_offsets.size() == needle_offsets.size());
+
+        const size_t haystack_size = haystack_offsets.size();
+
+        res_data.reserve(haystack_data.size());
+        res_offsets.resize(haystack_size);
 
         ColumnString::Offset res_offset = 0;
-        size_t count = data.size() / n;
-        res_data.reserve(data.size());
-        res_offsets.resize(count);
+
+        size_t prev_haystack_offset = 0;
+        size_t prev_needle_offset = 0;
+
+        for (size_t i = 0; i < haystack_size; ++i)
+        {
+            const auto * const cur_haystack_data = &haystack_data[prev_haystack_offset];
+            const size_t cur_haystack_length = haystack_offsets[i] - prev_haystack_offset - 1;
+
+            const auto * const cur_needle_data = &needle_data[prev_needle_offset];
+            const size_t cur_needle_length = needle_offsets[i] - prev_needle_offset - 1;
+
+            if (cur_needle_length == 0)
+                throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Length of the pattern argument in function {} must be greater than 0.", name);
+
+            /// Using "slow" "stdlib searcher instead of Volnitsky because there is a different pattern in each row
+            StdLibASCIIStringSearcher</*CaseInsensitive*/ false> searcher(cur_needle_data, cur_needle_length);
+
+            const auto * last_match = static_cast<UInt8 *>(nullptr);
+            const auto * start_pos = cur_haystack_data;
+            const auto * const cur_haystack_end = cur_haystack_data + cur_haystack_length;
+
+            while (start_pos < cur_haystack_end)
+            {
+                if (const auto * const match = searcher.search(start_pos, cur_haystack_end); match != cur_haystack_end)
+                {
+                    /// Copy prefix before match
+                    copyToOutput(start_pos, match - start_pos, res_data, res_offset);
+
+                    /// Insert replacement for match
+                    copyToOutput(replacement.data(), replacement.size(), res_data, res_offset);
+
+                    last_match = match;
+                    start_pos = match + cur_needle_length;
+
+                    if constexpr (replace == ReplaceStringTraits::Replace::First)
+                        break;
+                }
+                else
+                    break;
+            }
+
+            /// Copy suffix after last match
+            size_t bytes = (last_match == nullptr) ? (cur_haystack_end - cur_haystack_data + 1)
+                                                   : (cur_haystack_end - last_match - cur_needle_length + 1);
+            copyToOutput(start_pos, bytes, res_data, res_offset);
+
+            res_offsets[i] = res_offset;
+
+            prev_haystack_offset = haystack_offsets[i];
+            prev_needle_offset = needle_offsets[i];
+        }
+    }
+
+    static void vectorConstantVector(
+        const ColumnString::Chars & haystack_data,
+        const ColumnString::Offsets & haystack_offsets,
+        const String & needle,
+        const ColumnString::Chars & replacement_data,
+        const ColumnString::Offsets & replacement_offsets,
+        ColumnString::Chars & res_data,
+        ColumnString::Offsets & res_offsets)
+    {
+        chassert(haystack_offsets.size() == replacement_offsets.size());
+
+        if (needle.empty())
+            throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Length of the pattern argument in function {} must be greater than 0.", name);
+
+        const size_t haystack_size = haystack_offsets.size();
+
+        res_data.reserve(haystack_data.size());
+        res_offsets.resize(haystack_size);
+
+        ColumnString::Offset res_offset = 0;
+
+        size_t prev_haystack_offset = 0;
+        size_t prev_replacement_offset = 0;
+
+        for (size_t i = 0; i < haystack_size; ++i)
+        {
+            const auto * const cur_haystack_data = &haystack_data[prev_haystack_offset];
+            const size_t cur_haystack_length = haystack_offsets[i] - prev_haystack_offset - 1;
+
+            const auto * const cur_replacement_data = &replacement_data[prev_replacement_offset];
+            const size_t cur_replacement_length = replacement_offsets[i] - prev_replacement_offset - 1;
+
+            /// Using "slow" "stdlib searcher instead of Volnitsky just to keep things simple
+            StdLibASCIIStringSearcher</*CaseInsensitive*/ false> searcher(needle.data(), needle.size());
+
+            const auto * last_match = static_cast<UInt8 *>(nullptr);
+            const auto * start_pos = cur_haystack_data;
+            const auto * const cur_haystack_end = cur_haystack_data + cur_haystack_length;
+
+            while (start_pos < cur_haystack_end)
+            {
+                if (const auto * const match = searcher.search(start_pos, cur_haystack_end); match != cur_haystack_end)
+                {
+                    /// Copy prefix before match
+                    copyToOutput(start_pos, match - start_pos, res_data, res_offset);
+
+                    /// Insert replacement for match
+                    copyToOutput(cur_replacement_data, cur_replacement_length, res_data, res_offset);
+
+                    last_match = match;
+                    start_pos = match + needle.size();
+
+                    if constexpr (replace == ReplaceStringTraits::Replace::First)
+                        break;
+                }
+                else
+                    break;
+            }
+
+            /// Copy suffix after last match
+            size_t bytes = (last_match == nullptr) ? (cur_haystack_end - cur_haystack_data + 1)
+                                                   : (cur_haystack_end - last_match - needle.size() + 1);
+            copyToOutput(start_pos, bytes, res_data, res_offset);
+
+            res_offsets[i] = res_offset;
+
+            prev_haystack_offset = haystack_offsets[i];
+            prev_replacement_offset = replacement_offsets[i];
+        }
+    }
+
+    static void vectorVectorVector(
+        const ColumnString::Chars & haystack_data,
+        const ColumnString::Offsets & haystack_offsets,
+        const ColumnString::Chars & needle_data,
+        const ColumnString::Offsets & needle_offsets,
+        const ColumnString::Chars & replacement_data,
+        const ColumnString::Offsets & replacement_offsets,
+        ColumnString::Chars & res_data,
+        ColumnString::Offsets & res_offsets)
+    {
+        chassert(haystack_offsets.size() == needle_offsets.size());
+        chassert(needle_offsets.size() == replacement_offsets.size());
+
+        const size_t haystack_size = haystack_offsets.size();
+
+        res_data.reserve(haystack_data.size());
+        res_offsets.resize(haystack_size);
+
+        ColumnString::Offset res_offset = 0;
+
+        size_t prev_haystack_offset = 0;
+        size_t prev_needle_offset = 0;
+        size_t prev_replacement_offset = 0;
+
+        for (size_t i = 0; i < haystack_size; ++i)
+        {
+            const auto * const cur_haystack_data = &haystack_data[prev_haystack_offset];
+            const size_t cur_haystack_length = haystack_offsets[i] - prev_haystack_offset - 1;
+
+            const auto * const cur_needle_data = &needle_data[prev_needle_offset];
+            const size_t cur_needle_length = needle_offsets[i] - prev_needle_offset - 1;
+
+            const auto * const cur_replacement_data = &replacement_data[prev_replacement_offset];
+            const size_t cur_replacement_length = replacement_offsets[i] - prev_replacement_offset - 1;
+
+            if (cur_needle_length == 0)
+                throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Length of the pattern argument in function {} must be greater than 0.", name);
+
+            /// Using "slow" "stdlib searcher instead of Volnitsky because there is a different pattern in each row
+            StdLibASCIIStringSearcher</*CaseInsensitive*/ false> searcher(cur_needle_data, cur_needle_length);
+
+            const auto * last_match = static_cast<UInt8 *>(nullptr);
+            const auto * start_pos = cur_haystack_data;
+            const auto * const cur_haystack_end = cur_haystack_data + cur_haystack_length;
+
+            while (start_pos < cur_haystack_end)
+            {
+                if (const auto * const match = searcher.search(start_pos, cur_haystack_end); match != cur_haystack_end)
+                {
+                    /// Copy prefix before match
+                    copyToOutput(start_pos, match - start_pos, res_data, res_offset);
+
+                    /// Insert replacement for match
+                    copyToOutput(cur_replacement_data, cur_replacement_length, res_data, res_offset);
+
+                    last_match = match;
+                    start_pos = match + cur_needle_length;
+
+                    if constexpr (replace == ReplaceStringTraits::Replace::First)
+                        break;
+                }
+                else
+                    break;
+            }
+
+            /// Copy suffix after last match
+            size_t bytes = (last_match == nullptr) ? (cur_haystack_end - cur_haystack_data + 1)
+                                                   : (cur_haystack_end - last_match - cur_needle_length + 1);
+            copyToOutput(start_pos, bytes, res_data, res_offset);
+
+            res_offsets[i] = res_offset;
+
+            prev_haystack_offset = haystack_offsets[i];
+            prev_needle_offset = needle_offsets[i];
+            prev_replacement_offset = replacement_offsets[i];
+        }
+    }
+
+    /// Note: this function converts fixed-length strings to variable-length strings
+    ///       and each variable-length string should ends with zero byte.
+    static void vectorFixedConstantConstant(
+        const ColumnString::Chars & haystack_data,
+        size_t n,
+        const String & needle,
+        const String & replacement,
+        ColumnString::Chars & res_data,
+        ColumnString::Offsets & res_offsets)
+    {
+        if (needle.empty())
+            throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Length of the pattern argument in function {} must be greater than 0.", name);
+
+        const UInt8 * const begin = haystack_data.data();
+        const UInt8 * const end = haystack_data.data() + haystack_data.size();
+        const UInt8 * pos = begin;
+
+        ColumnString::Offset res_offset = 0;
+        size_t haystack_size = haystack_data.size() / n;
+        res_data.reserve(haystack_data.size());
+        res_offsets.resize(haystack_size);
 
         /// The current index in the string array.
         size_t i = 0;
@@ -139,13 +384,13 @@ struct ReplaceStringImpl
 
             /// Copy skipped strings without any changes but
             /// add zero byte to the end of each string.
-            while (i < count && begin + n * (i + 1) <= match)
+            while (i < haystack_size && begin + n * (i + 1) <= match)
             {
                 COPY_REST_OF_CURRENT_STRING();
             }
 
             /// If you have reached the end, it's time to stop
-            if (i == count)
+            if (i == haystack_size)
                 break;
 
             /// Copy unchanged part of current string.
diff --git a/src/Functions/formatDateTime.cpp b/src/Functions/formatDateTime.cpp
index dd96a44c17b..d6275a54c75 100644
--- a/src/Functions/formatDateTime.cpp
+++ b/src/Functions/formatDateTime.cpp
@@ -17,6 +17,7 @@
 
 #include <IO/WriteHelpers.h>
 
+#include <Common/Concepts.h>
 #include <Common/DateLUTImpl.h>
 #include <base/find_symbols.h>
 #include <Core/DecimalFunctions.h>
@@ -38,22 +39,19 @@ namespace ErrorCodes
 
 namespace
 {
+using Pos = const char *;
 
-struct FormatDateTimeTraits
+enum class SupportInteger
 {
-    enum class SupportInteger
-    {
-        Yes,
-        No
-    };
-
-    enum class FormatSyntax
-    {
-        MySQL,
-        Joda
-    };
+    Yes,
+    No
 };
 
+enum class FormatSyntax
+{
+    MySQL,
+    Joda
+};
 
 template <typename DataType> struct InstructionValueTypeMap {};
 template <> struct InstructionValueTypeMap<DataTypeInt8>       { using InstructionValueType = UInt32; };
@@ -85,11 +83,9 @@ constexpr std::string_view weekdaysFull[] = {"Sunday", "Monday", "Tuesday", "Wed
 
 constexpr std::string_view weekdaysShort[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
 
-constexpr std::string_view monthsFull[]
-    = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
+constexpr std::string_view monthsFull[] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
 
-constexpr std::string_view monthsShort[]
-    = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+constexpr std::string_view monthsShort[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 
 /** formatDateTime(time, 'format')
   * Performs formatting of time, according to provided format.
@@ -115,13 +111,13 @@ constexpr std::string_view monthsShort[]
   *
   * Performance on Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz:
   *
-  * WITH formatDateTime(now() + number, '%H:%M:%S') AS x SELECT count() FROM system.numbers WHERE NOT ignore(x);
+  * WITH formatDateTime(now() + number, '%H:%i:%S') AS x SELECT count() FROM system.numbers WHERE NOT ignore(x);
   * - 97 million rows per second per core;
   *
   * WITH formatDateTime(toDateTime('2018-01-01 00:00:00') + number, '%F %T') AS x SELECT count() FROM system.numbers WHERE NOT ignore(x)
   * - 71 million rows per second per core;
   *
-  * select count() from (select formatDateTime(t, '%m/%d/%Y %H:%M:%S') from (select toDateTime('2018-01-01 00:00:00')+number as t from numbers(100000000)));
+  * select count() from (select formatDateTime(t, '%m/%d/%Y %H:%i:%S') from (select toDateTime('2018-01-01 00:00:00')+number as t from numbers(100000000)));
   * - 53 million rows per second per core;
   *
   * select count() from (select formatDateTime(t, 'Hello %Y World') from (select toDateTime('2018-01-01 00:00:00')+number as t from numbers(100000000)));
@@ -129,7 +125,7 @@ constexpr std::string_view monthsShort[]
   *
   * PS. We can make this function to return FixedString. Currently it returns String.
   */
-template <typename Name, FormatDateTimeTraits::SupportInteger support_integer, FormatDateTimeTraits::FormatSyntax format_syntax>
+template <typename Name, SupportInteger support_integer, FormatSyntax format_syntax>
 class FunctionFormatDateTimeImpl : public IFunction
 {
 private:
@@ -152,26 +148,34 @@ private:
     class Instruction
     {
     public:
-        /// Using std::function will cause performance degradation in MySQL format by 0.45x.
-        /// But std::function is required for Joda format to capture extra variables.
-        /// This is the reason why we use raw function pointer in MySQL format and std::function
-        /// in Joda format.
-        using Func = std::conditional_t<
-            format_syntax == FormatDateTimeTraits::FormatSyntax::MySQL,
-            size_t (*)(char *, Time, UInt64, UInt32, const DateLUTImpl &),
-            std::function<size_t(char *, Time, UInt64, UInt32, const DateLUTImpl &)>>;
+        /// Joda format generally requires capturing extra variables (i.e. holding state) which is more convenient with
+        /// std::function and std::bind. Unfortunately, std::function causes a performance degradation by 0.45x compared to raw function
+        /// pointers. For MySQL format, we generally prefer raw function pointers. Because of the special case that not all formatters are
+        /// fixed-width formatters (see mysqlLiteral instruction), we still need to be able to store state. For that reason, we use member
+        /// function pointers instead of static function pointers.
+        using FuncMysql = size_t (Instruction<Time>::*)(char *, Time, UInt64, UInt32, const DateLUTImpl &);
+        FuncMysql func_mysql = nullptr;
 
-        Func func;
+        using FuncJoda = std::function<size_t(char *, Time, UInt64, UInt32, const DateLUTImpl &)>;
+        FuncJoda func_joda = nullptr;
 
         /// extra_shift is only used in MySQL format syntax. It is always 0 in Joda format syntax.
         size_t extra_shift = 0;
 
-        /// Instruction for appending date/time related number in specified format.
-        explicit Instruction(Func && func_) : func(std::move(func_)) {}
+        // Holds literal characters that will be copied into the output. Used by the mysqlLiteral instruction.
+        String literal;
+
+        Instruction() = default;
+
+        void setMysqlFunc(FuncMysql && func) { func_mysql = std::move(func); }
+        void setJodaFunc(FuncJoda && func) { func_joda = std::move(func); }
+        void setLiteral(std::string_view literal_) { literal = literal_; }
 
         void perform(char *& dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
         {
-            auto shift = func(dest, source, fractional_second, scale, timezone);
+            size_t shift = func_mysql
+                           ? std::invoke(func_mysql, this, dest, source, fractional_second, scale, timezone)
+                           : std::invoke(func_joda, dest, source, fractional_second, scale, timezone);
             dest += shift + extra_shift;
         }
 
@@ -257,21 +261,30 @@ private:
             return pos;
         }
     public:
-        static size_t mysqlNoop(char *, Time, UInt64, UInt32, const DateLUTImpl &) { return 0; }
+        size_t mysqlNoop(char *, Time, UInt64, UInt32, const DateLUTImpl &)
+        {
+            return 0;
+        }
 
-        static size_t mysqlCentury(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlLiteral(char * dest, Time, UInt64, UInt32, const DateLUTImpl &)
+        {
+            memcpy(dest, literal.data(), literal.size());
+            return literal.size();
+        }
+
+        size_t mysqlCentury(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             auto year = ToYearImpl::execute(source, timezone);
             auto century = year / 100;
             return writeNumber2(dest, century);
         }
 
-        static size_t mysqlDayOfMonth(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlDayOfMonth(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber2(dest, ToDayOfMonthImpl::execute(source, timezone));
         }
 
-        static size_t mysqlAmericanDate(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlAmericanDate(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             writeNumber2(dest, ToMonthImpl::execute(source, timezone));
             writeNumber2(dest + 3, ToDayOfMonthImpl::execute(source, timezone));
@@ -279,7 +292,7 @@ private:
             return 8;
         }
 
-        static size_t mysqlDayOfMonthSpacePadded(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlDayOfMonthSpacePadded(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             auto day = ToDayOfMonthImpl::execute(source, timezone);
             if (day < 10)
@@ -289,7 +302,7 @@ private:
             return 2;
         }
 
-        static size_t mysqlISO8601Date(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone) // NOLINT
+        size_t mysqlISO8601Date(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             writeNumber4(dest, ToYearImpl::execute(source, timezone));
             writeNumber2(dest + 5, ToMonthImpl::execute(source, timezone));
@@ -297,12 +310,12 @@ private:
             return 10;
         }
 
-        static size_t mysqlDayOfYear(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlDayOfYear(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber3(dest, ToDayOfYearImpl::execute(source, timezone));
         }
 
-        static size_t mysqlMonth(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlMonth(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber2(dest, ToMonthImpl::execute(source, timezone));
         }
@@ -315,17 +328,17 @@ private:
             return str_view.size();
         }
 
-        static size_t mysqlMonthOfYearTextShort(char * dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
+        size_t mysqlMonthOfYearTextShort(char * dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
         {
             return monthOfYearText(dest, source, true, fractional_second, scale, timezone);
         }
 
-        static size_t mysqlMonthOfYearTextLong(char * dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
+        size_t mysqlMonthOfYearTextLong(char * dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
         {
             return monthOfYearText(dest, source, false, fractional_second, scale, timezone);
         }
 
-        static size_t mysqlDayOfWeek(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlDayOfWeek(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             *dest = '0' + ToDayOfWeekImpl::execute(source, 0, timezone);
             return 1;
@@ -342,65 +355,65 @@ private:
             return str_view.size();
         }
 
-        static size_t mysqlDayOfWeekTextShort(char * dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
+        size_t mysqlDayOfWeekTextShort(char * dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
         {
             return dayOfWeekText(dest, source, true, fractional_second, scale, timezone);
         }
 
-        static size_t mysqlDayOfWeekTextLong(char * dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
+        size_t mysqlDayOfWeekTextLong(char * dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
         {
             return dayOfWeekText(dest, source, false, fractional_second, scale, timezone);
         }
 
-        static size_t mysqlDayOfWeek0To6(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlDayOfWeek0To6(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             auto day = ToDayOfWeekImpl::execute(source, 0, timezone);
             *dest = '0' + (day == 7 ? 0 : day);
             return 1;
         }
 
-        static size_t mysqlISO8601Week(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone) // NOLINT
+        size_t mysqlISO8601Week(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber2(dest, ToISOWeekImpl::execute(source, timezone));
         }
 
-        static size_t mysqlISO8601Year2(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone) // NOLINT
+        size_t mysqlISO8601Year2(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber2(dest, ToISOYearImpl::execute(source, timezone) % 100);
         }
 
-        static size_t mysqlISO8601Year4(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone) // NOLINT
+        size_t mysqlISO8601Year4(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber4(dest, ToISOYearImpl::execute(source, timezone));
         }
 
-        static size_t mysqlYear2(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlYear2(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber2(dest, ToYearImpl::execute(source, timezone) % 100);
         }
 
-        static size_t mysqlYear4(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlYear4(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber4(dest, ToYearImpl::execute(source, timezone));
         }
 
-        static size_t mysqlHour24(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlHour24(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber2(dest, ToHourImpl::execute(source, timezone));
         }
 
-        static size_t mysqlHour12(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlHour12(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             auto x = ToHourImpl::execute(source, timezone);
             return writeNumber2(dest, x == 0 ? 12 : (x > 12 ? x - 12 : x));
         }
 
-        static size_t mysqlMinute(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlMinute(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber2(dest, ToMinuteImpl::execute(source, timezone));
         }
 
-        static size_t mysqlAMPM(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone) // NOLINT
+        static size_t AMPM(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone) // NOLINT
         {
             auto hour = ToHourImpl::execute(source, timezone);
             dest[0] = hour >= 12 ? 'P' : 'A';
@@ -408,14 +421,19 @@ private:
             return 2;
         }
 
-        static size_t mysqlHHMM24(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlAMPM(char * dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
+        {
+            return AMPM(dest, source, fractional_second, scale, timezone);
+        }
+
+        size_t mysqlHHMM24(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             writeNumber2(dest, ToHourImpl::execute(source, timezone));
             writeNumber2(dest + 3, ToMinuteImpl::execute(source, timezone));
             return 5;
         }
 
-        static size_t mysqlHHMM12(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlHHMM12(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             auto hour = ToHourImpl::execute(source, timezone);
             writeNumber2(dest, hour == 0 ? 12 : (hour > 12 ? hour - 12 : hour));
@@ -425,13 +443,12 @@ private:
             return 8;
         }
 
-        static size_t mysqlSecond(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlSecond(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             return writeNumber2(dest, ToSecondImpl::execute(source, timezone));
         }
 
-        static size_t
-        mysqlFractionalSecond(char * dest, Time /*source*/, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & /*timezone*/)
+        size_t mysqlFractionalSecond(char * dest, Time /*source*/, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & /*timezone*/)
         {
             if (scale == 0)
                 scale = 1;
@@ -444,7 +461,7 @@ private:
             return scale;
         }
 
-        static size_t mysqlISO8601Time(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone) // NOLINT
+        size_t mysqlISO8601Time(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone) // NOLINT
         {
             writeNumber2(dest, ToHourImpl::execute(source, timezone));
             writeNumber2(dest + 3, ToMinuteImpl::execute(source, timezone));
@@ -452,7 +469,7 @@ private:
             return 8;
         }
 
-        static size_t mysqlTimezoneOffset(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlTimezoneOffset(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             auto offset = TimezoneOffsetImpl::execute(source, timezone);
             if (offset < 0)
@@ -466,7 +483,7 @@ private:
             return 5;
         }
 
-        static size_t mysqlQuarter(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
+        size_t mysqlQuarter(char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
         {
             *dest = '0' + ToQuarterImpl::execute(source, timezone);
             return 1;
@@ -575,7 +592,7 @@ private:
         static size_t jodaHalfDayOfDay(
             size_t /*min_represent_digits*/, char * dest, Time source, UInt64 fractional_second, UInt32 scale, const DateLUTImpl & timezone)
         {
-            return mysqlAMPM(dest, source, fractional_second, scale, timezone);
+            return AMPM(dest, source, fractional_second, scale, timezone);
         }
 
         static size_t jodaHourOfHalfDay(size_t min_represent_digits, char * dest, Time source, UInt64, UInt32, const DateLUTImpl & timezone)
@@ -651,10 +668,58 @@ private:
         }
     };
 
+    [[noreturn]] static void throwLastCharacterIsPercentException()
+    {
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "'%' must not be the last character in the format string, use '%%' instead");
+    }
+
+    static bool containsOnlyFixedWidthMySQLFormatters(std::string_view format, bool mysql_M_is_month_name)
+    {
+        static constexpr std::array variable_width_formatter = {'W'};
+        static constexpr std::array variable_width_formatter_M_is_month_name = {'W', 'M'};
+
+        for (size_t i = 0; i < format.size(); ++i)
+        {
+            switch (format[i])
+            {
+                case '%':
+                    if (i + 1 >= format.size())
+                        throwLastCharacterIsPercentException();
+                    if (mysql_M_is_month_name)
+                    {
+                        if (std::any_of(
+                                variable_width_formatter_M_is_month_name.begin(), variable_width_formatter_M_is_month_name.end(),
+                                [&](char c){ return c == format[i + 1]; }))
+                            return false;
+                    }
+                    else
+                    {
+                        if (std::any_of(
+                                variable_width_formatter.begin(), variable_width_formatter.end(),
+                                [&](char c){ return c == format[i + 1]; }))
+                            return false;
+                    }
+                    i += 1;
+                    continue;
+                default:
+                    break;
+            }
+        }
+
+        return true;
+    }
+
+    const bool mysql_M_is_month_name;
+
 public:
     static constexpr auto name = Name::name;
 
-    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionFormatDateTimeImpl>(); }
+    static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionFormatDateTimeImpl>(context); }
+
+    explicit FunctionFormatDateTimeImpl(ContextPtr context)
+        : mysql_M_is_month_name(context->getSettings().formatdatetime_parsedatetime_m_is_month_name)
+    {
+    }
 
     String getName() const override
     {
@@ -672,7 +737,7 @@ public:
 
     DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
     {
-        if constexpr (support_integer == FormatDateTimeTraits::SupportInteger::Yes)
+        if constexpr (support_integer == SupportInteger::Yes)
         {
             if (arguments.size() != 1 && arguments.size() != 2 && arguments.size() != 3)
                 throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
@@ -718,7 +783,7 @@ public:
     ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, [[maybe_unused]] size_t input_rows_count) const override
     {
         ColumnPtr res;
-        if constexpr (support_integer == FormatDateTimeTraits::SupportInteger::Yes)
+        if constexpr (support_integer == SupportInteger::Yes)
         {
             if (arguments.size() == 1)
             {
@@ -790,10 +855,27 @@ public:
         if constexpr (std::is_same_v<DataType, DataTypeDateTime64>)
             scale = times->getScale();
 
+        /// For MySQL, we support two modes of execution:
+        ///
+        /// - All formatters in the format string are fixed-width. As a result, all output rows will have the same width and structure. We
+        ///   take advantage of this and
+        ///     1. create a "template" with placeholders from the format string,
+        ///     2. allocate a result column large enough to store the template on each row,
+        ///     3. copy the template into each result row,
+        ///     4. run instructions which replace the formatter placeholders. All other parts of the template (e.g. whitespaces) are already
+        ///        as desired and instructions skip over them (see 'extra_shift' in the formatters).
+        ///
+        /// - The format string contains at least one variable-width formatter. Output rows will potentially be of different size.
+        ///   Steps 1. and 2. are performed as above (the result column is allocated based on a worst-case size estimation). The result
+        ///   column rows are NOT populated with the template and left uninitialized. We run the normal instructions for formatters AND
+        ///   instructions that copy literal characters before/between/after formatters. As a result, each byte of each result row is
+        ///   written which is obviously slow.
+        bool mysql_with_only_fixed_length_formatters = (format_syntax == FormatSyntax::MySQL) ? containsOnlyFixedWidthMySQLFormatters(format, mysql_M_is_month_name) : false;
+
         using T = typename InstructionValueTypeMap<DataType>::InstructionValueType;
         std::vector<Instruction<T>> instructions;
         String out_template;
-        auto result_size = parseFormat(format, instructions, scale, out_template);
+        size_t out_template_size = parseFormat(format, instructions, scale, mysql_with_only_fixed_length_formatters, out_template);
 
         const DateLUTImpl * time_zone_tmp = nullptr;
         if (castType(arguments[0].type.get(), [&]([[maybe_unused]] const auto & type) { return true; }))
@@ -807,36 +889,39 @@ public:
         const auto & vec = times->getData();
 
         auto col_res = ColumnString::create();
-        auto & dst_data = col_res->getChars();
-        auto & dst_offsets = col_res->getOffsets();
-        dst_data.resize(vec.size() * (result_size + 1));
-        dst_offsets.resize(vec.size());
+        auto & res_data = col_res->getChars();
+        auto & res_offsets = col_res->getOffsets();
+        res_data.resize(vec.size() * (out_template_size + 1));
+        res_offsets.resize(vec.size());
 
-        if constexpr (format_syntax == FormatDateTimeTraits::FormatSyntax::MySQL)
+        if constexpr (format_syntax == FormatSyntax::MySQL)
         {
-            /// Fill result with literals.
+            if (mysql_with_only_fixed_length_formatters)
             {
-                UInt8 * begin = dst_data.data();
-                UInt8 * end = begin + dst_data.size();
-                UInt8 * pos = begin;
-
-                if (pos < end)
+                /// Fill result with template.
                 {
-                    memcpy(pos, out_template.data(), result_size + 1); /// With zero terminator.
-                    pos += result_size + 1;
-                }
+                    const UInt8 * const begin = res_data.data();
+                    const UInt8 * const end = res_data.data() + res_data.size();
+                    UInt8 * pos = res_data.data();
 
-                /// Fill by copying exponential growing ranges.
-                while (pos < end)
-                {
-                    size_t bytes_to_copy = std::min(pos - begin, end - pos);
-                    memcpy(pos, begin, bytes_to_copy);
-                    pos += bytes_to_copy;
+                    if (pos < end)
+                    {
+                        memcpy(pos, out_template.data(), out_template_size + 1); /// With zero terminator. mystring[mystring.size()] = '\0' is guaranteed since C++11.
+                        pos += out_template_size + 1;
+                    }
+
+                    /// Copy exponentially growing ranges.
+                    while (pos < end)
+                    {
+                        size_t bytes_to_copy = std::min(pos - begin, end - pos);
+                        memcpy(pos, begin, bytes_to_copy);
+                        pos += bytes_to_copy;
+                    }
                 }
             }
         }
 
-        auto * begin = reinterpret_cast<char *>(dst_data.data());
+        auto * begin = reinterpret_cast<char *>(res_data.data());
         auto * pos = begin;
         for (size_t i = 0; i < vec.size(); ++i)
         {
@@ -844,9 +929,7 @@ public:
             {
                 const auto c = DecimalUtils::split(vec[i], scale);
                 for (auto & instruction : instructions)
-                {
                     instruction.perform(pos, static_cast<Int64>(c.whole), c.fractional, scale, time_zone);
-                }
             }
             else
             {
@@ -855,289 +938,456 @@ public:
             }
             *pos++ = '\0';
 
-            dst_offsets[i] = pos - begin;
+            res_offsets[i] = pos - begin;
         }
 
-        dst_data.resize(pos - begin);
+        res_data.resize(pos - begin);
         return col_res;
     }
 
     template <typename T>
-    size_t parseFormat(const String & format, std::vector<Instruction<T>> & instructions, UInt32 scale, String & out_template) const
+    size_t parseFormat(const String & format, std::vector<Instruction<T>> & instructions, UInt32 scale, bool mysql_with_only_fixed_length_formatters, String & out_template) const
     {
-        static_assert(
-            format_syntax == FormatDateTimeTraits::FormatSyntax::MySQL || format_syntax == FormatDateTimeTraits::FormatSyntax::Joda,
-            "format syntax must be one of MySQL or Joda");
+        static_assert(format_syntax == FormatSyntax::MySQL || format_syntax == FormatSyntax::Joda);
 
-        if constexpr (format_syntax == FormatDateTimeTraits::FormatSyntax::MySQL)
-            return parseMySQLFormat(format, instructions, scale, out_template);
+        if constexpr (format_syntax == FormatSyntax::MySQL)
+            return parseMySQLFormat(format, instructions, scale, mysql_with_only_fixed_length_formatters, out_template);
         else
-            return parseJodaFormat(format, instructions, scale, out_template);
+            return parseJodaFormat(format, instructions, scale, mysql_with_only_fixed_length_formatters, out_template);
     }
 
     template <typename T>
-    size_t parseMySQLFormat(const String & format, std::vector<Instruction<T>> & instructions, UInt32 scale, String & out_template) const
+    size_t parseMySQLFormat(const String & format, std::vector<Instruction<T>> & instructions, UInt32 scale, bool mysql_with_only_fixed_length_formatters, String & out_template) const
     {
         auto add_extra_shift = [&](size_t amount)
         {
             if (instructions.empty())
-                instructions.emplace_back(&Instruction<T>::mysqlNoop);
+            {
+                Instruction<T> instruction;
+                instruction.setMysqlFunc(&Instruction<T>::mysqlNoop);
+                instructions.push_back(std::move(instruction));
+            }
             instructions.back().extra_shift += amount;
         };
 
-        auto add_instruction_or_extra_shift = [&](auto * func [[maybe_unused]], size_t amount [[maybe_unused]])
+        auto add_literal_instruction = [&](std::string_view literal)
         {
-            if constexpr (std::is_same_v<T, UInt32> || std::is_same_v<T, Int64>)
-                instructions.emplace_back(std::move(func));
-            else
-                add_extra_shift(amount);
+            Instruction<T> instruction;
+            instruction.setMysqlFunc(&Instruction<T>::mysqlLiteral);
+            instruction.setLiteral(literal);
+            instructions.push_back(std::move(instruction));
         };
 
-        const char * pos = format.data();
-        const char * const end = format.data() + format.size();
+        auto add_extra_shift_or_literal_instruction = [&](size_t amount, std::string_view literal)
+        {
+            if (mysql_with_only_fixed_length_formatters)
+                add_extra_shift(amount);
+            else
+                add_literal_instruction(literal);
+        };
+
+        auto add_time_instruction = [&]([[maybe_unused]] typename Instruction<T>::FuncMysql && func, [[maybe_unused]] size_t amount, [[maybe_unused]] std::string_view literal)
+        {
+            /// DateTime/DateTime64 --> insert instruction
+            /// Other types cannot provide the requested data --> write out template
+            if constexpr (is_any_of<T, UInt32, Int64>)
+            {
+                Instruction<T> instruction;
+                instruction.setMysqlFunc(std::move(func));
+                instructions.push_back(std::move(instruction));
+            }
+            else
+                add_extra_shift_or_literal_instruction(amount, literal);
+        };
+
+        Pos pos = format.data();
+        Pos const end = format.data() + format.size();
 
         while (true)
         {
-            const char * percent_pos = find_first_symbols<'%'>(pos, end);
+            Pos const percent_pos = find_first_symbols<'%'>(pos, end);
 
             if (percent_pos < end)
             {
                 if (pos < percent_pos)
                 {
-                    add_extra_shift(percent_pos - pos);
+                    /// Handle characters before next %
+                    add_extra_shift_or_literal_instruction(percent_pos - pos, std::string_view(pos, percent_pos - pos));
                     out_template += String(pos, percent_pos - pos);
                 }
 
                 pos = percent_pos + 1;
                 if (pos >= end)
-                    throw Exception(ErrorCodes::BAD_ARGUMENTS, "Sign '%' is the last in format, if you need it, use '%%'");
+                    throwLastCharacterIsPercentException();
 
                 switch (*pos)
                 {
-                    // Abbreviated weekday [Mon...Sun]
+                    // Abbreviated weekday [Mon-Sun]
                     case 'a':
-                        instructions.emplace_back(&Instruction<T>::mysqlDayOfWeekTextShort);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlDayOfWeekTextShort);
+                        instructions.push_back(std::move(instruction));
                         out_template += "Mon";
                         break;
+                    }
 
-                    // Abbreviated month [Jan...Dec]
+                    // Abbreviated month [Jan-Dec]
                     case 'b':
-                        instructions.emplace_back(&Instruction<T>::mysqlMonthOfYearTextShort);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlMonthOfYearTextShort);
+                        instructions.push_back(std::move(instruction));
                         out_template += "Jan";
                         break;
+                    }
 
                     // Month as a integer number (01-12)
                     case 'c':
-                        instructions.emplace_back(&Instruction<T>::mysqlMonth);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlMonth);
+                        instructions.push_back(std::move(instruction));
                         out_template += "00";
                         break;
+                    }
 
                     // Year, divided by 100, zero-padded
                     case 'C':
-                        instructions.emplace_back(&Instruction<T>::mysqlCentury);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlCentury);
+                        instructions.push_back(std::move(instruction));
                         out_template += "00";
                         break;
+                    }
 
                     // Day of month, zero-padded (01-31)
                     case 'd':
-                        instructions.emplace_back(&Instruction<T>::mysqlDayOfMonth);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlDayOfMonth);
+                        instructions.push_back(std::move(instruction));
                         out_template += "00";
                         break;
+                    }
 
                     // Short MM/DD/YY date, equivalent to %m/%d/%y
                     case 'D':
-                        instructions.emplace_back(&Instruction<T>::mysqlAmericanDate);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlAmericanDate);
+                        instructions.push_back(std::move(instruction));
                         out_template += "00/00/00";
                         break;
+                    }
 
                     // Day of month, space-padded ( 1-31)  23
                     case 'e':
-                        instructions.emplace_back(&Instruction<T>::mysqlDayOfMonthSpacePadded);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlDayOfMonthSpacePadded);
+                        instructions.push_back(std::move(std::move(instruction)));
                         out_template += " 0";
                         break;
+                    }
+
+                    // Depending on a setting
+                    // - Full month [January-December] OR
+                    // - Minute of hour range [0, 59]
+                    case 'M':
+                    {
+                        Instruction<T> instruction;
+                        if (mysql_M_is_month_name)
+                        {
+                            instruction.setMysqlFunc(&Instruction<T>::mysqlMonthOfYearTextLong);
+                            instructions.push_back(std::move(instruction));
+                            out_template += "September"; /// longest possible month name
+                        }
+                        else
+                        {
+                            static constexpr std::string_view val = "00";
+                            add_time_instruction(&Instruction<T>::mysqlMinute, 2, val);
+                            out_template += val;
+                        }
+                        break;
+                    }
 
                     // Fractional seconds
                     case 'f':
                     {
                         /// If the time data type has no fractional part, then we print '0' as the fractional part.
-                        instructions.emplace_back(&Instruction<T>::mysqlFractionalSecond);
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlFractionalSecond);
+                        instructions.push_back(std::move(instruction));
                         out_template += String(std::max<UInt32>(1, scale), '0');
                         break;
                     }
 
                     // Short YYYY-MM-DD date, equivalent to %Y-%m-%d   2001-08-23
                     case 'F':
-                        instructions.emplace_back(&Instruction<T>::mysqlISO8601Date);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlISO8601Date);
+                        instructions.push_back(std::move(instruction));
                         out_template += "0000-00-00";
                         break;
+                    }
 
                     // Last two digits of year of ISO 8601 week number (see %G)
                     case 'g':
-                        instructions.emplace_back(&Instruction<T>::mysqlISO8601Year2);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlISO8601Year2);
+                        instructions.push_back(std::move(instruction));
                         out_template += "00";
                         break;
+                    }
 
                     // Year of ISO 8601 week number (see %V)
                     case 'G':
-                        instructions.emplace_back(&Instruction<T>::mysqlISO8601Year4);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlISO8601Year4);
+                        instructions.push_back(std::move(instruction));
                         out_template += "0000";
                         break;
+                    }
 
                     // Day of the year (001-366)   235
                     case 'j':
-                        instructions.emplace_back(&Instruction<T>::mysqlDayOfYear);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlDayOfYear);
+                        instructions.push_back(std::move(instruction));
                         out_template += "000";
                         break;
+                    }
 
                     // Month as a integer number (01-12)
                     case 'm':
-                        instructions.emplace_back(&Instruction<T>::mysqlMonth);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlMonth);
+                        instructions.push_back(std::move(instruction));
                         out_template += "00";
                         break;
+                    }
 
                     // ISO 8601 weekday as number with Monday as 1 (1-7)
                     case 'u':
-                        instructions.emplace_back(&Instruction<T>::mysqlDayOfWeek);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlDayOfWeek);
+                        instructions.push_back(std::move(instruction));
                         out_template += "0";
                         break;
+                    }
 
                     // ISO 8601 week number (01-53)
                     case 'V':
-                        instructions.emplace_back(&Instruction<T>::mysqlISO8601Week);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlISO8601Week);
+                        instructions.push_back(std::move(instruction));
                         out_template += "00";
                         break;
+                    }
 
-                    // Weekday as a integer number with Sunday as 0 (0-6)  4
+                    // Weekday as a decimal number with Sunday as 0 (0-6)  4
                     case 'w':
-                        instructions.emplace_back(&Instruction<T>::mysqlDayOfWeek0To6);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlDayOfWeek0To6);
+                        instructions.push_back(std::move(instruction));
                         out_template += "0";
                         break;
+                    }
 
-                    // Full weekday [Monday...Sunday]
+                    // Full weekday [Monday-Sunday]
                     case 'W':
-                        instructions.emplace_back(&Instruction<T>::mysqlDayOfWeekTextLong);
-                        out_template += "Monday";
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlDayOfWeekTextLong);
+                        instructions.push_back(std::move(instruction));
+                        out_template += "Wednesday"; /// longest possible weekday name
                         break;
+                    }
 
                     // Two digits year
                     case 'y':
-                        instructions.emplace_back(&Instruction<T>::mysqlYear2);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlYear2);
+                        instructions.push_back(std::move(instruction));
                         out_template += "00";
                         break;
+                    }
 
                     // Four digits year
                     case 'Y':
-                        instructions.emplace_back(&Instruction<T>::mysqlYear4);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlYear4);
+                        instructions.push_back(std::move(instruction));
                         out_template += "0000";
                         break;
+                    }
 
                     // Quarter (1-4)
                     case 'Q':
-                        instructions.template emplace_back(&Instruction<T>::mysqlQuarter);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlQuarter);
+                        instructions.push_back(std::move(instruction));
                         out_template += "0";
                         break;
+                    }
 
                     // Offset from UTC timezone as +hhmm or -hhmm
                     case 'z':
-                        instructions.emplace_back(&Instruction<T>::mysqlTimezoneOffset);
+                    {
+                        Instruction<T> instruction;
+                        instruction.setMysqlFunc(&Instruction<T>::mysqlTimezoneOffset);
+                        instructions.push_back(std::move(instruction));
                         out_template += "+0000";
                         break;
+                    }
 
                     /// Time components. If the argument is Date, not a DateTime, then this components will have default value.
 
-                    // Minute (00-59)
-                    case 'M':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlMinute, 2);
-                        out_template += "00";
-                        break;
-
                     // AM or PM
                     case 'p':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlAMPM, 2);
-                        out_template += "AM";
+                    {
+                        static constexpr std::string_view val = "AM";
+                        add_time_instruction(&Instruction<T>::mysqlAMPM, 2, val);
+                        out_template += val;
                         break;
+                    }
 
                     // 12-hour HH:MM time, equivalent to %h:%i %p 2:55 PM
                     case 'r':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlHHMM12, 8);
-                        out_template += "12:00 AM";
+                    {
+                        static constexpr std::string_view val = "12:00 AM";
+                        add_time_instruction(&Instruction<T>::mysqlHHMM12, 8, val);
+                        out_template += val;
                         break;
+                    }
 
                     // 24-hour HH:MM time, equivalent to %H:%i 14:55
                     case 'R':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlHHMM24, 5);
-                        out_template += "00:00";
+                    {
+                        static constexpr std::string_view val = "00:00";
+                        add_time_instruction(&Instruction<T>::mysqlHHMM24, 5, val);
+                        out_template += val;
                         break;
+                    }
 
                     // Seconds
                     case 's':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlSecond, 2);
-                        out_template += "00";
+                    {
+                        static constexpr std::string_view val = "00";
+                        add_time_instruction(&Instruction<T>::mysqlSecond, 2, val);
+                        out_template += val;
                         break;
+                    }
 
                     // Seconds
                     case 'S':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlSecond, 2);
-                        out_template += "00";
+                    {
+                        static constexpr std::string_view val = "00";
+                        add_time_instruction(&Instruction<T>::mysqlSecond, 2, val);
+                        out_template += val;
                         break;
+                    }
 
                     // ISO 8601 time format (HH:MM:SS), equivalent to %H:%i:%S 14:55:02
                     case 'T':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlISO8601Time, 8);
-                        out_template += "00:00:00";
+                    {
+                        static constexpr std::string_view val = "00:00:00";
+                        add_time_instruction(&Instruction<T>::mysqlISO8601Time, 8, val);
+                        out_template += val;
                         break;
+                    }
 
                     // Hour in 12h format (01-12)
                     case 'h':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlHour12, 2);
-                        out_template += "12";
+                    {
+                        static constexpr std::string_view val = "12";
+                        add_time_instruction(&Instruction<T>::mysqlHour12, 2, val);
+                        out_template += val;
                         break;
+                    }
 
                     // Hour in 24h format (00-23)
                     case 'H':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlHour24, 2);
-                        out_template += "00";
+                    {
+                        static constexpr std::string_view val = "00";
+                        add_time_instruction(&Instruction<T>::mysqlHour24, 2, val);
+                        out_template += val;
                         break;
+                    }
 
                     // Minute of hour range [0, 59]
                     case 'i':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlMinute, 2);
-                        out_template += "00";
+                    {
+                        static constexpr std::string_view val = "00";
+                        add_time_instruction(&Instruction<T>::mysqlMinute, 2, val);
+                        out_template += val;
                         break;
+                    }
 
                     // Hour in 12h format (01-12)
                     case 'I':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlHour12, 2);
-                        out_template += "12";
+                    {
+                        static constexpr std::string_view val = "12";
+                        add_time_instruction(&Instruction<T>::mysqlHour12, 2, val);
+                        out_template += val;
                         break;
+                    }
 
                     // Hour in 24h format (00-23)
                     case 'k':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlHour24, 2);
-                        out_template += "00";
+                    {
+                        static constexpr std::string_view val = "00";
+                        add_time_instruction(&Instruction<T>::mysqlHour24, 2, val);
+                        out_template += val;
                         break;
+                    }
 
                     // Hour in 12h format (01-12)
                     case 'l':
-                        add_instruction_or_extra_shift(&Instruction<T>::mysqlHour12, 2);
-                        out_template += "12";
+                    {
+                        static constexpr std::string_view val = "12";
+                        add_time_instruction(&Instruction<T>::mysqlHour12, 2, val);
+                        out_template += val;
                         break;
+                    }
 
                     case 't':
-                        add_extra_shift(1);
-                        out_template += "\t";
+                    {
+                        static constexpr std::string_view val = "\t";
+                        add_extra_shift_or_literal_instruction(1, val);
+                        out_template += val;
                         break;
+                    }
 
                     case 'n':
-                        add_extra_shift(1);
-                        out_template += "\n";
+                    {
+                        static constexpr std::string_view val = "\n";
+                        add_extra_shift_or_literal_instruction(1, val);
+                        out_template += val;
                         break;
+                    }
 
                     // Escaped literal characters.
                     case '%':
-                        add_extra_shift(1);
-                        out_template += "%";
+                    {
+                        static constexpr std::string_view val = "%";
+                        add_extra_shift_or_literal_instruction(1, val);
+                        out_template += val;
                         break;
+                    }
 
                     // Unimplemented
                     case 'U':
@@ -1148,7 +1398,6 @@ public:
                         throw Exception(ErrorCodes::NOT_IMPLEMENTED, "format is not supported for YEAR for week (Mon-Sun)");
                     case 'X':
                         throw Exception(ErrorCodes::NOT_IMPLEMENTED, "format is not supported for YEAR for week (Sun-Sat)");
-
                     default:
                         throw Exception(
                             ErrorCodes::BAD_ARGUMENTS,
@@ -1157,12 +1406,12 @@ public:
                             *pos,
                             getName());
                 }
-
                 ++pos;
             }
             else
             {
-                add_extra_shift(end - pos);
+                /// Handle characters after last %
+                add_extra_shift_or_literal_instruction(end - pos, std::string_view(pos, end - pos));
                 out_template += String(pos, end - pos);
                 break;
             }
@@ -1172,32 +1421,41 @@ public:
     }
 
     template <typename T>
-    size_t parseJodaFormat(const String & format, std::vector<Instruction<T>> & instructions, UInt32, String &) const
+    size_t parseJodaFormat(const String & format, std::vector<Instruction<T>> & instructions, UInt32, bool, String &) const
     {
         /// If the argument was DateTime, add instruction for printing. If it was date, just append default literal
-        auto add_instruction = [&](auto && func [[maybe_unused]], const String & default_literal [[maybe_unused]])
+        auto add_instruction = [&]([[maybe_unused]] typename Instruction<T>::FuncJoda && func, [[maybe_unused]] const String & default_literal)
         {
-            if constexpr (std::is_same_v<T, UInt32> || std::is_same_v<T, Int64>)
-                instructions.emplace_back(func);
+            if constexpr (is_any_of<T, UInt32, Int64>)
+            {
+                Instruction<T> instruction;
+                instruction.setJodaFunc(std::move(func));
+                instructions.push_back(std::move(instruction));
+            }
             else
-                instructions.emplace_back(std::bind_front(&Instruction<T>::template jodaLiteral<String>, default_literal));
+            {
+                Instruction<T> instruction;
+                instruction.setJodaFunc(std::bind_front(&Instruction<T>::template jodaLiteral<String>, default_literal));
+                instructions.push_back(std::move(instruction));
+            }
         };
 
         size_t reserve_size = 0;
-        const char * pos = format.data();
-        const char * end = format.data() + format.size();
+        Pos pos = format.data();
+        Pos end = format.data() + format.size();
         while (pos < end)
         {
-            const char * cur_token = pos;
-
+            Pos cur_token = pos;
             // Literal case
             if (*cur_token == '\'')
             {
                 // Case 1: 2 consecutive single quote
                 if (pos + 1 < end && *(pos + 1) == '\'')
                 {
+                    Instruction<T> instruction;
                     std::string_view literal(cur_token, 1);
-                    instructions.emplace_back(std::bind_front(&Instruction<T>::template jodaLiteral<decltype(literal)>, literal));
+                    instruction.setJodaFunc(std::bind_front(&Instruction<T>::template jodaLiteral<decltype(literal)>, literal));
+                    instructions.push_back(std::move(instruction));
                     ++reserve_size;
                     pos += 2;
                 }
@@ -1211,9 +1469,10 @@ public:
                     {
                         for (Int64 i = 1; i <= count; i++)
                         {
+                            Instruction<T> instruction;
                             std::string_view literal(cur_token + i, 1);
-                            instructions.emplace_back(
-                                std::bind_front(&Instruction<T>::template jodaLiteral<decltype(literal)>, literal));
+                            instruction.setJodaFunc(std::bind_front(&Instruction<T>::template jodaLiteral<decltype(literal)>, literal));
+                            instructions.push_back(std::move(instruction));
                             ++reserve_size;
                             if (*(cur_token + i) == '\'')
                                 i += 1;
@@ -1234,68 +1493,114 @@ public:
                 switch (*cur_token)
                 {
                     case 'G':
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaEra, repetitions));
+                    {
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaEra, repetitions));
+                        instructions.push_back(std::move(instruction));
                         reserve_size += repetitions <= 3 ? 2 : 13;
                         break;
+                    }
                     case 'C':
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaCenturyOfEra, repetitions));
+                    {
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaCenturyOfEra, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// Year range [1900, 2299]
                         reserve_size += std::max(repetitions, 2);
                         break;
+                    }
                     case 'Y':
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaYearOfEra, repetitions));
+                    {
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaYearOfEra, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// Year range [1900, 2299]
                         reserve_size += repetitions == 2 ? 2 : std::max(repetitions, 4);
                         break;
+                    }
                     case 'x':
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaWeekYear, repetitions));
+                    {
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaWeekYear, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// weekyear range [1900, 2299]
                         reserve_size += std::max(repetitions, 4);
                         break;
+                    }
                     case 'w':
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaWeekOfWeekYear, repetitions));
+                    {
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaWeekOfWeekYear, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// Week of weekyear range [1, 52]
                         reserve_size += std::max(repetitions, 2);
                         break;
+                    }
                     case 'e':
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaDayOfWeek1Based, repetitions));
+                    {
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaDayOfWeek1Based, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// Day of week range [1, 7]
                         reserve_size += std::max(repetitions, 1);
                         break;
+                    }
                     case 'E':
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaDayOfWeekText, repetitions));
+                    {
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaDayOfWeekText, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// Maximum length of short name is 3, maximum length of full name is 9.
                         reserve_size += repetitions <= 3 ? 3 : 9;
                         break;
+                    }
                     case 'y':
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaYear, repetitions));
+                    {
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaYear, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// Year range [1900, 2299]
                         reserve_size += repetitions == 2 ? 2 : std::max(repetitions, 4);
                         break;
+                    }
                     case 'D':
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaDayOfYear, repetitions));
+                    {
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaDayOfYear, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// Day of year range [1, 366]
                         reserve_size += std::max(repetitions, 3);
                         break;
+                    }
                     case 'M':
+                    {
                         if (repetitions <= 2)
                         {
-                            instructions.emplace_back(std::bind_front(&Instruction<T>::jodaMonthOfYear, repetitions));
+                            Instruction<T> instruction;
+                            instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaMonthOfYear, repetitions));
+                            instructions.push_back(std::move(instruction));
                             /// Month of year range [1, 12]
                             reserve_size += 2;
                         }
                         else
                         {
-                            instructions.emplace_back(std::bind_front(&Instruction<T>::jodaMonthOfYearText, repetitions));
+                            Instruction<T> instruction;
+                            instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaMonthOfYearText, repetitions));
+                            instructions.push_back(std::move(instruction));
                             /// Maximum length of short name is 3, maximum length of full name is 9.
                             reserve_size += repetitions <= 3 ? 3 : 9;
                         }
                         break;
+                    }
                     case 'd':
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaDayOfMonth, repetitions));
+                    {
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaDayOfMonth, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// Day of month range [1, 3]
                         reserve_size += std::max(repetitions, 3);
                         break;
+                    }
                     case 'a':
                         /// Default half day of day is "AM"
                         add_instruction(std::bind_front(&Instruction<T>::jodaHalfDayOfDay, repetitions), "AM");
@@ -1341,29 +1646,41 @@ public:
                         reserve_size += std::max(repetitions, 2);
                         break;
                     case 'S':
+                    {
                         /// Default fraction of second is 0
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaFractionOfSecond, repetitions));
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaFractionOfSecond, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// 'S' repetitions range [0, 9]
                         reserve_size += repetitions <= 9 ? repetitions : 9;
                         break;
+                    }
                     case 'z':
+                    {
                         if (repetitions <= 3)
                             throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Short name time zone is not yet supported");
 
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::jodaTimezone, repetitions));
+                        Instruction<T> instruction;
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::jodaTimezone, repetitions));
+                        instructions.push_back(std::move(instruction));
                         /// Longest length of full name of time zone is 32.
                         reserve_size += 32;
                         break;
+                    }
                     case 'Z':
                         throw Exception(ErrorCodes::NOT_IMPLEMENTED, "format is not supported for TIMEZONE_OFFSET_ID");
                     default:
+                    {
                         if (isalpha(*cur_token))
                             throw Exception(ErrorCodes::NOT_IMPLEMENTED, "format is not supported for {}", String(cur_token, repetitions));
 
+                        Instruction<T> instruction;
                         std::string_view literal(cur_token, pos - cur_token);
-                        instructions.emplace_back(std::bind_front(&Instruction<T>::template jodaLiteral<decltype(literal)>, literal));
+                        instruction.setJodaFunc(std::bind_front(&Instruction<T>::template jodaLiteral<decltype(literal)>, literal));
+                        instructions.push_back(std::move(instruction));
                         reserve_size += pos - cur_token;
                         break;
+                    }
                 }
             }
         }
@@ -1392,10 +1709,10 @@ struct NameFromUnixTimeInJodaSyntax
 };
 
 
-using FunctionFormatDateTime = FunctionFormatDateTimeImpl<NameFormatDateTime, FormatDateTimeTraits::SupportInteger::No, FormatDateTimeTraits::FormatSyntax::MySQL>;
-using FunctionFromUnixTimestamp = FunctionFormatDateTimeImpl<NameFromUnixTime, FormatDateTimeTraits::SupportInteger::Yes, FormatDateTimeTraits::FormatSyntax::MySQL>;
-using FunctionFormatDateTimeInJodaSyntax = FunctionFormatDateTimeImpl<NameFormatDateTimeInJodaSyntax, FormatDateTimeTraits::SupportInteger::No, FormatDateTimeTraits::FormatSyntax::Joda>;
-using FunctionFromUnixTimestampInJodaSyntax = FunctionFormatDateTimeImpl<NameFromUnixTimeInJodaSyntax, FormatDateTimeTraits::SupportInteger::Yes, FormatDateTimeTraits::FormatSyntax::Joda>;
+using FunctionFormatDateTime = FunctionFormatDateTimeImpl<NameFormatDateTime, SupportInteger::No, FormatSyntax::MySQL>;
+using FunctionFromUnixTimestamp = FunctionFormatDateTimeImpl<NameFromUnixTime, SupportInteger::Yes, FormatSyntax::MySQL>;
+using FunctionFormatDateTimeInJodaSyntax = FunctionFormatDateTimeImpl<NameFormatDateTimeInJodaSyntax, SupportInteger::No, FormatSyntax::Joda>;
+using FunctionFromUnixTimestampInJodaSyntax = FunctionFormatDateTimeImpl<NameFromUnixTimeInJodaSyntax, SupportInteger::Yes, FormatSyntax::Joda>;
 
 }
 
diff --git a/src/Functions/parseDateTime.cpp b/src/Functions/parseDateTime.cpp
index 6077e00f915..3a784a74eb5 100644
--- a/src/Functions/parseDateTime.cpp
+++ b/src/Functions/parseDateTime.cpp
@@ -48,7 +48,7 @@ namespace
     const std::unordered_map<String, std::pair<String, Int32>> monthMap{
         {"jan", {"uary", 1}},
         {"feb", {"ruary", 2}},
-        {"mar", {"rch", 3}},
+        {"mar", {"ch", 3}},
         {"apr", {"il", 4}},
         {"may", {"", 5}},
         {"jun", {"e", 6}},
@@ -101,16 +101,16 @@ namespace
         bool is_year_of_era = false; /// If true, year is calculated from era and year of era, the latter cannot be zero or negative.
         bool has_year = false; /// Whether year was explicitly specified.
 
-        /// If is_clock_hour = true, is_hour_of_half_day = true, hour's range is [1, 12]
-        /// If is_clock_hour = true, is_hour_of_half_day = false, hour's range is [1, 24]
-        /// If is_clock_hour = false, is_hour_of_half_day = true, hour's range is [0, 11]
-        /// If is_clock_hour = false, is_hour_of_half_day = false, hour's range is [0, 23]
+        /// If hour_starts_at_1 = true, is_hour_of_half_day = true, hour's range is [1, 12]
+        /// If hour_starts_at_1 = true, is_hour_of_half_day = false, hour's range is [1, 24]
+        /// If hour_starts_at_1 = false, is_hour_of_half_day = true, hour's range is [0, 11]
+        /// If hour_starts_at_1 = false, is_hour_of_half_day = false, hour's range is [0, 23]
         Int32 hour = 0;
         Int32 minute = 0; /// range [0, 59]
         Int32 second = 0; /// range [0, 59]
 
         bool is_am = true; /// If is_hour_of_half_day = true and is_am = false (i.e. pm) then add 12 hours to the result DateTime
-        bool is_clock_hour = false; /// Whether the hour is clockhour
+        bool hour_starts_at_1 = false; /// Whether the hour is clockhour
         bool is_hour_of_half_day = false; /// Whether the hour is of half day
 
         bool has_time_zone_offset = false; /// If true, time zone offset is explicitly specified.
@@ -137,7 +137,7 @@ namespace
             second = 0;
 
             is_am = true;
-            is_clock_hour = false;
+            hour_starts_at_1 = false;
             is_hour_of_half_day = false;
 
             has_time_zone_offset = false;
@@ -275,23 +275,23 @@ namespace
                 throw Exception(ErrorCodes::CANNOT_PARSE_DATETIME, "Unknown half day of day: {}", text);
         }
 
-        void setHour(Int32 hour_, bool is_hour_of_half_day_ = false, bool is_clock_hour_ = false)
+        void setHour(Int32 hour_, bool is_hour_of_half_day_ = false, bool hour_starts_at_1_ = false)
         {
             Int32 max_hour;
             Int32 min_hour;
             Int32 new_hour = hour_;
-            if (!is_hour_of_half_day_ && !is_clock_hour_)
+            if (!is_hour_of_half_day_ && !hour_starts_at_1_)
             {
                 max_hour = 23;
                 min_hour = 0;
             }
-            else if (!is_hour_of_half_day_ && is_clock_hour_)
+            else if (!is_hour_of_half_day_ && hour_starts_at_1_)
             {
                 max_hour = 24;
                 min_hour = 1;
                 new_hour = hour_ % 24;
             }
-            else if (is_hour_of_half_day_ && !is_clock_hour_)
+            else if (is_hour_of_half_day_ && !hour_starts_at_1_)
             {
                 max_hour = 11;
                 min_hour = 0;
@@ -306,16 +306,16 @@ namespace
             if (hour_ < min_hour || hour_ > max_hour)
                 throw Exception(
                     ErrorCodes::CANNOT_PARSE_DATETIME,
-                    "Value {} for hour must be in the range [{}, {}] if_hour_of_half_day={} and is_clock_hour={}",
+                    "Value {} for hour must be in the range [{}, {}] if_hour_of_half_day={} and hour_starts_at_1={}",
                     hour,
                     max_hour,
                     min_hour,
                     is_hour_of_half_day_,
-                    is_clock_hour_);
+                    hour_starts_at_1_);
 
             hour = new_hour;
             is_hour_of_half_day = is_hour_of_half_day_;
-            is_clock_hour = is_clock_hour_;
+            hour_starts_at_1 = hour_starts_at_1_;
         }
 
         void setMinute(Int32 minute_)
@@ -464,8 +464,15 @@ namespace
     class FunctionParseDateTimeImpl : public IFunction
     {
     public:
+        const bool mysql_M_is_month_name;
+
         static constexpr auto name = Name::name;
-        static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionParseDateTimeImpl>(); }
+        static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionParseDateTimeImpl>(context); }
+
+        explicit FunctionParseDateTimeImpl(ContextPtr context)
+            : mysql_M_is_month_name(context->getSettings().formatdatetime_parsedatetime_m_is_month_name)
+        {
+        }
 
         String getName() const override { return name; }
 
@@ -768,6 +775,38 @@ namespace
                 return cur;
             }
 
+            static Pos mysqlMonthOfYearTextLong(Pos cur, Pos end, const String & fragment, DateTime & date)
+            {
+                checkSpace(cur, end, 3, "mysqlMonthOfYearTextLong requires size >= 3", fragment);
+                String text1(cur, 3);
+                boost::to_lower(text1);
+                auto it = monthMap.find(text1);
+                if (it == monthMap.end())
+                    throw Exception(
+                        ErrorCodes::CANNOT_PARSE_DATETIME,
+                        "Unable to parse first part of fragment {} from {} because of unknown month of year text: {}",
+                        fragment,
+                        std::string_view(cur, end - cur),
+                        text1);
+                cur += 3;
+
+                size_t expected_remaining_size = it->second.first.size();
+                checkSpace(cur, end, expected_remaining_size, "mysqlMonthOfYearTextLong requires the second parg size >= " + std::to_string(expected_remaining_size), fragment);
+                String text2(cur, expected_remaining_size);
+                boost::to_lower(text2);
+                if (text2 != it->second.first)
+                    throw Exception(
+                        ErrorCodes::CANNOT_PARSE_DATETIME,
+                        "Unable to parse second part of fragment {} from {} because of unknown month of year text: {}",
+                        fragment,
+                        std::string_view(cur, end - cur),
+                        text1 + text2);
+                cur += expected_remaining_size;
+
+                date.setMonth(it->second.second);
+                return cur;
+            }
+
             static Pos mysqlMonth(Pos cur, Pos end, const String & fragment, DateTime & date)
             {
                 Int32 month;
@@ -900,7 +939,7 @@ namespace
 
             static Pos mysqlDayOfWeekTextLong(Pos cur, Pos end, const String & fragment, DateTime & date)
             {
-                checkSpace(cur, end, 6, "jodaDayOfWeekText requires size >= 6", fragment);
+                checkSpace(cur, end, 6, "mysqlDayOfWeekTextLong requires size >= 6", fragment);
                 String text1(cur, 3);
                 boost::to_lower(text1);
                 auto it = dayOfWeekMap.find(text1);
@@ -914,7 +953,7 @@ namespace
                 cur += 3;
 
                 size_t expected_remaining_size = it->second.first.size();
-                checkSpace(cur, end, expected_remaining_size, "jodaDayOfWeekText requires the second parg size >= " + std::to_string(expected_remaining_size), fragment);
+                checkSpace(cur, end, expected_remaining_size, "mysqlDayOfWeekTextLong requires the second parg size >= " + std::to_string(expected_remaining_size), fragment);
                 String text2(cur, expected_remaining_size);
                 boost::to_lower(text2);
                 if (text2 != it->second.first)
@@ -1512,9 +1551,14 @@ namespace
                             instructions.emplace_back(ACTION_ARGS(Instruction::mysqlTimezoneOffset));
                             break;
 
-                        // Minute (00-59)
+                        // Depending on a setting
+                        // - Full month [January...December]
+                        // - Minute (00-59) OR
                         case 'M':
-                            instructions.emplace_back(ACTION_ARGS(Instruction::mysqlMinute));
+                            if (mysql_M_is_month_name)
+                                instructions.emplace_back(ACTION_ARGS(Instruction::mysqlMonthOfYearTextLong));
+                            else
+                                instructions.emplace_back(ACTION_ARGS(Instruction::mysqlMinute));
                             break;
 
                         // AM or PM
diff --git a/src/Functions/replaceAll.cpp b/src/Functions/replaceAll.cpp
index d85d192d199..6c06f5984b3 100644
--- a/src/Functions/replaceAll.cpp
+++ b/src/Functions/replaceAll.cpp
@@ -13,7 +13,7 @@ struct NameReplaceAll
     static constexpr auto name = "replaceAll";
 };
 
-using FunctionReplaceAll = FunctionStringReplace<ReplaceStringImpl<ReplaceStringTraits::Replace::All>, NameReplaceAll>;
+using FunctionReplaceAll = FunctionStringReplace<ReplaceStringImpl<NameReplaceAll, ReplaceStringTraits::Replace::All>, NameReplaceAll>;
 
 }
 
diff --git a/src/Functions/replaceOne.cpp b/src/Functions/replaceOne.cpp
index 6557339537e..62be2906a71 100644
--- a/src/Functions/replaceOne.cpp
+++ b/src/Functions/replaceOne.cpp
@@ -13,7 +13,7 @@ struct NameReplaceOne
     static constexpr auto name = "replaceOne";
 };
 
-using FunctionReplaceOne = FunctionStringReplace<ReplaceStringImpl<ReplaceStringTraits::Replace::First>, NameReplaceOne>;
+using FunctionReplaceOne = FunctionStringReplace<ReplaceStringImpl<NameReplaceOne, ReplaceStringTraits::Replace::First>, NameReplaceOne>;
 
 }
 
diff --git a/src/Functions/replaceRegexpAll.cpp b/src/Functions/replaceRegexpAll.cpp
index 4eaf46c05d4..f5f56fb0f35 100644
--- a/src/Functions/replaceRegexpAll.cpp
+++ b/src/Functions/replaceRegexpAll.cpp
@@ -13,7 +13,7 @@ struct NameReplaceRegexpAll
     static constexpr auto name = "replaceRegexpAll";
 };
 
-using FunctionReplaceRegexpAll = FunctionStringReplace<ReplaceRegexpImpl<ReplaceRegexpTraits::Replace::All>, NameReplaceRegexpAll>;
+using FunctionReplaceRegexpAll = FunctionStringReplace<ReplaceRegexpImpl<NameReplaceRegexpAll, ReplaceRegexpTraits::Replace::All>, NameReplaceRegexpAll>;
 
 }
 
diff --git a/src/Functions/replaceRegexpOne.cpp b/src/Functions/replaceRegexpOne.cpp
index 60e29213a9a..fc3e55aa791 100644
--- a/src/Functions/replaceRegexpOne.cpp
+++ b/src/Functions/replaceRegexpOne.cpp
@@ -13,7 +13,7 @@ struct NameReplaceRegexpOne
     static constexpr auto name = "replaceRegexpOne";
 };
 
-using FunctionReplaceRegexpOne = FunctionStringReplace<ReplaceRegexpImpl<ReplaceRegexpTraits::Replace::First>, NameReplaceRegexpOne>;
+using FunctionReplaceRegexpOne = FunctionStringReplace<ReplaceRegexpImpl<NameReplaceRegexpOne, ReplaceRegexpTraits::Replace::First>, NameReplaceRegexpOne>;
 
 }
 
diff --git a/src/Functions/widthBucket.cpp b/src/Functions/widthBucket.cpp
index a32fa159c2c..e14ef90223d 100644
--- a/src/Functions/widthBucket.cpp
+++ b/src/Functions/widthBucket.cpp
@@ -11,6 +11,7 @@
 #include <Functions/IFunction.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/castColumn.h>
+#include <Common/Concepts.h>
 #include <Common/Exception.h>
 #include <Common/NaNUtils.h>
 #include <Common/register_objects.h>
diff --git a/src/IO/AsynchronousReadBufferFromFile.h b/src/IO/AsynchronousReadBufferFromFile.h
index 1b7eeec4f19..0ac0a820e48 100644
--- a/src/IO/AsynchronousReadBufferFromFile.h
+++ b/src/IO/AsynchronousReadBufferFromFile.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <Common/Throttler_fwd.h>
 #include <IO/AsynchronousReadBufferFromFileDescriptor.h>
 #include <IO/OpenedFileCache.h>
 
@@ -7,6 +8,7 @@
 namespace DB
 {
 
+/* NOTE: Unused */
 class AsynchronousReadBufferFromFile : public AsynchronousReadBufferFromFileDescriptor
 {
 protected:
@@ -62,8 +64,9 @@ public:
         int flags = -1,
         char * existing_memory = nullptr,
         size_t alignment = 0,
-        std::optional<size_t> file_size_ = std::nullopt)
-        : AsynchronousReadBufferFromFileDescriptor(reader_, priority_, -1, buf_size, existing_memory, alignment, file_size_)
+        std::optional<size_t> file_size_ = std::nullopt,
+        ThrottlerPtr throttler_ = {})
+        : AsynchronousReadBufferFromFileDescriptor(reader_, priority_, -1, buf_size, existing_memory, alignment, file_size_, throttler_)
         , file_name(file_name_)
     {
         file = OpenedFileCache::instance().get(file_name, flags);
diff --git a/src/IO/AsynchronousReadBufferFromFileDescriptor.cpp b/src/IO/AsynchronousReadBufferFromFileDescriptor.cpp
index dc8dcc6c3e6..743892d24f6 100644
--- a/src/IO/AsynchronousReadBufferFromFileDescriptor.cpp
+++ b/src/IO/AsynchronousReadBufferFromFileDescriptor.cpp
@@ -5,14 +5,17 @@
 #include <Common/Stopwatch.h>
 #include <Common/Exception.h>
 #include <Common/CurrentMetrics.h>
+#include <Common/Throttler.h>
+#include <Common/filesystemHelpers.h>
 #include <IO/AsynchronousReadBufferFromFileDescriptor.h>
 #include <IO/WriteHelpers.h>
-#include <Common/filesystemHelpers.h>
 
 
 namespace ProfileEvents
 {
     extern const Event AsynchronousReadWaitMicroseconds;
+    extern const Event LocalReadThrottlerBytes;
+    extern const Event LocalReadThrottlerSleepMicroseconds;
 }
 
 namespace CurrentMetrics
@@ -92,6 +95,8 @@ bool AsynchronousReadBufferFromFileDescriptor::nextImpl()
 
         assert(offset <= size);
         size_t bytes_read = size - offset;
+        if (throttler)
+            throttler->add(bytes_read, ProfileEvents::LocalReadThrottlerBytes, ProfileEvents::LocalReadThrottlerSleepMicroseconds);
 
         if (bytes_read)
         {
@@ -117,6 +122,8 @@ bool AsynchronousReadBufferFromFileDescriptor::nextImpl()
 
         assert(offset <= size);
         size_t bytes_read = size - offset;
+        if (throttler)
+            throttler->add(bytes_read, ProfileEvents::LocalReadThrottlerBytes, ProfileEvents::LocalReadThrottlerSleepMicroseconds);
 
         if (bytes_read)
         {
@@ -149,12 +156,14 @@ AsynchronousReadBufferFromFileDescriptor::AsynchronousReadBufferFromFileDescript
     size_t buf_size,
     char * existing_memory,
     size_t alignment,
-    std::optional<size_t> file_size_)
+    std::optional<size_t> file_size_,
+    ThrottlerPtr throttler_)
     : ReadBufferFromFileBase(buf_size, existing_memory, alignment, file_size_)
     , reader(reader_)
     , base_priority(priority_)
     , required_alignment(alignment)
     , fd(fd_)
+    , throttler(throttler_)
 {
     if (required_alignment > buf_size)
         throw Exception(
diff --git a/src/IO/AsynchronousReadBufferFromFileDescriptor.h b/src/IO/AsynchronousReadBufferFromFileDescriptor.h
index 1629f344b35..dff56baef4e 100644
--- a/src/IO/AsynchronousReadBufferFromFileDescriptor.h
+++ b/src/IO/AsynchronousReadBufferFromFileDescriptor.h
@@ -3,6 +3,7 @@
 #include <IO/ReadBufferFromFileBase.h>
 #include <IO/AsynchronousReader.h>
 #include <Interpreters/Context.h>
+#include <Common/Throttler_fwd.h>
 
 #include <optional>
 #include <unistd.h>
@@ -26,6 +27,7 @@ protected:
     size_t file_offset_of_buffer_end = 0; /// What offset in file corresponds to working_buffer.end().
     size_t bytes_to_ignore = 0;           /// How many bytes should we ignore upon a new read request.
     int fd;
+    ThrottlerPtr throttler;
 
     bool nextImpl() override;
 
@@ -42,7 +44,8 @@ public:
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
         char * existing_memory = nullptr,
         size_t alignment = 0,
-        std::optional<size_t> file_size_ = std::nullopt);
+        std::optional<size_t> file_size_ = std::nullopt,
+        ThrottlerPtr throttler_ = {});
 
     ~AsynchronousReadBufferFromFileDescriptor() override;
 
diff --git a/src/IO/ReadBufferFromFile.cpp b/src/IO/ReadBufferFromFile.cpp
index 3b2decc1f94..79ac62c6421 100644
--- a/src/IO/ReadBufferFromFile.cpp
+++ b/src/IO/ReadBufferFromFile.cpp
@@ -30,8 +30,10 @@ ReadBufferFromFile::ReadBufferFromFile(
     int flags,
     char * existing_memory,
     size_t alignment,
-    std::optional<size_t> file_size_)
-    : ReadBufferFromFileDescriptor(-1, buf_size, existing_memory, alignment, file_size_), file_name(file_name_)
+    std::optional<size_t> file_size_,
+    ThrottlerPtr throttler_)
+    : ReadBufferFromFileDescriptor(-1, buf_size, existing_memory, alignment, file_size_, throttler_)
+    , file_name(file_name_)
 {
     ProfileEvents::increment(ProfileEvents::FileOpen);
 
@@ -61,8 +63,9 @@ ReadBufferFromFile::ReadBufferFromFile(
     size_t buf_size,
     char * existing_memory,
     size_t alignment,
-    std::optional<size_t> file_size_)
-    : ReadBufferFromFileDescriptor(fd_, buf_size, existing_memory, alignment, file_size_)
+    std::optional<size_t> file_size_,
+    ThrottlerPtr throttler_)
+    : ReadBufferFromFileDescriptor(fd_, buf_size, existing_memory, alignment, file_size_, throttler_)
     , file_name(original_file_name.empty() ? "(fd = " + toString(fd_) + ")" : original_file_name)
 {
     fd_ = -1;
diff --git a/src/IO/ReadBufferFromFile.h b/src/IO/ReadBufferFromFile.h
index a720f8dd36d..462453d974d 100644
--- a/src/IO/ReadBufferFromFile.h
+++ b/src/IO/ReadBufferFromFile.h
@@ -29,7 +29,8 @@ public:
         int flags = -1,
         char * existing_memory = nullptr,
         size_t alignment = 0,
-        std::optional<size_t> file_size_ = std::nullopt);
+        std::optional<size_t> file_size_ = std::nullopt,
+        ThrottlerPtr throttler = {});
 
     /// Use pre-opened file descriptor.
     explicit ReadBufferFromFile(
@@ -38,7 +39,8 @@ public:
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
         char * existing_memory = nullptr,
         size_t alignment = 0,
-        std::optional<size_t> file_size_ = std::nullopt);
+        std::optional<size_t> file_size_ = std::nullopt,
+        ThrottlerPtr throttler = {});
 
     ~ReadBufferFromFile() override;
 
@@ -88,8 +90,9 @@ public:
         int flags = -1,
         char * existing_memory = nullptr,
         size_t alignment = 0,
-        std::optional<size_t> file_size_ = std::nullopt)
-        : ReadBufferFromFileDescriptorPRead(-1, buf_size, existing_memory, alignment, file_size_)
+        std::optional<size_t> file_size_ = std::nullopt,
+        ThrottlerPtr throttler_ = {})
+        : ReadBufferFromFileDescriptorPRead(-1, buf_size, existing_memory, alignment, file_size_, throttler_)
         , file_name(file_name_)
     {
         file = OpenedFileCache::instance().get(file_name, flags);
diff --git a/src/IO/ReadBufferFromFileDescriptor.cpp b/src/IO/ReadBufferFromFileDescriptor.cpp
index 65df93413dd..1e7ea855364 100644
--- a/src/IO/ReadBufferFromFileDescriptor.cpp
+++ b/src/IO/ReadBufferFromFileDescriptor.cpp
@@ -5,6 +5,7 @@
 #include <Common/Stopwatch.h>
 #include <Common/Exception.h>
 #include <Common/CurrentMetrics.h>
+#include <Common/Throttler.h>
 #include <IO/ReadBufferFromFileDescriptor.h>
 #include <IO/WriteHelpers.h>
 #include <Common/filesystemHelpers.h>
@@ -21,6 +22,8 @@ namespace ProfileEvents
     extern const Event ReadBufferFromFileDescriptorReadBytes;
     extern const Event DiskReadElapsedMicroseconds;
     extern const Event Seek;
+    extern const Event LocalReadThrottlerBytes;
+    extern const Event LocalReadThrottlerSleepMicroseconds;
 }
 
 namespace CurrentMetrics
@@ -82,7 +85,12 @@ bool ReadBufferFromFileDescriptor::nextImpl()
         }
 
         if (res > 0)
+        {
             bytes_read += res;
+            if (throttler)
+                throttler->add(res, ProfileEvents::LocalReadThrottlerBytes, ProfileEvents::LocalReadThrottlerSleepMicroseconds);
+        }
+
 
         /// It reports real time spent including the time spent while thread was preempted doing nothing.
         /// And it is Ok for the purpose of this watch (it is used to lower the number of threads to read from tables).
diff --git a/src/IO/ReadBufferFromFileDescriptor.h b/src/IO/ReadBufferFromFileDescriptor.h
index ebd0f6db32d..46bf04d41ed 100644
--- a/src/IO/ReadBufferFromFileDescriptor.h
+++ b/src/IO/ReadBufferFromFileDescriptor.h
@@ -2,6 +2,7 @@
 
 #include <IO/ReadBufferFromFileBase.h>
 #include <Interpreters/Context_fwd.h>
+#include <Common/Throttler_fwd.h>
 
 #include <unistd.h>
 
@@ -21,6 +22,8 @@ protected:
 
     int fd;
 
+    ThrottlerPtr throttler;
+
     bool nextImpl() override;
     void prefetch(int64_t priority) override;
 
@@ -33,10 +36,12 @@ public:
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
         char * existing_memory = nullptr,
         size_t alignment = 0,
-        std::optional<size_t> file_size_ = std::nullopt)
+        std::optional<size_t> file_size_ = std::nullopt,
+        ThrottlerPtr throttler_ = {})
         : ReadBufferFromFileBase(buf_size, existing_memory, alignment, file_size_)
         , required_alignment(alignment)
         , fd(fd_)
+        , throttler(throttler_)
     {
     }
 
@@ -78,8 +83,9 @@ public:
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
         char * existing_memory = nullptr,
         size_t alignment = 0,
-        std::optional<size_t> file_size_ = std::nullopt)
-        : ReadBufferFromFileDescriptor(fd_, buf_size, existing_memory, alignment, file_size_)
+        std::optional<size_t> file_size_ = std::nullopt,
+        ThrottlerPtr throttler_ = {})
+        : ReadBufferFromFileDescriptor(fd_, buf_size, existing_memory, alignment, file_size_, throttler_)
     {
         use_pread = true;
     }
diff --git a/src/IO/ReadSettings.h b/src/IO/ReadSettings.h
index a96766202ff..8c676b2d00b 100644
--- a/src/IO/ReadSettings.h
+++ b/src/IO/ReadSettings.h
@@ -81,7 +81,7 @@ struct ReadSettings
     size_t mmap_threshold = 0;
     MMappedFileCache * mmap_cache = nullptr;
 
-    /// For 'pread_threadpool' method. Lower is more priority.
+    /// For 'pread_threadpool'/'io_uring' method. Lower is more priority.
     size_t priority = 0;
 
     bool load_marks_asynchronously = true;
@@ -109,6 +109,7 @@ struct ReadSettings
 
     /// Bandwidth throttler to use during reading
     ThrottlerPtr remote_throttler;
+    ThrottlerPtr local_throttler;
 
     // Resource to be used during reading
     ResourceLink resource_link;
diff --git a/src/IO/VarInt.h b/src/IO/VarInt.h
index fa1908cf615..a314ea40cd1 100644
--- a/src/IO/VarInt.h
+++ b/src/IO/VarInt.h
@@ -15,25 +15,19 @@ namespace ErrorCodes
 }
 
 
-/** Variable-Length Quantity (VLQ) Base-128 compression
- *
- * NOTE: Due to historical reasons, only up to 1<<63-1 are supported, which
- * cannot be changed without breaking the backward compatibility.
- * Also some drivers may support full 1<<64 range (i.e. python -
- * clickhouse-driver), while others has the same limitations as ClickHouse
- * (i.e. Rust - clickhouse-rs).
- * So implementing VLQ for the whole 1<<64 range will require different set of
- * helpers.
- */
-constexpr UInt64 VAR_UINT_MAX = (1ULL<<63) - 1;
+/// Variable-Length Quantity (VLQ) Base-128 compression, also known as Variable Byte (VB) or Varint encoding.
 
-/** Write UInt64 in variable length format (base128) */
+/// Write UInt64 in variable length format (base128)
 void writeVarUInt(UInt64 x, std::ostream & ostr);
 void writeVarUInt(UInt64 x, WriteBuffer & ostr);
 char * writeVarUInt(UInt64 x, char * ostr);
 
+/// NOTE: Due to historical reasons, only values up to 1<<63-1 can be safely encoded/decoded (bigger values are not idempotent under
+/// encoding/decoding). This cannot be changed without breaking backward compatibility (some drivers, e.g. clickhouse-rs (Rust), have the
+/// same limitation, others support the full 1<<64 range, e.g. clickhouse-driver (Python))
+constexpr UInt64 VAR_UINT_MAX = (1ULL<<63) - 1;
 
-/** Write UInt64 in variable length format, wrap the value to VAR_UINT_MAX if it exceed VAR_UINT_MAX (to bypass sanity check) */
+/// Write UInt64 in variable length format (base128), limit the value to VAR_UINT_MAX if it exceed VAR_UINT_MAX (to bypass sanity check)
 template <typename ...Args>
 auto writeVarUIntOverflow(UInt64 x, Args && ... args)
 {
@@ -41,20 +35,20 @@ auto writeVarUIntOverflow(UInt64 x, Args && ... args)
 }
 
 
-/** Read UInt64, written in variable length format (base128) */
+/// Read UInt64, written in variable length format (base128)
 void readVarUInt(UInt64 & x, std::istream & istr);
 void readVarUInt(UInt64 & x, ReadBuffer & istr);
 const char * readVarUInt(UInt64 & x, const char * istr, size_t size);
 
 
-/** Get the length of UInt64 in VarUInt format */
+/// Get the length of UInt64 in VarUInt format
 size_t getLengthOfVarUInt(UInt64 x);
 
-/** Get the Int64 length in VarInt format */
+/// Get the Int64 length in VarInt format
 size_t getLengthOfVarInt(Int64 x);
 
 
-/** Write Int64 in variable length format (base128) */
+/// Write Int64 in variable length format (base128)
 template <typename OUT>
 inline void writeVarInt(Int64 x, OUT & ostr)
 {
@@ -67,7 +61,7 @@ inline char * writeVarInt(Int64 x, char * ostr)
 }
 
 
-/** Read Int64, written in variable length format (base128) */
+/// Read Int64, written in variable length format (base128)
 template <typename IN>
 inline void readVarInt(Int64 & x, IN & istr)
 {
diff --git a/src/IO/WriteBufferFromFile.cpp b/src/IO/WriteBufferFromFile.cpp
index 95a4bc8a652..e58f1e3a60c 100644
--- a/src/IO/WriteBufferFromFile.cpp
+++ b/src/IO/WriteBufferFromFile.cpp
@@ -29,10 +29,11 @@ WriteBufferFromFile::WriteBufferFromFile(
     const std::string & file_name_,
     size_t buf_size,
     int flags,
+    ThrottlerPtr throttler_,
     mode_t mode,
     char * existing_memory,
     size_t alignment)
-    : WriteBufferFromFileDescriptor(-1, buf_size, existing_memory, alignment, file_name_)
+    : WriteBufferFromFileDescriptor(-1, buf_size, existing_memory, throttler_, alignment, file_name_)
 {
     ProfileEvents::increment(ProfileEvents::FileOpen);
 
@@ -63,9 +64,10 @@ WriteBufferFromFile::WriteBufferFromFile(
     int & fd_,
     const std::string & original_file_name,
     size_t buf_size,
+    ThrottlerPtr throttler_,
     char * existing_memory,
     size_t alignment)
-    : WriteBufferFromFileDescriptor(fd_, buf_size, existing_memory, alignment, original_file_name)
+    : WriteBufferFromFileDescriptor(fd_, buf_size, existing_memory, throttler_, alignment, original_file_name)
 {
     fd_ = -1;
 }
diff --git a/src/IO/WriteBufferFromFile.h b/src/IO/WriteBufferFromFile.h
index 3363a568bac..57847d893af 100644
--- a/src/IO/WriteBufferFromFile.h
+++ b/src/IO/WriteBufferFromFile.h
@@ -3,6 +3,7 @@
 #include <sys/types.h>
 
 #include <Common/CurrentMetrics.h>
+#include <Common/Throttler_fwd.h>
 #include <IO/WriteBufferFromFileDescriptor.h>
 
 
@@ -32,6 +33,7 @@ public:
         const std::string & file_name_,
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
         int flags = -1,
+        ThrottlerPtr throttler_ = {},
         mode_t mode = 0666,
         char * existing_memory = nullptr,
         size_t alignment = 0);
@@ -41,6 +43,7 @@ public:
         int & fd,   /// Will be set to -1 if constructor didn't throw and ownership of file descriptor is passed to the object.
         const std::string & original_file_name = {},
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
+        ThrottlerPtr throttler_ = {},
         char * existing_memory = nullptr,
         size_t alignment = 0);
 
diff --git a/src/IO/WriteBufferFromFileDescriptor.cpp b/src/IO/WriteBufferFromFileDescriptor.cpp
index ba49c16c11f..135ff608967 100644
--- a/src/IO/WriteBufferFromFileDescriptor.cpp
+++ b/src/IO/WriteBufferFromFileDescriptor.cpp
@@ -3,6 +3,7 @@
 #include <cassert>
 #include <sys/stat.h>
 
+#include <Common/Throttler.h>
 #include <Common/Exception.h>
 #include <Common/ProfileEvents.h>
 #include <Common/CurrentMetrics.h>
@@ -20,6 +21,8 @@ namespace ProfileEvents
     extern const Event DiskWriteElapsedMicroseconds;
     extern const Event FileSync;
     extern const Event FileSyncElapsedMicroseconds;
+    extern const Event LocalWriteThrottlerBytes;
+    extern const Event LocalWriteThrottlerSleepMicroseconds;
 }
 
 namespace CurrentMetrics
@@ -71,7 +74,11 @@ void WriteBufferFromFileDescriptor::nextImpl()
         }
 
         if (res > 0)
+        {
             bytes_written += res;
+            if (throttler)
+                throttler->add(res, ProfileEvents::LocalWriteThrottlerBytes, ProfileEvents::LocalWriteThrottlerSleepMicroseconds);
+        }
     }
 
     ProfileEvents::increment(ProfileEvents::DiskWriteElapsedMicroseconds, watch.elapsedMicroseconds());
@@ -85,10 +92,12 @@ WriteBufferFromFileDescriptor::WriteBufferFromFileDescriptor(
     int fd_,
     size_t buf_size,
     char * existing_memory,
+    ThrottlerPtr throttler_,
     size_t alignment,
     std::string file_name_)
     : WriteBufferFromFileBase(buf_size, existing_memory, alignment)
     , fd(fd_)
+    , throttler(throttler_)
     , file_name(std::move(file_name_))
 {
 }
diff --git a/src/IO/WriteBufferFromFileDescriptor.h b/src/IO/WriteBufferFromFileDescriptor.h
index cc69567932f..cb73b1e1d08 100644
--- a/src/IO/WriteBufferFromFileDescriptor.h
+++ b/src/IO/WriteBufferFromFileDescriptor.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <IO/WriteBufferFromFileBase.h>
+#include <Common/Throttler_fwd.h>
 
 
 namespace DB
@@ -15,6 +16,7 @@ public:
         int fd_ = -1,
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
         char * existing_memory = nullptr,
+        ThrottlerPtr throttler_ = {},
         size_t alignment = 0,
         std::string file_name_ = "");
 
@@ -49,6 +51,7 @@ protected:
     void nextImpl() override;
 
     int fd;
+    ThrottlerPtr throttler;
 
     /// If file has name contains filename, otherwise contains string "(fd=...)"
     std::string file_name;
diff --git a/src/IO/WriteBufferFromTemporaryFile.cpp b/src/IO/WriteBufferFromTemporaryFile.cpp
index 4467a3d3d62..6528175cdb4 100644
--- a/src/IO/WriteBufferFromTemporaryFile.cpp
+++ b/src/IO/WriteBufferFromTemporaryFile.cpp
@@ -14,7 +14,7 @@ namespace ErrorCodes
 
 
 WriteBufferFromTemporaryFile::WriteBufferFromTemporaryFile(std::unique_ptr<PocoTemporaryFile> && tmp_file_)
-    : WriteBufferFromFile(tmp_file_->path(), DBMS_DEFAULT_BUFFER_SIZE, O_RDWR | O_TRUNC | O_CREAT, 0600), tmp_file(std::move(tmp_file_))
+    : WriteBufferFromFile(tmp_file_->path(), DBMS_DEFAULT_BUFFER_SIZE, O_RDWR | O_TRUNC | O_CREAT, /* throttler= */ {}, 0600), tmp_file(std::move(tmp_file_))
 {}
 
 
diff --git a/src/IO/WriteSettings.h b/src/IO/WriteSettings.h
index e7cd229bd6c..e160796d9a3 100644
--- a/src/IO/WriteSettings.h
+++ b/src/IO/WriteSettings.h
@@ -11,6 +11,7 @@ struct WriteSettings
 {
     /// Bandwidth throttler to use during writing
     ThrottlerPtr remote_throttler;
+    ThrottlerPtr local_throttler;
 
     // Resource to be used during reading
     ResourceLink resource_link;
diff --git a/src/IO/examples/o_direct_and_dirty_pages.cpp b/src/IO/examples/o_direct_and_dirty_pages.cpp
index 228b7ffe146..85a29830af2 100644
--- a/src/IO/examples/o_direct_and_dirty_pages.cpp
+++ b/src/IO/examples/o_direct_and_dirty_pages.cpp
@@ -46,7 +46,7 @@ int main(int, char **)
         /// Write to file with O_DIRECT, read as usual.
 
         {
-            WriteBufferFromFile wb("test2", BUF_SIZE, O_WRONLY | O_CREAT | O_TRUNC | O_DIRECT, 0666, nullptr, page_size);
+            WriteBufferFromFile wb("test2", BUF_SIZE, O_WRONLY | O_CREAT | O_TRUNC | O_DIRECT, /* throttler= */ {}, 0666, nullptr, page_size);
 
             for (size_t i = 0; i < N; ++i)
                 writeStringBinary(test, wb);
diff --git a/src/Interpreters/ClusterProxy/executeQuery.cpp b/src/Interpreters/ClusterProxy/executeQuery.cpp
index 439033f89f2..e2f1dfe8ba7 100644
--- a/src/Interpreters/ClusterProxy/executeQuery.cpp
+++ b/src/Interpreters/ClusterProxy/executeQuery.cpp
@@ -275,7 +275,9 @@ void executeQueryWithParallelReplicas(
     auto shard_info = not_optimized_cluster->getShardsInfo().front();
 
     const auto & settings = context->getSettingsRef();
-    auto all_replicas_count = std::min(static_cast<size_t>(settings.max_parallel_replicas), shard_info.all_addresses.size());
+    ClusterPtr new_cluster = not_optimized_cluster->getClusterWithReplicasAsShards(settings);
+
+    auto all_replicas_count = std::min(static_cast<size_t>(settings.max_parallel_replicas), new_cluster->getShardCount());
     auto coordinator = std::make_shared<ParallelReplicasReadingCoordinator>(all_replicas_count);
     auto remote_plan = std::make_unique<QueryPlan>();
     auto plans = std::vector<QueryPlanPtr>();
@@ -287,35 +289,13 @@ void executeQueryWithParallelReplicas(
     /// to then tell it about the reading method we chose.
     query_info.coordinator = coordinator;
 
-    UUID parallel_group_id = UUIDHelpers::generateV4();
-
-    plans.emplace_back(createLocalPlan(
-        query_ast,
-        stream_factory.header,
-        context,
-        stream_factory.processed_stage,
-        shard_info.shard_num,
-        /*shard_count*/1,
-        0,
-        all_replicas_count,
-        coordinator,
-        parallel_group_id));
-
-    if (!shard_info.hasRemoteConnections())
-    {
-        if (!plans.front())
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "An empty plan was generated to read from local shard and there is no remote connections. This is a bug");
-        query_plan = std::move(*plans.front());
-        return;
-    }
-
     auto new_context = Context::createCopy(context);
     auto scalars = new_context->hasQueryContext() ? new_context->getQueryContext()->getScalars() : Scalars{};
     auto external_tables = new_context->getExternalTables();
 
     auto read_from_remote = std::make_unique<ReadFromParallelRemoteReplicasStep>(
         query_ast,
-        std::move(shard_info),
+        new_cluster,
         coordinator,
         stream_factory.header,
         stream_factory.processed_stage,
@@ -326,8 +306,7 @@ void executeQueryWithParallelReplicas(
         std::move(scalars),
         std::move(external_tables),
         &Poco::Logger::get("ReadFromParallelRemoteReplicasStep"),
-        query_info.storage_limits,
-        parallel_group_id);
+        query_info.storage_limits);
 
     remote_plan->addStep(std::move(read_from_remote));
     remote_plan->addInterpreterContext(context);
diff --git a/src/Interpreters/Context.cpp b/src/Interpreters/Context.cpp
index 1358eb52cc4..d97473d0a36 100644
--- a/src/Interpreters/Context.cpp
+++ b/src/Interpreters/Context.cpp
@@ -19,6 +19,7 @@
 #include <Coordination/KeeperDispatcher.h>
 #include <Compression/ICompressionCodec.h>
 #include <Core/BackgroundSchedulePool.h>
+#include <Core/ServerSettings.h>
 #include <Formats/FormatFactory.h>
 #include <Databases/IDatabase.h>
 #include <Storages/IStorage.h>
@@ -42,7 +43,6 @@
 #include <Interpreters/ExternalLoaderXMLConfigRepository.h>
 #include <Interpreters/TemporaryDataOnDisk.h>
 #include <Interpreters/Cache/QueryCache.h>
-#include <Core/ServerSettings.h>
 #include <Core/Settings.h>
 #include <Core/SettingsQuirks.h>
 #include <Access/AccessControl.h>
@@ -276,9 +276,15 @@ struct ContextSharedPart : boost::noncopyable
 
     mutable ThrottlerPtr replicated_fetches_throttler;      /// A server-wide throttler for replicated fetches
     mutable ThrottlerPtr replicated_sends_throttler;        /// A server-wide throttler for replicated sends
+
     mutable ThrottlerPtr remote_read_throttler;             /// A server-wide throttler for remote IO reads
     mutable ThrottlerPtr remote_write_throttler;            /// A server-wide throttler for remote IO writes
 
+    mutable ThrottlerPtr local_read_throttler;              /// A server-wide throttler for local IO reads
+    mutable ThrottlerPtr local_write_throttler;             /// A server-wide throttler for local IO writes
+
+    mutable ThrottlerPtr backups_server_throttler;          /// A server-wide throttler for BACKUPs
+
     MultiVersion<Macros> macros;                            /// Substitutions extracted from config.
     std::unique_ptr<DDLWorker> ddl_worker;                  /// Process ddl commands from zk.
     /// Rules for selecting the compression settings, depending on the size of the part.
@@ -288,6 +294,8 @@ struct ContextSharedPart : boost::noncopyable
     /// Storage policy chooser for MergeTree engines
     mutable std::shared_ptr<const StoragePolicySelector> merge_tree_storage_policy_selector;
 
+    ServerSettings server_settings;
+
     std::optional<MergeTreeSettings> merge_tree_settings;   /// Settings of MergeTree* engines.
     std::optional<MergeTreeSettings> replicated_merge_tree_settings;   /// Settings of ReplicatedMergeTree* engines.
     std::atomic_size_t max_table_size_to_drop = 50000000000lu; /// Protects MergeTree tables from accidental DROP (50GB by default)
@@ -1757,6 +1765,32 @@ ContextMutablePtr Context::getBufferContext() const
     return buffer_context;
 }
 
+void Context::makeQueryContext()
+{
+    query_context = shared_from_this();
+
+    /// Create throttlers, to inherit the ThrottlePtr in the context copies.
+    {
+        getRemoteReadThrottler();
+        getRemoteWriteThrottler();
+
+        getLocalReadThrottler();
+        getLocalWriteThrottler();
+
+        getBackupsThrottler();
+    }
+}
+
+void Context::makeSessionContext()
+{
+    session_context = shared_from_this();
+}
+
+void Context::makeGlobalContext()
+{
+    initGlobal();
+    global_context = shared_from_this();
+}
 
 const EmbeddedDictionaries & Context::getEmbeddedDictionaries() const
 {
@@ -2188,11 +2222,8 @@ BackgroundSchedulePool & Context::getBufferFlushSchedulePool() const
     auto lock = getLock();
     if (!shared->buffer_flush_schedule_pool)
     {
-        ServerSettings server_settings;
-        server_settings.loadSettingsFromConfig(getConfigRef());
-
         shared->buffer_flush_schedule_pool = std::make_unique<BackgroundSchedulePool>(
-            server_settings.background_buffer_flush_schedule_pool_size,
+            shared->server_settings.background_buffer_flush_schedule_pool_size,
             CurrentMetrics::BackgroundBufferFlushSchedulePoolTask,
             CurrentMetrics::BackgroundBufferFlushSchedulePoolSize,
             "BgBufSchPool");
@@ -2237,11 +2268,8 @@ BackgroundSchedulePool & Context::getSchedulePool() const
     auto lock = getLock();
     if (!shared->schedule_pool)
     {
-        ServerSettings server_settings;
-        server_settings.loadSettingsFromConfig(getConfigRef());
-
         shared->schedule_pool = std::make_unique<BackgroundSchedulePool>(
-            server_settings.background_schedule_pool_size,
+            shared->server_settings.background_schedule_pool_size,
             CurrentMetrics::BackgroundSchedulePoolTask,
             CurrentMetrics::BackgroundSchedulePoolSize,
             "BgSchPool");
@@ -2255,11 +2283,8 @@ BackgroundSchedulePool & Context::getDistributedSchedulePool() const
     auto lock = getLock();
     if (!shared->distributed_schedule_pool)
     {
-        ServerSettings server_settings;
-        server_settings.loadSettingsFromConfig(getConfigRef());
-
         shared->distributed_schedule_pool = std::make_unique<BackgroundSchedulePool>(
-            server_settings.background_distributed_schedule_pool_size,
+            shared->server_settings.background_distributed_schedule_pool_size,
             CurrentMetrics::BackgroundDistributedSchedulePoolTask,
             CurrentMetrics::BackgroundDistributedSchedulePoolSize,
             "BgDistSchPool");
@@ -2273,11 +2298,8 @@ BackgroundSchedulePool & Context::getMessageBrokerSchedulePool() const
     auto lock = getLock();
     if (!shared->message_broker_schedule_pool)
     {
-        ServerSettings server_settings;
-        server_settings.loadSettingsFromConfig(getConfigRef());
-
         shared->message_broker_schedule_pool = std::make_unique<BackgroundSchedulePool>(
-            server_settings.background_message_broker_schedule_pool_size,
+            shared->server_settings.background_message_broker_schedule_pool_size,
             CurrentMetrics::BackgroundMessageBrokerSchedulePoolTask,
             CurrentMetrics::BackgroundMessageBrokerSchedulePoolSize,
             "BgMBSchPool");
@@ -2308,22 +2330,124 @@ ThrottlerPtr Context::getReplicatedSendsThrottler() const
 
 ThrottlerPtr Context::getRemoteReadThrottler() const
 {
-    auto lock = getLock();
-    if (!shared->remote_read_throttler)
-        shared->remote_read_throttler = std::make_shared<Throttler>(
-            settings.max_remote_read_network_bandwidth_for_server);
+    ThrottlerPtr throttler;
 
-    return shared->remote_read_throttler;
+    const auto & query_settings = getSettingsRef();
+    UInt64 bandwidth_for_server = shared->server_settings.max_remote_read_network_bandwidth_for_server;
+    if (bandwidth_for_server)
+    {
+        auto lock = getLock();
+        if (!shared->remote_read_throttler)
+            shared->remote_read_throttler = std::make_shared<Throttler>(bandwidth_for_server);
+        throttler = shared->remote_read_throttler;
+    }
+
+    if (query_settings.max_remote_read_network_bandwidth)
+    {
+        auto lock = getLock();
+        if (!remote_read_query_throttler)
+            remote_read_query_throttler = std::make_shared<Throttler>(query_settings.max_remote_read_network_bandwidth, throttler);
+        throttler = remote_read_query_throttler;
+    }
+
+    return throttler;
 }
 
 ThrottlerPtr Context::getRemoteWriteThrottler() const
 {
-    auto lock = getLock();
-    if (!shared->remote_write_throttler)
-        shared->remote_write_throttler = std::make_shared<Throttler>(
-            settings.max_remote_write_network_bandwidth_for_server);
+    ThrottlerPtr throttler;
 
-    return shared->remote_write_throttler;
+    const auto & query_settings = getSettingsRef();
+    UInt64 bandwidth_for_server = shared->server_settings.max_remote_write_network_bandwidth_for_server;
+    if (bandwidth_for_server)
+    {
+        auto lock = getLock();
+        if (!shared->remote_write_throttler)
+            shared->remote_write_throttler = std::make_shared<Throttler>(bandwidth_for_server);
+        throttler = shared->remote_write_throttler;
+    }
+
+    if (query_settings.max_remote_write_network_bandwidth)
+    {
+        auto lock = getLock();
+        if (!remote_write_query_throttler)
+            remote_write_query_throttler = std::make_shared<Throttler>(query_settings.max_remote_write_network_bandwidth, throttler);
+        throttler = remote_write_query_throttler;
+    }
+
+    return throttler;
+}
+
+ThrottlerPtr Context::getLocalReadThrottler() const
+{
+    ThrottlerPtr throttler;
+
+    if (shared->server_settings.max_local_read_bandwidth_for_server)
+    {
+        auto lock = getLock();
+        if (!shared->local_read_throttler)
+            shared->local_read_throttler = std::make_shared<Throttler>(shared->server_settings.max_local_read_bandwidth_for_server);
+        throttler = shared->local_read_throttler;
+    }
+
+    const auto & query_settings = getSettingsRef();
+    if (query_settings.max_local_read_bandwidth)
+    {
+        auto lock = getLock();
+        if (!local_read_query_throttler)
+            local_read_query_throttler = std::make_shared<Throttler>(query_settings.max_local_read_bandwidth, throttler);
+        throttler = local_read_query_throttler;
+    }
+
+    return throttler;
+}
+
+ThrottlerPtr Context::getLocalWriteThrottler() const
+{
+    ThrottlerPtr throttler;
+
+    if (shared->server_settings.max_local_write_bandwidth_for_server)
+    {
+        auto lock = getLock();
+        if (!shared->local_write_throttler)
+            shared->local_write_throttler = std::make_shared<Throttler>(shared->server_settings.max_local_write_bandwidth_for_server);
+        throttler = shared->local_write_throttler;
+    }
+
+    const auto & query_settings = getSettingsRef();
+    if (query_settings.max_local_write_bandwidth)
+    {
+        auto lock = getLock();
+        if (!local_write_query_throttler)
+            local_write_query_throttler = std::make_shared<Throttler>(query_settings.max_local_write_bandwidth, throttler);
+        throttler = local_write_query_throttler;
+    }
+
+    return throttler;
+}
+
+ThrottlerPtr Context::getBackupsThrottler() const
+{
+    ThrottlerPtr throttler;
+
+    if (shared->server_settings.max_backup_bandwidth_for_server)
+    {
+        auto lock = getLock();
+        if (!shared->backups_server_throttler)
+            shared->backups_server_throttler = std::make_shared<Throttler>(shared->server_settings.max_backup_bandwidth_for_server);
+        throttler = shared->backups_server_throttler;
+    }
+
+    const auto & query_settings = getSettingsRef();
+    if (query_settings.max_backup_bandwidth)
+    {
+        auto lock = getLock();
+        if (!backups_query_throttler)
+            backups_query_throttler = std::make_shared<Throttler>(query_settings.max_backup_bandwidth, throttler);
+        throttler = backups_query_throttler;
+    }
+
+    return throttler;
 }
 
 bool Context::hasDistributedDDL() const
@@ -3357,6 +3481,9 @@ void Context::setApplicationType(ApplicationType type)
 {
     /// Lock isn't required, you should set it at start
     shared->application_type = type;
+
+    if (type == ApplicationType::SERVER)
+        shared->server_settings.loadSettingsFromConfig(Poco::Util::Application::instance().config());
 }
 
 void Context::setDefaultProfiles(const Poco::Util::AbstractConfiguration & config)
@@ -3813,11 +3940,7 @@ void Context::initializeBackgroundExecutorsIfNeeded()
     if (shared->are_background_executors_initialized)
         return;
 
-    const auto & config = getConfigRef();
-
-    ServerSettings server_settings;
-    server_settings.loadSettingsFromConfig(config);
-
+    const ServerSettings & server_settings = shared->server_settings;
     size_t background_pool_size = server_settings.background_pool_size;
     auto background_merges_mutations_concurrency_ratio = server_settings.background_merges_mutations_concurrency_ratio;
     size_t background_pool_max_tasks_count = static_cast<size_t>(background_pool_size * background_merges_mutations_concurrency_ratio);
@@ -4034,6 +4157,7 @@ ReadSettings Context::getReadSettings() const
     res.priority = settings.read_priority;
 
     res.remote_throttler = getRemoteReadThrottler();
+    res.local_throttler = getLocalReadThrottler();
 
     res.http_max_tries = settings.http_max_tries;
     res.http_retry_initial_backoff_ms = settings.http_retry_initial_backoff_ms;
@@ -4045,6 +4169,14 @@ ReadSettings Context::getReadSettings() const
     return res;
 }
 
+ReadSettings Context::getBackupReadSettings() const
+{
+    ReadSettings settings = getReadSettings();
+    settings.remote_throttler = getBackupsThrottler();
+    settings.local_throttler = getBackupsThrottler();
+    return settings;
+}
+
 WriteSettings Context::getWriteSettings() const
 {
     WriteSettings res;
@@ -4056,6 +4188,7 @@ WriteSettings Context::getWriteSettings() const
     res.s3_allow_parallel_part_upload = settings.s3_allow_parallel_part_upload;
 
     res.remote_throttler = getRemoteWriteThrottler();
+    res.local_throttler = getLocalWriteThrottler();
 
     return res;
 }
diff --git a/src/Interpreters/Context.h b/src/Interpreters/Context.h
index bbfbd4defdc..99e83046323 100644
--- a/src/Interpreters/Context.h
+++ b/src/Interpreters/Context.h
@@ -6,6 +6,7 @@
 #include <Common/OpenTelemetryTraceContext.h>
 #include <Common/RemoteHostFilter.h>
 #include <Common/ThreadPool.h>
+#include <Common/Throttler_fwd.h>
 #include <Core/Block.h>
 #include <Core/NamesAndTypes.h>
 #include <Core/Settings.h>
@@ -18,8 +19,6 @@
 #include <IO/IResourceManager.h>
 #include <Parsers/ASTSelectQuery.h>
 #include <Parsers/IAST_fwd.h>
-#include <Processors/ResizeProcessor.h>
-#include <Processors/Transforms/ReadFromMergeTreeDependencyTransform.h>
 #include <Server/HTTP/HTTPContext.h>
 #include <Storages/ColumnsDescription.h>
 #include <Storages/IStorage_fwd.h>
@@ -163,9 +162,6 @@ struct BackgroundTaskSchedulingSettings;
     class Lemmatizers;
 #endif
 
-class Throttler;
-using ThrottlerPtr = std::shared_ptr<Throttler>;
-
 class ZooKeeperMetadataTransaction;
 using ZooKeeperMetadataTransactionPtr = std::shared_ptr<ZooKeeperMetadataTransaction>;
 
@@ -783,9 +779,9 @@ public:
     void setQueryContext(ContextMutablePtr context_) { query_context = context_; }
     void setSessionContext(ContextMutablePtr context_) { session_context = context_; }
 
-    void makeQueryContext() { query_context = shared_from_this(); }
-    void makeSessionContext() { session_context = shared_from_this(); }
-    void makeGlobalContext() { initGlobal(); global_context = shared_from_this(); }
+    void makeQueryContext();
+    void makeSessionContext();
+    void makeGlobalContext();
 
     const Settings & getSettingsRef() const { return settings; }
 
@@ -916,11 +912,6 @@ public:
     BackgroundSchedulePool & getMessageBrokerSchedulePool() const;
     BackgroundSchedulePool & getDistributedSchedulePool() const;
 
-    ThrottlerPtr getReplicatedFetchesThrottler() const;
-    ThrottlerPtr getReplicatedSendsThrottler() const;
-    ThrottlerPtr getRemoteReadThrottler() const;
-    ThrottlerPtr getRemoteWriteThrottler() const;
-
     /// Has distributed_ddl configuration or not.
     bool hasDistributedDDL() const;
     void setDDLWorker(std::unique_ptr<DDLWorker> ddl_worker);
@@ -1116,6 +1107,9 @@ public:
     /** Get settings for reading from filesystem. */
     ReadSettings getReadSettings() const;
 
+    /** Get settings for reading from filesystem for BACKUPs. */
+    ReadSettings getBackupReadSettings() const;
+
     /** Get settings for writing to filesystem. */
     WriteSettings getWriteSettings() const;
 
@@ -1152,6 +1146,28 @@ private:
     DiskSelectorPtr getDiskSelector(std::lock_guard<std::mutex> & lock) const;
 
     DisksMap getDisksMap(std::lock_guard<std::mutex> & lock) const;
+
+    /// Throttling
+public:
+    ThrottlerPtr getReplicatedFetchesThrottler() const;
+    ThrottlerPtr getReplicatedSendsThrottler() const;
+
+    ThrottlerPtr getRemoteReadThrottler() const;
+    ThrottlerPtr getRemoteWriteThrottler() const;
+
+    ThrottlerPtr getLocalReadThrottler() const;
+    ThrottlerPtr getLocalWriteThrottler() const;
+
+    ThrottlerPtr getBackupsThrottler() const;
+
+private:
+    mutable ThrottlerPtr remote_read_query_throttler;       /// A query-wide throttler for remote IO reads
+    mutable ThrottlerPtr remote_write_query_throttler;      /// A query-wide throttler for remote IO writes
+
+    mutable ThrottlerPtr local_read_query_throttler;        /// A query-wide throttler for local IO reads
+    mutable ThrottlerPtr local_write_query_throttler;       /// A query-wide throttler for local IO writes
+
+    mutable ThrottlerPtr backups_query_throttler;           /// A query-wide throttler for BACKUPs
 };
 
 struct HTTPContext : public IHTTPContext
diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp
index e471f279a14..a24d9312e46 100644
--- a/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/src/Interpreters/InterpreterSelectQuery.cpp
@@ -462,6 +462,20 @@ InterpreterSelectQuery::InterpreterSelectQuery(
         context->setSetting("parallel_replicas_custom_key", String{""});
     }
 
+    /// Try to execute query without parallel replicas if we find that there is a FINAL modifier there.
+    bool is_query_with_final = false;
+    if (query_info.table_expression_modifiers)
+        is_query_with_final = query_info.table_expression_modifiers->hasFinal();
+    else if (query_info.query)
+        is_query_with_final = query_info.query->as<ASTSelectQuery &>().final();
+
+    if (is_query_with_final && (!settings.parallel_replicas_custom_key.value.empty() || settings.allow_experimental_parallel_reading_from_replicas))
+    {
+        LOG_WARNING(log, "FINAL modifier is supported with parallel replicas. Will try to execute the query without using them.");
+        context->setSetting("allow_experimental_parallel_reading_from_replicas", false);
+        context->setSetting("parallel_replicas_custom_key", String{""});
+    }
+
     /// Rewrite JOINs
     if (!has_input && joined_tables.tablesCount() > 1)
     {
diff --git a/src/Interpreters/Session.cpp b/src/Interpreters/Session.cpp
index f0bb339e278..64f7b4fc934 100644
--- a/src/Interpreters/Session.cpp
+++ b/src/Interpreters/Session.cpp
@@ -107,7 +107,7 @@ public:
         if (it == sessions.end())
         {
             if (throw_if_not_found)
-                throw Exception(ErrorCodes::SESSION_NOT_FOUND, "Session not found.");
+                throw Exception(ErrorCodes::SESSION_NOT_FOUND, "Session {} not found", session_id);
 
             /// Create a new session from current context.
             auto context = Context::createCopy(global_context);
@@ -129,7 +129,7 @@ public:
             LOG_TEST(log, "Reuse session from storage with session_id: {}, user_id: {}", key.second, key.first);
 
             if (!session.unique())
-                throw Exception(ErrorCodes::SESSION_IS_LOCKED, "Session is locked by a concurrent client.");
+                throw Exception(ErrorCodes::SESSION_IS_LOCKED, "Session {} is locked by a concurrent client", session_id);
             return {session, false};
         }
     }
diff --git a/src/Processors/Executors/ExecutingGraph.cpp b/src/Processors/Executors/ExecutingGraph.cpp
index 9ec9cd2e0e4..574b1ccbcd2 100644
--- a/src/Processors/Executors/ExecutingGraph.cpp
+++ b/src/Processors/Executors/ExecutingGraph.cpp
@@ -122,13 +122,8 @@ bool ExecutingGraph::expandPipeline(std::stack<uint64_t> & stack, uint64_t pid)
         }
         processors->insert(processors->end(), new_processors.begin(), new_processors.end());
 
-        source_processors.reserve(source_processors.size() + new_processors.size());
-
-        for (auto & proc: new_processors)
-        {
-            bool is_source = proc->getInputs().empty();
-            source_processors.emplace_back(is_source);
-        }
+        // Do not consider sources added during pipeline expansion as cancelable to avoid tricky corner cases (e.g. ConvertingAggregatedToChunksWithMergingSource cancellation)
+        source_processors.resize(source_processors.size() + new_processors.size(), false);
     }
 
     uint64_t num_processors = processors->size();
diff --git a/src/Processors/Formats/Impl/BSONEachRowRowInputFormat.cpp b/src/Processors/Formats/Impl/BSONEachRowRowInputFormat.cpp
index 9e3a4a85c9a..370cddd2dcb 100644
--- a/src/Processors/Formats/Impl/BSONEachRowRowInputFormat.cpp
+++ b/src/Processors/Formats/Impl/BSONEachRowRowInputFormat.cpp
@@ -446,11 +446,6 @@ void BSONEachRowRowInputFormat::readMap(IColumn & column, const DataTypePtr & da
 
     const auto * data_type_map = assert_cast<const DataTypeMap *>(data_type.get());
     const auto & key_data_type = data_type_map->getKeyType();
-    if (!isStringOrFixedString(key_data_type))
-        throw Exception(ErrorCodes::ILLEGAL_COLUMN,
-                        "Only maps with String key type are supported in BSON, got key type: {}",
-                        key_data_type->getName());
-
     const auto & value_data_type = data_type_map->getValueType();
     auto & column_map = assert_cast<ColumnMap &>(column);
     auto & key_column = column_map.getNestedData().getColumn(0);
@@ -464,7 +459,8 @@ void BSONEachRowRowInputFormat::readMap(IColumn & column, const DataTypePtr & da
     {
         auto nested_bson_type = getBSONType(readBSONType(*in));
         auto name = readBSONKeyName(*in, current_key_name);
-        key_column.insertData(name.data, name.size);
+        ReadBufferFromMemory buf(name.data, name.size);
+        key_data_type->getDefaultSerialization()->deserializeWholeText(key_column, buf, format_settings);
         readField(value_column, value_data_type, nested_bson_type);
     }
 
@@ -511,6 +507,7 @@ bool BSONEachRowRowInputFormat::readField(IColumn & column, const DataTypePtr &
             lc_column.insertFromFullColumn(*tmp_column, 0);
             return res;
         }
+        case TypeIndex::Enum8: [[fallthrough]];
         case TypeIndex::Int8:
         {
             readAndInsertInteger<Int8>(*in, column, data_type, bson_type);
@@ -521,6 +518,7 @@ bool BSONEachRowRowInputFormat::readField(IColumn & column, const DataTypePtr &
             readAndInsertInteger<UInt8>(*in, column, data_type, bson_type);
             return true;
         }
+        case TypeIndex::Enum16: [[fallthrough]];
         case TypeIndex::Int16:
         {
             readAndInsertInteger<Int16>(*in, column, data_type, bson_type);
@@ -1008,6 +1006,9 @@ fileSegmentationEngineBSONEachRow(ReadBuffer & in, DB::Memory<> & memory, size_t
                 "the value setting 'min_chunk_bytes_for_parallel_parsing' or check your data manually, most likely BSON is malformed",
                 min_bytes, document_size);
 
+        if (document_size < sizeof(document_size))
+            throw ParsingException(ErrorCodes::INCORRECT_DATA, "Size of BSON document is invalid");
+
         size_t old_size = memory.size();
         memory.resize(old_size + document_size);
         unalignedStore<BSONSizeT>(memory.data() + old_size, document_size);
diff --git a/src/Processors/Formats/Impl/BSONEachRowRowOutputFormat.cpp b/src/Processors/Formats/Impl/BSONEachRowRowOutputFormat.cpp
index 9093f72e2b1..2bb5410781c 100644
--- a/src/Processors/Formats/Impl/BSONEachRowRowOutputFormat.cpp
+++ b/src/Processors/Formats/Impl/BSONEachRowRowOutputFormat.cpp
@@ -33,13 +33,14 @@ namespace ErrorCodes
 }
 
 /// In BSON all names should be valid UTF8 sequences
-static String toValidUTF8String(const String & name)
+static String toValidUTF8String(const String & name, const FormatSettings & settings)
 {
     WriteBufferFromOwnString buf;
     WriteBufferValidUTF8 validating_buf(buf);
-    writeString(name, validating_buf);
+    writeJSONString(name, validating_buf, settings);
     validating_buf.finalize();
-    return buf.str();
+    /// Return value without quotes
+    return buf.str().substr(1, buf.str().size() - 2);
 }
 
 BSONEachRowRowOutputFormat::BSONEachRowRowOutputFormat(
@@ -49,7 +50,7 @@ BSONEachRowRowOutputFormat::BSONEachRowRowOutputFormat(
     const auto & sample = getPort(PortKind::Main).getHeader();
     fields.reserve(sample.columns());
     for (const auto & field : sample.getNamesAndTypes())
-        fields.emplace_back(toValidUTF8String(field.name), field.type);
+        fields.emplace_back(toValidUTF8String(field.name, settings), field.type);
 }
 
 static void writeBSONSize(size_t size, WriteBuffer & buf)
@@ -112,7 +113,7 @@ static void writeBSONBigInteger(const IColumn & column, size_t row_num, const St
     buf.write(data.data, data.size);
 }
 
-size_t BSONEachRowRowOutputFormat::countBSONFieldSize(const IColumn & column, const DataTypePtr & data_type, size_t row_num, const String & name)
+size_t BSONEachRowRowOutputFormat::countBSONFieldSize(const IColumn & column, const DataTypePtr & data_type, size_t row_num, const String & name, const String & path, std::unordered_map<String, size_t> & nested_document_sizes)
 {
     size_t size = 1; // Field type
     size += name.size() + 1; // Field name and \0
@@ -125,6 +126,8 @@ size_t BSONEachRowRowOutputFormat::countBSONFieldSize(const IColumn & column, co
         case TypeIndex::Date32: [[fallthrough]];
         case TypeIndex::Decimal32: [[fallthrough]];
         case TypeIndex::IPv4: [[fallthrough]];
+        case TypeIndex::Enum8: [[fallthrough]];
+        case TypeIndex::Enum16: [[fallthrough]];
         case TypeIndex::Int32:
         {
             return size + sizeof(Int32);
@@ -183,7 +186,7 @@ size_t BSONEachRowRowOutputFormat::countBSONFieldSize(const IColumn & column, co
             auto dict_type = assert_cast<const DataTypeLowCardinality *>(data_type.get())->getDictionaryType();
             auto dict_column = lc_column.getDictionary().getNestedColumn();
             size_t index = lc_column.getIndexAt(row_num);
-            return countBSONFieldSize(*dict_column, dict_type, index, name);
+            return countBSONFieldSize(*dict_column, dict_type, index, name, path, nested_document_sizes);
         }
         case TypeIndex::Nullable:
         {
@@ -191,11 +194,11 @@ size_t BSONEachRowRowOutputFormat::countBSONFieldSize(const IColumn & column, co
             const ColumnNullable & column_nullable = assert_cast<const ColumnNullable &>(column);
             if (column_nullable.isNullAt(row_num))
                 return size; /// Null has no value, just type
-            return countBSONFieldSize(column_nullable.getNestedColumn(), nested_type, row_num, name);
+            return countBSONFieldSize(column_nullable.getNestedColumn(), nested_type, row_num, name, path, nested_document_sizes);
         }
         case TypeIndex::Array:
         {
-            size += sizeof(BSONSizeT); // Size of a document
+            size_t document_size = sizeof(BSONSizeT); // Size of a document
 
             const auto & nested_type = assert_cast<const DataTypeArray *>(data_type.get())->getNestedType();
             const ColumnArray & column_array = assert_cast<const ColumnArray &>(column);
@@ -204,39 +207,41 @@ size_t BSONEachRowRowOutputFormat::countBSONFieldSize(const IColumn & column, co
             size_t offset = offsets[row_num - 1];
             size_t array_size = offsets[row_num] - offset;
 
+            String current_path = path + "." + name;
             for (size_t i = 0; i < array_size; ++i)
-                size += countBSONFieldSize(nested_column, nested_type, offset + i, std::to_string(i)); // Add size of each value from array
+                document_size += countBSONFieldSize(nested_column, nested_type, offset + i, std::to_string(i), current_path, nested_document_sizes); // Add size of each value from array
 
-            return size + sizeof(BSON_DOCUMENT_END); // Add final \0
+            document_size += sizeof(BSON_DOCUMENT_END); // Add final \0
+            nested_document_sizes[current_path] = document_size;
+            return size + document_size;
         }
         case TypeIndex::Tuple:
         {
-            size += sizeof(BSONSizeT); // Size of a document
+            size_t document_size = sizeof(BSONSizeT); // Size of a document
 
             const auto * tuple_type = assert_cast<const DataTypeTuple *>(data_type.get());
             const auto & nested_types = tuple_type->getElements();
-            bool have_explicit_names = tuple_type->haveExplicitNames();
             const auto & nested_names = tuple_type->getElementNames();
             const auto & tuple_column = assert_cast<const ColumnTuple &>(column);
             const auto & nested_columns = tuple_column.getColumns();
 
+            String current_path = path + "." + name;
             for (size_t i = 0; i < nested_columns.size(); ++i)
             {
-                String key_name = have_explicit_names ? toValidUTF8String(nested_names[i]) : std::to_string(i);
-                size += countBSONFieldSize(*nested_columns[i], nested_types[i], row_num, key_name); // Add size of each value from tuple
+                String key_name = toValidUTF8String(nested_names[i], settings);
+                document_size += countBSONFieldSize(*nested_columns[i], nested_types[i], row_num, key_name, current_path, nested_document_sizes); // Add size of each value from tuple
             }
 
-            return size + sizeof(BSON_DOCUMENT_END); // Add final \0
+            document_size += sizeof(BSON_DOCUMENT_END); // Add final \0
+            nested_document_sizes[current_path] = document_size;
+            return size + document_size;
         }
         case TypeIndex::Map:
         {
-            size += sizeof(BSONSizeT); // Size of a document
+            size_t document_size = sizeof(BSONSizeT); // Size of a document
 
             const auto & map_type = assert_cast<const DataTypeMap &>(*data_type);
-            if (!isStringOrFixedString(map_type.getKeyType()))
-                throw Exception(ErrorCodes::ILLEGAL_COLUMN,
-                                "Only maps with String key type are supported in BSON, got key type: {}",
-                                map_type.getKeyType()->getName());
+            const auto & key_type = map_type.getKeyType();
             const auto & value_type = map_type.getValueType();
 
             const auto & map_column = assert_cast<const ColumnMap &>(column);
@@ -248,20 +253,26 @@ size_t BSONEachRowRowOutputFormat::countBSONFieldSize(const IColumn & column, co
             size_t offset = offsets[row_num - 1];
             size_t map_size = offsets[row_num] - offset;
 
+            WriteBufferFromOwnString buf;
+            String current_path = path + "." + name;
             for (size_t i = 0; i < map_size; ++i)
             {
-                String key = toValidUTF8String(key_column->getDataAt(offset + i).toString());
-                size += countBSONFieldSize(*value_column, value_type, offset + i, key);
+                key_type->getDefaultSerialization()->serializeText(*key_column, offset + i, buf, settings);
+                auto s = countBSONFieldSize(*value_column, value_type, offset + i, toValidUTF8String(buf.str(), settings), current_path, nested_document_sizes);
+                document_size += s;
+                buf.restart();
             }
 
-            return size + sizeof(BSON_DOCUMENT_END); // Add final \0
+            document_size += sizeof(BSON_DOCUMENT_END); // Add final \0
+            nested_document_sizes[current_path] = document_size;
+            return size + document_size;
         }
         default:
             throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Type {} is not supported in BSON output format", data_type->getName());
     }
 }
 
-void BSONEachRowRowOutputFormat::serializeField(const IColumn & column, const DataTypePtr & data_type, size_t row_num, const String & name)
+void BSONEachRowRowOutputFormat::serializeField(const IColumn & column, const DataTypePtr & data_type, size_t row_num, const String & name, const String & path, std::unordered_map<String, size_t> & nested_document_sizes)
 {
     switch (data_type->getTypeId())
     {
@@ -275,6 +286,7 @@ void BSONEachRowRowOutputFormat::serializeField(const IColumn & column, const Da
             writeBSONNumber<ColumnFloat64, double>(BSONType::DOUBLE, column, row_num, name, out);
             break;
         }
+        case TypeIndex::Enum8: [[fallthrough]];
         case TypeIndex::Int8:
         {
             writeBSONNumber<ColumnInt8, Int32>(BSONType::INT32, column, row_num, name, out);
@@ -288,6 +300,7 @@ void BSONEachRowRowOutputFormat::serializeField(const IColumn & column, const Da
                 writeBSONNumber<ColumnUInt8, Int32>(BSONType::INT32, column, row_num, name, out);
             break;
         }
+        case TypeIndex::Enum16: [[fallthrough]];
         case TypeIndex::Int16:
         {
             writeBSONNumber<ColumnInt16, Int32>(BSONType::INT32, column, row_num, name, out);
@@ -403,7 +416,7 @@ void BSONEachRowRowOutputFormat::serializeField(const IColumn & column, const Da
             auto dict_type = assert_cast<const DataTypeLowCardinality *>(data_type.get())->getDictionaryType();
             auto dict_column = lc_column.getDictionary().getNestedColumn();
             size_t index = lc_column.getIndexAt(row_num);
-            serializeField(*dict_column, dict_type, index, name);
+            serializeField(*dict_column, dict_type, index, name, path, nested_document_sizes);
             break;
         }
         case TypeIndex::Nullable:
@@ -411,7 +424,7 @@ void BSONEachRowRowOutputFormat::serializeField(const IColumn & column, const Da
             auto nested_type = removeNullable(data_type);
             const ColumnNullable & column_nullable = assert_cast<const ColumnNullable &>(column);
             if (!column_nullable.isNullAt(row_num))
-                serializeField(column_nullable.getNestedColumn(), nested_type, row_num, name);
+                serializeField(column_nullable.getNestedColumn(), nested_type, row_num, name, path, nested_document_sizes);
             else
                 writeBSONTypeAndKeyName(BSONType::NULL_VALUE, name, out);
             break;
@@ -427,15 +440,12 @@ void BSONEachRowRowOutputFormat::serializeField(const IColumn & column, const Da
 
             writeBSONTypeAndKeyName(BSONType::ARRAY, name, out);
 
-            size_t document_size = sizeof(BSONSizeT);
-            for (size_t i = 0; i < array_size; ++i)
-                document_size += countBSONFieldSize(nested_column, nested_type, offset + i, std::to_string(i)); // Add size of each value from array
-            document_size += sizeof(BSON_DOCUMENT_END); // Add final \0
-
+            String current_path = path + "." + name;
+            size_t document_size = nested_document_sizes[current_path];
             writeBSONSize(document_size, out);
 
             for (size_t i = 0; i < array_size; ++i)
-                serializeField(nested_column, nested_type, offset + i, std::to_string(i));
+                serializeField(nested_column, nested_type, offset + i, std::to_string(i), current_path, nested_document_sizes);
 
             writeChar(BSON_DOCUMENT_END, out);
             break;
@@ -444,26 +454,19 @@ void BSONEachRowRowOutputFormat::serializeField(const IColumn & column, const Da
         {
             const auto * tuple_type = assert_cast<const DataTypeTuple *>(data_type.get());
             const auto & nested_types = tuple_type->getElements();
-            bool have_explicit_names = tuple_type->haveExplicitNames();
             const auto & nested_names = tuple_type->getElementNames();
             const auto & tuple_column = assert_cast<const ColumnTuple &>(column);
             const auto & nested_columns = tuple_column.getColumns();
 
-            BSONType bson_type = have_explicit_names ? BSONType::DOCUMENT : BSONType::ARRAY;
+            BSONType bson_type =  tuple_type->haveExplicitNames() ? BSONType::DOCUMENT : BSONType::ARRAY;
             writeBSONTypeAndKeyName(bson_type, name, out);
 
-            size_t document_size = sizeof(BSONSizeT);
-            for (size_t i = 0; i < nested_columns.size(); ++i)
-            {
-                String key_name = have_explicit_names ? toValidUTF8String(nested_names[i]) : std::to_string(i);
-                document_size += countBSONFieldSize(*nested_columns[i], nested_types[i], row_num, key_name); // Add size of each value from tuple
-            }
-            document_size += sizeof(BSON_DOCUMENT_END); // Add final \0
-
+            String current_path = path + "." + name;
+            size_t document_size = nested_document_sizes[current_path];
             writeBSONSize(document_size, out);
 
             for (size_t i = 0; i < nested_columns.size(); ++i)
-                serializeField(*nested_columns[i], nested_types[i], row_num, have_explicit_names ? toValidUTF8String(nested_names[i]) : std::to_string(i));
+                serializeField(*nested_columns[i], nested_types[i], row_num, toValidUTF8String(nested_names[i], settings), current_path, nested_document_sizes);
 
             writeChar(BSON_DOCUMENT_END, out);
             break;
@@ -471,10 +474,7 @@ void BSONEachRowRowOutputFormat::serializeField(const IColumn & column, const Da
         case TypeIndex::Map:
         {
             const auto & map_type = assert_cast<const DataTypeMap &>(*data_type);
-            if (!isStringOrFixedString(map_type.getKeyType()))
-                throw Exception(ErrorCodes::ILLEGAL_COLUMN,
-                                "Only maps with String key type are supported in BSON, got key type: {}",
-                                map_type.getKeyType()->getName());
+            const auto & key_type = map_type.getKeyType();
             const auto & value_type = map_type.getValueType();
 
             const auto & map_column = assert_cast<const ColumnMap &>(column);
@@ -488,20 +488,16 @@ void BSONEachRowRowOutputFormat::serializeField(const IColumn & column, const Da
 
             writeBSONTypeAndKeyName(BSONType::DOCUMENT, name, out);
 
-            size_t document_size = sizeof(BSONSizeT);
-            for (size_t i = 0; i < map_size; ++i)
-            {
-                String key = toValidUTF8String(key_column->getDataAt(offset + i).toString());
-                document_size += countBSONFieldSize(*value_column, value_type, offset + i, key);
-            }
-            document_size += sizeof(BSON_DOCUMENT_END);
-
+            String current_path = path + "." + name;
+            size_t document_size = nested_document_sizes[current_path];
             writeBSONSize(document_size, out);
 
+            WriteBufferFromOwnString buf;
             for (size_t i = 0; i < map_size; ++i)
             {
-                String key = toValidUTF8String(key_column->getDataAt(offset + i).toString());
-                serializeField(*value_column, value_type, offset + i, key);
+                key_type->getDefaultSerialization()->serializeText(*key_column, offset + i, buf, settings);
+                serializeField(*value_column, value_type, offset + i, toValidUTF8String(buf.str(), settings), current_path, nested_document_sizes);
+                buf.restart();
             }
 
             writeChar(BSON_DOCUMENT_END, out);
@@ -516,15 +512,18 @@ void BSONEachRowRowOutputFormat::write(const Columns & columns, size_t row_num)
 {
     /// We should calculate and write document size before its content
     size_t document_size = sizeof(BSONSizeT);
+    /// Remember calculated sizes for nested documents (map document path -> size), so we won't need
+    /// to recalculate it while serializing.
+    std::unordered_map<String, size_t> nested_document_sizes;
     for (size_t i = 0; i != columns.size(); ++i)
-        document_size += countBSONFieldSize(*columns[i], fields[i].type, row_num, fields[i].name);
+        document_size += countBSONFieldSize(*columns[i], fields[i].type, row_num, fields[i].name, "$", nested_document_sizes);
     document_size += sizeof(BSON_DOCUMENT_END);
 
     size_t document_start = out.count();
     writeBSONSize(document_size, out);
 
     for (size_t i = 0; i != columns.size(); ++i)
-        serializeField(*columns[i], fields[i].type, row_num, fields[i].name);
+        serializeField(*columns[i], fields[i].type, row_num, fields[i].name, "$", nested_document_sizes);
 
     writeChar(BSON_DOCUMENT_END, out);
 
diff --git a/src/Processors/Formats/Impl/BSONEachRowRowOutputFormat.h b/src/Processors/Formats/Impl/BSONEachRowRowOutputFormat.h
index d6fcd38c841..d885cd497af 100644
--- a/src/Processors/Formats/Impl/BSONEachRowRowOutputFormat.h
+++ b/src/Processors/Formats/Impl/BSONEachRowRowOutputFormat.h
@@ -17,8 +17,8 @@ namespace DB
  *
  * ClickHouse type         | BSON Type
  * Bool                    | \x08 boolean
- * Int8/UInt8              | \x10 int32
- * Int16UInt16             | \x10 int32
+ * Int8/UInt8/Enum8        | \x10 int32
+ * Int16UInt16/Enum16      | \x10 int32
  * Int32                   | \x10 int32
  * UInt32                  | \x12 int64
  * Int64                   | \x12 int64
@@ -38,7 +38,7 @@ namespace DB
  * Array                   | \x04 array
  * Tuple                   | \x04 array
  * Named Tuple             | \x03 document
- * Map (with String keys)  | \x03 document
+ * Map                     | \x03 document
  *
  * Note: on Big-Endian platforms this format will not work properly.
  */
@@ -55,12 +55,24 @@ private:
     void write(const Columns & columns, size_t row_num) override;
     void writeField(const IColumn &, const ISerialization &, size_t) override { }
 
-    void serializeField(const IColumn & column, const DataTypePtr & data_type, size_t row_num, const String & name);
+    void serializeField(
+        const IColumn & column,
+        const DataTypePtr & data_type,
+        size_t row_num,
+        const String & name,
+        const String & path,
+        std::unordered_map<String, size_t> & nested_document_sizes);
 
     /// Count field size in bytes that we will get after serialization in BSON format.
     /// It's needed to calculate document size before actual serialization,
     /// because in BSON format we should write the size of the document before its content.
-    size_t countBSONFieldSize(const IColumn & column, const DataTypePtr & data_type, size_t row_num, const String & name);
+    size_t countBSONFieldSize(
+        const IColumn & column,
+        const DataTypePtr & data_type,
+        size_t row_num,
+        const String & name,
+        const String & path,
+        std::unordered_map<String, size_t> & nested_document_sizes);
 
     NamesAndTypes fields;
     FormatSettings settings;
diff --git a/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp b/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
index 9f37bcc3219..2f84e9bde3c 100644
--- a/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
+++ b/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
@@ -16,6 +16,7 @@
 #include <Columns/ColumnLowCardinality.h>
 #include <Columns/ColumnNullable.h>
 #include <Columns/ColumnDecimal.h>
+#include <Columns/ColumnMap.h>
 
 #include <DataTypes/DataTypeEnum.h>
 #include <DataTypes/DataTypeArray.h>
@@ -23,6 +24,7 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypeLowCardinality.h>
+#include <DataTypes/DataTypeMap.h>
 
 namespace DB
 {
@@ -80,22 +82,39 @@ kj::Array<capnp::word> CapnProtoRowInputFormat::readMessage()
     return msg;
 }
 
-static void insertSignedInteger(IColumn & column, const DataTypePtr & column_type, Int64 value)
+static void insertInteger(IColumn & column, const DataTypePtr & column_type, UInt64 value)
 {
     switch (column_type->getTypeId())
     {
         case TypeIndex::Int8:
             assert_cast<ColumnInt8 &>(column).insertValue(value);
             break;
+        case TypeIndex::UInt8:
+            assert_cast<ColumnUInt8 &>(column).insertValue(value);
+            break;
         case TypeIndex::Int16:
             assert_cast<ColumnInt16 &>(column).insertValue(value);
             break;
+        case TypeIndex::Date: [[fallthrough]];
+        case TypeIndex::UInt16:
+            assert_cast<ColumnUInt16 &>(column).insertValue(value);
+            break;
         case TypeIndex::Int32:
             assert_cast<ColumnInt32 &>(column).insertValue(static_cast<Int32>(value));
             break;
+        case TypeIndex::DateTime: [[fallthrough]];
+        case TypeIndex::UInt32:
+            assert_cast<ColumnUInt32 &>(column).insertValue(static_cast<UInt32>(value));
+            break;
+        case TypeIndex::IPv4:
+            assert_cast<ColumnIPv4 &>(column).insertValue(IPv4(static_cast<UInt32>(value)));
+            break;
         case TypeIndex::Int64:
             assert_cast<ColumnInt64 &>(column).insertValue(value);
             break;
+        case TypeIndex::UInt64:
+            assert_cast<ColumnUInt64 &>(column).insertValue(value);
+            break;
         case TypeIndex::DateTime64:
             assert_cast<ColumnDecimal<DateTime64> &>(column).insertValue(value);
             break;
@@ -106,33 +125,7 @@ static void insertSignedInteger(IColumn & column, const DataTypePtr & column_typ
             assert_cast<ColumnDecimal<Decimal64> &>(column).insertValue(value);
             break;
         default:
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Column type is not a signed integer.");
-    }
-}
-
-static void insertUnsignedInteger(IColumn & column, const DataTypePtr & column_type, UInt64 value)
-{
-    switch (column_type->getTypeId())
-    {
-        case TypeIndex::UInt8:
-            assert_cast<ColumnUInt8 &>(column).insertValue(value);
-            break;
-        case TypeIndex::Date: [[fallthrough]];
-        case TypeIndex::UInt16:
-            assert_cast<ColumnUInt16 &>(column).insertValue(value);
-            break;
-        case TypeIndex::DateTime: [[fallthrough]];
-        case TypeIndex::UInt32:
-            assert_cast<ColumnUInt32 &>(column).insertValue(static_cast<UInt32>(value));
-            break;
-        case TypeIndex::UInt64:
-            assert_cast<ColumnUInt64 &>(column).insertValue(value);
-            break;
-        case TypeIndex::IPv4:
-            assert_cast<ColumnIPv4 &>(column).insertValue(IPv4(static_cast<UInt32>(value)));
-            break;
-        default:
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Column type is not an unsigned integer.");
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Column type {} cannot be parsed from integer", column_type->getName());
     }
 }
 
@@ -152,8 +145,11 @@ static void insertFloat(IColumn & column, const DataTypePtr & column_type, Float
 }
 
 template <typename Value>
-static void insertString(IColumn & column, Value value)
+static void insertData(IColumn & column, const DataTypePtr & column_type, Value value)
 {
+    if (column_type->haveMaximumSizeOfValue() && value.size() != column_type->getSizeOfValueInMemory())
+        throw Exception(ErrorCodes::INCORRECT_DATA, "Unexpected size of {} value: {}", column_type->getName(), value.size());
+
     column.insertData(reinterpret_cast<const char *>(value.begin()), value.size());
 }
 
@@ -166,10 +162,10 @@ static void insertEnum(IColumn & column, const DataTypePtr & column_type, const
     switch (enum_comparing_mode)
     {
         case FormatSettings::EnumComparingMode::BY_VALUES:
-            insertSignedInteger(column, nested_type, Int64(enumerant.getOrdinal()));
+            insertInteger(column, nested_type, Int64(enumerant.getOrdinal()));
             return;
         case FormatSettings::EnumComparingMode::BY_NAMES:
-            insertSignedInteger(column, nested_type, Int64(enum_type->getValue(String(enumerant.getProto().getName()))));
+            insertInteger(column, nested_type, Int64(enum_type->getValue(String(enumerant.getProto().getName()))));
             return;
         case FormatSettings::EnumComparingMode::BY_NAMES_CASE_INSENSITIVE:
         {
@@ -179,7 +175,7 @@ static void insertEnum(IColumn & column, const DataTypePtr & column_type, const
             {
                 if (compareEnumNames(name, enum_name, enum_comparing_mode))
                 {
-                    insertSignedInteger(column, nested_type, Int64(enum_type->getValue(name)));
+                    insertInteger(column, nested_type, Int64(enum_type->getValue(name)));
                     break;
                 }
             }
@@ -202,22 +198,22 @@ static void insertValue(IColumn & column, const DataTypePtr & column_type, const
     switch (value.getType())
     {
         case capnp::DynamicValue::Type::INT:
-            insertSignedInteger(column, column_type, value.as<Int64>());
+            insertInteger(column, column_type, value.as<Int64>());
             break;
         case capnp::DynamicValue::Type::UINT:
-            insertUnsignedInteger(column, column_type, value.as<UInt64>());
+            insertInteger(column, column_type, value.as<UInt64>());
             break;
         case capnp::DynamicValue::Type::FLOAT:
             insertFloat(column, column_type, value.as<Float64>());
             break;
         case capnp::DynamicValue::Type::BOOL:
-            insertUnsignedInteger(column, column_type, UInt64(value.as<bool>()));
+            insertInteger(column, column_type, UInt64(value.as<bool>()));
             break;
         case capnp::DynamicValue::Type::DATA:
-            insertString(column, value.as<capnp::Data>());
+            insertData(column, column_type, value.as<capnp::Data>());
             break;
         case capnp::DynamicValue::Type::TEXT:
-            insertString(column, value.as<capnp::Text>());
+            insertData(column, column_type, value.as<capnp::Text>());
             break;
         case capnp::DynamicValue::Type::ENUM:
             if (column_type->getTypeId() == TypeIndex::Enum8)
@@ -260,14 +256,26 @@ static void insertValue(IColumn & column, const DataTypePtr & column_type, const
             {
                 auto & tuple_column = assert_cast<ColumnTuple &>(column);
                 const auto * tuple_type = assert_cast<const DataTypeTuple *>(column_type.get());
-                for (size_t i = 0; i != tuple_column.tupleSize(); ++i)
+                bool have_explicit_names = tuple_type->haveExplicitNames();
+                auto struct_schema = struct_value.getSchema();
+                for (uint32_t i = 0; i != tuple_column.tupleSize(); ++i)
                     insertValue(
                         tuple_column.getColumn(i),
                         tuple_type->getElements()[i],
                         tuple_type->getElementNames()[i],
-                        struct_value.get(tuple_type->getElementNames()[i]),
+                        struct_value.get(have_explicit_names ? struct_schema.getFieldByName(tuple_type->getElementNames()[i]) : struct_schema.getFields()[i]),
                         enum_comparing_mode);
             }
+            else if (isMap(column_type))
+            {
+                const auto & map_type = assert_cast<const DataTypeMap &>(*column_type);
+                DataTypes key_value_types = {map_type.getKeyType(), map_type.getValueType()};
+                Names key_value_names = {"key", "value"};
+                auto entries_type = std::make_shared<DataTypeArray>(std::make_shared<DataTypeTuple>(key_value_types, key_value_names));
+                auto & entries_column = assert_cast<ColumnMap &>(column).getNestedColumn();
+                auto entries_field = struct_value.getSchema().getFields()[0];
+                insertValue(entries_column, entries_type, column_name, struct_value.get(entries_field), enum_comparing_mode);
+            }
             else
             {
                 /// It can be nested column from Nested type.
diff --git a/src/Processors/Formats/Impl/CapnProtoRowOutputFormat.cpp b/src/Processors/Formats/Impl/CapnProtoRowOutputFormat.cpp
index c0f61bbd586..0225680b396 100644
--- a/src/Processors/Formats/Impl/CapnProtoRowOutputFormat.cpp
+++ b/src/Processors/Formats/Impl/CapnProtoRowOutputFormat.cpp
@@ -14,12 +14,14 @@
 #include <Columns/ColumnTuple.h>
 #include <Columns/ColumnLowCardinality.h>
 #include <Columns/ColumnDecimal.h>
+#include <Columns/ColumnMap.h>
 
 #include <DataTypes/DataTypeArray.h>
 #include <DataTypes/DataTypeEnum.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypeLowCardinality.h>
+#include <DataTypes/DataTypeMap.h>
 
 namespace DB
 {
@@ -177,18 +179,46 @@ static std::optional<capnp::DynamicValue::Reader> convertToDynamicValue(
             else if (isTuple(data_type))
             {
                 const auto * tuple_data_type = assert_cast<const DataTypeTuple *>(data_type.get());
-                auto nested_types = tuple_data_type->getElements();
+                const auto & nested_types = tuple_data_type->getElements();
+                const auto & nested_names = tuple_data_type->getElementNames();
                 const auto & nested_columns = assert_cast<const ColumnTuple *>(column.get())->getColumns();
-                for (const auto & name : tuple_data_type->getElementNames())
+                bool have_explicit_names = tuple_data_type->haveExplicitNames();
+                for (uint32_t i = 0; i != nested_names.size(); ++i)
                 {
-                    auto pos = tuple_data_type->getPositionByName(name);
-                    auto field_builder
-                        = initStructFieldBuilder(nested_columns[pos], row_num, struct_builder, nested_struct_schema.getFieldByName(name));
-                    auto value = convertToDynamicValue(nested_columns[pos], nested_types[pos], row_num, column_name, field_builder, enum_comparing_mode, temporary_text_data_storage);
+                    capnp::StructSchema::Field nested_field = have_explicit_names ? nested_struct_schema.getFieldByName(nested_names[i]) : nested_struct_schema.getFields()[i];
+                    auto field_builder = initStructFieldBuilder(nested_columns[i], row_num, struct_builder, nested_field);
+                    auto value = convertToDynamicValue(nested_columns[i], nested_types[i], row_num, nested_names[i], field_builder, enum_comparing_mode, temporary_text_data_storage);
                     if (value)
-                        struct_builder.set(name, *value);
+                        struct_builder.set(nested_field, *value);
                 }
             }
+            else if (isMap(data_type))
+            {
+                /// We output Map type as follow CapnProto schema
+                ///
+                /// struct Map {
+                ///     struct Entry {
+                ///         key @0: Key;
+                ///         value @1: Value;
+                ///     }
+                ///     entries @0 :List(Entry);
+                /// }
+                ///
+                /// And we don't need to check that struct have this form here because we checked it before.
+                const auto & map_type = assert_cast<const DataTypeMap &>(*data_type);
+                DataTypes key_value_types = {map_type.getKeyType(), map_type.getValueType()};
+                Names key_value_names = {"key", "value"};
+                auto entries_type = std::make_shared<DataTypeArray>(std::make_shared<DataTypeTuple>(key_value_types, key_value_names));
+
+                /// Nested column in Map is actually Array(Tuple), so we can output it according to "entries" field schema.
+                const auto & entries_column = assert_cast<const ColumnMap *>(column.get())->getNestedColumnPtr();
+
+                auto entries_field = nested_struct_schema.getFields()[0];
+                auto field_builder = initStructFieldBuilder(entries_column, row_num, struct_builder, entries_field);
+                auto entries_value = convertToDynamicValue(entries_column, entries_type, row_num, column_name, field_builder, enum_comparing_mode, temporary_text_data_storage);
+                if (entries_value)
+                    struct_builder.set(entries_field, *entries_value);
+            }
             else
             {
                 /// It can be nested column from Nested type.
diff --git a/src/Processors/QueryPlan/QueryPlan.cpp b/src/Processors/QueryPlan/QueryPlan.cpp
index 3d5bd0db6d0..3fbe3d89845 100644
--- a/src/Processors/QueryPlan/QueryPlan.cpp
+++ b/src/Processors/QueryPlan/QueryPlan.cpp
@@ -201,13 +201,6 @@ QueryPipelineBuilderPtr QueryPlan::buildQueryPipeline(
     last_pipeline->setProcessListElement(build_pipeline_settings.process_list_element);
     last_pipeline->addResources(std::move(resources));
 
-    /// This is related to parallel replicas.
-    /// Not to let the remote sources starve for CPU we create an
-    /// explicit dependency between processors which read from local replica
-    /// and ones that receive data from remote replicas and constantly answer
-    /// to coordination packets.
-    last_pipeline->connectDependencies();
-
     return last_pipeline;
 }
 
diff --git a/src/Processors/QueryPlan/ReadFromMergeTree.cpp b/src/Processors/QueryPlan/ReadFromMergeTree.cpp
index a3e53df6279..185ec9bace8 100644
--- a/src/Processors/QueryPlan/ReadFromMergeTree.cpp
+++ b/src/Processors/QueryPlan/ReadFromMergeTree.cpp
@@ -19,7 +19,6 @@
 #include <Processors/Sources/NullSource.h>
 #include <Processors/Transforms/ExpressionTransform.h>
 #include <Processors/Transforms/FilterTransform.h>
-#include <Processors/Transforms/ReadFromMergeTreeDependencyTransform.h>
 #include <Processors/Transforms/ReverseTransform.h>
 #include <QueryPipeline/QueryPipelineBuilder.h>
 #include <Storages/MergeTree/MergeTreeDataSelectExecutor.h>
@@ -100,6 +99,7 @@ namespace ErrorCodes
     extern const int INDEX_NOT_USED;
     extern const int LOGICAL_ERROR;
     extern const int TOO_MANY_ROWS;
+    extern const int SUPPORT_IS_DISABLED;
 }
 
 static MergeTreeReaderSettings getMergeTreeReaderSettings(
@@ -295,9 +295,7 @@ Pipe ReadFromMergeTree::readFromPoolParallelReplicas(
 
     /// We have a special logic for local replica. It has to read less data, because in some cases it should
     /// merge states of aggregate functions or do some other important stuff other than reading from Disk.
-    auto is_local_replica = context->getClientInfo().interface == ClientInfo::Interface::LOCAL;
-    if (!is_local_replica)
-        min_marks_for_concurrent_read = static_cast<size_t>(min_marks_for_concurrent_read * context->getSettingsRef().parallel_replicas_single_task_marks_count_multiplier);
+    min_marks_for_concurrent_read = static_cast<size_t>(min_marks_for_concurrent_read * context->getSettingsRef().parallel_replicas_single_task_marks_count_multiplier);
 
     auto pool = std::make_shared<MergeTreeReadPoolParallelReplicas>(
         storage_snapshot,
@@ -334,16 +332,6 @@ Pipe ReadFromMergeTree::readFromPoolParallelReplicas(
             source->addTotalRowsApprox(total_rows);
 
         pipes.emplace_back(std::move(source));
-
-        /// Add a special dependency transform which will be connected later with
-        /// all RemoteSources through a simple scheduler (ResizeProcessor)
-        if (context->getClientInfo().interface == ClientInfo::Interface::LOCAL)
-        {
-            pipes.back().addSimpleTransform([&](const Block & header) -> ProcessorPtr
-            {
-                return std::make_shared<ReadFromMergeTreeDependencyTransform>(header, context->getParallelReplicasGroupUUID());
-            });
-        }
     }
 
     return Pipe::unitePipes(std::move(pipes));
@@ -749,12 +737,8 @@ Pipe ReadFromMergeTree::spreadMarkRangesAmongStreamsWithOrder(
             .colums_to_read = column_names
         };
 
-        /// We have a special logic for local replica. It has to read less data, because in some cases it should
-        /// merge states of aggregate functions or do some other important stuff other than reading from Disk.
-        auto is_local_replica = context->getClientInfo().interface == ClientInfo::Interface::LOCAL;
         auto min_marks_for_concurrent_read = info.min_marks_for_concurrent_read;
-        if (!is_local_replica)
-            min_marks_for_concurrent_read = static_cast<size_t>(min_marks_for_concurrent_read * settings.parallel_replicas_single_task_marks_count_multiplier);
+        min_marks_for_concurrent_read = static_cast<size_t>(min_marks_for_concurrent_read * settings.parallel_replicas_single_task_marks_count_multiplier);
 
         pool = std::make_shared<MergeTreeInOrderReadPoolParallelReplicas>(
             parts_with_ranges,
@@ -1553,18 +1537,10 @@ Pipe ReadFromMergeTree::spreadMarkRanges(
         column_names_to_read.erase(std::unique(column_names_to_read.begin(), column_names_to_read.end()), column_names_to_read.end());
     }
 
-    /// Construct a proper coordinator
-    if (input_order_info && is_parallel_reading_from_replicas && context->getClientInfo().interface == ClientInfo::Interface::LOCAL)
-    {
-        assert(context->parallel_reading_coordinator);
-        auto mode = input_order_info->direction == 1 ? CoordinationMode::WithOrder : CoordinationMode::ReverseOrder;
-        context->parallel_reading_coordinator->setMode(mode);
-    }
-
     if (final)
     {
         if (is_parallel_reading_from_replicas)
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Final modifier is not supported with parallel replicas");
+            throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, "FINAL modifier is not supported with parallel replicas");
 
         if (output_each_partition_through_separate_port)
             throw Exception(ErrorCodes::LOGICAL_ERROR, "Optimisation isn't supposed to be used for queries with final");
diff --git a/src/Processors/QueryPlan/ReadFromRemote.cpp b/src/Processors/QueryPlan/ReadFromRemote.cpp
index 63325488e90..8482312dbf3 100644
--- a/src/Processors/QueryPlan/ReadFromRemote.cpp
+++ b/src/Processors/QueryPlan/ReadFromRemote.cpp
@@ -11,7 +11,6 @@
 #include <Processors/Sources/RemoteSource.h>
 #include <Processors/Sources/DelayedSource.h>
 #include <Processors/Transforms/ExpressionTransform.h>
-#include <Processors/Transforms/ReadFromMergeTreeDependencyTransform.h>
 #include <Interpreters/ActionsDAG.h>
 #include "Common/logger_useful.h"
 #include <Common/checkStackSize.h>
@@ -270,7 +269,7 @@ void ReadFromRemote::initializePipeline(QueryPipelineBuilder & pipeline, const B
 
 ReadFromParallelRemoteReplicasStep::ReadFromParallelRemoteReplicasStep(
     ASTPtr query_ast_,
-    Cluster::ShardInfo shard_info_,
+    ClusterPtr cluster_,
     ParallelReplicasReadingCoordinatorPtr coordinator_,
     Block header_,
     QueryProcessingStage::Enum stage_,
@@ -281,10 +280,9 @@ ReadFromParallelRemoteReplicasStep::ReadFromParallelRemoteReplicasStep(
     Scalars scalars_,
     Tables external_tables_,
     Poco::Logger * log_,
-    std::shared_ptr<const StorageLimitsList> storage_limits_,
-    UUID uuid_)
+    std::shared_ptr<const StorageLimitsList> storage_limits_)
     : ISourceStep(DataStream{.header = std::move(header_)})
-    , shard_info(shard_info_)
+    , cluster(cluster_)
     , query_ast(query_ast_)
     , coordinator(std::move(coordinator_))
     , stage(std::move(stage_))
@@ -296,13 +294,11 @@ ReadFromParallelRemoteReplicasStep::ReadFromParallelRemoteReplicasStep(
     , external_tables{external_tables_}
     , storage_limits(std::move(storage_limits_))
     , log(log_)
-    , uuid(uuid_)
 {
     std::vector<String> description;
 
-    for (const auto & address : shard_info.all_addresses)
-        if (!address.is_local)
-            description.push_back(fmt::format("Replica: {}", address.host_name));
+    for (const auto & address : cluster->getShardsAddresses())
+        description.push_back(fmt::format("Replica: {}", address[0].host_name));
 
     setStepDescription(boost::algorithm::join(description, ", "));
 }
@@ -324,42 +320,49 @@ void ReadFromParallelRemoteReplicasStep::initializePipeline(QueryPipelineBuilder
     auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(current_settings);
 
     size_t all_replicas_count = current_settings.max_parallel_replicas;
-    if (all_replicas_count > shard_info.all_addresses.size())
+    if (all_replicas_count > cluster->getShardsInfo().size())
     {
         LOG_INFO(&Poco::Logger::get("ReadFromParallelRemoteReplicasStep"),
             "The number of replicas requested ({}) is bigger than the real number available in the cluster ({}). "\
-            "Will use the latter number to execute the query.", current_settings.max_parallel_replicas, shard_info.all_addresses.size());
-        all_replicas_count = shard_info.all_addresses.size();
+            "Will use the latter number to execute the query.", current_settings.max_parallel_replicas, cluster->getShardsInfo().size());
+        all_replicas_count = cluster->getShardsInfo().size();
     }
 
-    /// The requested number of replicas to read from could be less
-    /// than the total number of replicas in the shard
-    /// And we have to pick only "remote" ones
-    /// So, that's why this loop looks like this.
-    size_t replica_num = 0;
-    while (pipes.size() != all_replicas_count - 1)
+    /// Find local shard
+    for (const auto & shard: cluster->getShardsInfo())
     {
-        if (shard_info.all_addresses[replica_num].is_local)
+        if (shard.isLocal())
         {
-            ++replica_num;
+            IConnections::ReplicaInfo replica_info
+            {
+                .all_replicas_count = all_replicas_count,
+                .number_of_current_replica = 0
+            };
+
+            addPipeForSingeReplica(pipes, shard.pool, replica_info);
+        }
+    }
+
+    if (pipes.empty())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "No local shard");
+
+    auto current_shard = cluster->getShardsInfo().begin();
+    while (pipes.size() != all_replicas_count)
+    {
+        if (current_shard->isLocal())
+        {
+            ++current_shard;
             continue;
         }
 
         IConnections::ReplicaInfo replica_info
         {
             .all_replicas_count = all_replicas_count,
-            /// Replica 0 is threated as local always
-            .number_of_current_replica = pipes.size() + 1
+            .number_of_current_replica = pipes.size()
         };
 
-        auto pool = shard_info.per_replica_pools[replica_num];
-        assert(pool);
-
-        auto pool_with_failover = std::make_shared<ConnectionPoolWithFailover>(
-            ConnectionPoolPtrs{pool}, current_settings.load_balancing);
-
-        addPipeForSingeReplica(pipes, std::move(pool_with_failover), replica_info);
-        ++replica_num;
+        addPipeForSingeReplica(pipes, current_shard->pool, replica_info);
+        ++current_shard;
     }
 
     auto pipe = Pipe::unitePipes(std::move(pipes));
@@ -396,7 +399,7 @@ void ReadFromParallelRemoteReplicasStep::addPipeForSingeReplica(Pipes & pipes, s
 
     remote_query_executor->setLogger(log);
 
-    pipes.emplace_back(createRemoteSourcePipe(std::move(remote_query_executor), add_agg_info, add_totals, add_extremes, async_read, uuid));
+    pipes.emplace_back(createRemoteSourcePipe(std::move(remote_query_executor), add_agg_info, add_totals, add_extremes, async_read));
     addConvertingActions(pipes.back(), output_stream->header);
 }
 
diff --git a/src/Processors/QueryPlan/ReadFromRemote.h b/src/Processors/QueryPlan/ReadFromRemote.h
index e1979ee1aaa..d4005d81f1b 100644
--- a/src/Processors/QueryPlan/ReadFromRemote.h
+++ b/src/Processors/QueryPlan/ReadFromRemote.h
@@ -66,7 +66,7 @@ class ReadFromParallelRemoteReplicasStep : public ISourceStep
 public:
     ReadFromParallelRemoteReplicasStep(
         ASTPtr query_ast_,
-        Cluster::ShardInfo shard_info,
+        ClusterPtr cluster_,
         ParallelReplicasReadingCoordinatorPtr coordinator_,
         Block header_,
         QueryProcessingStage::Enum stage_,
@@ -77,8 +77,7 @@ public:
         Scalars scalars_,
         Tables external_tables_,
         Poco::Logger * log_,
-        std::shared_ptr<const StorageLimitsList> storage_limits_,
-        UUID uuid);
+        std::shared_ptr<const StorageLimitsList> storage_limits_);
 
     String getName() const override { return "ReadFromRemoteParallelReplicas"; }
 
@@ -91,7 +90,7 @@ private:
 
     void addPipeForSingeReplica(Pipes & pipes, std::shared_ptr<ConnectionPoolWithFailover> pool, IConnections::ReplicaInfo replica_info);
 
-    Cluster::ShardInfo shard_info;
+    ClusterPtr cluster;
     ASTPtr query_ast;
     ParallelReplicasReadingCoordinatorPtr coordinator;
     QueryProcessingStage::Enum stage;
@@ -101,10 +100,8 @@ private:
     ThrottlerPtr throttler;
     Scalars scalars;
     Tables external_tables;
-
     std::shared_ptr<const StorageLimitsList> storage_limits;
     Poco::Logger * log;
-    UUID uuid;
 };
 
 }
diff --git a/src/Processors/Sources/RemoteSource.cpp b/src/Processors/Sources/RemoteSource.cpp
index aeb02b1dd02..ce7191adab0 100644
--- a/src/Processors/Sources/RemoteSource.cpp
+++ b/src/Processors/Sources/RemoteSource.cpp
@@ -14,11 +14,10 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
-RemoteSource::RemoteSource(RemoteQueryExecutorPtr executor, bool add_aggregation_info_, bool async_read_, UUID uuid_)
+RemoteSource::RemoteSource(RemoteQueryExecutorPtr executor, bool add_aggregation_info_, bool async_read_)
     : ISource(executor->getHeader(), false)
     , add_aggregation_info(add_aggregation_info_), query_executor(std::move(executor))
     , async_read(async_read_)
-    , uuid(uuid_)
 {
     /// Add AggregatedChunkInfo if we expect DataTypeAggregateFunction as a result.
     const auto & sample = getPort().getHeader();
@@ -29,18 +28,6 @@ RemoteSource::RemoteSource(RemoteQueryExecutorPtr executor, bool add_aggregation
 
 RemoteSource::~RemoteSource() = default;
 
-void RemoteSource::connectToScheduler(InputPort & input_port)
-{
-    outputs.emplace_back(Block{}, this);
-    dependency_port = &outputs.back();
-    connect(*dependency_port, input_port);
-}
-
-UUID RemoteSource::getParallelReplicasGroupUUID()
-{
-    return uuid;
-}
-
 void RemoteSource::setStorageLimits(const std::shared_ptr<const StorageLimitsList> & storage_limits_)
 {
     /// Remove leaf limits for remote source.
@@ -69,21 +56,10 @@ ISource::Status RemoteSource::prepare()
     if (status == Status::Finished)
     {
         query_executor->finish(&read_context);
-        if (dependency_port)
-            dependency_port->finish();
         is_async_state = false;
-
         return status;
     }
 
-    if (status == Status::PortFull || status == Status::Ready)
-    {
-        /// Also push empty chunk to dependency to signal that we read data from remote source
-        /// or answered to the incoming request from parallel replica
-        if (dependency_port && !dependency_port->isFinished() && dependency_port->canPush())
-            dependency_port->push(Chunk());
-    }
-
     return status;
 }
 
@@ -231,9 +207,9 @@ Chunk RemoteExtremesSource::generate()
 
 Pipe createRemoteSourcePipe(
     RemoteQueryExecutorPtr query_executor,
-    bool add_aggregation_info, bool add_totals, bool add_extremes, bool async_read, UUID uuid)
+    bool add_aggregation_info, bool add_totals, bool add_extremes, bool async_read)
 {
-    Pipe pipe(std::make_shared<RemoteSource>(query_executor, add_aggregation_info, async_read, uuid));
+    Pipe pipe(std::make_shared<RemoteSource>(query_executor, add_aggregation_info, async_read));
 
     if (add_totals)
         pipe.addTotalsSource(std::make_shared<RemoteTotalsSource>(query_executor));
diff --git a/src/Processors/Sources/RemoteSource.h b/src/Processors/Sources/RemoteSource.h
index e47bf3b578f..a98a17501ad 100644
--- a/src/Processors/Sources/RemoteSource.h
+++ b/src/Processors/Sources/RemoteSource.h
@@ -21,18 +21,14 @@ public:
     /// Flag add_aggregation_info tells if AggregatedChunkInfo should be added to result chunk.
     /// AggregatedChunkInfo stores the bucket number used for two-level aggregation.
     /// This flag should be typically enabled for queries with GROUP BY which are executed till WithMergeableState.
-    RemoteSource(RemoteQueryExecutorPtr executor, bool add_aggregation_info_, bool async_read_, UUID uuid = UUIDHelpers::Nil);
+    RemoteSource(RemoteQueryExecutorPtr executor, bool add_aggregation_info_, bool async_read_);
     ~RemoteSource() override;
 
     Status prepare() override;
     String getName() const override { return "Remote"; }
 
-    void connectToScheduler(InputPort & input_port);
-
     void setRowsBeforeLimitCounter(RowsBeforeLimitCounterPtr counter) override { rows_before_limit.swap(counter); }
 
-    UUID getParallelReplicasGroupUUID();
-
     /// Stop reading from stream if output port is finished.
     void onUpdatePorts() override;
 
@@ -51,12 +47,10 @@ private:
     RemoteQueryExecutorPtr query_executor;
     RowsBeforeLimitCounterPtr rows_before_limit;
 
-    OutputPort * dependency_port{nullptr};
-
     const bool async_read;
     bool is_async_state = false;
     std::unique_ptr<RemoteQueryExecutorReadContext> read_context;
-    UUID uuid;
+
     int fd = -1;
     size_t rows = 0;
     bool manually_add_rows_before_limit_counter = false;
@@ -97,6 +91,6 @@ private:
 /// Create pipe with remote sources.
 Pipe createRemoteSourcePipe(
     RemoteQueryExecutorPtr query_executor,
-    bool add_aggregation_info, bool add_totals, bool add_extremes, bool async_read, UUID uuid = UUIDHelpers::Nil);
+    bool add_aggregation_info, bool add_totals, bool add_extremes, bool async_read);
 
 }
diff --git a/src/Processors/Transforms/ReadFromMergeTreeDependencyTransform.cpp b/src/Processors/Transforms/ReadFromMergeTreeDependencyTransform.cpp
deleted file mode 100644
index 295eddb206d..00000000000
--- a/src/Processors/Transforms/ReadFromMergeTreeDependencyTransform.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#include <Processors/Transforms/ReadFromMergeTreeDependencyTransform.h>
-
-#include <QueryPipeline/RemoteQueryExecutor.h>
-#include "Processors/Port.h"
-
-namespace DB
-{
-
-ReadFromMergeTreeDependencyTransform::ReadFromMergeTreeDependencyTransform(const Block & header, UUID uuid_)
-    : IProcessor(InputPorts(1, header), OutputPorts(1, header))
-    , uuid(uuid_)
-    , data_port(&inputs.front())
-{
-}
-
-void ReadFromMergeTreeDependencyTransform::connectToScheduler(OutputPort & output_port)
-{
-    inputs.emplace_back(Block{}, this);
-    dependency_port = &inputs.back();
-    connect(output_port, *dependency_port);
-}
-
-UUID ReadFromMergeTreeDependencyTransform::getParallelReplicasGroupUUID()
-{
-    return uuid;
-}
-
-IProcessor::Status ReadFromMergeTreeDependencyTransform::prepare()
-{
-    Status status = Status::Ready;
-
-    while (status == Status::Ready)
-    {
-        status = !has_data ? prepareConsume()
-                           : prepareGenerate();
-    }
-
-    return status;
-}
-
-IProcessor::Status ReadFromMergeTreeDependencyTransform::prepareConsume()
-{
-    auto & output_port = getOutputPort();
-
-    /// Check all outputs are finished or ready to get data.
-    if (output_port.isFinished())
-    {
-        data_port->close();
-        dependency_port->close();
-        return Status::Finished;
-    }
-
-    /// Try get chunk from input.
-    if (data_port->isFinished())
-    {
-        if (dependency_port->hasData())
-            dependency_port->pull(true);
-        dependency_port->close();
-        output_port.finish();
-        return Status::Finished;
-    }
-
-    if (!dependency_port->isFinished())
-    {
-        dependency_port->setNeeded();
-        if (!dependency_port->hasData())
-            return Status::NeedData;
-    }
-
-    data_port->setNeeded();
-    if (!data_port->hasData())
-        return Status::NeedData;
-
-    if (!dependency_port->isFinished())
-        dependency_port->pull();
-
-    chunk = data_port->pull();
-    has_data = true;
-
-    return Status::Ready;
-}
-
-IProcessor::Status ReadFromMergeTreeDependencyTransform::prepareGenerate()
-{
-    auto & output_port = getOutputPort();
-    if (!output_port.isFinished() && output_port.canPush())
-    {
-        output_port.push(std::move(chunk));
-        has_data = false;
-        return Status::Ready;
-    }
-
-    if (output_port.isFinished())
-    {
-        data_port->close();
-        dependency_port->close();
-        return Status::Finished;
-    }
-
-    return Status::PortFull;
-}
-
-}
diff --git a/src/Processors/Transforms/ReadFromMergeTreeDependencyTransform.h b/src/Processors/Transforms/ReadFromMergeTreeDependencyTransform.h
deleted file mode 100644
index 929841e7ce0..00000000000
--- a/src/Processors/Transforms/ReadFromMergeTreeDependencyTransform.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-#include <Processors/IProcessor.h>
-
-namespace DB
-{
-
-class RemoteQueryExecutor;
-using RemoteQueryExecutorPtr = std::shared_ptr<RemoteQueryExecutor>;
-
-/// A tiny class which is used for reading with multiple replicas in parallel.
-/// Motivation is that we don't have a full control on how
-/// processors are scheduled across threads and there could be a situation
-/// when all available threads will read from local replica and will just
-/// forget about remote replicas existence. That is not what we want.
-/// For parallel replicas we have to constantly answer to incoming requests
-/// with a set of marks to read.
-/// With the help of this class, we explicitly connect a "local" source with
-/// all the remote ones. And thus achieve fairness somehow.
-class ReadFromMergeTreeDependencyTransform : public IProcessor
-{
-public:
-    ReadFromMergeTreeDependencyTransform(const Block & header, UUID uuid_);
-
-    String getName() const override { return "ReadFromMergeTreeDependency"; }
-    Status prepare() override;
-
-    InputPort & getInputPort() { assert(data_port); return *data_port; }
-    InputPort & getDependencyPort() { assert(dependency_port); return *dependency_port; }
-    OutputPort & getOutputPort() { return outputs.front(); }
-
-    UUID getParallelReplicasGroupUUID();
-
-    void connectToScheduler(OutputPort & output_port);
-private:
-    bool has_data{false};
-    Chunk chunk;
-
-    UUID uuid;
-
-    InputPort * data_port{nullptr};
-    InputPort * dependency_port{nullptr};
-
-    Status prepareGenerate();
-    Status prepareConsume();
-};
-
-
-}
diff --git a/src/Processors/Transforms/WindowTransform.cpp b/src/Processors/Transforms/WindowTransform.cpp
index c2293c3097d..04a1f12f30a 100644
--- a/src/Processors/Transforms/WindowTransform.cpp
+++ b/src/Processors/Transforms/WindowTransform.cpp
@@ -1981,7 +1981,7 @@ struct WindowFunctionNtile final : public WindowFunction
             throw Exception(ErrorCodes::BAD_ARGUMENTS, "Function {} takes exactly one parameter", name_);
         }
         auto type_id = argument_types[0]->getTypeId();
-        if (type_id != TypeIndex::UInt8 && type_id != TypeIndex::UInt16 && type_id != TypeIndex::UInt32 && type_id != TypeIndex::UInt32 && type_id != TypeIndex::UInt64)
+        if (type_id != TypeIndex::UInt8 && type_id != TypeIndex::UInt16 && type_id != TypeIndex::UInt32 && type_id != TypeIndex::UInt64)
         {
             throw Exception(ErrorCodes::BAD_ARGUMENTS, "ntile's argument type must be an unsigned integer (not larger then 64-bit), but got {}", argument_types[0]->getName());
         }
diff --git a/src/QueryPipeline/QueryPipelineBuilder.cpp b/src/QueryPipeline/QueryPipelineBuilder.cpp
index 07adc6b0b3a..a4edf107b2f 100644
--- a/src/QueryPipeline/QueryPipelineBuilder.cpp
+++ b/src/QueryPipeline/QueryPipelineBuilder.cpp
@@ -27,7 +27,6 @@
 #include <Processors/Transforms/MergeJoinTransform.h>
 #include <Processors/Transforms/MergingAggregatedMemoryEfficientTransform.h>
 #include <Processors/Transforms/PartialSortingTransform.h>
-#include <Processors/Transforms/ReadFromMergeTreeDependencyTransform.h>
 #include <Processors/Transforms/TotalsHavingTransform.h>
 #include <QueryPipeline/narrowPipe.h>
 
@@ -621,65 +620,6 @@ void QueryPipelineBuilder::setProgressCallback(ProgressCallback callback)
     progress_callback = callback;
 }
 
-void QueryPipelineBuilder::connectDependencies()
-{
-    /**
-    * This is needed because among all RemoteSources there could be
-    * one or several that don't belong to the parallel replicas reading process.
-    * It could happen for example if we read through distributed table + prefer_localhost_replica=1 + parallel replicas
-    * SELECT * FROM remote('127.0.0.{1,2}', table.merge_tree)
-    * Will generate a local pipeline and a remote source. For local pipeline because of parallel replicas we will create
-    * several processors to read and several remote sources.
-    */
-    std::set<UUID> all_parallel_replicas_groups;
-    for (auto & processor : *pipe.getProcessorsPtr())
-    {
-        if (auto * remote_dependency = typeid_cast<RemoteSource *>(processor.get()); remote_dependency)
-            if (auto uuid = remote_dependency->getParallelReplicasGroupUUID(); uuid != UUIDHelpers::Nil)
-                all_parallel_replicas_groups.insert(uuid);
-        if (auto * merge_tree_dependency = typeid_cast<ReadFromMergeTreeDependencyTransform *>(processor.get()); merge_tree_dependency)
-            if (auto uuid = merge_tree_dependency->getParallelReplicasGroupUUID(); uuid != UUIDHelpers::Nil)
-                all_parallel_replicas_groups.insert(uuid);
-    }
-
-    for (const auto & group_id : all_parallel_replicas_groups)
-    {
-        std::vector<RemoteSource *> input_dependencies;
-        std::vector<ReadFromMergeTreeDependencyTransform *> output_dependencies;
-
-        for (auto & processor : *pipe.getProcessorsPtr())
-        {
-            if (auto * remote_dependency = typeid_cast<RemoteSource *>(processor.get()); remote_dependency)
-                if (auto uuid = remote_dependency->getParallelReplicasGroupUUID(); uuid == group_id)
-                    input_dependencies.emplace_back(remote_dependency);
-            if (auto * merge_tree_dependency = typeid_cast<ReadFromMergeTreeDependencyTransform *>(processor.get()); merge_tree_dependency)
-                if (auto uuid = merge_tree_dependency->getParallelReplicasGroupUUID(); uuid == group_id)
-                    output_dependencies.emplace_back(merge_tree_dependency);
-        }
-
-        if (input_dependencies.empty() || output_dependencies.empty())
-            continue;
-
-        auto input_dependency_iter = input_dependencies.begin();
-        auto output_dependency_iter = output_dependencies.begin();
-        auto scheduler = std::make_shared<ResizeProcessor>(Block{}, input_dependencies.size(), output_dependencies.size());
-
-        for (auto & scheduler_input : scheduler->getInputs())
-        {
-            (*input_dependency_iter)->connectToScheduler(scheduler_input);
-            ++input_dependency_iter;
-        }
-
-        for (auto & scheduler_output : scheduler->getOutputs())
-        {
-            (*output_dependency_iter)->connectToScheduler(scheduler_output);
-            ++output_dependency_iter;
-        }
-
-        pipe.getProcessorsPtr()->emplace_back(std::move(scheduler));
-    }
-}
-
 PipelineExecutorPtr QueryPipelineBuilder::execute()
 {
     if (!isCompleted())
diff --git a/src/QueryPipeline/QueryPipelineBuilder.h b/src/QueryPipeline/QueryPipelineBuilder.h
index 4f984680c75..3a5d65d4388 100644
--- a/src/QueryPipeline/QueryPipelineBuilder.h
+++ b/src/QueryPipeline/QueryPipelineBuilder.h
@@ -140,12 +140,6 @@ public:
 
     void addCreatingSetsTransform(const Block & res_header, SubqueryForSet subquery_for_set, const SizeLimits & limits, ContextPtr context);
 
-    /// Finds all processors for reading from MergeTree
-    /// And explicitly connects them with all RemoteSources
-    /// using a ResizeProcessor. This is needed not to let
-    /// the RemoteSource to starve for CPU time
-    void connectDependencies();
-
     PipelineExecutorPtr execute();
 
     size_t getNumStreams() const { return pipe.numOutputPorts(); }
diff --git a/src/Storages/Distributed/DistributedAsyncInsertBatch.cpp b/src/Storages/Distributed/DistributedAsyncInsertBatch.cpp
index bf410eed6cc..ba5938e057d 100644
--- a/src/Storages/Distributed/DistributedAsyncInsertBatch.cpp
+++ b/src/Storages/Distributed/DistributedAsyncInsertBatch.cpp
@@ -8,13 +8,6 @@
 #include <IO/Operators.h>
 #include <IO/WriteBufferFromFile.h>
 
-namespace
-{
-
-namespace fs = std::filesystem;
-
-}
-
 namespace CurrentMetrics
 {
     extern const Metric DistributedSend;
@@ -140,7 +133,7 @@ void DistributedAsyncInsertBatch::send()
     total_bytes = 0;
     recovered = false;
 
-    fs::resize_file(parent.current_batch_file_path, 0);
+    std::filesystem::resize_file(parent.current_batch_file_path, 0);
 }
 
 void DistributedAsyncInsertBatch::serialize()
@@ -149,7 +142,7 @@ void DistributedAsyncInsertBatch::serialize()
     String tmp_file{parent.current_batch_file_path + ".tmp"};
 
     auto dir_sync_guard = parent.getDirectorySyncGuard(parent.relative_path);
-    if (fs::exists(tmp_file))
+    if (std::filesystem::exists(tmp_file))
         LOG_ERROR(parent.log, "Temporary file {} exists. Unclean shutdown?", backQuote(tmp_file));
 
     {
@@ -161,7 +154,7 @@ void DistributedAsyncInsertBatch::serialize()
             out.sync();
     }
 
-    fs::rename(tmp_file, parent.current_batch_file_path);
+    std::filesystem::rename(tmp_file, parent.current_batch_file_path);
 }
 
 void DistributedAsyncInsertBatch::deserialize()
@@ -174,7 +167,7 @@ void DistributedAsyncInsertBatch::writeText(WriteBuffer & out)
 {
     for (const auto & file : files)
     {
-        UInt64 file_index = parse<UInt64>(fs::path(file).stem());
+        UInt64 file_index = parse<UInt64>(std::filesystem::path(file).stem());
         out << file_index << '\n';
     }
 }
@@ -185,7 +178,7 @@ void DistributedAsyncInsertBatch::readText(ReadBuffer & in)
     {
         UInt64 idx;
         in >> idx >> "\n";
-        files.push_back(fs::absolute(fmt::format("{}/{}.bin", parent.path, idx)).string());
+        files.push_back(std::filesystem::absolute(fmt::format("{}/{}.bin", parent.path, idx)).string());
     }
 
     recovered = true;
diff --git a/src/Storages/MergeTree/DataPartStorageOnDiskBase.cpp b/src/Storages/MergeTree/DataPartStorageOnDiskBase.cpp
index 175df9b6e28..9b601d9f3af 100644
--- a/src/Storages/MergeTree/DataPartStorageOnDiskBase.cpp
+++ b/src/Storages/MergeTree/DataPartStorageOnDiskBase.cpp
@@ -5,6 +5,7 @@
 #include <IO/ReadBufferFromString.h>
 #include <IO/ReadHelpers.h>
 #include <Common/logger_useful.h>
+#include <Interpreters/Context.h>
 #include <Storages/MergeTree/localBackup.h>
 #include <Backups/BackupEntryFromSmallFile.h>
 #include <Backups/BackupEntryFromImmutableFile.h>
@@ -311,6 +312,7 @@ DataPartStorageOnDiskBase::getReplicatedFilesDescriptionForRemoteDisk(const Name
 }
 
 void DataPartStorageOnDiskBase::backup(
+    const ReadSettings & read_settings,
     const MergeTreeDataPartChecksums & checksums,
     const NameSet & files_without_checksums,
     const String & path_in_backup,
@@ -386,7 +388,7 @@ void DataPartStorageOnDiskBase::backup(
 
         backup_entries.emplace_back(
             filepath_in_backup,
-            std::make_unique<BackupEntryFromImmutableFile>(disk, filepath_on_disk, file_size, file_hash, temp_dir_owner));
+            std::make_unique<BackupEntryFromImmutableFile>(disk, filepath_on_disk, read_settings, file_size, file_hash, temp_dir_owner));
     }
 }
 
diff --git a/src/Storages/MergeTree/DataPartStorageOnDiskBase.h b/src/Storages/MergeTree/DataPartStorageOnDiskBase.h
index 7c408dcf381..11806e25a1e 100644
--- a/src/Storages/MergeTree/DataPartStorageOnDiskBase.h
+++ b/src/Storages/MergeTree/DataPartStorageOnDiskBase.h
@@ -49,6 +49,7 @@ public:
     ReplicatedFilesDescription getReplicatedFilesDescriptionForRemoteDisk(const NameSet & file_names) const override;
 
     void backup(
+        const ReadSettings & read_settings,
         const MergeTreeDataPartChecksums & checksums,
         const NameSet & files_without_checksums,
         const String & path_in_backup,
diff --git a/src/Storages/MergeTree/IDataPartStorage.h b/src/Storages/MergeTree/IDataPartStorage.h
index f92784cb0da..4d7212eb17b 100644
--- a/src/Storages/MergeTree/IDataPartStorage.h
+++ b/src/Storages/MergeTree/IDataPartStorage.h
@@ -197,6 +197,7 @@ public:
     /// Also creates a new tmp_dir for internal disk (if disk is mentioned the first time).
     using TemporaryFilesOnDisks = std::map<DiskPtr, std::shared_ptr<TemporaryFileOnDisk>>;
     virtual void backup(
+        const ReadSettings & read_settings,
         const MergeTreeDataPartChecksums & checksums,
         const NameSet & files_without_checksums,
         const String & path_in_backup,
diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp
index 66c52e6e24c..aece7f56aec 100644
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@@ -4869,24 +4869,12 @@ Pipe MergeTreeData::alterPartition(
 }
 
 
-void MergeTreeData::backupData(BackupEntriesCollector & backup_entries_collector, const String & data_path_in_backup, const std::optional<ASTs> & partitions)
-{
-    auto local_context = backup_entries_collector.getContext();
-
-    DataPartsVector data_parts;
-    if (partitions)
-        data_parts = getVisibleDataPartsVectorInPartitions(local_context, getPartitionIDsFromQuery(*partitions, local_context));
-    else
-        data_parts = getVisibleDataPartsVector(local_context);
-
-    backup_entries_collector.addBackupEntries(backupParts(data_parts, data_path_in_backup, local_context));
-}
-
 BackupEntries MergeTreeData::backupParts(const DataPartsVector & data_parts, const String & data_path_in_backup, const ContextPtr & local_context)
 {
     BackupEntries backup_entries;
     std::map<DiskPtr, std::shared_ptr<TemporaryFileOnDisk>> temp_dirs;
     TableLockHolder table_lock;
+    ReadSettings read_settings = local_context->getBackupReadSettings();
 
     for (const auto & part : data_parts)
     {
@@ -4916,6 +4904,7 @@ BackupEntries MergeTreeData::backupParts(const DataPartsVector & data_parts, con
 
         BackupEntries backup_entries_from_part;
         part->getDataPartStorage().backup(
+            read_settings,
             part->checksums,
             part->getFileNamesWithoutChecksums(),
             data_path_in_backup,
@@ -4927,6 +4916,7 @@ BackupEntries MergeTreeData::backupParts(const DataPartsVector & data_parts, con
         for (const auto & [projection_name, projection_part] : projection_parts)
         {
             projection_part->getDataPartStorage().backup(
+                read_settings,
                 projection_part->checksums,
                 projection_part->getFileNamesWithoutChecksums(),
                 fs::path{data_path_in_backup} / part->name,
@@ -6939,8 +6929,7 @@ QueryProcessingStage::Enum MergeTreeData::getQueryProcessingStage(
     if (query_context->getClientInfo().collaborate_with_initiator)
         return QueryProcessingStage::Enum::FetchColumns;
 
-    if (query_context->getSettingsRef().allow_experimental_parallel_reading_from_replicas
-        && !query_context->getClientInfo().collaborate_with_initiator
+    if (query_context->canUseParallelReplicasOnInitiator()
         && to_stage >= QueryProcessingStage::WithMergeableState)
         return QueryProcessingStage::Enum::WithMergeableState;
 
diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h
index 0be932ccdaf..8312efa216d 100644
--- a/src/Storages/MergeTree/MergeTreeData.h
+++ b/src/Storages/MergeTree/MergeTreeData.h
@@ -751,9 +751,6 @@ public:
         ContextPtr context,
         TableLockHolder & table_lock_holder);
 
-    /// Makes backup entries to backup the data of the storage.
-    void backupData(BackupEntriesCollector & backup_entries_collector, const String & data_path_in_backup, const std::optional<ASTs> & partitions) override;
-
     /// Extract data from the backup and put it to the storage.
     void restoreDataFromBackup(RestorerFromBackup & restorer, const String & data_path_in_backup, const std::optional<ASTs> & partitions) override;
 
diff --git a/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.cpp b/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.cpp
index 3ef064ff743..6ad0628eac4 100644
--- a/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.cpp
+++ b/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.cpp
@@ -9,6 +9,7 @@
 
 #include <consistent_hashing.h>
 
+#include "Common/Exception.h"
 #include <Common/logger_useful.h>
 #include <Common/SipHash.h>
 #include <Common/thread_local_rng.h>
@@ -47,7 +48,6 @@ public:
     }
 
     Stats stats;
-    std::mutex mutex;
     size_t replicas_count;
 
     explicit ImplInterface(size_t replicas_count_)
@@ -220,9 +220,11 @@ void DefaultCoordinator::finalizeReadingState()
 
 void DefaultCoordinator::handleInitialAllRangesAnnouncement(InitialAllRangesAnnouncement announcement)
 {
-    std::lock_guard lock(mutex);
-
     updateReadingState(announcement);
+
+    if (announcement.replica_num >= stats.size())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Replica number ({}) is bigger than total replicas count ({})", announcement.replica_num, stats.size());
+
     stats[announcement.replica_num].number_of_requests +=1;
 
     ++sent_initial_requests;
@@ -282,8 +284,6 @@ void DefaultCoordinator::selectPartsAndRanges(const PartRefs & container, size_t
 
 ParallelReadResponse DefaultCoordinator::handleRequest(ParallelReadRequest request)
 {
-    std::lock_guard lock(mutex);
-
     LOG_TRACE(log, "Handling request from replica {}, minimal marks size is {}", request.replica_num, request.min_number_of_marks);
 
     size_t current_mark_size = 0;
@@ -349,7 +349,6 @@ public:
 template <CoordinationMode mode>
 void InOrderCoordinator<mode>::handleInitialAllRangesAnnouncement(InitialAllRangesAnnouncement announcement)
 {
-    std::lock_guard lock(mutex);
     LOG_TRACE(log, "Received an announecement {}", announcement.describe());
 
     /// To get rid of duplicates
@@ -387,8 +386,6 @@ void InOrderCoordinator<mode>::handleInitialAllRangesAnnouncement(InitialAllRang
 template <CoordinationMode mode>
 ParallelReadResponse InOrderCoordinator<mode>::handleRequest(ParallelReadRequest request)
 {
-    std::lock_guard lock(mutex);
-
     if (request.mode != mode)
         throw Exception(ErrorCodes::LOGICAL_ERROR,
             "Replica {} decided to read in {} mode, not in {}. This is a bug",
@@ -479,16 +476,27 @@ ParallelReadResponse InOrderCoordinator<mode>::handleRequest(ParallelReadRequest
 
 void ParallelReplicasReadingCoordinator::handleInitialAllRangesAnnouncement(InitialAllRangesAnnouncement announcement)
 {
+    std::lock_guard lock(mutex);
+
     if (!pimpl)
+    {
+        setMode(announcement.mode);
         initialize();
+    }
+
 
     return pimpl->handleInitialAllRangesAnnouncement(announcement);
 }
 
 ParallelReadResponse ParallelReplicasReadingCoordinator::handleRequest(ParallelReadRequest request)
 {
+    std::lock_guard lock(mutex);
+
     if (!pimpl)
+    {
+        setMode(request.mode);
         initialize();
+    }
 
     return pimpl->handleRequest(std::move(request));
 }
diff --git a/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.h b/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.h
index 0656a128884..0f41d24a9c6 100644
--- a/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.h
+++ b/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.h
@@ -25,8 +25,9 @@ public:
 private:
     void initialize();
 
-    CoordinationMode mode{CoordinationMode::Default};
+    std::mutex mutex;
     size_t replicas_count{0};
+    CoordinationMode mode{CoordinationMode::Default};
     std::atomic<bool> initialized{false};
     std::unique_ptr<ImplInterface> pimpl;
 };
diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp b/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
index 34cdefc99e0..c8ce55f9600 100644
--- a/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
+++ b/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
@@ -1134,12 +1134,14 @@ void ReplicatedMergeTreeQueue::removePartProducingOpsInRange(
         bool replace_range_covered = covering_entry && checkReplaceRangeCanBeRemoved(part_info, *it, *covering_entry);
         if (simple_op_covered || replace_range_covered)
         {
+            const String & znode_name = (*it)->znode_name;
+
             if ((*it)->currently_executing)
                 to_wait.push_back(*it);
 
-            auto code = zookeeper->tryRemove(fs::path(replica_path) / "queue" / (*it)->znode_name);
+            auto code = zookeeper->tryRemove(fs::path(replica_path) / "queue" / znode_name);
             if (code != Coordination::Error::ZOK)
-                LOG_INFO(log, "Couldn't remove {}: {}", (fs::path(replica_path) / "queue" / (*it)->znode_name).string(), Coordination::errorMessage(code));
+                LOG_INFO(log, "Couldn't remove {}: {}", (fs::path(replica_path) / "queue" / znode_name).string(), Coordination::errorMessage(code));
 
             updateStateOnQueueEntryRemoval(
                 *it, /* is_successful = */ false,
@@ -1147,6 +1149,7 @@ void ReplicatedMergeTreeQueue::removePartProducingOpsInRange(
 
             (*it)->removed_by_other_entry = true;
             it = queue.erase(it);
+            notifySubscribers(queue.size(), &znode_name);
             ++removed_entries;
         }
         else
diff --git a/src/Storages/MergeTree/RequestResponse.cpp b/src/Storages/MergeTree/RequestResponse.cpp
index 5249128590f..945477c5a34 100644
--- a/src/Storages/MergeTree/RequestResponse.cpp
+++ b/src/Storages/MergeTree/RequestResponse.cpp
@@ -3,7 +3,7 @@
 
 #include <Core/ProtocolDefines.h>
 #include <Common/SipHash.h>
-#include "IO/VarInt.h"
+#include <IO/VarInt.h>
 #include <IO/WriteHelpers.h>
 #include <IO/ReadHelpers.h>
 
@@ -15,6 +15,18 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int UNKNOWN_PROTOCOL;
+    extern const int UNKNOWN_ELEMENT_OF_ENUM;
+}
+
+namespace
+{
+     CoordinationMode validateAndGet(uint8_t candidate)
+    {
+        if (candidate <= static_cast<uint8_t>(CoordinationMode::MAX))
+            return static_cast<CoordinationMode>(candidate);
+
+        throw Exception(ErrorCodes::UNKNOWN_ELEMENT_OF_ENUM, "Unknown reading mode: {}", candidate);
+    }
 }
 
 void ParallelReadRequest::serialize(WriteBuffer & out) const
@@ -48,7 +60,9 @@ void ParallelReadRequest::deserialize(ReadBuffer & in)
             "from replicas differ. Got: {}, supported version: {}",
             version, DBMS_PARALLEL_REPLICAS_PROTOCOL_VERSION);
 
-    readIntBinary(mode, in);
+    uint8_t mode_candidate;
+    readIntBinary(mode_candidate, in);
+    mode = validateAndGet(mode_candidate);
     readIntBinary(replica_num, in);
     readIntBinary(min_number_of_marks, in);
     description.deserialize(in);
@@ -100,6 +114,7 @@ void InitialAllRangesAnnouncement::serialize(WriteBuffer & out) const
     /// Must be the first
     writeIntBinary(version, out);
 
+    writeIntBinary(mode, out);
     description.serialize(out);
     writeIntBinary(replica_num, out);
 }
@@ -122,6 +137,9 @@ void InitialAllRangesAnnouncement::deserialize(ReadBuffer & in)
             "from replicas differ. Got: {}, supported version: {}",
             version, DBMS_PARALLEL_REPLICAS_PROTOCOL_VERSION);
 
+    uint8_t mode_candidate;
+    readIntBinary(mode_candidate, in);
+    mode = validateAndGet(mode_candidate);
     description.deserialize(in);
     readIntBinary(replica_num, in);
 }
diff --git a/src/Storages/MergeTree/RequestResponse.h b/src/Storages/MergeTree/RequestResponse.h
index 8cdb9e49be5..7e5563c0553 100644
--- a/src/Storages/MergeTree/RequestResponse.h
+++ b/src/Storages/MergeTree/RequestResponse.h
@@ -16,12 +16,16 @@
 namespace DB
 {
 
-enum class CoordinationMode
+/// This enum is being serialized and transferred over a network
+/// You can't reorder it or add another value in the middle
+enum class CoordinationMode : uint8_t
 {
-    Default,
+    Default = 0,
     /// For reading in order
-    WithOrder,
-    ReverseOrder
+    WithOrder = 1,
+    ReverseOrder = 2,
+
+    MAX = ReverseOrder,
 };
 
 /// Represents a segment [left; right]
@@ -64,6 +68,7 @@ struct ParallelReadResponse
 
 struct InitialAllRangesAnnouncement
 {
+    CoordinationMode mode;
     RangesInDataPartsDescription description;
     size_t replica_num;
 
diff --git a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp
index 9ff0c152399..20839982ec3 100644
--- a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp
+++ b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp
@@ -276,7 +276,7 @@ void StorageEmbeddedRocksDB::mutate(const MutationCommands & commands, ContextPt
 
     assert(commands.front().type == MutationCommand::Type::UPDATE);
     if (commands.front().column_to_update_expression.contains(primary_key))
-        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Primary key cannot be updated");
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Primary key cannot be updated (cannot update column {})", primary_key);
 
     auto interpreter = std::make_unique<MutationsInterpreter>(
         storage_ptr, metadata_snapshot, commands, context_, /*can_execute_*/ true, /*return_all_columns*/ true);
diff --git a/src/Storages/StorageKeeperMap.cpp b/src/Storages/StorageKeeperMap.cpp
index aeb206f1e05..d59ee005e31 100644
--- a/src/Storages/StorageKeeperMap.cpp
+++ b/src/Storages/StorageKeeperMap.cpp
@@ -924,7 +924,7 @@ void StorageKeeperMap::mutate(const MutationCommands & commands, ContextPtr loca
 
     assert(commands.front().type == MutationCommand::Type::UPDATE);
     if (commands.front().column_to_update_expression.contains(primary_key))
-        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Primary key cannot be updated");
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Primary key cannot be updated (cannot update column {})", primary_key);
 
     auto interpreter = std::make_unique<MutationsInterpreter>(
         storage_ptr, metadata_snapshot, commands, local_context, /*can_execute_*/ true, /*return_all_columns*/ true);
diff --git a/src/Storages/StorageLog.cpp b/src/Storages/StorageLog.cpp
index 772ed34b7a9..8264d67aaba 100644
--- a/src/Storages/StorageLog.cpp
+++ b/src/Storages/StorageLog.cpp
@@ -926,7 +926,10 @@ std::optional<UInt64> StorageLog::totalBytes(const Settings &) const
 
 void StorageLog::backupData(BackupEntriesCollector & backup_entries_collector, const String & data_path_in_backup, const std::optional<ASTs> & /* partitions */)
 {
-    auto lock_timeout = getLockTimeout(backup_entries_collector.getContext());
+    auto local_context = backup_entries_collector.getContext();
+    ReadSettings read_settings = local_context->getBackupReadSettings();
+
+    auto lock_timeout = getLockTimeout(local_context);
     loadMarks(lock_timeout);
 
     ReadLock lock{rwlock, lock_timeout};
@@ -951,7 +954,7 @@ void StorageLog::backupData(BackupEntriesCollector & backup_entries_collector, c
         backup_entries_collector.addBackupEntry(
             data_path_in_backup_fs / data_file_name,
             std::make_unique<BackupEntryFromAppendOnlyFile>(
-                disk, hardlink_file_path, file_checker.getFileSize(data_file.path), std::nullopt, temp_dir_owner));
+                disk, hardlink_file_path, read_settings, file_checker.getFileSize(data_file.path), std::nullopt, temp_dir_owner));
     }
 
     /// __marks.mrk
@@ -964,7 +967,7 @@ void StorageLog::backupData(BackupEntriesCollector & backup_entries_collector, c
         backup_entries_collector.addBackupEntry(
             data_path_in_backup_fs / marks_file_name,
             std::make_unique<BackupEntryFromAppendOnlyFile>(
-                disk, hardlink_file_path, file_checker.getFileSize(marks_file_path), std::nullopt, temp_dir_owner));
+                disk, hardlink_file_path, read_settings, file_checker.getFileSize(marks_file_path), std::nullopt, temp_dir_owner));
     }
 
     /// sizes.json
diff --git a/src/Storages/StorageMemory.cpp b/src/Storages/StorageMemory.cpp
index 11688582877..c568178a469 100644
--- a/src/Storages/StorageMemory.cpp
+++ b/src/Storages/StorageMemory.cpp
@@ -290,12 +290,14 @@ namespace
     {
     public:
         MemoryBackup(
+            ContextPtr context_,
             const StorageMetadataPtr & metadata_snapshot_,
             const std::shared_ptr<const Blocks> blocks_,
             const String & data_path_in_backup,
             const DiskPtr & temp_disk_,
             UInt64 max_compress_block_size_)
-            : metadata_snapshot(metadata_snapshot_)
+            : context(context_)
+            , metadata_snapshot(metadata_snapshot_)
             , blocks(blocks_)
             , temp_disk(temp_disk_)
             , max_compress_block_size(max_compress_block_size_)
@@ -326,6 +328,8 @@ namespace
 
         BackupEntries generate() override
         {
+            ReadSettings read_settings = context->getBackupReadSettings();
+
             BackupEntries backup_entries;
             backup_entries.resize(file_paths.size());
 
@@ -342,7 +346,7 @@ namespace
                 NativeWriter block_out{data_out, 0, metadata_snapshot->getSampleBlock(), false, &index};
                 for (const auto & block : *blocks)
                     block_out.write(block);
-                backup_entries[data_bin_pos] = {file_paths[data_bin_pos], std::make_shared<BackupEntryFromImmutableFile>(temp_disk, data_file_path)};
+                backup_entries[data_bin_pos] = {file_paths[data_bin_pos], std::make_shared<BackupEntryFromImmutableFile>(temp_disk, data_file_path, read_settings)};
             }
 
             /// Writing index.mrk
@@ -351,7 +355,7 @@ namespace
                 auto index_mrk_out_compressed = temp_disk->writeFile(index_mrk_path);
                 CompressedWriteBuffer index_mrk_out{*index_mrk_out_compressed};
                 index.write(index_mrk_out);
-                backup_entries[index_mrk_pos] = {file_paths[index_mrk_pos], std::make_shared<BackupEntryFromImmutableFile>(temp_disk, index_mrk_path)};
+                backup_entries[index_mrk_pos] = {file_paths[index_mrk_pos], std::make_shared<BackupEntryFromImmutableFile>(temp_disk, index_mrk_path, read_settings)};
             }
 
             /// Writing columns.txt
@@ -389,6 +393,7 @@ namespace
             return backup_entries;
         }
 
+        ContextPtr context;
         StorageMetadataPtr metadata_snapshot;
         std::shared_ptr<const Blocks> blocks;
         DiskPtr temp_disk;
@@ -403,9 +408,13 @@ void StorageMemory::backupData(BackupEntriesCollector & backup_entries_collector
 {
     auto temp_disk = backup_entries_collector.getContext()->getTemporaryVolume()->getDisk(0);
     auto max_compress_block_size = backup_entries_collector.getContext()->getSettingsRef().max_compress_block_size;
-    backup_entries_collector.addBackupEntries(
-        std::make_shared<MemoryBackup>(getInMemoryMetadataPtr(), data.get(), data_path_in_backup, temp_disk, max_compress_block_size)
-            ->getBackupEntries());
+    backup_entries_collector.addBackupEntries(std::make_shared<MemoryBackup>(
+        backup_entries_collector.getContext(),
+        getInMemoryMetadataPtr(),
+        data.get(),
+        data_path_in_backup,
+        temp_disk,
+        max_compress_block_size)->getBackupEntries());
 }
 
 void StorageMemory::restoreDataFromBackup(RestorerFromBackup & restorer, const String & data_path_in_backup, const std::optional<ASTs> & /* partitions */)
diff --git a/src/Storages/StorageStripeLog.cpp b/src/Storages/StorageStripeLog.cpp
index 30585250be2..d54725b8b39 100644
--- a/src/Storages/StorageStripeLog.cpp
+++ b/src/Storages/StorageStripeLog.cpp
@@ -527,7 +527,10 @@ std::optional<UInt64> StorageStripeLog::totalBytes(const Settings &) const
 
 void StorageStripeLog::backupData(BackupEntriesCollector & backup_entries_collector, const String & data_path_in_backup, const std::optional<ASTs> & /* partitions */)
 {
-    auto lock_timeout = getLockTimeout(backup_entries_collector.getContext());
+    auto local_context = backup_entries_collector.getContext();
+    ReadSettings read_settings = local_context->getBackupReadSettings();
+
+    auto lock_timeout = getLockTimeout(local_context);
     loadIndices(lock_timeout);
 
     ReadLock lock{rwlock, lock_timeout};
@@ -551,7 +554,7 @@ void StorageStripeLog::backupData(BackupEntriesCollector & backup_entries_collec
         backup_entries_collector.addBackupEntry(
             data_path_in_backup_fs / data_file_name,
             std::make_unique<BackupEntryFromAppendOnlyFile>(
-                disk, hardlink_file_path, file_checker.getFileSize(data_file_path), std::nullopt, temp_dir_owner));
+                disk, hardlink_file_path, read_settings, file_checker.getFileSize(data_file_path), std::nullopt, temp_dir_owner));
     }
 
     /// index.mrk
@@ -563,7 +566,7 @@ void StorageStripeLog::backupData(BackupEntriesCollector & backup_entries_collec
         backup_entries_collector.addBackupEntry(
             data_path_in_backup_fs / index_file_name,
             std::make_unique<BackupEntryFromAppendOnlyFile>(
-                disk, hardlink_file_path, file_checker.getFileSize(index_file_path), std::nullopt, temp_dir_owner));
+                disk, hardlink_file_path, read_settings, file_checker.getFileSize(index_file_path), std::nullopt, temp_dir_owner));
     }
 
     /// sizes.json
diff --git a/tests/clickhouse-test b/tests/clickhouse-test
index d0dfdd783f1..3e2ef18f72a 100755
--- a/tests/clickhouse-test
+++ b/tests/clickhouse-test
@@ -2076,7 +2076,19 @@ def reportLogStats(args):
               'AST is too deep. Maximum: {}', 'Array sizes are too large: {}', 'Unable to connect to HDFS: {}',
               'Shutdown is called for table', 'File is not inside {}',
               'Table {} doesn''t exist', 'Database {} doesn''t exist', 'Table {}.{} doesn''t exist',
-              'File {} doesn''t exist', 'No such attribute ''{}''', 'User name ''{}'' is reserved'
+              'File {} doesn''t exist', 'No such attribute ''{}''', 'User name ''{}'' is reserved',
+              'Could not find table: {}', 'Detached part "{}" not found', 'Unknown data type family: {}',
+              'Unknown input format {}', 'Cannot UPDATE key column {}', 'Substitution {} is not set',
+              'Cannot OPTIMIZE table: {}', 'User name is empty', 'Table name is empty', 'AST is too big. Maximum: {}',
+              'Unsupported cipher mode', 'Unknown explain kind ''{}''', 'Table {} was suddenly removed',
+              'No cache found by path: {}', 'No such column {} in table {}', 'There is no port named {}',
+              'Function {} cannot resize {}', 'Function {} is not parametric', 'Unknown key attribute ''{}''',
+              'Transaction was cancelled', 'Unknown parent id {}', 'Session {} not found', 'Mutation {} was killed',
+              'Table {}.{} doesn''t exist.', 'Table is not initialized yet', '{} is not an identifier',
+              'Column ''{}'' already exists', 'No macro {} in config', 'Invalid origin H3 index: {}',
+              'Invalid session timeout: ''{}''', 'Tuple cannot be empty', 'Database name is empty',
+              'Table {} is not a Dictionary', 'Expected function, got: {}', 'Unknown identifier: ''{}''',
+              'Failed to {} input ''{}''', '{}.{} is not a VIEW', 'Cannot convert NULL to {}', 'Dictionary {} doesn''t exist'
         ) AS known_short_messages
         SELECT count() AS c, message_format_string, substr(any(message), 1, 120)
         FROM system.text_log
@@ -2084,7 +2096,7 @@ def reportLogStats(args):
             AND (length(message_format_string) < 16
                 OR (length(message_format_string) < 30 AND message ilike '%DB::Exception%'))
             AND message_format_string NOT IN known_short_messages
-        GROUP BY message_format_string ORDER BY c DESC LIMIT 30 FORMAT TSVWithNamesAndTypes
+        GROUP BY message_format_string ORDER BY c DESC LIMIT 50 FORMAT TSVWithNamesAndTypes
     """
     value = clickhouse_execute(args, query).decode(errors="replace")
     print("\nTop short messages:\n")
diff --git a/tests/config/config.d/backups.xml b/tests/config/config.d/backups.xml
new file mode 100644
index 00000000000..48f7a256233
--- /dev/null
+++ b/tests/config/config.d/backups.xml
@@ -0,0 +1,6 @@
+<clickhouse>
+    <backups>
+        <allowed_disk>default</allowed_disk>
+        <allowed_path>/backups</allowed_path>
+    </backups>
+</clickhouse>
diff --git a/tests/config/install.sh b/tests/config/install.sh
index 44eab0e4db0..77e8a8460ad 100755
--- a/tests/config/install.sh
+++ b/tests/config/install.sh
@@ -56,6 +56,7 @@ ln -sf $SRC_PATH/config.d/display_name.xml $DEST_SERVER_PATH/config.d/
 ln -sf $SRC_PATH/config.d/reverse_dns_query_function.xml $DEST_SERVER_PATH/config.d/
 ln -sf $SRC_PATH/config.d/compressed_marks_and_index.xml $DEST_SERVER_PATH/config.d/
 ln -sf $SRC_PATH/config.d/disable_s3_env_credentials.xml $DEST_SERVER_PATH/config.d/
+ln -sf $SRC_PATH/config.d/backups.xml $DEST_SERVER_PATH/config.d/
 
 # Not supported with fasttest.
 if [ "${DEST_SERVER_PATH}" = "/etc/clickhouse-server" ]
diff --git a/tests/integration/helpers/cluster.py b/tests/integration/helpers/cluster.py
index a9a996e0a5f..b2aedfce3ca 100644
--- a/tests/integration/helpers/cluster.py
+++ b/tests/integration/helpers/cluster.py
@@ -115,14 +115,11 @@ def run_and_check(
     return out
 
 
-# Based on https://stackoverflow.com/questions/2838244/get-open-tcp-port-in-python/2838309#2838309
+# Based on https://stackoverflow.com/a/1365284/3706827
 def get_free_port():
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    s.bind(("", 0))
-    s.listen(1)
-    port = s.getsockname()[1]
-    s.close()
-    return port
+    with socket.socket() as s:
+        s.bind(("", 0))
+        return s.getsockname()[1]
 
 
 def retry_exception(num, delay, func, exception=Exception, *args, **kwargs):
@@ -470,10 +467,10 @@ class ClickHouseCluster:
         # available when with_kafka == True
         self.kafka_host = "kafka1"
         self.kafka_dir = os.path.join(self.instances_dir, "kafka")
-        self.kafka_port = get_free_port()
+        self._kafka_port = 0
         self.kafka_docker_id = None
         self.schema_registry_host = "schema-registry"
-        self.schema_registry_port = get_free_port()
+        self._schema_registry_port = 0
         self.kafka_docker_id = self.get_instance_docker_id(self.kafka_host)
 
         self.coredns_host = "coredns"
@@ -481,7 +478,7 @@ class ClickHouseCluster:
         # available when with_kerberozed_kafka == True
         # reuses kafka_dir
         self.kerberized_kafka_host = "kerberized_kafka1"
-        self.kerberized_kafka_port = get_free_port()
+        self._kerberized_kafka_port = 0
         self.kerberized_kafka_docker_id = self.get_instance_docker_id(
             self.kerberized_kafka_host
         )
@@ -492,15 +489,15 @@ class ClickHouseCluster:
 
         # available when with_mongo == True
         self.mongo_host = "mongo1"
-        self.mongo_port = get_free_port()
+        self._mongo_port = 0
         self.mongo_no_cred_host = "mongo2"
-        self.mongo_no_cred_port = get_free_port()
+        self._mongo_no_cred_port = 0
 
         # available when with_meili == True
         self.meili_host = "meili1"
-        self.meili_port = get_free_port()
+        self._meili_port = 0
         self.meili_secure_host = "meili_secure"
-        self.meili_secure_port = get_free_port()
+        self._meili_secure_port = 0
 
         # available when with_cassandra == True
         self.cassandra_host = "cassandra1"
@@ -530,7 +527,7 @@ class ClickHouseCluster:
 
         # available when with_redis == True
         self.redis_host = "redis1"
-        self.redis_port = get_free_port()
+        self._redis_port = 0
 
         # available when with_postgres == True
         self.postgres_host = "postgres1"
@@ -616,6 +613,62 @@ class ClickHouseCluster:
             shutil.rmtree(self.instances_dir, ignore_errors=True)
             logging.debug(f"Removed :{self.instances_dir}")
 
+    @property
+    def kafka_port(self):
+        if self._kafka_port:
+            return self._kafka_port
+        self._kafka_port = get_free_port()
+        return self._kafka_port
+
+    @property
+    def schema_registry_port(self):
+        if self._schema_registry_port:
+            return self._schema_registry_port
+        self._schema_registry_port = get_free_port()
+        return self._schema_registry_port
+
+    @property
+    def kerberized_kafka_port(self):
+        if self._kerberized_kafka_port:
+            return self._kerberized_kafka_port
+        self._kerberized_kafka_port = get_free_port()
+        return self._kerberized_kafka_port
+
+    @property
+    def mongo_port(self):
+        if self._mongo_port:
+            return self._mongo_port
+        self._mongo_port = get_free_port()
+        return self._mongo_port
+
+    @property
+    def mongo_no_cred_port(self):
+        if self._mongo_no_cred_port:
+            return self._mongo_no_cred_port
+        self._mongo_no_cred_port = get_free_port()
+        return self._mongo_no_cred_port
+
+    @property
+    def meili_port(self):
+        if self._meili_port:
+            return self._meili_port
+        self._meili_port = get_free_port()
+        return self._meili_port
+
+    @property
+    def meili_secure_port(self):
+        if self._meili_secure_port:
+            return self._meili_secure_port
+        self._meili_secure_port = get_free_port()
+        return self._meili_secure_port
+
+    @property
+    def redis_port(self):
+        if self._redis_port:
+            return self._redis_port
+        self._redis_port = get_free_port()
+        return self._redis_port
+
     def print_all_docker_pieces(self):
         res_networks = subprocess.check_output(
             f"docker network ls --filter name='{self.project_name}*'",
diff --git a/tests/integration/test_backup_restore_new/test.py b/tests/integration/test_backup_restore_new/test.py
index ed9747f940b..98f0bd54aa7 100644
--- a/tests/integration/test_backup_restore_new/test.py
+++ b/tests/integration/test_backup_restore_new/test.py
@@ -1206,13 +1206,9 @@ def test_backup_all(exclude_system_log_tables):
 
     exclude_from_backup = []
     if exclude_system_log_tables:
-        system_log_tables = (
-            instance.query(
-                "SELECT concat('system.', table) FROM system.tables WHERE (database = 'system') AND (table LIKE '%_log')"
-            )
-            .rstrip("\n")
-            .split("\n")
-        )
+        system_log_tables = instance.query(
+            "SELECT concat('system.', table) FROM system.tables WHERE (database = 'system') AND (table LIKE '%_log')"
+        ).splitlines()
         exclude_from_backup += system_log_tables
 
     backup_command = f"BACKUP ALL {'EXCEPT TABLES ' + ','.join(exclude_from_backup) if exclude_from_backup else ''} TO {backup_name}"
diff --git a/tests/integration/test_keeper_snapshots/test.py b/tests/integration/test_keeper_snapshots/test.py
index ce57a852dca..2e126ed1152 100644
--- a/tests/integration/test_keeper_snapshots/test.py
+++ b/tests/integration/test_keeper_snapshots/test.py
@@ -57,9 +57,10 @@ def restart_clickhouse():
 
 
 def test_state_after_restart(started_cluster):
+    keeper_utils.wait_until_connected(started_cluster, node)
+    node_zk = None
+    node_zk2 = None
     try:
-        node_zk = None
-        node_zk2 = None
         node_zk = get_connection_zk("node")
 
         node_zk.create("/test_state_after_restart", b"somevalue")
@@ -108,9 +109,10 @@ def test_state_after_restart(started_cluster):
 
 
 def test_ephemeral_after_restart(started_cluster):
+    keeper_utils.wait_until_connected(started_cluster, node)
+    node_zk = None
+    node_zk2 = None
     try:
-        node_zk = None
-        node_zk2 = None
         node_zk = get_connection_zk("node")
 
         session_id = node_zk._session_id
diff --git a/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.reference b/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.reference
index fddfbd49de3..d3991f053f0 100644
--- a/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.reference
+++ b/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.reference
@@ -1,8 +1,8 @@
 runtime messages	0.001
 runtime exceptions	0.05
-messages shorter than 10	10
-messages shorter than 16	40
-exceptions shorter than 30	120
+messages shorter than 10	0
+messages shorter than 16	2
+exceptions shorter than 30	27
 noisy messages	0.3
 noisy Trace messages	0.16
 noisy Debug messages	0.09
diff --git a/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.sql b/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.sql
index 71f41c7a9d2..e1409985e41 100644
--- a/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.sql
+++ b/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.sql
@@ -14,14 +14,52 @@ select 'runtime messages', max2(coalesce(sum(length(message_format_string) = 0)
 -- Check the same for exceptions. The value was 0.03
 select 'runtime exceptions', max2(coalesce(sum(length(message_format_string) = 0) / countOrNull(), 0), 0.05) from logs where message like '%DB::Exception%';
 
+-- FIXME some of the following messages are not informative and it has to be fixed
+create temporary table known_short_messages (s String) as select * from (select
+['', '({}) Keys: {}', '({}) {}', 'Aggregating', 'Became leader', 'Cleaning queue', 'Creating set.',
+'Cyclic aliases', 'Detaching {}', 'Executing {}', 'Fire events: {}', 'Found part {}', 'Loaded queue',
+'No sharding key', 'No tables', 'Query: {}', 'Removed', 'Removed part {}', 'Removing parts.',
+'Request URI: {}', 'Sending part {}', 'Sent handshake', 'Starting {}', 'Will mimic {}', 'Writing to {}',
+'dropIfEmpty', 'loadAll {}', '{} ({}:{})', '{} -> {}', '{} {}', '{}: {}', 'Query was cancelled',
+'Table {} already exists.', '{}%', 'Cancelled merging parts', 'All replicas are lost',
+'Cancelled mutating parts', 'Read object: {}', 'New segment: {}', 'Unknown geometry type {}',
+'Table {} is not replicated', '{} {}.{} already exists', 'Attempt to read after eof',
+'Replica {} already exists', 'Convert overflow', 'key must be a tuple', 'Division by zero',
+'No part {} in committed state', 'Files set to {}', 'Bytes set to {}', 'Sharding key {} is not used',
+'Cannot parse datetime', 'Bad get: has {}, requested {}', 'There is no {} in {}', 'Numeric overflow',
+'Polygon is not valid: {}', 'Decimal math overflow', '{} only accepts maps', 'Dictionary ({}) not found',
+'Unknown format {}', 'Invalid IPv4 value', 'Invalid IPv6 value', 'Unknown setting {}',
+'Unknown table function {}', 'Database {} already exists.', 'Table {} doesn''t exist',
+'Invalid credentials', 'Part {} already exists', 'Invalid mode: {}', 'Log pulling is cancelled',
+'JOIN {} cannot get JOIN keys', 'Unknown function {}{}', 'Cannot parse IPv6 {}',
+'Not found address of host: {}', '{} must contain a tuple', 'Unknown codec family: {}',
+'Expected const String column', 'Invalid partition format: {}', 'Cannot parse IPv4 {}',
+'AST is too deep. Maximum: {}', 'Array sizes are too large: {}', 'Unable to connect to HDFS: {}',
+'Shutdown is called for table', 'File is not inside {}',
+'Table {} doesn''t exist', 'Database {} doesn''t exist', 'Table {}.{} doesn''t exist',
+'File {} doesn''t exist', 'No such attribute ''{}''', 'User name ''{}'' is reserved',
+'Could not find table: {}', 'Detached part "{}" not found', 'Unknown data type family: {}',
+'Unknown input format {}', 'Cannot UPDATE key column {}', 'Substitution {} is not set',
+'Cannot OPTIMIZE table: {}', 'User name is empty', 'Table name is empty', 'AST is too big. Maximum: {}',
+'Unsupported cipher mode', 'Unknown explain kind ''{}''', 'Table {} was suddenly removed',
+'No cache found by path: {}', 'No such column {} in table {}', 'There is no port named {}',
+'Function {} cannot resize {}', 'Function {} is not parametric', 'Unknown key attribute ''{}''',
+'Transaction was cancelled', 'Unknown parent id {}', 'Session {} not found', 'Mutation {} was killed',
+'Table {}.{} doesn''t exist.', 'Table is not initialized yet', '{} is not an identifier',
+'Column ''{}'' already exists', 'No macro {} in config', 'Invalid origin H3 index: {}',
+'Invalid session timeout: ''{}''', 'Tuple cannot be empty', 'Database name is empty',
+'Table {} is not a Dictionary', 'Expected function, got: {}', 'Unknown identifier: ''{}''',
+'Failed to {} input ''{}''', '{}.{} is not a VIEW', 'Cannot convert NULL to {}', 'Dictionary {} doesn''t exist'
+] as arr) array join arr;
+
 -- Check that we don't have too many short meaningless message patterns.
-select 'messages shorter than 10', max2(countDistinctOrDefault(message_format_string), 10) from logs where length(message_format_string) < 10;
+select 'messages shorter than 10', max2(countDistinctOrDefault(message_format_string), 0) from logs where length(message_format_string) < 10 and message_format_string not in known_short_messages;
 
 -- Same as above. Feel free to update the threshold or remove this query if really necessary
-select 'messages shorter than 16', max2(countDistinctOrDefault(message_format_string), 40) from logs where length(message_format_string) < 16;
+select 'messages shorter than 16', max2(countDistinctOrDefault(message_format_string), 2) from logs where length(message_format_string) < 16 and message_format_string not in known_short_messages;
 
 -- Same as above, but exceptions must be more informative. Feel free to update the threshold or remove this query if really necessary
-select 'exceptions shorter than 30', max2(countDistinctOrDefault(message_format_string), 120) from logs where length(message_format_string) < 30 and message ilike '%DB::Exception%';
+select 'exceptions shorter than 30', max2(countDistinctOrDefault(message_format_string), 27) from logs where length(message_format_string) < 30 and message ilike '%DB::Exception%' and message_format_string not in known_short_messages;
 
 
 -- Avoid too noisy messages: top 1 message frequency must be less than 30%. We should reduce the threshold
diff --git a/tests/queries/0_stateless/00463_long_sessions_in_http_interface.sh b/tests/queries/0_stateless/00463_long_sessions_in_http_interface.sh
index 89da84a5bdd..d41d6409315 100755
--- a/tests/queries/0_stateless/00463_long_sessions_in_http_interface.sh
+++ b/tests/queries/0_stateless/00463_long_sessions_in_http_interface.sh
@@ -8,7 +8,7 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 
 
 echo "Using non-existent session with the 'session_check' flag will throw exception:"
-${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}&session_id=nonexistent&session_check=1" --data-binary "SELECT 1" | grep -c -F 'Session not found'
+${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}&session_id=nonexistent&session_check=1" --data-binary "SELECT 1" | grep -c -F 'SESSION_NOT_FOUND'
 
 echo "Using non-existent session without the 'session_check' flag will create a new session:"
 ${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}&session_id=${CLICKHOUSE_DATABASE}_1" --data-binary "SELECT 1"
@@ -30,7 +30,7 @@ ${CLICKHOUSE_CLIENT} --multiquery --query "DROP USER IF EXISTS test_00463; CREAT
 ${CLICKHOUSE_CURL} -sS -X POST "${CLICKHOUSE_URL}&session_id=${CLICKHOUSE_DATABASE}_6&session_timeout=600" --data-binary "CREATE TEMPORARY TABLE t (s String)"
 ${CLICKHOUSE_CURL} -sS -X POST "${CLICKHOUSE_URL}&session_id=${CLICKHOUSE_DATABASE}_6" --data-binary "INSERT INTO t VALUES ('Hello')"
 
-${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}&user=test_00463&session_id=${CLICKHOUSE_DATABASE}_6&session_check=1" --data-binary "SELECT 1" | grep -c -F 'Session not found'
+${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}&user=test_00463&session_id=${CLICKHOUSE_DATABASE}_6&session_check=1" --data-binary "SELECT 1" | grep -c -F 'SESSION_NOT_FOUND'
 ${CLICKHOUSE_CURL} -sS -X POST "${CLICKHOUSE_URL}&user=test_00463&session_id=${CLICKHOUSE_DATABASE}_6&session_timeout=600" --data-binary "CREATE TEMPORARY TABLE t (s String)"
 ${CLICKHOUSE_CURL} -sS -X POST "${CLICKHOUSE_URL}&user=test_00463&session_id=${CLICKHOUSE_DATABASE}_6" --data-binary "INSERT INTO t VALUES ('World')"
 
@@ -53,7 +53,7 @@ do
         ${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}&session_id=${CLICKHOUSE_DATABASE}_7&session_timeout=1" --data-binary "SELECT 1"
         ${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}&session_id=${CLICKHOUSE_DATABASE}_7&session_check=1" --data-binary "SELECT 1"
         sleep 3
-        ${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}&session_id=${CLICKHOUSE_DATABASE}_7&session_check=1" --data-binary "SELECT 1" | grep -c -F 'Session not found'
+        ${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}&session_id=${CLICKHOUSE_DATABASE}_7&session_check=1" --data-binary "SELECT 1" | grep -c -F 'SESSION_NOT_FOUND'
     ) | tr -d '\n' | grep -F '111' && break || sleep 1
 done
 
@@ -82,6 +82,6 @@ do
     ${CLICKHOUSE_CLIENT} --query "SELECT count() > 0 FROM system.processes WHERE query_id = '${CLICKHOUSE_DATABASE}_9'" | grep -F '1' && break || sleep 1
 done
 
-${CLICKHOUSE_CURL} -sS -X POST "${CLICKHOUSE_URL}&session_id=${CLICKHOUSE_DATABASE}_9" --data-binary "SELECT 1" | grep -c -F 'Session is locked'
+${CLICKHOUSE_CURL} -sS -X POST "${CLICKHOUSE_URL}&session_id=${CLICKHOUSE_DATABASE}_9" --data-binary "SELECT 1" | grep -c -F 'SESSION_IS_LOCKED'
 ${CLICKHOUSE_CLIENT} --multiquery --query "KILL QUERY WHERE query_id = '${CLICKHOUSE_DATABASE}_9' SYNC FORMAT Null";
 wait
diff --git a/tests/queries/0_stateless/00718_format_datetime.reference b/tests/queries/0_stateless/00718_format_datetime.reference
index e35484d4b0b..eb2c23576eb 100644
--- a/tests/queries/0_stateless/00718_format_datetime.reference
+++ b/tests/queries/0_stateless/00718_format_datetime.reference
@@ -17,6 +17,7 @@ Jan	Jan
 366	366
 00	00
 01	01
+January	January
 33	00
 \n	\n
 AM	AM
diff --git a/tests/queries/0_stateless/00718_format_datetime.sql b/tests/queries/0_stateless/00718_format_datetime.sql
index 3f8c927dfe7..a77578fc7c3 100644
--- a/tests/queries/0_stateless/00718_format_datetime.sql
+++ b/tests/queries/0_stateless/00718_format_datetime.sql
@@ -29,7 +29,8 @@ SELECT formatDateTime(toDateTime('2018-01-01 00:33:44'), '%j'), formatDateTime(t
 SELECT formatDateTime(toDateTime('2000-12-31 00:33:44'), '%j'), formatDateTime(toDate32('2000-12-31'), '%j');
 SELECT formatDateTime(toDateTime('2000-12-31 00:33:44'), '%k'), formatDateTime(toDate32('2000-12-31'), '%k');
 SELECT formatDateTime(toDateTime('2018-01-02 22:33:44'), '%m'), formatDateTime(toDate32('2018-01-02'), '%m');
-SELECT formatDateTime(toDateTime('2018-01-02 22:33:44'), '%M'), formatDateTime(toDate32('2018-01-02'), '%M');
+SELECT formatDateTime(toDateTime('2018-01-02 22:33:44'), '%M'), formatDateTime(toDate32('2018-01-02'), '%M') SETTINGS formatdatetime_parsedatetime_m_is_month_name = 1;
+SELECT formatDateTime(toDateTime('2018-01-02 22:33:44'), '%M'), formatDateTime(toDate32('2018-01-02'), '%M') SETTINGS formatdatetime_parsedatetime_m_is_month_name = 0;
 SELECT formatDateTime(toDateTime('2018-01-02 22:33:44'), '%n'), formatDateTime(toDate32('2018-01-02'), '%n');
 SELECT formatDateTime(toDateTime('2018-01-02 00:33:44'), '%p'), formatDateTime(toDateTime('2018-01-02'), '%p');
 SELECT formatDateTime(toDateTime('2018-01-02 11:33:44'), '%p');
diff --git a/tests/queries/0_stateless/00765_sql_compatibility_aliases.reference b/tests/queries/0_stateless/00765_sql_compatibility_aliases.reference
index 6a2a0523476..285b9a62d20 100644
--- a/tests/queries/0_stateless/00765_sql_compatibility_aliases.reference
+++ b/tests/queries/0_stateless/00765_sql_compatibility_aliases.reference
@@ -3,6 +3,7 @@ FOO
 foo
 FOO
 baz
+zzz
 2
 fo
 oo
diff --git a/tests/queries/0_stateless/00765_sql_compatibility_aliases.sql b/tests/queries/0_stateless/00765_sql_compatibility_aliases.sql
index 4e16768b373..da0eb9bea6d 100644
--- a/tests/queries/0_stateless/00765_sql_compatibility_aliases.sql
+++ b/tests/queries/0_stateless/00765_sql_compatibility_aliases.sql
@@ -5,6 +5,7 @@ select ucase('foo');
 select LOWER('Foo');
 select UPPER('Foo');
 select REPLACE('bar', 'r', 'z');
+select REGEXP_REPLACE('bar', '.', 'z');
 select Locate('foo', 'o');
 select SUBSTRING('foo', 1, 2);
 select Substr('foo', 2);
diff --git a/tests/queries/0_stateless/00921_datetime64_compatibility_long.python b/tests/queries/0_stateless/00921_datetime64_compatibility_long.python
index 2706c0f5b12..3db80aef845 100644
--- a/tests/queries/0_stateless/00921_datetime64_compatibility_long.python
+++ b/tests/queries/0_stateless/00921_datetime64_compatibility_long.python
@@ -83,7 +83,7 @@ CAST(N as DateTime64(9, 'Europe/Minsk'))
 # CAST(N as DateTime64(12, 'Asia/Istanbul'))
 # DateTime64(18) will always fail due to zero precision, but it is Ok to test here:
 # CAST(N as DateTime64(18, 'Asia/Istanbul'))
-formatDateTime(N, '%C %d %D %e %F %H %I %j %m %M %p %R %S %T %u %V %w %y %Y %%', 'Asia/Istanbul')
+formatDateTime(N, '%C %d %D %e %F %H %I %j %m %i %p %R %S %T %u %V %w %y %Y %%', 'Asia/Istanbul')
 """.splitlines()
 
 # Expanded later to cartesian product of all arguments, using format string.
diff --git a/tests/queries/0_stateless/00921_datetime64_compatibility_long.reference b/tests/queries/0_stateless/00921_datetime64_compatibility_long.reference
index 8a168ed0e9e..62de3a149a7 100644
--- a/tests/queries/0_stateless/00921_datetime64_compatibility_long.reference
+++ b/tests/queries/0_stateless/00921_datetime64_compatibility_long.reference
@@ -353,7 +353,7 @@ SELECT CAST(N as DateTime64(9, \'Europe/Minsk\'))
 "DateTime64(9, 'Europe/Minsk')","2019-09-16 19:20:11.000000000"
 "DateTime64(9, 'Europe/Minsk')","2019-09-16 19:20:11.234000000"
 ------------------------------------------
-SELECT formatDateTime(N, \'%C %d %D %e %F %H %I %j %m %M %p %R %S %T %u %V %w %y %Y %%\', \'Asia/Istanbul\')
+SELECT formatDateTime(N, \'%C %d %D %e %F %H %I %j %m %i %p %R %S %T %u %V %w %y %Y %%\', \'Asia/Istanbul\')
 "String","20 16 09/16/19 16 2019-09-16 00 12 259 09 00 AM 00:00 00 00:00:00 1 38 1 19 2019 %"
 "String","20 16 09/16/19 16 2019-09-16 19 07 259 09 20 PM 19:20 11 19:20:11 1 38 1 19 2019 %"
 "String","20 16 09/16/19 16 2019-09-16 19 07 259 09 20 PM 19:20 11 19:20:11 1 38 1 19 2019 %"
diff --git a/tests/queries/0_stateless/01411_from_unixtime.reference b/tests/queries/0_stateless/01411_from_unixtime.reference
index 4114c9b98d3..f5b3be44e00 100644
--- a/tests/queries/0_stateless/01411_from_unixtime.reference
+++ b/tests/queries/0_stateless/01411_from_unixtime.reference
@@ -24,7 +24,7 @@ Jan	Jan
 366	366
 00	00
 01	01
-33	00
+January	January
 \n	\n
 AM	AM
 AM
diff --git a/tests/queries/0_stateless/02030_capnp_format.reference b/tests/queries/0_stateless/02030_capnp_format.reference
index 8c3c81b5bc3..2b2307bfc6a 100644
--- a/tests/queries/0_stateless/02030_capnp_format.reference
+++ b/tests/queries/0_stateless/02030_capnp_format.reference
@@ -50,4 +50,3 @@ OK
 OK
 OK
 OK
-OK
diff --git a/tests/queries/0_stateless/02030_capnp_format.sh b/tests/queries/0_stateless/02030_capnp_format.sh
index cdc1587bccd..c15d6fe442e 100755
--- a/tests/queries/0_stateless/02030_capnp_format.sh
+++ b/tests/queries/0_stateless/02030_capnp_format.sh
@@ -109,8 +109,6 @@ $CLICKHOUSE_CLIENT --query="SELECT * FROM file('data.capnp', 'CapnProto', 'uint6
 $CLICKHOUSE_CLIENT --query="SELECT * FROM file('data.capnp', 'CapnProto', 'uint64 Enum(\'one\' = 1)') SETTINGS format_schema='$SERVER_SCHEMADIR/02030_capnp_simple_types:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
 $CLICKHOUSE_CLIENT --query="SELECT * FROM file('data.capnp', 'CapnProto', 'uint64 Tuple(UInt64)') SETTINGS format_schema='$SERVER_SCHEMADIR/02030_capnp_simple_types:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
 $CLICKHOUSE_CLIENT --query="SELECT * FROM file('data.capnp', 'CapnProto', 'uint64 Nullable(UInt64)') SETTINGS format_schema='$SERVER_SCHEMADIR/02030_capnp_simple_types:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
-$CLICKHOUSE_CLIENT --query="SELECT * FROM file('data.capnp', 'CapnProto', 'uint64 Int32') SETTINGS format_schema='$SERVER_SCHEMADIR/02030_capnp_simple_types:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
-
 
 $CLICKHOUSE_CLIENT --query="SELECT number AS a, toString(number) as b FROM numbers(5) FORMAT CapnProto SETTINGS format_schema='$CLIENT_SCHEMADIR/02030_capnp_unnamed_union:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
 $CLICKHOUSE_CLIENT --query="SELECT toNullable(toString(number)) as nullable1 FROM numbers(5) FORMAT CapnProto SETTINGS format_schema='$CLIENT_SCHEMADIR/02030_capnp_fake_nullable:Message'" 2>&1 | grep -F -q "CAPN_PROTO_BAD_CAST" && echo 'OK' || echo 'FAIL';
diff --git a/tests/queries/0_stateless/02319_lightweight_delete_on_merge_tree.sql b/tests/queries/0_stateless/02319_lightweight_delete_on_merge_tree.sql
index 00b90bb38b5..9413c664293 100644
--- a/tests/queries/0_stateless/02319_lightweight_delete_on_merge_tree.sql
+++ b/tests/queries/0_stateless/02319_lightweight_delete_on_merge_tree.sql
@@ -74,7 +74,7 @@ select table, partition, name, rows from system.parts where database = currentDa
 drop table t_light;
 
 SELECT '-----Test lightweight delete in multi blocks-----';
-CREATE TABLE t_large(a UInt32, b int) ENGINE=MergeTree order BY a settings min_bytes_for_wide_part=0;
+CREATE TABLE t_large(a UInt32, b int) ENGINE=MergeTree order BY a settings min_bytes_for_wide_part=0, index_granularity=8192, index_granularity_bytes='10Mi';
 INSERT INTO t_large SELECT number + 1, number + 1  FROM numbers(100000);
 
 DELETE FROM t_large WHERE a = 50000;
diff --git a/tests/queries/0_stateless/02319_lightweight_delete_on_merge_tree_compact_parts.sql b/tests/queries/0_stateless/02319_lightweight_delete_on_merge_tree_compact_parts.sql
index 4e9f3db0b96..db0567f252a 100644
--- a/tests/queries/0_stateless/02319_lightweight_delete_on_merge_tree_compact_parts.sql
+++ b/tests/queries/0_stateless/02319_lightweight_delete_on_merge_tree_compact_parts.sql
@@ -80,7 +80,7 @@ select table, partition, name, rows from system.parts where database = currentDa
 drop table t_light;
 
 SELECT '-----Test lightweight delete in multi blocks-----';
-CREATE TABLE t_large(a UInt32, b int) ENGINE=MergeTree order BY a settings min_bytes_for_wide_part=0;
+CREATE TABLE t_large(a UInt32, b int) ENGINE=MergeTree order BY a settings min_bytes_for_wide_part=0, index_granularity=8192, index_granularity_bytes='10Mi';
 INSERT INTO t_large SELECT number + 1, number + 1  FROM numbers(100000);
 
 DELETE FROM t_large WHERE a = 50000;
diff --git a/tests/queries/0_stateless/02352_lightweight_delete.sql b/tests/queries/0_stateless/02352_lightweight_delete.sql
index e1759e56a3a..b13688282a4 100644
--- a/tests/queries/0_stateless/02352_lightweight_delete.sql
+++ b/tests/queries/0_stateless/02352_lightweight_delete.sql
@@ -1,6 +1,6 @@
 DROP TABLE IF EXISTS lwd_test;
 
-CREATE TABLE lwd_test (id UInt64 , value String) ENGINE MergeTree() ORDER BY id;
+CREATE TABLE lwd_test (id UInt64 , value String) ENGINE MergeTree() ORDER BY id SETTINGS index_granularity=8192, index_granularity_bytes='10Mi';
 
 INSERT INTO lwd_test SELECT number, randomString(10) FROM system.numbers LIMIT 1000000;
 
diff --git a/tests/queries/0_stateless/02404_memory_bound_merging.reference b/tests/queries/0_stateless/02404_memory_bound_merging.reference
index f774abe834d..d9fac433189 100644
--- a/tests/queries/0_stateless/02404_memory_bound_merging.reference
+++ b/tests/queries/0_stateless/02404_memory_bound_merging.reference
@@ -113,21 +113,13 @@ ExpressionTransform
             (Expression)
             ExpressionTransform × 4
               (MergingAggregated)
-              MergingAggregatedBucketTransform × 4
-                Resize 1 → 4
-                  FinishAggregatingInOrderTransform 3 → 1
-                    (Union)
-                      (Aggregating)
-                      SortingAggregatedForMemoryBoundMergingTransform 4 → 1
-                        MergingAggregatedBucketTransform × 4
-                          Resize 1 → 4
-                            FinishAggregatingInOrderTransform 4 → 1
-                              AggregatingInOrderTransform × 4
-                                (Expression)
-                                ExpressionTransform × 4
-                                  (ReadFromMergeTree)
-                                  MergeTreeInOrder × 4 0 → 1
-                      (ReadFromRemoteParallelReplicas)
+              Resize 1 → 4
+                SortingAggregatedTransform 4 → 1
+                  MergingAggregatedBucketTransform × 4
+                    Resize 1 → 4
+                      GroupingAggregatedTransform 3 → 1
+                        (Union)
+                          (ReadFromRemoteParallelReplicas)
 select a, count() from pr_t group by a order by a limit 5 offset 500;
 500	1000
 501	1000
diff --git a/tests/queries/0_stateless/02475_bson_each_row_format.reference b/tests/queries/0_stateless/02475_bson_each_row_format.reference
index 5922167dc97..f90867d92b1 100644
--- a/tests/queries/0_stateless/02475_bson_each_row_format.reference
+++ b/tests/queries/0_stateless/02475_bson_each_row_format.reference
@@ -121,7 +121,7 @@ Nullable
 2
 0
 4
-FAIL
+OK
 null	Nullable(Int64)					
 0
 \N
@@ -191,8 +191,11 @@ tuple	Tuple(Nullable(Int64), Nullable(String))
 (3,'Hello')
 (4,'Hello')
 Map
-OK
-OK
+{1:0,2:1}
+{1:1,2:2}
+{1:2,2:3}
+{1:3,2:4}
+{1:4,2:5}
 {'a':0,'b':1}
 {'a':1,'b':2}
 {'a':2,'b':3}
diff --git a/tests/queries/0_stateless/02475_bson_each_row_format.sh b/tests/queries/0_stateless/02475_bson_each_row_format.sh
index b4efea7e326..aa58d27fa50 100755
--- a/tests/queries/0_stateless/02475_bson_each_row_format.sh
+++ b/tests/queries/0_stateless/02475_bson_each_row_format.sh
@@ -88,7 +88,7 @@ echo "Nullable"
 $CLICKHOUSE_CLIENT -q "insert into function file(02475_data.bsonEachRow, auto, 'null Nullable(UInt32)') select number % 2 ? NULL : number from numbers(5) settings engine_file_truncate_on_insert=1"
 $CLICKHOUSE_CLIENT -q "select * from file(02475_data.bsonEachRow, auto, 'null Nullable(UInt32)')"
 $CLICKHOUSE_CLIENT -q "select * from file(02475_data.bsonEachRow, auto, 'null UInt32')"
-$CLICKHOUSE_CLIENT -q "select * from file(02475_data.bsonEachRow, auto, 'null UInt32') settings input_format_null_as_default=0" 2>&1 | grep -q -F "INCORRECT_DATA" && echo "OK" || echo "FAIL"
+$CLICKHOUSE_CLIENT -q "select * from file(02475_data.bsonEachRow, auto, 'null UInt32') settings input_format_null_as_default=0" 2>&1 | grep -q -F "ILLEGAL_COLUMN" && echo "OK" || echo "FAIL"
 
 $CLICKHOUSE_CLIENT -q "desc file(02475_data.bsonEachRow)"
 $CLICKHOUSE_CLIENT -q "select * from file(02475_data.bsonEachRow)"
@@ -132,10 +132,10 @@ $CLICKHOUSE_CLIENT -q "select * from file(02475_data.bsonEachRow)"
 
 
 echo "Map"
-$CLICKHOUSE_CLIENT -q "insert into function file(02475_data.bsonEachRow, auto, 'map Map(UInt64, UInt64)') select map(1, number, 2, number + 1) from numbers(5) settings engine_file_truncate_on_insert=1" 2>&1 | grep -q -F "ILLEGAL_COLUMN" && echo "OK" || echo "FAIL"
-$CLICKHOUSE_CLIENT -q "insert into function file(02475_data.bsonEachRow, auto, 'map Map(String, UInt64)') select map('a', number, 'b', number + 1) from numbers(5) settings engine_file_truncate_on_insert=1"
+$CLICKHOUSE_CLIENT -q "insert into function file(02475_data.bsonEachRow, auto, 'map Map(UInt64, UInt64)') select map(1, number, 2, number + 1) from numbers(5) settings engine_file_truncate_on_insert=1"
+$CLICKHOUSE_CLIENT -q "select * from file(02475_data.bsonEachRow, auto, 'map Map(UInt64, UInt64)')"
 
-$CLICKHOUSE_CLIENT -q "select * from file(02475_data.bsonEachRow, auto, 'map Map(UInt64, UInt64)')" 2>&1 | grep -q -F "ILLEGAL_COLUMN" && echo "OK" || echo "FAIL"
+$CLICKHOUSE_CLIENT -q "insert into function file(02475_data.bsonEachRow, auto, 'map Map(String, UInt64)') select map('a', number, 'b', number + 1) from numbers(5) settings engine_file_truncate_on_insert=1"
 $CLICKHOUSE_CLIENT -q "select * from file(02475_data.bsonEachRow, auto, 'map Map(String, UInt64)')"
 
 $CLICKHOUSE_CLIENT -q "desc file(02475_data.bsonEachRow)"
diff --git a/tests/queries/0_stateless/02536_replace_with_nonconst_needle_and_replacement.reference b/tests/queries/0_stateless/02536_replace_with_nonconst_needle_and_replacement.reference
new file mode 100644
index 00000000000..c7a02045316
--- /dev/null
+++ b/tests/queries/0_stateless/02536_replace_with_nonconst_needle_and_replacement.reference
@@ -0,0 +1,77 @@
+** replaceAll() **
+- non-const needle, const replacement
+1	Hello World	l	x	Hexxo Worxd
+2	Hello World	ll	x	Hexo World
+3	Hello World	not_found	x	Hello World
+4	Hello World	[eo]	x	Hello World
+5	Hello World	.	x	Hello World
+- const needle, non-const replacement
+1	Hello World	l	xx	Hexxxxo Worxxd
+2	Hello World	l	x	Hexxo Worxd
+3	Hello World	l	x	Hexxo Worxd
+4	Hello World	l	x	Hexxo Worxd
+5	Hello World	l	x	Hexxo Worxd
+- non-const needle, non-const replacement
+1	Hello World	l	xx	Hexxxxo Worxxd
+2	Hello World	ll	x	Hexo World
+3	Hello World	not_found	x	Hello World
+4	Hello World	[eo]	x	Hello World
+5	Hello World	.	x	Hello World
+** replaceOne() **
+- non-const needle, const replacement
+1	Hello World	l	x	Hexlo World
+2	Hello World	ll	x	Hexo World
+3	Hello World	not_found	x	Hello World
+4	Hello World	[eo]	x	Hello World
+5	Hello World	.	x	Hello World
+- const needle, non-const replacement
+1	Hello World	l	xx	Hexxlo World
+2	Hello World	l	x	Hexlo World
+3	Hello World	l	x	Hexlo World
+4	Hello World	l	x	Hexlo World
+5	Hello World	l	x	Hexlo World
+- non-const needle, non-const replacement
+1	Hello World	l	xx	Hexxlo World
+2	Hello World	ll	x	Hexo World
+3	Hello World	not_found	x	Hello World
+4	Hello World	[eo]	x	Hello World
+5	Hello World	.	x	Hello World
+** replaceRegexpAll() **
+- non-const needle, const replacement
+1	Hello World	l	x	Hexxo Worxd
+2	Hello World	ll	x	Hexo World
+3	Hello World	not_found	x	Hello World
+4	Hello World	[eo]	x	Hxllx Wxrld
+5	Hello World	.	x	xxxxxxxxxxx
+- const needle, non-const replacement
+1	Hello World	l	xx	Hexxxxo Worxxd
+2	Hello World	l	x	Hexxo Worxd
+3	Hello World	l	x	Hexxo Worxd
+4	Hello World	l	x	Hexxo Worxd
+5	Hello World	l	x	Hexxo Worxd
+- non-const needle, non-const replacement
+1	Hello World	l	xx	Hexxxxo Worxxd
+2	Hello World	ll	x	Hexo World
+3	Hello World	not_found	x	Hello World
+4	Hello World	[eo]	x	Hxllx Wxrld
+5	Hello World	.	x	xxxxxxxxxxx
+** replaceRegexpOne() **
+- non-const needle, const replacement
+1	Hello World	l	x	Hexlo World
+2	Hello World	ll	x	Hexo World
+3	Hello World	not_found	x	Hello World
+4	Hello World	[eo]	x	Hxllo World
+5	Hello World	.	x	xello World
+- const needle, non-const replacement
+1	Hello World	l	xx	Hexxlo World
+2	Hello World	l	x	Hexlo World
+3	Hello World	l	x	Hexlo World
+4	Hello World	l	x	Hexlo World
+5	Hello World	l	x	Hexlo World
+- non-const needle, non-const replacement
+1	Hello World	l	xx	Hexxlo World
+2	Hello World	ll	x	Hexo World
+3	Hello World	not_found	x	Hello World
+4	Hello World	[eo]	x	Hxllo World
+5	Hello World	.	x	xello World
+Check that an exception is thrown if the needle is empty
diff --git a/tests/queries/0_stateless/02536_replace_with_nonconst_needle_and_replacement.sql b/tests/queries/0_stateless/02536_replace_with_nonconst_needle_and_replacement.sql
new file mode 100644
index 00000000000..7406f0309bb
--- /dev/null
+++ b/tests/queries/0_stateless/02536_replace_with_nonconst_needle_and_replacement.sql
@@ -0,0 +1,90 @@
+-- Tests that functions replaceOne(), replaceAll(), replaceRegexpOne(), replaceRegexpAll() work with with non-const pattern and replacement arguments
+
+DROP TABLE IF EXISTS test_tab;
+
+CREATE TABLE test_tab
+  (id UInt32, haystack String, needle String, replacement String)
+  engine = MergeTree()
+  ORDER BY id;
+
+INSERT INTO test_tab VALUES (1, 'Hello World', 'l', 'xx') (2, 'Hello World', 'll', 'x') (3, 'Hello World', 'not_found', 'x') (4, 'Hello World', '[eo]', 'x') (5, 'Hello World', '.', 'x')
+
+SELECT '** replaceAll() **';
+
+SELECT '- non-const needle, const replacement';
+SELECT id, haystack, needle, 'x', replaceAll(haystack, needle, 'x') FROM test_tab ORDER BY id;
+
+SELECT '- const needle, non-const replacement';
+SELECT id, haystack, 'l', replacement, replaceAll(haystack, 'l', replacement) FROM test_tab ORDER BY id;
+
+SELECT '- non-const needle, non-const replacement';
+SELECT id, haystack, needle, replacement, replaceAll(haystack, needle, replacement) FROM test_tab ORDER BY id;
+
+SELECT '** replaceOne() **';
+
+SELECT '- non-const needle, const replacement';
+SELECT id, haystack, needle, 'x', replaceOne(haystack, needle, 'x') FROM test_tab ORDER BY id;
+
+
+SELECT '- const needle, non-const replacement';
+SELECT id, haystack, 'l', replacement, replaceOne(haystack, 'l', replacement) FROM test_tab ORDER BY id;
+
+
+SELECT '- non-const needle, non-const replacement';
+SELECT id, haystack, needle, replacement, replaceOne(haystack, needle, replacement) FROM test_tab ORDER BY id;
+
+SELECT '** replaceRegexpAll() **';
+
+SELECT '- non-const needle, const replacement';
+SELECT id, haystack, needle, 'x', replaceRegexpAll(haystack, needle, 'x') FROM test_tab ORDER BY id;
+
+SELECT '- const needle, non-const replacement';
+SELECT id, haystack, 'l', replacement, replaceRegexpAll(haystack, 'l', replacement) FROM test_tab ORDER BY id;
+
+SELECT '- non-const needle, non-const replacement';
+SELECT id, haystack, needle, replacement, replaceRegexpAll(haystack, needle, replacement) FROM test_tab ORDER BY id;
+
+SELECT '** replaceRegexpOne() **';
+
+SELECT '- non-const needle, const replacement';
+SELECT id, haystack, needle, 'x', replaceRegexpOne(haystack, needle, 'x') FROM test_tab ORDER BY id;
+
+
+SELECT '- const needle, non-const replacement';
+SELECT id, haystack, 'l', replacement, replaceRegexpOne(haystack, 'l', replacement) FROM test_tab ORDER BY id;
+
+
+SELECT '- non-const needle, non-const replacement';
+SELECT id, haystack, needle, replacement, replaceRegexpOne(haystack, needle, replacement) FROM test_tab ORDER BY id;
+
+DROP TABLE IF EXISTS test_tab;
+
+
+SELECT 'Check that an exception is thrown if the needle is empty';
+
+CREATE TABLE test_tab
+  (id UInt32, haystack String, needle String, replacement String)
+  engine = MergeTree()
+  ORDER BY id;
+
+INSERT INTO test_tab VALUES (1, 'Hello World', 'l', 'x') (2, 'Hello World', '', 'y')
+
+-- needle: non-const, replacement: const
+SELECT replaceAll(haystack, needle, 'x') FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+SELECT replaceOne(haystack, needle, 'x') FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+SELECT replaceRegexpAll(haystack, needle, 'x') FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+SELECT replaceRegexpOne(haystack, needle, 'x') FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+
+-- needle: const, replacement: non-const
+SELECT replaceAll(haystack, '', replacement) FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+SELECT replaceOne(haystack, '', replacement) FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+SELECT replaceRegexpAll(haystack, '', replacement) FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+SELECT replaceRegexpOne(haystack, '', replacement) FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+
+-- needle: non-const, replacement: non-const
+SELECT replaceAll(haystack, needle, replacement) FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+SELECT replaceOne(haystack, needle, replacement) FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+SELECT replaceRegexpAll(haystack, needle, replacement) FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+SELECT replaceRegexpOne(haystack, needle, replacement) FROM test_tab;  -- { serverError ARGUMENT_OUT_OF_BOUND }
+
+DROP TABLE IF EXISTS test_tab;
diff --git a/tests/queries/0_stateless/02564_date_format.reference b/tests/queries/0_stateless/02564_date_format.reference
index a5f2e362cc6..38c0d39340b 100644
--- a/tests/queries/0_stateless/02564_date_format.reference
+++ b/tests/queries/0_stateless/02564_date_format.reference
@@ -17,7 +17,7 @@ Jan	Jan
 366	366
 00	00
 01	01
-33	00
+January	January
 \n	\n
 AM	AM
 AM
diff --git a/tests/queries/0_stateless/02591_bson_long_tuple.reference b/tests/queries/0_stateless/02591_bson_long_tuple.reference
index 008a3c51138..98eb634721e 100644
Binary files a/tests/queries/0_stateless/02591_bson_long_tuple.reference and b/tests/queries/0_stateless/02591_bson_long_tuple.reference differ
diff --git a/tests/queries/0_stateless/02593_bson_more_types.reference b/tests/queries/0_stateless/02593_bson_more_types.reference
new file mode 100644
index 00000000000..e84b3c8efb8
--- /dev/null
+++ b/tests/queries/0_stateless/02593_bson_more_types.reference
@@ -0,0 +1,5 @@
+{'a\\u0000b':42}
+c1	Nullable(Int32)					
+c2	Nullable(Int32)					
+c3	Map(String, Nullable(Int32))					
+a	b	{42:42}
diff --git a/tests/queries/0_stateless/02593_bson_more_types.sh b/tests/queries/0_stateless/02593_bson_more_types.sh
new file mode 100755
index 00000000000..cd7b9e0aaf3
--- /dev/null
+++ b/tests/queries/0_stateless/02593_bson_more_types.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# Tags: no-fasttest
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+
+$CLICKHOUSE_LOCAL -q "select map('a\0b', 42) as c1 format BSONEachRow" | $CLICKHOUSE_LOCAL --input-format BSONEachRow --table test --structure "c1 Map(String, UInt32)" -q "select * from test"
+
+$CLICKHOUSE_LOCAL -q "select 'a'::Enum8('a' = 1) as c1, 'b'::Enum16('b' = 1) as c2, map(42, 42) as c3 format BSONEachRow" | $CLICKHOUSE_LOCAL --input-format BSONEachRow --table test -q "desc test"
+
+$CLICKHOUSE_LOCAL -q "select 'a'::Enum8('a' = 1) as c1, 'b'::Enum16('b' = 1) as c2, map(42, 42) as c3 format BSONEachRow" | $CLICKHOUSE_LOCAL --input-format BSONEachRow --table test --structure "c1 Enum8('a' = 1), c2 Enum16('b' = 1), c3 Map(UInt32, UInt32)" -q "select * from test"
+
+
diff --git a/tests/queries/0_stateless/02661_quantile_approx.reference b/tests/queries/0_stateless/02661_quantile_approx.reference
new file mode 100644
index 00000000000..73d99112c0b
--- /dev/null
+++ b/tests/queries/0_stateless/02661_quantile_approx.reference
@@ -0,0 +1,37 @@
+-- { echoOn }
+with arrayJoin([0, 1, 2, 10]) as x select quantilesApprox(100, 0.5, 0.4, 0.1)(x);
+[1,1,0]
+with arrayJoin([0, 6, 7, 9, 10]) as x select quantileApprox(100, 0.5)(x);
+7
+select quantilesApprox(10000, 0.25, 0.5, 0.75, 0.0, 1.0, 0, 1)(number + 1) from numbers(1000);
+[250,500,750,1,1000,1,1000]
+select quantilesApprox(10000, 0.01, 0.1, 0.11)(number + 1) from numbers(10);
+[1,1,2]
+with number + 1 as col select quantilesApprox(10000, 0.25, 0.5, 0.75)(col), count(col), quantilesApprox(10000, 0.0, 1.0)(col), sum(col) from numbers(1000);
+[250,500,750]	1000	[1,1000]	500500
+select quantilesApprox(1, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+[1,1,1,1,1]
+select quantilesApprox(10, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+[1,156,156,296,715]
+select quantilesApprox(100, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+[93,192,251,306,770]
+select quantilesApprox(1000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+[99,199,249,313,776]
+select quantilesApprox(10000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+[100,200,250,314,777]
+select quantileApprox()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantileApprox(100)(number) from numbers(10);
+4
+select quantileApprox(100, 0.5)(number) from numbers(10);
+4
+select quantileApprox(100, 0.5, 0.75)(number) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantileApprox('abc', 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantileApprox(1.23, 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantileApprox(-100, 0.5)(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantilesApprox()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantilesApprox(100)(number) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantilesApprox(100, 0.5)(number) from numbers(10);
+[4]
+select quantilesApprox('abc', 0.5, 0.75)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantilesApprox(1.23, 0.5, 0.75)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantilesApprox(-100, 0.5, 0.75)(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
diff --git a/tests/queries/0_stateless/02661_quantile_approx.sql b/tests/queries/0_stateless/02661_quantile_approx.sql
new file mode 100644
index 00000000000..f27c8150ee9
--- /dev/null
+++ b/tests/queries/0_stateless/02661_quantile_approx.sql
@@ -0,0 +1,31 @@
+-- { echoOn }
+with arrayJoin([0, 1, 2, 10]) as x select quantilesApprox(100, 0.5, 0.4, 0.1)(x);
+with arrayJoin([0, 6, 7, 9, 10]) as x select quantileApprox(100, 0.5)(x);
+
+select quantilesApprox(10000, 0.25, 0.5, 0.75, 0.0, 1.0, 0, 1)(number + 1) from numbers(1000);
+select quantilesApprox(10000, 0.01, 0.1, 0.11)(number + 1) from numbers(10);
+
+with number + 1 as col select quantilesApprox(10000, 0.25, 0.5, 0.75)(col), count(col), quantilesApprox(10000, 0.0, 1.0)(col), sum(col) from numbers(1000);
+
+select quantilesApprox(1, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesApprox(10, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesApprox(100, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesApprox(1000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+select quantilesApprox(10000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
+
+
+select quantileApprox()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantileApprox(100)(number) from numbers(10);
+select quantileApprox(100, 0.5)(number) from numbers(10);
+select quantileApprox(100, 0.5, 0.75)(number) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantileApprox('abc', 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantileApprox(1.23, 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantileApprox(-100, 0.5)(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+
+select quantilesApprox()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantilesApprox(100)(number) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantilesApprox(100, 0.5)(number) from numbers(10);
+select quantilesApprox('abc', 0.5, 0.75)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantilesApprox(1.23, 0.5, 0.75)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+select quantilesApprox(-100, 0.5, 0.75)(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+-- { echoOff }
diff --git a/tests/queries/0_stateless/02668_parse_datetime.reference b/tests/queries/0_stateless/02668_parse_datetime.reference
index 6bcd4a42c10..ec57efe64ed 100644
--- a/tests/queries/0_stateless/02668_parse_datetime.reference
+++ b/tests/queries/0_stateless/02668_parse_datetime.reference
@@ -26,6 +26,25 @@ select parseDateTime('jun', '%b', 'UTC') = toDateTime('2000-06-01', 'UTC');
 select parseDateTime('JUN', '%b', 'UTC') = toDateTime('2000-06-01', 'UTC');
 1
 select parseDateTime('abc', '%b'); -- { serverError CANNOT_PARSE_DATETIME }
+set formatdatetime_parsedatetime_m_is_month_name = 1;
+select parseDateTime('may', '%M', 'UTC') = toDateTime('2000-05-01', 'UTC');
+1
+select parseDateTime('MAY', '%M', 'UTC') = toDateTime('2000-05-01', 'UTC');
+1
+select parseDateTime('september', '%M', 'UTC') = toDateTime('2000-09-01', 'UTC');
+1
+select parseDateTime('summer', '%M'); -- { serverError CANNOT_PARSE_DATETIME }
+set formatdatetime_parsedatetime_m_is_month_name = 0;
+select parseDateTime('08', '%M', 'UTC') = toDateTime('1970-01-01 00:08:00', 'UTC');
+1
+select parseDateTime('59', '%M', 'UTC') = toDateTime('1970-01-01 00:59:00', 'UTC');
+1
+select parseDateTime('00/', '%M/', 'UTC') = toDateTime('1970-01-01 00:00:00', 'UTC');
+1
+select parseDateTime('60', '%M', 'UTC'); -- { serverError CANNOT_PARSE_DATETIME }
+select parseDateTime('-1', '%M', 'UTC'); -- { serverError CANNOT_PARSE_DATETIME }
+select parseDateTime('123456789', '%M', 'UTC'); -- { serverError CANNOT_PARSE_DATETIME }
+set formatdatetime_parsedatetime_m_is_month_name = 1;
 -- day of month
 select parseDateTime('07', '%d', 'UTC') = toDateTime('2000-01-07', 'UTC');
 1
diff --git a/tests/queries/0_stateless/02668_parse_datetime.sql b/tests/queries/0_stateless/02668_parse_datetime.sql
index abe3505de03..9ec2a94a72c 100644
--- a/tests/queries/0_stateless/02668_parse_datetime.sql
+++ b/tests/queries/0_stateless/02668_parse_datetime.sql
@@ -18,6 +18,19 @@ select parseDateTime('12345', '%c'); -- { serverError CANNOT_PARSE_DATETIME }
 select parseDateTime('jun', '%b', 'UTC') = toDateTime('2000-06-01', 'UTC');
 select parseDateTime('JUN', '%b', 'UTC') = toDateTime('2000-06-01', 'UTC');
 select parseDateTime('abc', '%b'); -- { serverError CANNOT_PARSE_DATETIME }
+set formatdatetime_parsedatetime_m_is_month_name = 1;
+select parseDateTime('may', '%M', 'UTC') = toDateTime('2000-05-01', 'UTC');
+select parseDateTime('MAY', '%M', 'UTC') = toDateTime('2000-05-01', 'UTC');
+select parseDateTime('september', '%M', 'UTC') = toDateTime('2000-09-01', 'UTC');
+select parseDateTime('summer', '%M'); -- { serverError CANNOT_PARSE_DATETIME }
+set formatdatetime_parsedatetime_m_is_month_name = 0;
+select parseDateTime('08', '%M', 'UTC') = toDateTime('1970-01-01 00:08:00', 'UTC');
+select parseDateTime('59', '%M', 'UTC') = toDateTime('1970-01-01 00:59:00', 'UTC');
+select parseDateTime('00/', '%M/', 'UTC') = toDateTime('1970-01-01 00:00:00', 'UTC');
+select parseDateTime('60', '%M', 'UTC'); -- { serverError CANNOT_PARSE_DATETIME }
+select parseDateTime('-1', '%M', 'UTC'); -- { serverError CANNOT_PARSE_DATETIME }
+select parseDateTime('123456789', '%M', 'UTC'); -- { serverError CANNOT_PARSE_DATETIME }
+set formatdatetime_parsedatetime_m_is_month_name = 1;
 
 -- day of month
 select parseDateTime('07', '%d', 'UTC') = toDateTime('2000-01-07', 'UTC');
diff --git a/tests/queries/0_stateless/02703_max_local_read_bandwidth.reference b/tests/queries/0_stateless/02703_max_local_read_bandwidth.reference
new file mode 100644
index 00000000000..e2968e9fef5
--- /dev/null
+++ b/tests/queries/0_stateless/02703_max_local_read_bandwidth.reference
@@ -0,0 +1,3 @@
+read	1	1	1	1
+pread	1	1	1	1
+pread_threadpool	1	1	1	1
diff --git a/tests/queries/0_stateless/02703_max_local_read_bandwidth.sh b/tests/queries/0_stateless/02703_max_local_read_bandwidth.sh
new file mode 100755
index 00000000000..bdcdb38846c
--- /dev/null
+++ b/tests/queries/0_stateless/02703_max_local_read_bandwidth.sh
@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Tags: no-s3-storage, no-random-settings, no-random-merge-tree-settings
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CUR_DIR"/../shell_config.sh
+
+$CLICKHOUSE_CLIENT -nm -q "
+    drop table if exists data;
+    create table data (key UInt64 CODEC(NONE)) engine=MergeTree() order by tuple() settings min_bytes_for_wide_part=1e9, min_bytes_for_compact_part=0;
+"
+
+# reading 1e6*8 bytes with 1M bandwith it should take (8-1)/1=7 seconds
+$CLICKHOUSE_CLIENT -q "insert into data select * from numbers(1e6)"
+
+read_methods=(
+    read
+    pread
+    pread_threadpool
+    # NOTE: io_uring doing all IO from one thread, that is not attached to the query
+    # io_uring
+    # NOTE: mmap cannot be throttled
+    # mmap
+)
+for read_method in "${read_methods[@]}"; do
+    query_id=$(random_str 10)
+    $CLICKHOUSE_CLIENT --query_id "$query_id" -q "select * from data format Null settings max_local_read_bandwidth='1M', local_filesystem_read_method='$read_method'"
+    $CLICKHOUSE_CLIENT -nm -q "
+        SYSTEM FLUSH LOGS;
+        SELECT
+            '$read_method',
+            query_duration_ms >= 7e3,
+            ProfileEvents['ReadBufferFromFileDescriptorReadBytes'] > 8e6,
+            ProfileEvents['LocalReadThrottlerBytes'] > 8e6,
+            ProfileEvents['LocalReadThrottlerSleepMicroseconds'] > 7e6
+        FROM system.query_log
+        WHERE current_database = '$CLICKHOUSE_DATABASE' AND query_id = '$query_id' AND type != 'QueryStart'
+    "
+done
diff --git a/tests/queries/0_stateless/02703_max_local_write_bandwidth.reference b/tests/queries/0_stateless/02703_max_local_write_bandwidth.reference
new file mode 100644
index 00000000000..ad05a699da0
--- /dev/null
+++ b/tests/queries/0_stateless/02703_max_local_write_bandwidth.reference
@@ -0,0 +1 @@
+1	1	1	1
diff --git a/tests/queries/0_stateless/02703_max_local_write_bandwidth.sh b/tests/queries/0_stateless/02703_max_local_write_bandwidth.sh
new file mode 100755
index 00000000000..276a15ca6cc
--- /dev/null
+++ b/tests/queries/0_stateless/02703_max_local_write_bandwidth.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Tags: no-s3-storage
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CUR_DIR"/../shell_config.sh
+
+$CLICKHOUSE_CLIENT -nm -q "
+    drop table if exists data;
+    create table data (key UInt64 CODEC(NONE)) engine=MergeTree() order by tuple() settings min_bytes_for_wide_part=1e9, min_bytes_for_compact_part=0;
+"
+
+query_id=$(random_str 10)
+# writes 1e6*8 bytes with 1M bandwith it should take (8-1)/1=7 seconds
+$CLICKHOUSE_CLIENT --query_id "$query_id" -q "insert into data select * from numbers(1e6) settings max_local_write_bandwidth='1M'"
+$CLICKHOUSE_CLIENT -nm -q "
+    SYSTEM FLUSH LOGS;
+    SELECT
+        query_duration_ms >= 7e3,
+        ProfileEvents['WriteBufferFromFileDescriptorWriteBytes'] > 8e6,
+        ProfileEvents['LocalWriteThrottlerBytes'] > 8e6,
+        ProfileEvents['LocalWriteThrottlerSleepMicroseconds'] > 7e6
+    FROM system.query_log
+    WHERE current_database = '$CLICKHOUSE_DATABASE' AND query_id = '$query_id' AND type != 'QueryStart'
+"
diff --git a/tests/queries/0_stateless/02704_max_backup_bandwidth.reference b/tests/queries/0_stateless/02704_max_backup_bandwidth.reference
new file mode 100644
index 00000000000..9972842f982
--- /dev/null
+++ b/tests/queries/0_stateless/02704_max_backup_bandwidth.reference
@@ -0,0 +1 @@
+1	1
diff --git a/tests/queries/0_stateless/02704_max_backup_bandwidth.sh b/tests/queries/0_stateless/02704_max_backup_bandwidth.sh
new file mode 100755
index 00000000000..c9ad23031b6
--- /dev/null
+++ b/tests/queries/0_stateless/02704_max_backup_bandwidth.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Tags: no-s3-storage, no-random-settings, no-random-merge-tree-settings
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CUR_DIR"/../shell_config.sh
+
+$CLICKHOUSE_CLIENT -nm -q "
+    drop table if exists data;
+    create table data (key UInt64 CODEC(NONE)) engine=MergeTree() order by tuple() settings min_bytes_for_wide_part=1e9, min_bytes_for_compact_part=0;
+"
+
+# reading 1e6*8 bytes with 1M bandwith it should take (8-1)/1=7 seconds
+$CLICKHOUSE_CLIENT -q "insert into data select * from numbers(1e6)"
+
+query_id=$(random_str 10)
+$CLICKHOUSE_CLIENT --query_id "$query_id" -q "backup table data to Disk('default', 'backups/$CLICKHOUSE_DATABASE/data/backup1')" --max_backup_bandwidth=1M > /dev/null
+$CLICKHOUSE_CLIENT -nm -q "
+    SYSTEM FLUSH LOGS;
+    SELECT
+        query_duration_ms >= 7e3,
+        ProfileEvents['ReadBufferFromFileDescriptorReadBytes'] > 8e6
+    FROM system.query_log
+    WHERE current_database = '$CLICKHOUSE_DATABASE' AND query_id = '$query_id' AND type != 'QueryStart'
+"
diff --git a/tests/queries/0_stateless/02705_capnp_more_types.reference b/tests/queries/0_stateless/02705_capnp_more_types.reference
new file mode 100644
index 00000000000..9cacd1fe527
--- /dev/null
+++ b/tests/queries/0_stateless/02705_capnp_more_types.reference
@@ -0,0 +1,3 @@
+42	42	42	42	42.42	42.42
+{'Hello':42,'World':24}
+42	42	42	42	42	42	42	42
diff --git a/tests/queries/0_stateless/02705_capnp_more_types.sh b/tests/queries/0_stateless/02705_capnp_more_types.sh
new file mode 100755
index 00000000000..1f6b1f7c86b
--- /dev/null
+++ b/tests/queries/0_stateless/02705_capnp_more_types.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# Tags: no-fasttest, no-parallel, no-replicated-database
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+SCHEMADIR=$CURDIR/format_schemas
+$CLICKHOUSE_LOCAL -q "select 42::Int128 as int128, 42::UInt128 as uint128, 42::Int256 as int256, 42::UInt256 as uint256, 42.42::Decimal128(2) as decimal128, 42.42::Decimal256(2) as decimal256 format CapnProto settings format_schema='$SCHEMADIR/02705_big_numbers:Message'" | $CLICKHOUSE_LOCAL --input-format CapnProto --structure "int128 Int128, uint128 UInt128, int256 Int256, uint256 UInt256, decimal128 Decimal128(2), decimal256 Decimal256(2)" -q "select * from table" --format_schema="$SCHEMADIR/02705_big_numbers:Message"
+
+$CLICKHOUSE_LOCAL -q "select map('Hello', 42, 'World', 24) as map format CapnProto settings format_schema='$SCHEMADIR/02705_map:Message'" | $CLICKHOUSE_LOCAL  --input-format CapnProto --structure "map Map(String, UInt32)" --format_schema="$SCHEMADIR/02705_map:Message"  -q "select * from table"
+
+
+$CLICKHOUSE_LOCAL -q "select 42 as int8, 42 as uint8, 42 as int16, 42 as uint16, 42 as int32, 42 as uint32, 42 as int64, 42 as uint64 format CapnProto settings format_schema='$SCHEMADIR/02030_capnp_simple_types:Message'" | $CLICKHOUSE_LOCAL  --input-format CapnProto --structure "int8 UInt32, uint8 Int32, int16 Int8, uint16 UInt8, int32 UInt64, uint32 Int64, int64 UInt16, uint64 Int16" --format_schema="$SCHEMADIR/02030_capnp_simple_types:Message"  -q "select * from table"
+
+
+
diff --git a/tests/queries/0_stateless/02705_protobuf_debug_abort.reference b/tests/queries/0_stateless/02705_protobuf_debug_abort.reference
new file mode 100644
index 00000000000..d00491fd7e5
--- /dev/null
+++ b/tests/queries/0_stateless/02705_protobuf_debug_abort.reference
@@ -0,0 +1 @@
+1
diff --git a/tests/queries/0_stateless/02705_protobuf_debug_abort.sh b/tests/queries/0_stateless/02705_protobuf_debug_abort.sh
new file mode 100755
index 00000000000..ec564d4c6fc
--- /dev/null
+++ b/tests/queries/0_stateless/02705_protobuf_debug_abort.sh
@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+# Tags: no-fasttest
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+echo 'syntax = "proto3";
+
+message Message {
+    NotExisted x = 1;
+}' > 02705_schema_$CLICKHOUSE_TEST_UNIQUE_NAME.proto
+
+
+$CLICKHOUSE_LOCAL -q "select * from file(data.bin, Protobuf) settings format_schema='02705_schema_$CLICKHOUSE_TEST_UNIQUE_NAME:Message'" 2>&1 | grep -c "CANNOT_PARSE_PROTOBUF_SCHEMA"
+
+rm 02705_schema_$CLICKHOUSE_TEST_UNIQUE_NAME.proto
+
diff --git a/tests/queries/0_stateless/02707_protobuf_unnamed_tuple_as_nested_message.reference b/tests/queries/0_stateless/02707_protobuf_unnamed_tuple_as_nested_message.reference
new file mode 100644
index 00000000000..a01aba9895b
--- /dev/null
+++ b/tests/queries/0_stateless/02707_protobuf_unnamed_tuple_as_nested_message.reference
@@ -0,0 +1 @@
+(42,'Hello',[1,2,3])
diff --git a/tests/queries/0_stateless/02707_protobuf_unnamed_tuple_as_nested_message.sh b/tests/queries/0_stateless/02707_protobuf_unnamed_tuple_as_nested_message.sh
new file mode 100755
index 00000000000..735117c6603
--- /dev/null
+++ b/tests/queries/0_stateless/02707_protobuf_unnamed_tuple_as_nested_message.sh
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# Tags: no-fasttest
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+SCHEMADIR=$CURDIR/format_schemas
+
+$CLICKHOUSE_LOCAL -q "select tuple(42, 'Hello', [1,2,3]) as x format Protobuf settings format_schema='$SCHEMADIR/02707_schema:Message'" | $CLICKHOUSE_LOCAL --input-format Protobuf --structure='x Tuple(UInt32, String, Array(UInt32))' -q "select * from table" --format_schema="$SCHEMADIR/02707_schema:Message"
+
diff --git a/tests/queries/0_stateless/02708_parallel_replicas_not_found_column.reference b/tests/queries/0_stateless/02708_parallel_replicas_not_found_column.reference
new file mode 100644
index 00000000000..573541ac970
--- /dev/null
+++ b/tests/queries/0_stateless/02708_parallel_replicas_not_found_column.reference
@@ -0,0 +1 @@
+0
diff --git a/tests/queries/0_stateless/02708_parallel_replicas_not_found_column.sql b/tests/queries/0_stateless/02708_parallel_replicas_not_found_column.sql
new file mode 100644
index 00000000000..8900025502c
--- /dev/null
+++ b/tests/queries/0_stateless/02708_parallel_replicas_not_found_column.sql
@@ -0,0 +1,3 @@
+CREATE TABLE IF NOT EXISTS t_02708(x DateTime) ENGINE = MergeTree ORDER BY tuple();
+SELECT count() FROM t_02708 SETTINGS allow_experimental_parallel_reading_from_replicas=1;
+DROP TABLE t_02708;
diff --git a/tests/queries/0_stateless/02709_parallel_replicas_with_final_modifier.reference b/tests/queries/0_stateless/02709_parallel_replicas_with_final_modifier.reference
new file mode 100644
index 00000000000..f347e8b5857
--- /dev/null
+++ b/tests/queries/0_stateless/02709_parallel_replicas_with_final_modifier.reference
@@ -0,0 +1 @@
+1	1	2020-01-01 00:00:00
diff --git a/tests/queries/0_stateless/02709_parallel_replicas_with_final_modifier.sql b/tests/queries/0_stateless/02709_parallel_replicas_with_final_modifier.sql
new file mode 100644
index 00000000000..1f5daaae189
--- /dev/null
+++ b/tests/queries/0_stateless/02709_parallel_replicas_with_final_modifier.sql
@@ -0,0 +1,5 @@
+DROP TABLE IF EXISTS t_02709;
+CREATE TABLE t_02709 (key UInt32, sign Int8, date Datetime) ENGINE=CollapsingMergeTree(sign) PARTITION BY date ORDER BY key;
+INSERT INTO t_02709 VALUES (1, 1, '2020-01-01'), (2, 1, '2020-01-02'), (1, -1, '2020-01-01'), (2, -1, '2020-01-02'), (1, 1, '2020-01-01');
+SELECT * FROM t_02709 FINAL ORDER BY key SETTINGS max_parallel_replicas=3, allow_experimental_parallel_reading_from_replicas=1, use_hedged_requests=0, cluster_for_parallel_replicas='parallel_replicas';
+DROP TABLE t_02709;
diff --git a/tests/queries/0_stateless/format_schemas/02705_big_numbers.capnp b/tests/queries/0_stateless/format_schemas/02705_big_numbers.capnp
new file mode 100644
index 00000000000..67ef4637454
--- /dev/null
+++ b/tests/queries/0_stateless/format_schemas/02705_big_numbers.capnp
@@ -0,0 +1,10 @@
+@0xdbb9ad1f14bf0b36;
+
+struct Message {
+    int128 @0 :Data;
+    uint128 @1 :Data;
+    int256 @2 :Data;
+    uint256 @3 :Data;
+    decimal128 @4 :Data;
+    decimal256 @5 :Data;
+}
diff --git a/tests/queries/0_stateless/format_schemas/02705_map.capnp b/tests/queries/0_stateless/format_schemas/02705_map.capnp
new file mode 100644
index 00000000000..91f0125feeb
--- /dev/null
+++ b/tests/queries/0_stateless/format_schemas/02705_map.capnp
@@ -0,0 +1,14 @@
+@0xdbb9ad1f14bf0b36;
+
+struct Message {
+    struct Map {
+        struct Entry {
+            key @0 : Text;
+            value @1 : UInt32;
+        }
+
+        entries @0 : List(Entry);
+    }
+
+    map @0 : Map;
+}
diff --git a/tests/queries/0_stateless/format_schemas/02707_schema.proto b/tests/queries/0_stateless/format_schemas/02707_schema.proto
new file mode 100644
index 00000000000..afbc1f854b1
--- /dev/null
+++ b/tests/queries/0_stateless/format_schemas/02707_schema.proto
@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+message Nested {
+    int32 a = 1;
+    string b = 2;
+    repeated int32 c = 3;
+};
+
+message Message {
+    Nested x = 1;
+};
diff --git a/tests/queries/1_stateful/00177_memory_bound_merging.reference b/tests/queries/1_stateful/00177_memory_bound_merging.reference
index a96cfe2af9e..5689152d60a 100644
--- a/tests/queries/1_stateful/00177_memory_bound_merging.reference
+++ b/tests/queries/1_stateful/00177_memory_bound_merging.reference
@@ -10,10 +10,6 @@ http://auto.ru/chatay-baranta_bound-in-thankYou=ru/tver/zhanny	2014-03-18	http:/
 http://auto.ru/chatay-baranta_bound-in-thankYou=ru/tver/zhanny	2014-03-19	http://auto.ru/chatay-baranta_bound-in-thankYou=ru/tver/zhanny
 http://auto.ru/chatay-baranta_bound-in-thankYou=ru/tver/zhanny	2014-03-20	http://auto.ru/chatay-baranta_bound-in-thankYou=ru/tver/zhanny
 1
+SortingAggregatedTransform
 MergingAggregatedBucketTransform
-FinishAggregatingInOrderTransform
-SortingAggregatedForMemoryBoundMergingTransform
-MergingAggregatedBucketTransform
-FinishAggregatingInOrderTransform
-AggregatingInOrderTransform
-MergeTreeInOrder
+GroupingAggregatedTransform