diff --git a/.gitmodules b/.gitmodules
index ca55281e643..e4d63a34118 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -335,3 +335,6 @@
 [submodule "contrib/liburing"]
 	path = contrib/liburing
 	url = https://github.com/axboe/liburing
+[submodule "contrib/isa-l"]
+	path = contrib/isa-l
+	url = https://github.com/ClickHouse/isa-l.git
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47320208f02..1ccd4f9846d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,5 @@
 ### Table of Contents
+**[ClickHouse release v23.4, 2023-04-26](#234)**<br/>
 **[ClickHouse release v23.3 LTS, 2023-03-30](#233)**<br/>
 **[ClickHouse release v23.2, 2023-02-23](#232)**<br/>
 **[ClickHouse release v23.1, 2023-01-25](#231)**<br/>
@@ -6,6 +7,153 @@
 
 # 2023 Changelog
 
+### <a id="234"></a> ClickHouse release 23.4, 2023-04-26
+
+#### Backward Incompatible Change
+* Formatter '%M' in function formatDateTime() now prints the month name instead of the minutes. This makes the behavior consistent with MySQL. The previous behavior can be restored using setting "formatdatetime_parsedatetime_m_is_month_name = 0". [#47246](https://github.com/ClickHouse/ClickHouse/pull/47246) ([Robert Schulze](https://github.com/rschu1ze)).
+* This change makes sense only if you are using the virtual filesystem cache. If `path` in the virtual filesystem cache configuration is not empty and is not an absolute path, then it will be put in `<clickhouse server data directory>/caches/<path_from_cache_config>`. [#48784](https://github.com/ClickHouse/ClickHouse/pull/48784) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Primary/secondary indices and sorting keys with identical expressions are now rejected. This behavior can be disabled using setting `allow_suspicious_indices`. [#48536](https://github.com/ClickHouse/ClickHouse/pull/48536) ([凌涛](https://github.com/lingtaolf)).
+
+#### New Feature
+* Support new aggregate function `quantileGK`/`quantilesGK`, like [approx_percentile](https://spark.apache.org/docs/latest/api/sql/index.html#approx_percentile) in spark. Greenwald-Khanna algorithm refer to http://infolab.stanford.edu/~datar/courses/cs361a/papers/quantiles.pdf. [#46428](https://github.com/ClickHouse/ClickHouse/pull/46428) ([李扬](https://github.com/taiyang-li)).
+* Add a statement `SHOW COLUMNS` which shows distilled information from system.columns. [#48017](https://github.com/ClickHouse/ClickHouse/pull/48017) ([Robert Schulze](https://github.com/rschu1ze)).
+* Added `LIGHTWEIGHT` and `PULL` modifiers for `SYSTEM SYNC REPLICA` query. `LIGHTWEIGHT` version waits for fetches and drop-ranges only (merges and mutations are ignored). `PULL` version pulls new entries from ZooKeeper and does not wait for them. Fixes [#47794](https://github.com/ClickHouse/ClickHouse/issues/47794). [#48085](https://github.com/ClickHouse/ClickHouse/pull/48085) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Add `kafkaMurmurHash` function for compatibility with Kafka DefaultPartitioner. Closes [#47834](https://github.com/ClickHouse/ClickHouse/issues/47834). [#48185](https://github.com/ClickHouse/ClickHouse/pull/48185) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Allow to easily create a user with the same grants as the current user by using `GRANT CURRENT GRANTS`. [#48262](https://github.com/ClickHouse/ClickHouse/pull/48262) ([pufit](https://github.com/pufit)).
+* Add statistical aggregate function `kolmogorovSmirnovTest`. Close [#48228](https://github.com/ClickHouse/ClickHouse/issues/48228). [#48325](https://github.com/ClickHouse/ClickHouse/pull/48325) ([FFFFFFFHHHHHHH](https://github.com/FFFFFFFHHHHHHH)).
+* Added a `lost_part_count` column to the `system.replicas` table. The column value shows the total number of lost parts in the corresponding table. Value is stored in zookeeper and can be used instead of not persistent `ReplicatedDataLoss` profile event for monitoring. [#48526](https://github.com/ClickHouse/ClickHouse/pull/48526) ([Sergei Trifonov](https://github.com/serxa)).
+* Add `soundex` function for compatibility. Closes [#39880](https://github.com/ClickHouse/ClickHouse/issues/39880). [#48567](https://github.com/ClickHouse/ClickHouse/pull/48567) ([FriendLey](https://github.com/FriendLey)).
+* Support `Map` type for JSONExtract. [#48629](https://github.com/ClickHouse/ClickHouse/pull/48629) ([李扬](https://github.com/taiyang-li)).
+* Add `PrettyJSONEachRow` format to output pretty JSON with new line delimiters and 4 space indents. [#48898](https://github.com/ClickHouse/ClickHouse/pull/48898) ([Kruglov Pavel](https://github.com/Avogar)).
+* Add `ParquetMetadata` input format to read Parquet file metadata. [#48911](https://github.com/ClickHouse/ClickHouse/pull/48911) ([Kruglov Pavel](https://github.com/Avogar)).
+* Add `extractKeyValuePairs` function to extract key value pairs from strings. Input strings might contain noise (i.e. log files / do not need to be 100% formatted in key-value-pair format), the algorithm will look for key value pairs matching the arguments passed to the function. As of now, function accepts the following arguments: `data_column` (mandatory), `key_value_pair_delimiter` (defaults to `:`), `pair_delimiters` (defaults to `\space \, \;`) and `quoting_character` (defaults to double quotes). [#43606](https://github.com/ClickHouse/ClickHouse/pull/43606) ([Arthur Passos](https://github.com/arthurpassos)).
+* Functions replaceOne(), replaceAll(), replaceRegexpOne() and replaceRegexpAll() can now be called with non-const pattern and replacement arguments. [#46589](https://github.com/ClickHouse/ClickHouse/pull/46589) ([Robert Schulze](https://github.com/rschu1ze)).
+* Added functions to work with columns of type `Map`: `mapConcat`, `mapSort`, `mapExists`. [#48071](https://github.com/ClickHouse/ClickHouse/pull/48071) ([Anton Popov](https://github.com/CurtizJ)).
+
+#### Performance Improvement
+* Reading files in `Parquet` format is now much faster. IO and decoding are parallelized (controlled by `max_threads` setting), and only required data ranges are read. [#47964](https://github.com/ClickHouse/ClickHouse/pull/47964) ([Michael Kolupaev](https://github.com/al13n321)).
+* If we run a mutation with IN (subquery) like this: `ALTER TABLE t UPDATE col='new value' WHERE id IN (SELECT id FROM huge_table)` and the table `t` has multiple parts than for each part a set for subquery `SELECT id FROM huge_table` is built in memory. And if there are many parts then this might consume a lot of memory (and lead to an OOM) and CPU. The solution is to introduce a short-lived cache of sets that are currently being built by mutation tasks. If another task of the same mutation is executed concurrently it can look up the set in the cache, wait for it to be built and reuse it. [#46835](https://github.com/ClickHouse/ClickHouse/pull/46835) ([Alexander Gololobov](https://github.com/davenger)).
+* Only check dependencies if necessary when applying `ALTER TABLE` queries. [#48062](https://github.com/ClickHouse/ClickHouse/pull/48062) ([Raúl Marín](https://github.com/Algunenano)).
+* Optimize function `mapUpdate`. [#48118](https://github.com/ClickHouse/ClickHouse/pull/48118) ([Anton Popov](https://github.com/CurtizJ)).
+* Now an internal query to local replica is sent explicitly and data from it received through loopback interface. Setting `prefer_localhost_replica` is not respected for parallel replicas. This is needed for better scheduling and makes the code cleaner: the initiator is only responsible for coordinating of the reading process and merging results, continuously answering for requests while all the secondary queries read the data. Note: Using loopback interface is not so performant, otherwise some replicas could starve for tasks which could lead to even slower query execution and not utilizing all possible resources. The initialization of the coordinator is now even more lazy. All incoming requests contain the information about the reading algorithm we initialize the coordinator with it when first request comes. If any replica decides to read with a different algorithm–an exception will be thrown and a query will be aborted. [#48246](https://github.com/ClickHouse/ClickHouse/pull/48246) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)).
+* Do not build set for the right side of `IN` clause with subquery when it is used only for analysis of skip indexes, and they are disabled by setting (`use_skip_indexes=0`). Previously it might affect the performance of queries. [#48299](https://github.com/ClickHouse/ClickHouse/pull/48299) ([Anton Popov](https://github.com/CurtizJ)).
+* Query processing is parallelized right after reading `FROM file(...)`. Related to [#38755](https://github.com/ClickHouse/ClickHouse/issues/38755). [#48525](https://github.com/ClickHouse/ClickHouse/pull/48525) ([Igor Nikonov](https://github.com/devcrafter)). Query processing is parallelized right after reading from any data source. Affected data sources are mostly simple or external storages like table functions `url`, `file`. [#48727](https://github.com/ClickHouse/ClickHouse/pull/48727) ([Igor Nikonov](https://github.com/devcrafter)). This is controlled by the setting `parallelize_output_from_storages` which is not enabled by default.
+* Lowered contention of ThreadPool mutex (may increase performance for a huge amount of small jobs). [#48750](https://github.com/ClickHouse/ClickHouse/pull/48750) ([Sergei Trifonov](https://github.com/serxa)).
+* Reduce memory usage for multiple `ALTER DELETE` mutations. [#48522](https://github.com/ClickHouse/ClickHouse/pull/48522) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Remove the excessive connection attempts if the `skip_unavailable_shards` setting is enabled. [#48771](https://github.com/ClickHouse/ClickHouse/pull/48771) ([Azat Khuzhin](https://github.com/azat)).
+
+#### Experimental Feature
+* Entries in the query cache are now squashed to max_block_size and compressed. [#45912](https://github.com/ClickHouse/ClickHouse/pull/45912) ([Robert Schulze](https://github.com/rschu1ze)).
+* It is now possible to define per-user quotas in the query cache. [#48284](https://github.com/ClickHouse/ClickHouse/pull/48284) ([Robert Schulze](https://github.com/rschu1ze)).
+* Some fixes for parallel replicas [#48433](https://github.com/ClickHouse/ClickHouse/pull/48433) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)).
+* Implement zero-copy-replication (an experimental feature) on encrypted disks. [#48741](https://github.com/ClickHouse/ClickHouse/pull/48741) ([Vitaly Baranov](https://github.com/vitlibar)).
+
+#### Improvement
+* Increase default value for `connect_timeout_with_failover_ms` to 1000 ms (because of adding async connections in https://github.com/ClickHouse/ClickHouse/pull/47229) . Closes [#5188](https://github.com/ClickHouse/ClickHouse/issues/5188). [#49009](https://github.com/ClickHouse/ClickHouse/pull/49009) ([Kruglov Pavel](https://github.com/Avogar)).
+* Several improvements around data lakes: - Make `Iceberg` work with non-partitioned data. - Support `Iceberg` format version v2 (previously only v1 was supported) - Support reading partitioned data for `DeltaLake`/`Hudi` - Faster reading of `DeltaLake` metadata by using Delta's checkpoint files - Fixed incorrect `Hudi` reads: previously it incorrectly chose which data to read and therefore was able to read correctly only small size tables - Made these engines to pickup updates of changed data (previously the state was set on table creation) - Make proper testing for `Iceberg`/`DeltaLake`/`Hudi` using spark. [#47307](https://github.com/ClickHouse/ClickHouse/pull/47307) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Add async connection to socket and async writing to socket. Make creating connections and sending query/external tables async across shards. Refactor code with fibers. Closes [#46931](https://github.com/ClickHouse/ClickHouse/issues/46931). We will be able to increase `connect_timeout_with_failover_ms` by default after this PR (https://github.com/ClickHouse/ClickHouse/issues/5188). [#47229](https://github.com/ClickHouse/ClickHouse/pull/47229) ([Kruglov Pavel](https://github.com/Avogar)).
+* Support config sections `keeper`/`keeper_server` as an alternative to `zookeeper`. Close [#34766](https://github.com/ClickHouse/ClickHouse/issues/34766) , [#34767](https://github.com/ClickHouse/ClickHouse/issues/34767). [#35113](https://github.com/ClickHouse/ClickHouse/pull/35113) ([李扬](https://github.com/taiyang-li)).
+* It is possible to set _secure_ flag in named_collections for a dictionary with a ClickHouse table source. Addresses [#38450](https://github.com/ClickHouse/ClickHouse/issues/38450) . [#46323](https://github.com/ClickHouse/ClickHouse/pull/46323) ([Ilya Golshtein](https://github.com/ilejn)).
+* `bitCount` function support `FixedString` and `String` data type. [#49044](https://github.com/ClickHouse/ClickHouse/pull/49044) ([flynn](https://github.com/ucasfl)).
+* Added configurable retries for all operations with [Zoo]Keeper for Backup queries. [#47224](https://github.com/ClickHouse/ClickHouse/pull/47224) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)).
+* Enable `use_environment_credentials` for S3 by default, so the entire provider chain is constructed by default. [#47397](https://github.com/ClickHouse/ClickHouse/pull/47397) ([Antonio Andelic](https://github.com/antonio2368)).
+* Currently, the JSON_VALUE function is similar as spark's get_json_object function, which support to get value from JSON string by a path like '$.key'. But still has something different - 1. in spark's get_json_object will return null while the path is not exist, but in JSON_VALUE will return empty string; - 2. in spark's get_json_object will return a complex type value, such as a JSON object/array value, but in JSON_VALUE will return empty string. [#47494](https://github.com/ClickHouse/ClickHouse/pull/47494) ([KevinyhZou](https://github.com/KevinyhZou)).
+* For `use_structure_from_insertion_table_in_table_functions` more flexible insert table structure propagation to table function. Fixed an issue with name mapping and using virtual columns. No more need for 'auto' setting. [#47962](https://github.com/ClickHouse/ClickHouse/pull/47962) ([Yakov Olkhovskiy](https://github.com/yakov-olkhovskiy)).
+* Do not continue retrying to connect to Keeper if the query is killed or over limits. [#47985](https://github.com/ClickHouse/ClickHouse/pull/47985) ([Raúl Marín](https://github.com/Algunenano)).
+* Support Enum output/input in `BSONEachRow`, allow all map key types and avoid extra calculations on output. [#48122](https://github.com/ClickHouse/ClickHouse/pull/48122) ([Kruglov Pavel](https://github.com/Avogar)).
+* Support more ClickHouse types in `ORC`/`Arrow`/`Parquet` formats: Enum(8|16), (U)Int(128|256), Decimal256 (for ORC), allow reading IPv4 from Int32 values (ORC outputs IPv4 as Int32, and we couldn't read it back), fix reading Nullable(IPv6) from binary data for `ORC`. [#48126](https://github.com/ClickHouse/ClickHouse/pull/48126) ([Kruglov Pavel](https://github.com/Avogar)).
+* Add columns `perform_ttl_move_on_insert`, `load_balancing` for table `system.storage_policies`, modify column `volume_type` type to `Enum8`. [#48167](https://github.com/ClickHouse/ClickHouse/pull/48167) ([lizhuoyu5](https://github.com/lzydmxy)).
+* Added support for `BACKUP ALL` command which backups all tables and databases, including temporary and system ones. [#48189](https://github.com/ClickHouse/ClickHouse/pull/48189) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Function mapFromArrays supports `Map` type as an input. [#48207](https://github.com/ClickHouse/ClickHouse/pull/48207) ([李扬](https://github.com/taiyang-li)).
+* The output of some SHOW PROCESSLIST is now sorted. [#48241](https://github.com/ClickHouse/ClickHouse/pull/48241) ([Robert Schulze](https://github.com/rschu1ze)).
+* Per-query/per-server throttling for remote IO/local IO/BACKUPs (server settings: `max_remote_read_network_bandwidth_for_server`, `max_remote_write_network_bandwidth_for_server`, `max_local_read_bandwidth_for_server`, `max_local_write_bandwidth_for_server`, `max_backup_bandwidth_for_server`, settings: `max_remote_read_network_bandwidth`, `max_remote_write_network_bandwidth`, `max_local_read_bandwidth`, `max_local_write_bandwidth`, `max_backup_bandwidth`). [#48242](https://github.com/ClickHouse/ClickHouse/pull/48242) ([Azat Khuzhin](https://github.com/azat)).
+* Support more types in `CapnProto` format: Map, (U)Int(128|256), Decimal(128|256). Allow integer conversions during input/output. [#48257](https://github.com/ClickHouse/ClickHouse/pull/48257) ([Kruglov Pavel](https://github.com/Avogar)).
+* Don't throw CURRENT_WRITE_BUFFER_IS_EXHAUSTED for normal behaviour. [#48288](https://github.com/ClickHouse/ClickHouse/pull/48288) ([Raúl Marín](https://github.com/Algunenano)).
+* Add new setting `keeper_map_strict_mode` which enforces extra guarantees on operations made on top of `KeeperMap` tables. [#48293](https://github.com/ClickHouse/ClickHouse/pull/48293) ([Antonio Andelic](https://github.com/antonio2368)).
+* Check primary key type for simple dictionary is native unsigned integer type Add setting `check_dictionary_primary_key ` for compatibility(set `check_dictionary_primary_key =false` to disable checking). [#48335](https://github.com/ClickHouse/ClickHouse/pull/48335) ([lizhuoyu5](https://github.com/lzydmxy)).
+* Don't replicate mutations for `KeeperMap` because it's unnecessary. [#48354](https://github.com/ClickHouse/ClickHouse/pull/48354) ([Antonio Andelic](https://github.com/antonio2368)).
+* Allow to write/read unnamed tuple as nested Message in Protobuf format. Tuple elements and Message fields are matched by position. [#48390](https://github.com/ClickHouse/ClickHouse/pull/48390) ([Kruglov Pavel](https://github.com/Avogar)).
+* Support `additional_table_filters` and `additional_result_filter` settings in the new planner. Also, add a documentation entry for `additional_result_filter`. [#48405](https://github.com/ClickHouse/ClickHouse/pull/48405) ([Dmitry Novik](https://github.com/novikd)).
+* `parseDateTime` now understands format string '%f' (fractional seconds). [#48420](https://github.com/ClickHouse/ClickHouse/pull/48420) ([Robert Schulze](https://github.com/rschu1ze)).
+* Format string "%f" in formatDateTime() now prints "000000" if the formatted value has no fractional seconds, the previous behavior (single zero) can be restored using setting "formatdatetime_f_prints_single_zero = 1". [#48422](https://github.com/ClickHouse/ClickHouse/pull/48422) ([Robert Schulze](https://github.com/rschu1ze)).
+* Don't replicate DELETE and TRUNCATE for KeeperMap. [#48434](https://github.com/ClickHouse/ClickHouse/pull/48434) ([Antonio Andelic](https://github.com/antonio2368)).
+* Generate valid Decimals and Bools in generateRandom function. [#48436](https://github.com/ClickHouse/ClickHouse/pull/48436) ([Kruglov Pavel](https://github.com/Avogar)).
+* Allow trailing commas in expression list of SELECT query, for example `SELECT a, b, c, FROM table`. Closes [#37802](https://github.com/ClickHouse/ClickHouse/issues/37802). [#48438](https://github.com/ClickHouse/ClickHouse/pull/48438) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Override `CLICKHOUSE_USER` and `CLICKHOUSE_PASSWORD` environment variables with `--user` and `--password` client parameters. Closes [#38909](https://github.com/ClickHouse/ClickHouse/issues/38909). [#48440](https://github.com/ClickHouse/ClickHouse/pull/48440) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Added retries to loading of data parts in `MergeTree` tables in case of retryable errors. [#48442](https://github.com/ClickHouse/ClickHouse/pull/48442) ([Anton Popov](https://github.com/CurtizJ)).
+* Add support for `Date`, `Date32`, `DateTime`, `DateTime64` data types to `arrayMin`, `arrayMax`, `arrayDifference` functions. Closes [#21645](https://github.com/ClickHouse/ClickHouse/issues/21645). [#48445](https://github.com/ClickHouse/ClickHouse/pull/48445) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Add support for `{server_uuid}` macro. It is useful for identifying replicas in autoscaled clusters when new replicas are constantly added and removed in runtime. This closes [#48554](https://github.com/ClickHouse/ClickHouse/issues/48554). [#48563](https://github.com/ClickHouse/ClickHouse/pull/48563) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* The installation script will create a hard link instead of copying if it is possible. [#48578](https://github.com/ClickHouse/ClickHouse/pull/48578) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Support `SHOW TABLE` syntax meaning the same as `SHOW CREATE TABLE`. Closes [#48580](https://github.com/ClickHouse/ClickHouse/issues/48580). [#48591](https://github.com/ClickHouse/ClickHouse/pull/48591) ([flynn](https://github.com/ucasfl)).
+* HTTP temporary buffers now support working by evicting data from the virtual filesystem cache. [#48664](https://github.com/ClickHouse/ClickHouse/pull/48664) ([Vladimir C](https://github.com/vdimir)).
+* Make Schema inference works for `CREATE AS SELECT`. Closes [#47599](https://github.com/ClickHouse/ClickHouse/issues/47599). [#48679](https://github.com/ClickHouse/ClickHouse/pull/48679) ([flynn](https://github.com/ucasfl)).
+* Added a `replicated_max_mutations_in_one_entry` setting for `ReplicatedMergeTree` that allows limiting the number of mutation commands per one `MUTATE_PART` entry (default is 10000). [#48731](https://github.com/ClickHouse/ClickHouse/pull/48731) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* In AggregateFunction types, don't count unused arena bytes as `read_bytes`. [#48745](https://github.com/ClickHouse/ClickHouse/pull/48745) ([Raúl Marín](https://github.com/Algunenano)).
+* Fix some MySQL-related settings not being handled with the MySQL dictionary source + named collection. Closes [#48402](https://github.com/ClickHouse/ClickHouse/issues/48402). [#48759](https://github.com/ClickHouse/ClickHouse/pull/48759) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* If a user set `max_single_part_upload_size` to a very large value, it can lead to a crash due to a bug in the AWS S3 SDK. This fixes [#47679](https://github.com/ClickHouse/ClickHouse/issues/47679). [#48816](https://github.com/ClickHouse/ClickHouse/pull/48816) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Fix data race in `RabbitMQ` ([report](https://pastila.nl/?004f7100/de1505289ab5bb355e67ebe6c7cc8707)), refactor the code. [#48845](https://github.com/ClickHouse/ClickHouse/pull/48845) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Add aliases `name` and `part_name` form `system.parts` and `system.part_log`. Closes [#48718](https://github.com/ClickHouse/ClickHouse/issues/48718). [#48850](https://github.com/ClickHouse/ClickHouse/pull/48850) ([sichenzhao](https://github.com/sichenzhao)).
+* Functions "arrayDifferenceSupport()", "arrayCumSum()" and "arrayCumSumNonNegative()" now support input arrays of wide integer types (U)Int128/256. [#48866](https://github.com/ClickHouse/ClickHouse/pull/48866) ([cluster](https://github.com/infdahai)).
+* Multi-line history in clickhouse-client is now no longer padded. This makes pasting more natural. [#48870](https://github.com/ClickHouse/ClickHouse/pull/48870) ([Joanna Hulboj](https://github.com/jh0x)).
+* Implement a slight improvement for the rare case when ClickHouse is run inside LXC and LXCFS is used. The LXCFS has an issue: sometimes it returns an error "Transport endpoint is not connected" on reading from the file inside `/proc`. This error was correctly logged into ClickHouse's server log. We have additionally workaround this issue by reopening a file. This is a minuscule change. [#48922](https://github.com/ClickHouse/ClickHouse/pull/48922) ([Real](https://github.com/RunningXie)).
+* Improve memory accounting for prefetches. Randomise prefetch settings In CI. [#48973](https://github.com/ClickHouse/ClickHouse/pull/48973) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Correctly set headers for native copy operations on GCS. [#48981](https://github.com/ClickHouse/ClickHouse/pull/48981) ([Antonio Andelic](https://github.com/antonio2368)).
+* Add support for specifying setting names in the command line with dashes instead of underscores, for example, `--max-threads` instead of `--max_threads`. Additionally, support Unicode dash characters like `—` instead of `--` - this is useful when you communicate with a team in another company, and a manager from that team copy-pasted code from MS Word. [#48985](https://github.com/ClickHouse/ClickHouse/pull/48985) ([alekseygolub](https://github.com/alekseygolub)).
+* Add fallback to password authentication when authentication with SSL user certificate has failed. Closes [#48974](https://github.com/ClickHouse/ClickHouse/issues/48974). [#48989](https://github.com/ClickHouse/ClickHouse/pull/48989) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Improve the embedded dashboard. Close [#46671](https://github.com/ClickHouse/ClickHouse/issues/46671). [#49036](https://github.com/ClickHouse/ClickHouse/pull/49036) ([Kevin Zhang](https://github.com/Kinzeng)).
+* Add profile events for log messages, so you can easily see the count of log messages by severity. [#49042](https://github.com/ClickHouse/ClickHouse/pull/49042) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* In previous versions, the `LineAsString` format worked inconsistently when the parallel parsing was enabled or not, in presence of DOS or macOS Classic line breaks. This closes [#49039](https://github.com/ClickHouse/ClickHouse/issues/49039). [#49052](https://github.com/ClickHouse/ClickHouse/pull/49052) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* The exception message about the unparsed query parameter will also tell about the name of the parameter. Reimplement [#48878](https://github.com/ClickHouse/ClickHouse/issues/48878). Close [#48772](https://github.com/ClickHouse/ClickHouse/issues/48772). [#49061](https://github.com/ClickHouse/ClickHouse/pull/49061) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+
+#### Build/Testing/Packaging Improvement
+* Update time zones. The following were updated: Africa/Cairo, Africa/Casablanca, Africa/El_Aaiun, America/Bogota, America/Cambridge_Bay, America/Ciudad_Juarez, America/Godthab, America/Inuvik, America/Iqaluit, America/Nuuk, America/Ojinaga, America/Pangnirtung, America/Rankin_Inlet, America/Resolute, America/Whitehorse, America/Yellowknife, Asia/Gaza, Asia/Hebron, Asia/Kuala_Lumpur, Asia/Singapore, Canada/Yukon, Egypt, Europe/Kirov, Europe/Volgograd, Singapore. [#48572](https://github.com/ClickHouse/ClickHouse/pull/48572) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Reduce the number of dependencies in the header files to speed up the build. [#47984](https://github.com/ClickHouse/ClickHouse/pull/47984) ([Dmitry Novik](https://github.com/novikd)).
+* Randomize compression of marks and indices in tests. [#48286](https://github.com/ClickHouse/ClickHouse/pull/48286) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Bump internal ZSTD from 1.5.4 to 1.5.5. [#46797](https://github.com/ClickHouse/ClickHouse/pull/46797) ([Robert Schulze](https://github.com/rschu1ze)).
+* Randomize vertical merges from compact to wide parts in tests. [#48287](https://github.com/ClickHouse/ClickHouse/pull/48287) ([Raúl Marín](https://github.com/Algunenano)).
+* Support for CRC32 checksum in HDFS. Fix performance issues. [#48614](https://github.com/ClickHouse/ClickHouse/pull/48614) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Remove remainders of GCC support. [#48671](https://github.com/ClickHouse/ClickHouse/pull/48671) ([Robert Schulze](https://github.com/rschu1ze)).
+* Add CI run with new analyzer infrastructure enabled. [#48719](https://github.com/ClickHouse/ClickHouse/pull/48719) ([Dmitry Novik](https://github.com/novikd)).
+
+#### Bug Fix (user-visible misbehavior in an official stable release)
+
+* Fix system.query_views_log for MVs that are pushed from background threads [#46668](https://github.com/ClickHouse/ClickHouse/pull/46668) ([Azat Khuzhin](https://github.com/azat)).
+* Fix several `RENAME COLUMN` bugs [#46946](https://github.com/ClickHouse/ClickHouse/pull/46946) ([alesapin](https://github.com/alesapin)).
+* Fix minor hiliting issues in clickhouse-format [#47610](https://github.com/ClickHouse/ClickHouse/pull/47610) ([Natasha Murashkina](https://github.com/murfel)).
+* Fix a bug in LLVM's libc++ leading to a crash for uploading parts to S3 which size is greater than INT_MAX [#47693](https://github.com/ClickHouse/ClickHouse/pull/47693) ([Azat Khuzhin](https://github.com/azat)).
+* Fix overflow in the `sparkbar` function [#48121](https://github.com/ClickHouse/ClickHouse/pull/48121) ([Vladimir C](https://github.com/vdimir)).
+* Fix race in S3 [#48190](https://github.com/ClickHouse/ClickHouse/pull/48190) ([Anton Popov](https://github.com/CurtizJ)).
+* Disable JIT for aggregate functions due to inconsistent behavior [#48195](https://github.com/ClickHouse/ClickHouse/pull/48195) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Fix alter formatting (minor) [#48289](https://github.com/ClickHouse/ClickHouse/pull/48289) ([Natasha Murashkina](https://github.com/murfel)).
+* Fix CPU usage in RabbitMQ (was worsened in 23.2 after [#44404](https://github.com/ClickHouse/ClickHouse/issues/44404)) [#48311](https://github.com/ClickHouse/ClickHouse/pull/48311) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Fix crash in EXPLAIN PIPELINE for Merge over Distributed [#48320](https://github.com/ClickHouse/ClickHouse/pull/48320) ([Azat Khuzhin](https://github.com/azat)).
+* Fix serializing LowCardinality as Arrow dictionary [#48361](https://github.com/ClickHouse/ClickHouse/pull/48361) ([Kruglov Pavel](https://github.com/Avogar)).
+* Reset downloader for cache file segment in TemporaryFileStream [#48386](https://github.com/ClickHouse/ClickHouse/pull/48386) ([Vladimir C](https://github.com/vdimir)).
+* Fix possible SYSTEM SYNC REPLICA stuck in case of DROP/REPLACE PARTITION [#48391](https://github.com/ClickHouse/ClickHouse/pull/48391) ([Azat Khuzhin](https://github.com/azat)).
+* Fix a startup error when loading a distributed table that depends on a dictionary [#48419](https://github.com/ClickHouse/ClickHouse/pull/48419) ([MikhailBurdukov](https://github.com/MikhailBurdukov)).
+* Don't check dependencies when renaming system tables automatically [#48431](https://github.com/ClickHouse/ClickHouse/pull/48431) ([Raúl Marín](https://github.com/Algunenano)).
+* Update only affected rows in KeeperMap storage [#48435](https://github.com/ClickHouse/ClickHouse/pull/48435) ([Antonio Andelic](https://github.com/antonio2368)).
+* Fix possible segfault in the VFS cache [#48469](https://github.com/ClickHouse/ClickHouse/pull/48469) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* `toTimeZone` function throws an error when no constant string is provided [#48471](https://github.com/ClickHouse/ClickHouse/pull/48471) ([Jordi Villar](https://github.com/jrdi)).
+* Fix logical error with IPv4 in Protobuf, add support for Date32 [#48486](https://github.com/ClickHouse/ClickHouse/pull/48486) ([Kruglov Pavel](https://github.com/Avogar)).
+* "changed" flag in system.settings was calculated incorrectly for settings with multiple values [#48516](https://github.com/ClickHouse/ClickHouse/pull/48516) ([MikhailBurdukov](https://github.com/MikhailBurdukov)).
+* Fix storage `Memory` with enabled compression [#48517](https://github.com/ClickHouse/ClickHouse/pull/48517) ([Anton Popov](https://github.com/CurtizJ)).
+* Fix bracketed-paste mode messing up password input in the event of client reconnection [#48528](https://github.com/ClickHouse/ClickHouse/pull/48528) ([Michael Kolupaev](https://github.com/al13n321)).
+* Fix nested map for keys of IP and UUID types [#48556](https://github.com/ClickHouse/ClickHouse/pull/48556) ([Yakov Olkhovskiy](https://github.com/yakov-olkhovskiy)).
+* Fix an uncaught exception in case of parallel loader for hashed dictionaries [#48571](https://github.com/ClickHouse/ClickHouse/pull/48571) ([Azat Khuzhin](https://github.com/azat)).
+* The `groupArray` aggregate function correctly works for empty result over nullable types [#48593](https://github.com/ClickHouse/ClickHouse/pull/48593) ([lgbo](https://github.com/lgbo-ustc)).
+* Fix bug in Keeper when a node is not created with scheme `auth` in ACL sometimes. [#48595](https://github.com/ClickHouse/ClickHouse/pull/48595) ([Aleksei Filatov](https://github.com/aalexfvk)).
+* Allow IPv4 comparison operators with UInt [#48611](https://github.com/ClickHouse/ClickHouse/pull/48611) ([Yakov Olkhovskiy](https://github.com/yakov-olkhovskiy)).
+* Fix possible error from cache [#48636](https://github.com/ClickHouse/ClickHouse/pull/48636) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Async inserts with empty data will no longer throw exception. [#48663](https://github.com/ClickHouse/ClickHouse/pull/48663) ([Anton Popov](https://github.com/CurtizJ)).
+* Fix table dependencies in case of failed RENAME TABLE [#48683](https://github.com/ClickHouse/ClickHouse/pull/48683) ([Azat Khuzhin](https://github.com/azat)).
+* If the primary key has duplicate columns (which is only possible for projections), in previous versions it might lead to a bug [#48838](https://github.com/ClickHouse/ClickHouse/pull/48838) ([Amos Bird](https://github.com/amosbird)).
+* Fix for a race condition in ZooKeeper when joining send_thread/receive_thread [#48849](https://github.com/ClickHouse/ClickHouse/pull/48849) ([Alexander Gololobov](https://github.com/davenger)).
+* Fix unexpected part name error when trying to drop a ignored detached part with zero copy replication [#48862](https://github.com/ClickHouse/ClickHouse/pull/48862) ([Michael Lex](https://github.com/mlex)).
+* Fix reading `Date32` Parquet/Arrow column into not a `Date32` column [#48864](https://github.com/ClickHouse/ClickHouse/pull/48864) ([Kruglov Pavel](https://github.com/Avogar)).
+* Fix `UNKNOWN_IDENTIFIER` error while selecting from table with row policy and column with dots [#48976](https://github.com/ClickHouse/ClickHouse/pull/48976) ([Kruglov Pavel](https://github.com/Avogar)).
+* Fix aggregation by empty nullable strings [#48999](https://github.com/ClickHouse/ClickHouse/pull/48999) ([LiuNeng](https://github.com/liuneng1994)).
+
 ### <a id="233"></a> ClickHouse release 23.3 LTS, 2023-03-30
 
 #### Upgrade Notes
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cc1a64a9e96..c6ca18773a7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -176,6 +176,12 @@ if (OS_DARWIN)
     set (ENABLE_CURL_BUILD OFF)
 endif ()
 
+option(ENABLE_ISAL_LIBRARY "Enable ISA-L library ON by default except on aarch64." ON)
+if (ARCH_AARCH64)
+    # Disable ISA-L libray on aarch64.
+    set (ENABLE_ISAL_LIBRARY OFF)
+endif ()
+
 if (NOT CMAKE_BUILD_TYPE_UC STREQUAL "RELEASE")
     # Can be lld or ld-lld or lld-13 or /path/to/lld.
     if (LINKER_NAME MATCHES "lld")
@@ -421,8 +427,11 @@ endif ()
 
 set (CMAKE_POSTFIX_VARIABLE "CMAKE_${CMAKE_BUILD_TYPE_UC}_POSTFIX")
 
-set (CMAKE_POSITION_INDEPENDENT_CODE OFF)
-if (OS_LINUX AND NOT (ARCH_AARCH64 OR ARCH_S390X))
+if (NOT SANITIZE)
+    set (CMAKE_POSITION_INDEPENDENT_CODE OFF)
+endif()
+
+if (OS_LINUX AND NOT (ARCH_AARCH64 OR ARCH_S390X) AND NOT SANITIZE)
     # Slightly more efficient code can be generated
     # It's disabled for ARM because otherwise ClickHouse cannot run on Android.
     set (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fno-pie")
diff --git a/SECURITY.md b/SECURITY.md
index 566a1820834..44a122956b4 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -13,9 +13,10 @@ The following versions of ClickHouse server are currently being supported with s
 
 | Version | Supported |
 |:-|:-|
+| 23.4 | ✔️ |
 | 23.3 | ✔️ |
 | 23.2 | ✔️ |
-| 23.1 | ✔️ |
+| 23.1 | ❌ |
 | 22.12 | ❌ |
 | 22.11 | ❌ |
 | 22.10 | ❌ |
diff --git a/base/glibc-compatibility/glibc-compatibility.c b/base/glibc-compatibility/glibc-compatibility.c
index 7e8ea5051d7..49bb81a58be 100644
--- a/base/glibc-compatibility/glibc-compatibility.c
+++ b/base/glibc-compatibility/glibc-compatibility.c
@@ -235,6 +235,17 @@ ssize_t getrandom(void *buf, size_t buflen, unsigned flags)
     return syscall(SYS_getrandom, buf, buflen, flags);
 }
 
+/* Structure for scatter/gather I/O.  */
+struct iovec
+{
+    void *iov_base;    /* Pointer to data.  */
+    size_t iov_len;    /* Length of data.  */
+};
+
+ssize_t preadv(int __fd, const struct iovec *__iovec, int __count, __off_t __offset)
+{
+    return syscall(SYS_preadv, __fd, __iovec, __count, (long)(__offset), (long)(__offset>>32));
+}
 
 #include <errno.h>
 #include <limits.h>
diff --git a/cmake/autogenerated_versions.txt b/cmake/autogenerated_versions.txt
index 9bb148c12a9..462529fbc13 100644
--- a/cmake/autogenerated_versions.txt
+++ b/cmake/autogenerated_versions.txt
@@ -2,11 +2,11 @@
 
 # NOTE: has nothing common with DBMS_TCP_PROTOCOL_VERSION,
 # only DBMS_TCP_PROTOCOL_VERSION should be incremented on protocol changes.
-SET(VERSION_REVISION 54473)
+SET(VERSION_REVISION 54474)
 SET(VERSION_MAJOR 23)
-SET(VERSION_MINOR 4)
+SET(VERSION_MINOR 5)
 SET(VERSION_PATCH 1)
-SET(VERSION_GITHASH 46e85357ce2da2a99f56ee83a079e892d7ec3726)
-SET(VERSION_DESCRIBE v23.4.1.1-testing)
-SET(VERSION_STRING 23.4.1.1)
+SET(VERSION_GITHASH 3920eb987f7ed837ada5de8907284adf123f0583)
+SET(VERSION_DESCRIBE v23.5.1.1-testing)
+SET(VERSION_STRING 23.5.1.1)
 # end of autochange
diff --git a/cmake/fuzzer.cmake b/cmake/fuzzer.cmake
index 578a9757270..52f301ab8ad 100644
--- a/cmake/fuzzer.cmake
+++ b/cmake/fuzzer.cmake
@@ -7,10 +7,6 @@ if (FUZZER)
         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SAN_FLAGS} -fsanitize=fuzzer-no-link")
         set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SAN_FLAGS} -fsanitize=fuzzer-no-link")
 
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=fuzzer-no-link")
-        endif()
-
         # NOTE: oss-fuzz can change LIB_FUZZING_ENGINE variable
         if (NOT LIB_FUZZING_ENGINE)
             set (LIB_FUZZING_ENGINE "-fsanitize=fuzzer")
diff --git a/cmake/sanitize.cmake b/cmake/sanitize.cmake
index 13aaa414b93..bf5eddf09f5 100644
--- a/cmake/sanitize.cmake
+++ b/cmake/sanitize.cmake
@@ -16,50 +16,24 @@ if (SANITIZE)
         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SAN_FLAGS} ${ASAN_FLAGS}")
         set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SAN_FLAGS} ${ASAN_FLAGS}")
 
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${ASAN_FLAGS}")
-        endif()
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libasan")
-        endif ()
-
     elseif (SANITIZE STREQUAL "memory")
         # MemorySanitizer flags are set according to the official documentation:
         # https://clang.llvm.org/docs/MemorySanitizer.html#usage
-        #
-        # For now, it compiles with `cmake -DSANITIZE=memory -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_CXX_FLAGS_ADD="-O1" -DCMAKE_C_FLAGS_ADD="-O1"`
-        # Compiling with -DCMAKE_BUILD_TYPE=Debug leads to ld.lld failures because
-        # of large files (was not tested with ld.gold). This is why we compile with
-        # RelWithDebInfo, and downgrade optimizations to -O1 but not to -Og, to
-        # keep the binary size down.
-        # TODO: try compiling with -Og and with ld.gold.
-        set (MSAN_FLAGS "-fsanitize=memory -fsanitize-memory-use-after-dtor -fsanitize-memory-track-origins -fno-optimize-sibling-calls -fsanitize-blacklist=${CMAKE_SOURCE_DIR}/tests/msan_suppressions.txt")
 
+        # Linking can fail due to relocation overflows (see #49145), caused by too big object files / libraries.
+        # Work around this with position-independent builds (-fPIC and -fpie), this is slightly slower than non-PIC/PIE but that's okay.
+        set (MSAN_FLAGS "-fsanitize=memory -fsanitize-memory-use-after-dtor -fsanitize-memory-track-origins -fno-optimize-sibling-calls -fPIC -fpie -fsanitize-blacklist=${CMAKE_SOURCE_DIR}/tests/msan_suppressions.txt")
         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SAN_FLAGS} ${MSAN_FLAGS}")
         set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SAN_FLAGS} ${MSAN_FLAGS}")
 
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=memory")
-        endif()
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libmsan")
-        endif ()
-
     elseif (SANITIZE STREQUAL "thread")
         set (TSAN_FLAGS "-fsanitize=thread")
         if (COMPILER_CLANG)
             set (TSAN_FLAGS "${TSAN_FLAGS} -fsanitize-blacklist=${CMAKE_SOURCE_DIR}/tests/tsan_suppressions.txt")
         endif()
 
-
         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SAN_FLAGS} ${TSAN_FLAGS}")
         set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SAN_FLAGS} ${TSAN_FLAGS}")
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=thread")
-        endif()
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libtsan")
-        endif ()
 
     elseif (SANITIZE STREQUAL "undefined")
         set (UBSAN_FLAGS "-fsanitize=undefined -fno-sanitize-recover=all -fno-sanitize=float-divide-by-zero")
@@ -78,12 +52,6 @@ if (SANITIZE)
 
         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SAN_FLAGS} ${UBSAN_FLAGS}")
         set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SAN_FLAGS} ${UBSAN_FLAGS}")
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined")
-        endif()
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libubsan")
-        endif ()
 
         # llvm-tblgen, that is used during LLVM build, doesn't work with UBSan.
         set (ENABLE_EMBEDDED_COMPILER 0 CACHE BOOL "")
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index be3563d2c61..f88323f022b 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -191,6 +191,10 @@ add_contrib (google-benchmark-cmake google-benchmark)
 
 add_contrib (ulid-c-cmake ulid-c)
 
+if (ENABLE_ISAL_LIBRARY)
+    add_contrib (isa-l-cmake isa-l)
+endif()
+
 # Put all targets defined here and in subdirectories under "contrib/<immediate-subdir>" folders in GUI-based IDEs.
 # Some of third-party projects may override CMAKE_FOLDER or FOLDER property of their targets, so they would not appear
 # in "contrib/..." as originally planned, so we workaround this by fixing FOLDER properties of all targets manually,
diff --git a/contrib/curl b/contrib/curl
index c12fb3ddaf4..b0edf0b7dae 160000
--- a/contrib/curl
+++ b/contrib/curl
@@ -1 +1 @@
-Subproject commit c12fb3ddaf48e709a7a4deaa55ec485e4df163ee
+Subproject commit b0edf0b7dae44d9e66f270a257cf654b35d5263d
diff --git a/contrib/curl-cmake/CMakeLists.txt b/contrib/curl-cmake/CMakeLists.txt
index 8a570bd267c..70d9c2816dc 100644
--- a/contrib/curl-cmake/CMakeLists.txt
+++ b/contrib/curl-cmake/CMakeLists.txt
@@ -12,6 +12,9 @@ set (SRCS
     "${LIBRARY_DIR}/lib/noproxy.c"
     "${LIBRARY_DIR}/lib/idn.c"
     "${LIBRARY_DIR}/lib/cfilters.c"
+    "${LIBRARY_DIR}/lib/cf-socket.c"
+    "${LIBRARY_DIR}/lib/cf-haproxy.c"
+    "${LIBRARY_DIR}/lib/cf-https-connect.c"
     "${LIBRARY_DIR}/lib/file.c"
     "${LIBRARY_DIR}/lib/timeval.c"
     "${LIBRARY_DIR}/lib/base64.c"
@@ -37,8 +40,8 @@ set (SRCS
     "${LIBRARY_DIR}/lib/strcase.c"
     "${LIBRARY_DIR}/lib/easy.c"
     "${LIBRARY_DIR}/lib/curl_fnmatch.c"
+    "${LIBRARY_DIR}/lib/curl_log.c"
     "${LIBRARY_DIR}/lib/fileinfo.c"
-    "${LIBRARY_DIR}/lib/wildcard.c"
     "${LIBRARY_DIR}/lib/krb5.c"
     "${LIBRARY_DIR}/lib/memdebug.c"
     "${LIBRARY_DIR}/lib/http_chunks.c"
@@ -96,6 +99,7 @@ set (SRCS
     "${LIBRARY_DIR}/lib/rand.c"
     "${LIBRARY_DIR}/lib/curl_multibyte.c"
     "${LIBRARY_DIR}/lib/conncache.c"
+    "${LIBRARY_DIR}/lib/cf-h1-proxy.c"
     "${LIBRARY_DIR}/lib/http2.c"
     "${LIBRARY_DIR}/lib/smb.c"
     "${LIBRARY_DIR}/lib/curl_endian.c"
@@ -113,12 +117,13 @@ set (SRCS
     "${LIBRARY_DIR}/lib/altsvc.c"
     "${LIBRARY_DIR}/lib/socketpair.c"
     "${LIBRARY_DIR}/lib/bufref.c"
+    "${LIBRARY_DIR}/lib/bufq.c"
     "${LIBRARY_DIR}/lib/dynbuf.c"
+    "${LIBRARY_DIR}/lib/dynhds.c"
     "${LIBRARY_DIR}/lib/hsts.c"
     "${LIBRARY_DIR}/lib/http_aws_sigv4.c"
     "${LIBRARY_DIR}/lib/mqtt.c"
     "${LIBRARY_DIR}/lib/rename.c"
-    "${LIBRARY_DIR}/lib/h2h3.c"
     "${LIBRARY_DIR}/lib/headers.c"
     "${LIBRARY_DIR}/lib/timediff.c"
     "${LIBRARY_DIR}/lib/vauth/vauth.c"
@@ -133,6 +138,7 @@ set (SRCS
     "${LIBRARY_DIR}/lib/vauth/oauth2.c"
     "${LIBRARY_DIR}/lib/vauth/spnego_gssapi.c"
     "${LIBRARY_DIR}/lib/vauth/spnego_sspi.c"
+    "${LIBRARY_DIR}/lib/vquic/vquic.c"
     "${LIBRARY_DIR}/lib/vtls/openssl.c"
     "${LIBRARY_DIR}/lib/vtls/gtls.c"
     "${LIBRARY_DIR}/lib/vtls/vtls.c"
@@ -147,9 +153,6 @@ set (SRCS
     "${LIBRARY_DIR}/lib/vtls/keylog.c"
     "${LIBRARY_DIR}/lib/vtls/x509asn1.c"
     "${LIBRARY_DIR}/lib/vtls/hostcheck.c"
-    "${LIBRARY_DIR}/lib/vquic/ngtcp2.c"
-    "${LIBRARY_DIR}/lib/vquic/quiche.c"
-    "${LIBRARY_DIR}/lib/vquic/msh3.c"
     "${LIBRARY_DIR}/lib/vssh/libssh2.c"
     "${LIBRARY_DIR}/lib/vssh/libssh.c"
 )
diff --git a/contrib/isa-l b/contrib/isa-l
new file mode 160000
index 00000000000..9f2b68f0575
--- /dev/null
+++ b/contrib/isa-l
@@ -0,0 +1 @@
+Subproject commit 9f2b68f05752097f0f16632fc4a9a86950831efd
diff --git a/contrib/isa-l-cmake/CMakeLists.txt b/contrib/isa-l-cmake/CMakeLists.txt
new file mode 100644
index 00000000000..5c549cbba02
--- /dev/null
+++ b/contrib/isa-l-cmake/CMakeLists.txt
@@ -0,0 +1,192 @@
+set(ISAL_SOURCE_DIR "${ClickHouse_SOURCE_DIR}/contrib/isa-l")
+
+# The YASM and NASM assembers are somewhat mutually compatible. ISAL specifically needs NASM. If only YASM is installed, then check_language(ASM_NASM)
+# below happily finds YASM, leading to weird errors at build time. Therefore, do an explicit check for NASM here.
+find_program(NASM_PATH NAMES nasm)
+if (NOT NASM_PATH)
+    message(FATAL_ERROR "Please install NASM from 'https://www.nasm.us/' because NASM compiler can not be found!")
+endif ()
+
+include(CheckLanguage)
+check_language(ASM_NASM)
+if(NOT CMAKE_ASM_NASM_COMPILER)
+    message(FATAL_ERROR "Please install NASM from 'https://www.nasm.us/' because NASM compiler can not be found!")
+endif()
+
+enable_language(ASM_NASM)
+
+set(ISAL_C_SRC
+        ${ISAL_SOURCE_DIR}/crc/crc_base_aliases.c
+        ${ISAL_SOURCE_DIR}/crc/crc_base.c
+        ${ISAL_SOURCE_DIR}/crc/crc64_base.c
+        ${ISAL_SOURCE_DIR}/erasure_code/ec_base.c
+        ${ISAL_SOURCE_DIR}/erasure_code/ec_base_aliases.c
+        ${ISAL_SOURCE_DIR}/erasure_code/ec_highlevel_func.c
+        ${ISAL_SOURCE_DIR}/erasure_code/gen_rs_matrix_limits.c
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_dot_prod_1tbl.c
+        ${ISAL_SOURCE_DIR}/igzip/adler32_base.c
+        ${ISAL_SOURCE_DIR}/igzip/encode_df.c
+        ${ISAL_SOURCE_DIR}/igzip/flatten_ll.c
+        ${ISAL_SOURCE_DIR}/igzip/generate_custom_hufftables.c
+        ${ISAL_SOURCE_DIR}/igzip/generate_static_inflate.c
+        ${ISAL_SOURCE_DIR}/igzip/huff_codes.c
+        ${ISAL_SOURCE_DIR}/igzip/hufftables_c.c
+        ${ISAL_SOURCE_DIR}/igzip/igzip_base_aliases.c
+        ${ISAL_SOURCE_DIR}/igzip/igzip_base.c
+        ${ISAL_SOURCE_DIR}/igzip/igzip_icf_base.c
+        ${ISAL_SOURCE_DIR}/igzip/igzip_icf_body.c
+        ${ISAL_SOURCE_DIR}/igzip/igzip_inflate.c
+        ${ISAL_SOURCE_DIR}/igzip/igzip.c
+        ${ISAL_SOURCE_DIR}/mem/mem_zero_detect_base_aliases.c
+        ${ISAL_SOURCE_DIR}/mem/mem_zero_detect_base.c
+        ${ISAL_SOURCE_DIR}/programs/igzip_cli.c
+        ${ISAL_SOURCE_DIR}/raid/raid_base_aliases.c
+        ${ISAL_SOURCE_DIR}/raid/raid_base.c
+)
+
+set(ISAL_ASM_SRC
+        ${ISAL_SOURCE_DIR}/crc/crc_multibinary.asm
+        ${ISAL_SOURCE_DIR}/crc/crc16_t10dif_01.asm
+        ${ISAL_SOURCE_DIR}/crc/crc16_t10dif_02.asm
+        ${ISAL_SOURCE_DIR}/crc/crc16_t10dif_by4.asm
+        ${ISAL_SOURCE_DIR}/crc/crc16_t10dif_by16_10.asm
+        ${ISAL_SOURCE_DIR}/crc/crc16_t10dif_copy_by4_02.asm
+        ${ISAL_SOURCE_DIR}/crc/crc16_t10dif_copy_by4.asm
+        ${ISAL_SOURCE_DIR}/crc/crc32_gzip_refl_by8_02.asm
+        ${ISAL_SOURCE_DIR}/crc/crc32_gzip_refl_by8.asm
+        ${ISAL_SOURCE_DIR}/crc/crc32_gzip_refl_by16_10.asm
+        ${ISAL_SOURCE_DIR}/crc/crc32_ieee_01.asm
+        ${ISAL_SOURCE_DIR}/crc/crc32_ieee_02.asm
+        ${ISAL_SOURCE_DIR}/crc/crc32_ieee_by4.asm
+        ${ISAL_SOURCE_DIR}/crc/crc32_ieee_by16_10.asm
+        ${ISAL_SOURCE_DIR}/crc/crc32_iscsi_00.asm
+        ${ISAL_SOURCE_DIR}/crc/crc32_iscsi_01.asm
+        ${ISAL_SOURCE_DIR}/crc/crc32_iscsi_by16_10.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_ecma_norm_by8.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_ecma_norm_by16_10.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_ecma_refl_by8.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_ecma_refl_by16_10.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_iso_norm_by8.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_iso_norm_by16_10.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_iso_refl_by8.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_iso_refl_by16_10.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_jones_norm_by8.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_jones_norm_by16_10.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_jones_refl_by8.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_jones_refl_by16_10.asm
+        ${ISAL_SOURCE_DIR}/crc/crc64_multibinary.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_2vect_dot_prod_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_2vect_dot_prod_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_2vect_dot_prod_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_2vect_dot_prod_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/ec_multibinary.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_2vect_mad_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_2vect_mad_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_2vect_mad_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_2vect_mad_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_3vect_dot_prod_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_3vect_dot_prod_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_3vect_dot_prod_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_3vect_dot_prod_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_3vect_mad_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_3vect_mad_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_3vect_mad_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_3vect_mad_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_4vect_dot_prod_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_4vect_dot_prod_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_4vect_dot_prod_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_4vect_dot_prod_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_4vect_mad_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_4vect_mad_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_4vect_mad_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_4vect_mad_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_5vect_dot_prod_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_5vect_dot_prod_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_5vect_dot_prod_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_5vect_dot_prod_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_5vect_mad_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_5vect_mad_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_5vect_mad_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_5vect_mad_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_6vect_dot_prod_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_6vect_dot_prod_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_6vect_dot_prod_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_6vect_dot_prod_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_6vect_mad_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_6vect_mad_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_6vect_mad_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_6vect_mad_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_dot_prod_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_dot_prod_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_dot_prod_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_dot_prod_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_mad_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_mad_avx2.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_mad_avx512.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_mad_sse.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_mul_avx.asm
+        ${ISAL_SOURCE_DIR}/erasure_code/gf_vect_mul_sse.asm
+        ${ISAL_SOURCE_DIR}/igzip/adler32_avx2_4.asm
+        ${ISAL_SOURCE_DIR}/igzip/adler32_sse.asm
+        ${ISAL_SOURCE_DIR}/igzip/bitbuf2.asm
+        ${ISAL_SOURCE_DIR}/igzip/encode_df_04.asm
+        ${ISAL_SOURCE_DIR}/igzip/encode_df_06.asm
+        ${ISAL_SOURCE_DIR}/igzip/heap_macros.asm
+        ${ISAL_SOURCE_DIR}/igzip/huffman.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_body.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_compare_types.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_decode_block_stateless_01.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_decode_block_stateless_04.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_deflate_hash.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_finish.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_gen_icf_map_lh1_04.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_gen_icf_map_lh1_06.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_icf_body_h1_gr_bt.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_icf_finish.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_inflate_multibinary.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_multibinary.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_set_long_icf_fg_04.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_set_long_icf_fg_06.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_update_histogram_01.asm
+        ${ISAL_SOURCE_DIR}/igzip/igzip_update_histogram_04.asm
+        ${ISAL_SOURCE_DIR}/igzip/lz0a_const.asm
+        ${ISAL_SOURCE_DIR}/igzip/options.asm
+        ${ISAL_SOURCE_DIR}/igzip/proc_heap.asm
+        ${ISAL_SOURCE_DIR}/igzip/rfc1951_lookup.asm
+        ${ISAL_SOURCE_DIR}/igzip/stdmac.asm
+        ${ISAL_SOURCE_DIR}/mem/mem_multibinary.asm
+        ${ISAL_SOURCE_DIR}/mem/mem_zero_detect_avx.asm
+        ${ISAL_SOURCE_DIR}/mem/mem_zero_detect_avx2.asm
+        ${ISAL_SOURCE_DIR}/mem/mem_zero_detect_avx512.asm
+        ${ISAL_SOURCE_DIR}/mem/mem_zero_detect_sse.asm
+        ${ISAL_SOURCE_DIR}/raid/pq_check_sse.asm
+        ${ISAL_SOURCE_DIR}/raid/pq_gen_avx.asm
+        ${ISAL_SOURCE_DIR}/raid/pq_gen_avx2.asm
+        ${ISAL_SOURCE_DIR}/raid/pq_gen_avx512.asm
+        ${ISAL_SOURCE_DIR}/raid/pq_gen_sse.asm
+        ${ISAL_SOURCE_DIR}/raid/raid_multibinary.asm
+        ${ISAL_SOURCE_DIR}/raid/xor_check_sse.asm
+        ${ISAL_SOURCE_DIR}/raid/xor_gen_avx.asm
+        ${ISAL_SOURCE_DIR}/raid/xor_gen_avx512.asm
+        ${ISAL_SOURCE_DIR}/raid/xor_gen_sse.asm
+)
+
+# Adding ISA-L library target
+add_library(_isal ${ISAL_C_SRC} ${ISAL_ASM_SRC})
+
+# Setting external and internal interfaces for ISA-L library
+target_include_directories(_isal
+        PUBLIC ${ISAL_SOURCE_DIR}/include
+        PUBLIC ${ISAL_SOURCE_DIR}/igzip
+        PUBLIC ${ISAL_SOURCE_DIR}/crc
+        PUBLIC ${ISAL_SOURCE_DIR}/erasure_code)
+
+# Here must remove "-fno-sanitize=undefined" from COMPILE_OPTIONS.
+# Otherwise nasm compiler would fail to proceed due to unrecognition of "-fno-sanitize=undefined"
+if (SANITIZE STREQUAL "undefined")
+    get_target_property(target_options _isal COMPILE_OPTIONS)
+    list(REMOVE_ITEM target_options "-fno-sanitize=undefined")
+    set_property(TARGET _isal PROPERTY COMPILE_OPTIONS ${target_options})
+endif()
+
+add_library(ch_contrib::isal ALIAS _isal)
diff --git a/contrib/libhdfs3 b/contrib/libhdfs3
index 3c91d96ff29..164b89253fa 160000
--- a/contrib/libhdfs3
+++ b/contrib/libhdfs3
@@ -1 +1 @@
-Subproject commit 3c91d96ff29fe5928f055519c6d979c4b104db9e
+Subproject commit 164b89253fad7991bce77882f01b51ab81d19f3d
diff --git a/contrib/libhdfs3-cmake/CMakeLists.txt b/contrib/libhdfs3-cmake/CMakeLists.txt
index c22cac731fe..ecc0627354a 100644
--- a/contrib/libhdfs3-cmake/CMakeLists.txt
+++ b/contrib/libhdfs3-cmake/CMakeLists.txt
@@ -70,6 +70,30 @@ set(SRCS
     "${HDFS3_SOURCE_DIR}/client/Token.cpp"
     "${HDFS3_SOURCE_DIR}/client/PacketPool.cpp"
     "${HDFS3_SOURCE_DIR}/client/OutputStream.cpp"
+    "${HDFS3_SOURCE_DIR}/client/AbstractNativeRawDecoder.cpp"
+    "${HDFS3_SOURCE_DIR}/client/AbstractNativeRawEncoder.cpp"
+    "${HDFS3_SOURCE_DIR}/client/ByteBufferDecodingState.cpp"
+    "${HDFS3_SOURCE_DIR}/client/ByteBufferEncodingState.cpp"
+    "${HDFS3_SOURCE_DIR}/client/CoderUtil.cpp"
+    "${HDFS3_SOURCE_DIR}/client/ECChunk.cpp"
+    "${HDFS3_SOURCE_DIR}/client/ErasureCoderOptions.cpp"
+    "${HDFS3_SOURCE_DIR}/client/GF256.cpp"
+    "${HDFS3_SOURCE_DIR}/client/GaloisField.cpp"
+    "${HDFS3_SOURCE_DIR}/client/NativeRSRawDecoder.cpp"
+    "${HDFS3_SOURCE_DIR}/client/NativeRSRawEncoder.cpp"
+    "${HDFS3_SOURCE_DIR}/client/Preconditions.cpp"
+    "${HDFS3_SOURCE_DIR}/client/RSUtil.cpp"
+    "${HDFS3_SOURCE_DIR}/client/RawErasureCoderFactory.cpp"
+    "${HDFS3_SOURCE_DIR}/client/RawErasureDecoder.cpp"
+    "${HDFS3_SOURCE_DIR}/client/RawErasureEncoder.cpp"
+    "${HDFS3_SOURCE_DIR}/client/StatefulStripeReader.cpp"
+    "${HDFS3_SOURCE_DIR}/client/StripeReader.cpp"
+    "${HDFS3_SOURCE_DIR}/client/StripedBlockUtil.cpp"
+    "${HDFS3_SOURCE_DIR}/client/StripedInputStreamImpl.cpp"
+    "${HDFS3_SOURCE_DIR}/client/StripedOutputStreamImpl.cpp"
+    "${HDFS3_SOURCE_DIR}/client/SystemECPolicies.cpp"
+    "${HDFS3_SOURCE_DIR}/client/dump.cpp"
+    "${HDFS3_SOURCE_DIR}/client/erasure_coder.cpp"
     "${HDFS3_SOURCE_DIR}/rpc/RpcChannelKey.cpp"
     "${HDFS3_SOURCE_DIR}/rpc/RpcProtocolInfo.cpp"
     "${HDFS3_SOURCE_DIR}/rpc/RpcClient.cpp"
@@ -148,6 +172,11 @@ if (TARGET OpenSSL::SSL)
     target_link_libraries(_hdfs3 PRIVATE OpenSSL::Crypto OpenSSL::SSL)
 endif()
 
+if (ENABLE_ISAL_LIBRARY)
+    target_link_libraries(_hdfs3 PRIVATE ch_contrib::isal)
+    add_definitions(-DHADOOP_ISAL_LIBRARY)
+endif()
+
 add_library(ch_contrib::hdfs ALIAS _hdfs3)
 
 if (ENABLE_CLICKHOUSE_BENCHMARK)
diff --git a/contrib/qpl b/contrib/qpl
index d75a29d95d8..0bce2b03423 160000
--- a/contrib/qpl
+++ b/contrib/qpl
@@ -1 +1 @@
-Subproject commit d75a29d95d8a548297fce3549d21020005364dc8
+Subproject commit 0bce2b03423f6fbeb8bce66cc8be0bf558058848
diff --git a/contrib/qpl-cmake/CMakeLists.txt b/contrib/qpl-cmake/CMakeLists.txt
index fc5548b0652..334731d105f 100644
--- a/contrib/qpl-cmake/CMakeLists.txt
+++ b/contrib/qpl-cmake/CMakeLists.txt
@@ -40,9 +40,10 @@ set (LOG_HW_INIT OFF)
 set (SANITIZE_MEMORY OFF)
 set (SANITIZE_THREADS OFF)
 set (LIB_FUZZING_ENGINE OFF)
+set (DYNAMIC_LOADING_LIBACCEL_CONFIG OFF)
 
 function(GetLibraryVersion _content _outputVar)
-    string(REGEX MATCHALL "Qpl VERSION (.+) LANGUAGES" VERSION_REGEX "${_content}")
+    string(REGEX MATCHALL "QPL VERSION (.+) LANGUAGES" VERSION_REGEX "${_content}")
     SET(${_outputVar} ${CMAKE_MATCH_1} PARENT_SCOPE)
 endfunction()
 
@@ -240,7 +241,9 @@ add_library(core_iaa OBJECT ${HW_PATH_SRC})
 target_include_directories(core_iaa
         PRIVATE ${UUID_DIR}
         PUBLIC $<BUILD_INTERFACE:${QPL_SRC_DIR}/core-iaa/include>
-        PRIVATE $<BUILD_INTERFACE:${QPL_SRC_DIR}/core-iaa/sources/include>
+        PUBLIC $<BUILD_INTERFACE:${QPL_SRC_DIR}/core-iaa/sources/include>
+        PRIVATE $<BUILD_INTERFACE:${QPL_PROJECT_DIR}/include>  # status.h in own_checkers.h
+        PRIVATE $<BUILD_INTERFACE:${QPL_PROJECT_DIR}/sources/c_api> # own_checkers.h
         PRIVATE $<TARGET_PROPERTY:qplcore_avx512,INTERFACE_INCLUDE_DIRECTORIES>)
 
 target_compile_options(core_iaa
@@ -339,4 +342,7 @@ target_link_libraries(_qpl
         PRIVATE ${CMAKE_DL_LIBS})
 
 add_library (ch_contrib::qpl ALIAS _qpl)
-target_include_directories(_qpl SYSTEM BEFORE PUBLIC "${QPL_PROJECT_DIR}/include")
+target_include_directories(_qpl SYSTEM BEFORE
+        PUBLIC "${QPL_PROJECT_DIR}/include"
+        PUBLIC "${LIBACCEL_SOURCE_DIR}/accfg"
+        PUBLIC ${UUID_DIR})
diff --git a/contrib/sysroot b/contrib/sysroot
index f0081b2649b..e0d1b64da66 160000
--- a/contrib/sysroot
+++ b/contrib/sysroot
@@ -1 +1 @@
-Subproject commit f0081b2649b94837855f3bc7d05ef326b100bad8
+Subproject commit e0d1b64da666afbfaa6f1ee0487c33f3fd2cd5cb
diff --git a/docker/keeper/Dockerfile b/docker/keeper/Dockerfile
index 35b94d2563e..59e8d2ed3d8 100644
--- a/docker/keeper/Dockerfile
+++ b/docker/keeper/Dockerfile
@@ -32,7 +32,7 @@ RUN arch=${TARGETARCH:-amd64} \
     esac
 
 ARG REPOSITORY="https://s3.amazonaws.com/clickhouse-builds/22.4/31c367d3cd3aefd316778601ff6565119fe36682/package_release"
-ARG VERSION="23.3.2.37"
+ARG VERSION="23.4.1.1943"
 ARG PACKAGES="clickhouse-keeper"
 
 # user/group precreated explicitly with fixed uid/gid on purpose.
diff --git a/docker/server/Dockerfile.alpine b/docker/server/Dockerfile.alpine
index a20feaf654f..d59a08c2805 100644
--- a/docker/server/Dockerfile.alpine
+++ b/docker/server/Dockerfile.alpine
@@ -33,7 +33,7 @@ RUN arch=${TARGETARCH:-amd64} \
 # lts / testing / prestable / etc
 ARG REPO_CHANNEL="stable"
 ARG REPOSITORY="https://packages.clickhouse.com/tgz/${REPO_CHANNEL}"
-ARG VERSION="23.3.2.37"
+ARG VERSION="23.4.1.1943"
 ARG PACKAGES="clickhouse-client clickhouse-server clickhouse-common-static"
 
 # user/group precreated explicitly with fixed uid/gid on purpose.
diff --git a/docker/server/Dockerfile.ubuntu b/docker/server/Dockerfile.ubuntu
index 4851e2b1fc7..390f347d549 100644
--- a/docker/server/Dockerfile.ubuntu
+++ b/docker/server/Dockerfile.ubuntu
@@ -22,7 +22,7 @@ RUN sed -i "s|http://archive.ubuntu.com|${apt_archive}|g" /etc/apt/sources.list
 
 ARG REPO_CHANNEL="stable"
 ARG REPOSITORY="deb https://packages.clickhouse.com/deb ${REPO_CHANNEL} main"
-ARG VERSION="23.3.2.37"
+ARG VERSION="23.4.1.1943"
 ARG PACKAGES="clickhouse-client clickhouse-server clickhouse-common-static"
 
 # set non-empty deb_location_url url to create a docker image
diff --git a/docker/test/util/process_functional_tests_result.py b/docker/test/util/process_functional_tests_result.py
index 3c1c6e2a795..470eb61b3fa 100755
--- a/docker/test/util/process_functional_tests_result.py
+++ b/docker/test/util/process_functional_tests_result.py
@@ -80,11 +80,9 @@ def process_test_log(log_path, broken_tests):
                         test_results.append(
                             (
                                 test_name,
-                                "FAIL",
+                                "SKIPPED",
                                 test_time,
-                                [
-                                    "Test is expected to fail! Please, update broken_tests.txt!\n"
-                                ],
+                                ["This test passed. Update broken_tests.txt.\n"],
                             )
                         )
                     else:
diff --git a/docs/changelogs/v23.4.1.1943-stable.md b/docs/changelogs/v23.4.1.1943-stable.md
new file mode 100644
index 00000000000..ea16f5856be
--- /dev/null
+++ b/docs/changelogs/v23.4.1.1943-stable.md
@@ -0,0 +1,375 @@
+---
+sidebar_position: 1
+sidebar_label: 2023
+---
+
+# 2023 Changelog
+
+### ClickHouse release v23.4.1.1943-stable (3920eb987f7) FIXME as compared to v23.3.1.2823-lts (46e85357ce2)
+
+#### Backward Incompatible Change
+* If `path` in cache configuration is not empty and is not absolute path, then it will be put in `<clickhouse server data directory>/caches/<path_from_cache_config>`. [#48784](https://github.com/ClickHouse/ClickHouse/pull/48784) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Compatibility setting `parallelize_output_from_storages` to enable behavior before [#48727](https://github.com/ClickHouse/ClickHouse/issues/48727). [#49101](https://github.com/ClickHouse/ClickHouse/pull/49101) ([Igor Nikonov](https://github.com/devcrafter)).
+
+#### New Feature
+* Add `extractKeyValuePairs` function to extract key value pairs from strings. Input strings might contain noise (i.e log files / do not need to be 100% formatted in key-value-pair format), the algorithm will look for key value pairs matching the arguments passed to the function. As of now, function accepts the following arguments: `data_column` (mandatory), `key_value_pair_delimiter` (defaults to `:`), `pair_delimiters` (defaults to `\space \, \;`) and `quoting_character` (defaults to double quotes). [#43606](https://github.com/ClickHouse/ClickHouse/pull/43606) ([Arthur Passos](https://github.com/arthurpassos)).
+* Add MemoryTracker for the background tasks (merges and mutation). Introduces `merges_mutations_memory_usage_soft_limit` and `merges_mutations_memory_usage_to_ram_ratio` settings that represent the soft memory limit for merges and mutations. If this limit is reached ClickHouse won't schedule new merge or mutation tasks. Also `MergesMutationsMemoryTracking` metric is introduced to allow observing current memory usage of background tasks. Closes [#45710](https://github.com/ClickHouse/ClickHouse/issues/45710). [#46089](https://github.com/ClickHouse/ClickHouse/pull/46089) ([Dmitry Novik](https://github.com/novikd)).
+* Support new aggregate function quantileGK/quantilesGK, like [approx_percentile](https://spark.apache.org/docs/latest/api/sql/index.html#approx_percentile) in spark. Greenwald-Khanna algorithm refer to http://infolab.stanford.edu/~datar/courses/cs361a/papers/quantiles.pdf. [#46428](https://github.com/ClickHouse/ClickHouse/pull/46428) ([李扬](https://github.com/taiyang-li)).
+* Add statement `SHOW COLUMNS` which shows distilled information from system.columns. [#48017](https://github.com/ClickHouse/ClickHouse/pull/48017) ([Robert Schulze](https://github.com/rschu1ze)).
+* Added `LIGHTWEIGHT` and `PULL` modifiers for `SYSTEM SYNC REPLICA` query. `LIGHTWEIGHT` version waits for fetches and drop-ranges only (merges and mutations are ignored). `PULL` version pulls new entries from ZooKeeper and does not wait for them. Fixes [#47794](https://github.com/ClickHouse/ClickHouse/issues/47794). [#48085](https://github.com/ClickHouse/ClickHouse/pull/48085) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Add kafkaMurmurHash function for compatibility with Kafka DefaultPartitioner. Closes [#47834](https://github.com/ClickHouse/ClickHouse/issues/47834). [#48185](https://github.com/ClickHouse/ClickHouse/pull/48185) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Allow to easily create a user with the same grants as the current user by using `GRANT CURRENT GRANTS`. [#48262](https://github.com/ClickHouse/ClickHouse/pull/48262) ([pufit](https://github.com/pufit)).
+* Add statistical aggregate function `kolmogorovSmirnovTest`. close [#48228](https://github.com/ClickHouse/ClickHouse/issues/48228). [#48325](https://github.com/ClickHouse/ClickHouse/pull/48325) ([FFFFFFFHHHHHHH](https://github.com/FFFFFFFHHHHHHH)).
+* Added a `lost_part_count` column to the `system.replicas` table. The column value shows the total number of lost parts in the corresponding table. Value is stored in zookeeper and can be used instead of not persistent `ReplicatedDataLoss` profile event for monitoring. [#48526](https://github.com/ClickHouse/ClickHouse/pull/48526) ([Sergei Trifonov](https://github.com/serxa)).
+* Add soundex function. Closes [#39880](https://github.com/ClickHouse/ClickHouse/issues/39880). [#48567](https://github.com/ClickHouse/ClickHouse/pull/48567) ([FriendLey](https://github.com/FriendLey)).
+* Support map type for JSONExtract. [#48629](https://github.com/ClickHouse/ClickHouse/pull/48629) ([李扬](https://github.com/taiyang-li)).
+* Add PrettyJSONEachRow format to output pretty JSON with new line delimieters and 4 space indents. [#48898](https://github.com/ClickHouse/ClickHouse/pull/48898) ([Kruglov Pavel](https://github.com/Avogar)).
+* Add ParquetMetadata input format to read Parquet file metadata. [#48911](https://github.com/ClickHouse/ClickHouse/pull/48911) ([Kruglov Pavel](https://github.com/Avogar)).
+
+#### Performance Improvement
+* Reading files in Parquet format is now much faster. IO and decoding are parallelized (controlled by `max_threads` setting), and only required data ranges are read. [#47964](https://github.com/ClickHouse/ClickHouse/pull/47964) ([Michael Kolupaev](https://github.com/al13n321)).
+* Only check dependencies if necessary when applying `ALTER TABLE` queries. [#48062](https://github.com/ClickHouse/ClickHouse/pull/48062) ([Raúl Marín](https://github.com/Algunenano)).
+* Optimize function `mapUpdate`. [#48118](https://github.com/ClickHouse/ClickHouse/pull/48118) ([Anton Popov](https://github.com/CurtizJ)).
+* Now an internal query to local replica is sent explicitly and data from it received through loopback interface. Setting `prefer_localhost_replica` is not respected for parallel replicas. This is needed for better scheduling and makes the code cleaner: the initiator is only responsible for coordinating of the reading process and merging results, continiously answering for requests while all the secondary queries read the data. Note: Using loopback interface is not so performant, otherwise some replicas could starve for tasks which could lead to even slower query execution and not utilizing all possible resources. The initialization of the coordinator is now even more lazy. All incoming requests contain the information about the reading algorithm we initialize the coordinator with it when first request comes. If any replica will decide to read with different algorithm - an exception will be thrown and a query will be aborted. [#48246](https://github.com/ClickHouse/ClickHouse/pull/48246) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)).
+* Do not build set for the right side of `IN` clause with subquery when it is used only for analysis of skip indexes and they are disabled by setting (`use_skip_indexes=0`). Previously it might affect the performance of queries. [#48299](https://github.com/ClickHouse/ClickHouse/pull/48299) ([Anton Popov](https://github.com/CurtizJ)).
+* Query processing is parallelized right after reading `FROM file(...)`. Related to [#38755](https://github.com/ClickHouse/ClickHouse/issues/38755). [#48525](https://github.com/ClickHouse/ClickHouse/pull/48525) ([Igor Nikonov](https://github.com/devcrafter)).
+* Query processing is parallelized right after reading from a data source. Affected data sources are mostly simple or external storages like table functions `url`, `file`. [#48727](https://github.com/ClickHouse/ClickHouse/pull/48727) ([Igor Nikonov](https://github.com/devcrafter)).
+* Using correct memory order for counter in `numebers_mt()`. [#48729](https://github.com/ClickHouse/ClickHouse/pull/48729) ([Igor Nikonov](https://github.com/devcrafter)).
+* Lowered contention of ThreadPool mutex (may increase performance for a huge amount of small jobs). [#48750](https://github.com/ClickHouse/ClickHouse/pull/48750) ([Sergei Trifonov](https://github.com/serxa)).
+* Simplify accounting of approximate size of granule in prefetched read pool. [#49051](https://github.com/ClickHouse/ClickHouse/pull/49051) ([Nikita Taranov](https://github.com/nickitat)).
+
+#### Improvement
+* Support config sections `keeper`/`keeper_server` as an alternative to `zookeeper`. Close [#34766](https://github.com/ClickHouse/ClickHouse/issues/34766) , [#34767](https://github.com/ClickHouse/ClickHouse/issues/34767). [#35113](https://github.com/ClickHouse/ClickHouse/pull/35113) ([李扬](https://github.com/taiyang-li)).
+* Many issues in ClickHouse applications's help were fixed. Help is now written to stdout from all tools. Status code for `clickhouse help` invocation is now 0. Updated help for `clickhouse-local`, `clickhouse-benchmark`, `clickhouse-client`, `clickhouse hash`, `clickhouse su`, `clickhouse-install`. [#45819](https://github.com/ClickHouse/ClickHouse/pull/45819) ([Ilya Yatsishin](https://github.com/qoega)).
+* Entries in the query cache are now squashed to max_block_size and compressed. [#45912](https://github.com/ClickHouse/ClickHouse/pull/45912) ([Robert Schulze](https://github.com/rschu1ze)).
+* It is possible to set _secure_ flag in named_collections for a dictionary with a ClickHouse table source. Addresses [#38450](https://github.com/ClickHouse/ClickHouse/issues/38450) . [#46323](https://github.com/ClickHouse/ClickHouse/pull/46323) ([Ilya Golshtein](https://github.com/ilejn)).
+* Functions replaceOne(), replaceAll(), replaceRegexpOne() and replaceRegexpAll() can now be called with non-const pattern and replacement arguments. [#46589](https://github.com/ClickHouse/ClickHouse/pull/46589) ([Robert Schulze](https://github.com/rschu1ze)).
+* Bump internal ZSTD from 1.5.4 to 1.5.5. [#46797](https://github.com/ClickHouse/ClickHouse/pull/46797) ([Robert Schulze](https://github.com/rschu1ze)).
+* If we run a mutation with IN (subquery) like this: `ALTER TABLE t UPDATE col='new value' WHERE id IN (SELECT id FROM huge_table)` and the table `t` has multiple parts than for each part a set for subquery `SELECT id FROM huge_table` is built in memory. And if there are many parts then this might consume a lot of memory (and lead to an OOM) and CPU. The solution is to introduce a short-lived cache of sets that are currently being built by mutation tasks. If another task of the same mutation is executed concurrently it can lookup the set in the cache, wait for it be be built and reuse it. [#46835](https://github.com/ClickHouse/ClickHouse/pull/46835) ([Alexander Gololobov](https://github.com/davenger)).
+* Added configurable retries for all operations with [Zoo]Keeper for Backup queries. [#47224](https://github.com/ClickHouse/ClickHouse/pull/47224) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)).
+* Add async connection to socket and async writing to socket. Make creating connections and sending query/external tables async across shards. Refactor code with fibers. Closes [#46931](https://github.com/ClickHouse/ClickHouse/issues/46931). We will be able to increase `connect_timeout_with_failover_ms` by default after this PR (https://github.com/ClickHouse/ClickHouse/issues/5188). [#47229](https://github.com/ClickHouse/ClickHouse/pull/47229) ([Kruglov Pavel](https://github.com/Avogar)).
+* Formatter '%M' in function formatDateTime() now prints the month name instead of the minutes. This makes the behavior consistent with MySQL. The previous behavior can be restored using setting "formatdatetime_parsedatetime_m_is_month_name = 0". [#47246](https://github.com/ClickHouse/ClickHouse/pull/47246) ([Robert Schulze](https://github.com/rschu1ze)).
+* Several improvements around data lakes: - Make StorageIceberg work with non-partitioned data. - Support Iceberg format version V2 (previously only V1 was supported) - Support reading partitioned data for DeltaLake/Hudi - Faster reading of DeltaLake metadata by using Delta's checkpoint files - Fixed incorrect Hudi reads: previously it incorrectly chose which data to read and therefore was able to read correctly only small size tables - Made these engines to pickup updates of changed data (previously the state was set on table creation) - Make proper testing for Iceberg/DeltaLake/Hudi using spark. [#47307](https://github.com/ClickHouse/ClickHouse/pull/47307) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Enable `use_environment_credentials` for S3 by default, so the entire provider chain is constructed by default. [#47397](https://github.com/ClickHouse/ClickHouse/pull/47397) ([Antonio Andelic](https://github.com/antonio2368)).
+* Currently, the JSON_VALUE function is similar as spark's get_json_object function, which support to get value from json string by a path like '$.key'. But still has something different - 1. in spark's get_json_object will return null while the path is not exist, but in JSON_VALUE will return empty string; - 2. in spark's get_json_object will return a complext type value, such as a json object/array value, but in JSON_VALUE will return empty string. [#47494](https://github.com/ClickHouse/ClickHouse/pull/47494) ([KevinyhZou](https://github.com/KevinyhZou)).
+* Add CNF/constraint optimizer in new analyzer. [#47617](https://github.com/ClickHouse/ClickHouse/pull/47617) ([Antonio Andelic](https://github.com/antonio2368)).
+* For use_structure_from_insertion_table_in_table_functions more flexible insert table structure propagation to table function. Fixed bug with name mapping and using virtual columns. No more need for 'auto' setting. [#47962](https://github.com/ClickHouse/ClickHouse/pull/47962) ([Yakov Olkhovskiy](https://github.com/yakov-olkhovskiy)).
+* Do not continue retrying to connect to ZK if the query is killed or over limits. [#47985](https://github.com/ClickHouse/ClickHouse/pull/47985) ([Raúl Marín](https://github.com/Algunenano)).
+* Added functions to work with columns of type `Map`: `mapConcat`, `mapSort`, `mapExists`. [#48071](https://github.com/ClickHouse/ClickHouse/pull/48071) ([Anton Popov](https://github.com/CurtizJ)).
+* Support Enum output/input in BSONEachRow, allow all map key types and avoid extra calculations on output. [#48122](https://github.com/ClickHouse/ClickHouse/pull/48122) ([Kruglov Pavel](https://github.com/Avogar)).
+* Support more ClickHouse types in ORC/Arrow/Parquet formats: Enum(8|16), (U)Int(128|256), Decimal256 (for ORC), allow reading IPv4 from Int32 values (ORC outputs IPv4 as Int32 and we couldn't read it back), fix reading Nullable(IPv6) from binary data for ORC. [#48126](https://github.com/ClickHouse/ClickHouse/pull/48126) ([Kruglov Pavel](https://github.com/Avogar)).
+* Add columns `perform_ttl_move_on_insert`, `load_balancing` for table `system.storage_policies`, modify column `volume_type` type to `enum8`. [#48167](https://github.com/ClickHouse/ClickHouse/pull/48167) ([lizhuoyu5](https://github.com/lzydmxy)).
+* Added support for `BACKUP ALL` command which backups all tables and databases, including temporary and system ones. [#48189](https://github.com/ClickHouse/ClickHouse/pull/48189) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Function mapFromArrays support map type as input. [#48207](https://github.com/ClickHouse/ClickHouse/pull/48207) ([李扬](https://github.com/taiyang-li)).
+* The output of some SHOW PROCESSLIST is now sorted. [#48241](https://github.com/ClickHouse/ClickHouse/pull/48241) ([Robert Schulze](https://github.com/rschu1ze)).
+* Per-query/per-server throttling for remote IO/local IO/BACKUPs (server settings: `max_remote_read_network_bandwidth_for_server`, `max_remote_write_network_bandwidth_for_server`, `max_local_read_bandwidth_for_server`, `max_local_write_bandwidth_for_server`, `max_backup_bandwidth_for_server`, settings: `max_remote_read_network_bandwidth`, `max_remote_write_network_bandwidth`, `max_local_read_bandwidth`, `max_local_write_bandwidth`, `max_backup_bandwidth`). [#48242](https://github.com/ClickHouse/ClickHouse/pull/48242) ([Azat Khuzhin](https://github.com/azat)).
+* Support more types in CapnProto format: Map, (U)Int(128|256), Decimal(128|256). Allow integer conversions during input/output. [#48257](https://github.com/ClickHouse/ClickHouse/pull/48257) ([Kruglov Pavel](https://github.com/Avogar)).
+* It is now possible to define per-user quotas in the query cache. [#48284](https://github.com/ClickHouse/ClickHouse/pull/48284) ([Robert Schulze](https://github.com/rschu1ze)).
+* Don't throw CURRENT_WRITE_BUFFER_IS_EXHAUSTED for normal behaviour. [#48288](https://github.com/ClickHouse/ClickHouse/pull/48288) ([Raúl Marín](https://github.com/Algunenano)).
+* Add new setting `keeper_map_strict_mode` which enforces extra guarantees on operations made on top of `KeeperMap` tables. [#48293](https://github.com/ClickHouse/ClickHouse/pull/48293) ([Antonio Andelic](https://github.com/antonio2368)).
+* Check primary key type for simple dictionary is native unsigned integer type Add setting `check_dictionary_primary_key ` for compatibility(set `check_dictionary_primary_key =false` to disable checking). [#48335](https://github.com/ClickHouse/ClickHouse/pull/48335) ([lizhuoyu5](https://github.com/lzydmxy)).
+* Don't replicate mutations for `KeeperMap` because it's unnecessary. [#48354](https://github.com/ClickHouse/ClickHouse/pull/48354) ([Antonio Andelic](https://github.com/antonio2368)).
+* Allow write/read unnamed tuple as nested Message in Protobuf format. Tuple elements and Message fields are mathced by position. [#48390](https://github.com/ClickHouse/ClickHouse/pull/48390) ([Kruglov Pavel](https://github.com/Avogar)).
+* Support `additional_table_filters` and `additional_result_filter` settings in the new planner. Also, add a documentation entry for `additional_result_filter`. [#48405](https://github.com/ClickHouse/ClickHouse/pull/48405) ([Dmitry Novik](https://github.com/novikd)).
+* Parsedatetime now understands format string '%f' (fractional seconds). [#48420](https://github.com/ClickHouse/ClickHouse/pull/48420) ([Robert Schulze](https://github.com/rschu1ze)).
+* Format string "%f" in formatDateTime() now prints "000000" if the formatted value has no fractional seconds, the previous behavior (single zero) can be restored using setting "formatdatetime_f_prints_single_zero = 1". [#48422](https://github.com/ClickHouse/ClickHouse/pull/48422) ([Robert Schulze](https://github.com/rschu1ze)).
+* Don't replicate DELETE and TRUNCATE for KeeperMap. [#48434](https://github.com/ClickHouse/ClickHouse/pull/48434) ([Antonio Andelic](https://github.com/antonio2368)).
+* Generate valid Decimals and Bools in generateRandom function. [#48436](https://github.com/ClickHouse/ClickHouse/pull/48436) ([Kruglov Pavel](https://github.com/Avogar)).
+* Allow trailing commas in expression list of SELECT query, for example `SELECT a, b, c, FROM table`. Closes [#37802](https://github.com/ClickHouse/ClickHouse/issues/37802). [#48438](https://github.com/ClickHouse/ClickHouse/pull/48438) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Override `CLICKHOUSE_USER` and `CLICKHOUSE_PASSWORD` environment variables with `--user` and `--password` client parameters. Closes [#38909](https://github.com/ClickHouse/ClickHouse/issues/38909). [#48440](https://github.com/ClickHouse/ClickHouse/pull/48440) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Added retries to loading of data parts in `MergeTree` tables in case of retryable errors. [#48442](https://github.com/ClickHouse/ClickHouse/pull/48442) ([Anton Popov](https://github.com/CurtizJ)).
+* Add support for `Date`, `Date32`, `DateTime`, `DateTime64` data types to `arrayMin`, `arrayMax`, `arrayDifference` functions. Closes [#21645](https://github.com/ClickHouse/ClickHouse/issues/21645). [#48445](https://github.com/ClickHouse/ClickHouse/pull/48445) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Reduce memory usage for multiple `ALTER DELETE` mutations. [#48522](https://github.com/ClickHouse/ClickHouse/pull/48522) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Primary/secondary indices and sorting keys with identical expressions are now rejected. This behavior can be disabled using setting `allow_suspicious_indices`. [#48536](https://github.com/ClickHouse/ClickHouse/pull/48536) ([凌涛](https://github.com/lingtaolf)).
+* Just fix small typo in comment around `lockForAlter` method in `IStorage.h`. [#48559](https://github.com/ClickHouse/ClickHouse/pull/48559) ([artem-pershin](https://github.com/artem-pershin)).
+* Add support for `{server_uuid}` macro. It is useful for identifying replicas in autoscaled clusters when new replicas are constantly added and removed in runtime. This closes [#48554](https://github.com/ClickHouse/ClickHouse/issues/48554). [#48563](https://github.com/ClickHouse/ClickHouse/pull/48563) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* The installation script will create a hard link instead of copying if it is possible. [#48578](https://github.com/ClickHouse/ClickHouse/pull/48578) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Support `SHOW TABLE` syntax meaning the same as `SHOW CREATE TABLE`. Closes [#48580](https://github.com/ClickHouse/ClickHouse/issues/48580). [#48591](https://github.com/ClickHouse/ClickHouse/pull/48591) ([flynn](https://github.com/ucasfl)).
+* HTTP temporary buffer support working with fs cache. [#48664](https://github.com/ClickHouse/ClickHouse/pull/48664) ([Vladimir C](https://github.com/vdimir)).
+* Make Schema inference works for `CREATE AS SELECT`. Closes [#47599](https://github.com/ClickHouse/ClickHouse/issues/47599). [#48679](https://github.com/ClickHouse/ClickHouse/pull/48679) ([flynn](https://github.com/ucasfl)).
+* Added a `replicated_max_mutations_in_one_entry` setting for `ReplicatedMergeTree` that allows limiting the number of mutation commands per one `MUTATE_PART` entry (default is 10000). [#48731](https://github.com/ClickHouse/ClickHouse/pull/48731) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* In AggregateFunction types, don't count unused arena bytes as `read_bytes`. [#48745](https://github.com/ClickHouse/ClickHouse/pull/48745) ([Raúl Marín](https://github.com/Algunenano)).
+* Fix some mysql related settings not being handled with mysql dictionary source + named collection. Closes [#48402](https://github.com/ClickHouse/ClickHouse/issues/48402). [#48759](https://github.com/ClickHouse/ClickHouse/pull/48759) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Fix squashing in query cache. [#48763](https://github.com/ClickHouse/ClickHouse/pull/48763) ([Robert Schulze](https://github.com/rschu1ze)).
+* Support following new jsonpath format - '$.1key', path element begins with number - '$[key]', '$[“key”]', '$[\\\'key\\\']', '$["key 123"]', path element embraced in []. [#48768](https://github.com/ClickHouse/ClickHouse/pull/48768) ([lgbo](https://github.com/lgbo-ustc)).
+* If a user set `max_single_part_upload_size` to a very large value, it can lead to a crash due to a bug in the AWS S3 SDK. This fixes [#47679](https://github.com/ClickHouse/ClickHouse/issues/47679). [#48816](https://github.com/ClickHouse/ClickHouse/pull/48816) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Not for changelog. [#48824](https://github.com/ClickHouse/ClickHouse/pull/48824) ([Yakov Olkhovskiy](https://github.com/yakov-olkhovskiy)).
+* Fix data race in `StorageRabbitMQ` ([report](https://pastila.nl/?004f7100/de1505289ab5bb355e67ebe6c7cc8707)), refactor the code. [#48845](https://github.com/ClickHouse/ClickHouse/pull/48845) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Add aliases `name` and `part_name` form `system.parts` and `system.part_log`. Closes [#48718](https://github.com/ClickHouse/ClickHouse/issues/48718). [#48850](https://github.com/ClickHouse/ClickHouse/pull/48850) ([sichenzhao](https://github.com/sichenzhao)).
+* Functions "arrayDifferenceSupport()", "arrayCumSum()" and "arrayCumSumNonNegative()" now support input arrays of wide integer types (U)Int128/256. [#48866](https://github.com/ClickHouse/ClickHouse/pull/48866) ([cluster](https://github.com/infdahai)).
+* Multi-line history in clickhouse-client is now no longer padded. This makes pasting more natural. [#48870](https://github.com/ClickHouse/ClickHouse/pull/48870) ([Joanna Hulboj](https://github.com/jh0x)).
+* Not for changelog. [#48873](https://github.com/ClickHouse/ClickHouse/pull/48873) ([Yakov Olkhovskiy](https://github.com/yakov-olkhovskiy)).
+* Implement a slight improvement for the rare case when ClickHouse is run inside LXC and LXCFS is used. The LXCFS has an issue: sometimes it returns an error "Transport endpoint is not connected" on reading from the file inside `/proc`. This error was correctly logged into ClickHouse's server log. We have additionally workaround this issue by reopening a file. This is a minuscule change. [#48922](https://github.com/ClickHouse/ClickHouse/pull/48922) ([Real](https://github.com/RunningXie)).
+* Improve memory accounting for prefetches. Randomise prefetch settings In CI. [#48973](https://github.com/ClickHouse/ClickHouse/pull/48973) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Correctly set headers for native copy operations on GCS. [#48981](https://github.com/ClickHouse/ClickHouse/pull/48981) ([Antonio Andelic](https://github.com/antonio2368)).
+* Add support for specifying setting names in the command line with dashes instead of underscores, for example, `--max-threads` instead of `--max_threads`. Additionally, support Unicode dash characters like `—` instead of `--` - this is useful when you communicate with a team in another company, and a manager from that team copy-pasted code from MS Word. [#48985](https://github.com/ClickHouse/ClickHouse/pull/48985) ([alekseygolub](https://github.com/alekseygolub)).
+* Add fallback to password authentication when authentication with SSL user certificate has failed. Closes [#48974](https://github.com/ClickHouse/ClickHouse/issues/48974). [#48989](https://github.com/ClickHouse/ClickHouse/pull/48989) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Increase default value for `connect_timeout_with_failover_ms` to 1000 ms (because of adding async connections in https://github.com/ClickHouse/ClickHouse/pull/47229) . Closes [#5188](https://github.com/ClickHouse/ClickHouse/issues/5188). [#49009](https://github.com/ClickHouse/ClickHouse/pull/49009) ([Kruglov Pavel](https://github.com/Avogar)).
+* Improve the embedded dashboard. Close [#46671](https://github.com/ClickHouse/ClickHouse/issues/46671). [#49036](https://github.com/ClickHouse/ClickHouse/pull/49036) ([Kevin Zhang](https://github.com/Kinzeng)).
+* Add profile events for log messages, so you can easily see the count of log messages by severity. [#49042](https://github.com/ClickHouse/ClickHouse/pull/49042) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* `bitCount` function support `FixedString` and `String` data type. [#49044](https://github.com/ClickHouse/ClickHouse/pull/49044) ([flynn](https://github.com/ucasfl)).
+* In previous versions, the `LineAsString` format worked inconsistently when the parallel parsing was enabled or not, in presence of DOS or MacOS Classic line breaks. This closes [#49039](https://github.com/ClickHouse/ClickHouse/issues/49039). [#49052](https://github.com/ClickHouse/ClickHouse/pull/49052) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* The exception message about the unparsed query parameter will also tell about the name of the parameter. Reimplement [#48878](https://github.com/ClickHouse/ClickHouse/issues/48878). Close [#48772](https://github.com/ClickHouse/ClickHouse/issues/48772). [#49061](https://github.com/ClickHouse/ClickHouse/pull/49061) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Added field `rows` with number of rows parsed from asynchronous insert to `system.asynchronous_insert_log`. [#49120](https://github.com/ClickHouse/ClickHouse/pull/49120) ([Anton Popov](https://github.com/CurtizJ)).
+* 1. Bump Intel QPL from v1.0.0 to v1.1.0 (fixes build issue [#47877](https://github.com/ClickHouse/ClickHouse/issues/47877)) 2. the DEFLATE_QPL codec now respects the maximum hardware jobs returned by libaccel_config. [#49126](https://github.com/ClickHouse/ClickHouse/pull/49126) ([jasperzhu](https://github.com/jinjunzh)).
+
+#### Build/Testing/Packaging Improvement
+* Reduce the number of dependencies in the header files to speed up the build. [#47984](https://github.com/ClickHouse/ClickHouse/pull/47984) ([Dmitry Novik](https://github.com/novikd)).
+* Randomize compression of marks and indices in tests. [#48286](https://github.com/ClickHouse/ClickHouse/pull/48286) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Randomize vertical merges from compact to wide parts in tests. [#48287](https://github.com/ClickHouse/ClickHouse/pull/48287) ([Raúl Marín](https://github.com/Algunenano)).
+* With the current approach, all ports are calculated at the beginning and could overlap or even be highjacked, see [the report](https://s3.amazonaws.com/clickhouse-test-reports/46793/02928ae50c52f31ce8e5bfa99eb1b5db046f4a4f/integration_tests__release__[1/2]/integration_run_parallel8_0.log) for `port is already allocated`. It's possibly the reason for [#45368](https://github.com/ClickHouse/ClickHouse/issues/45368). [#48393](https://github.com/ClickHouse/ClickHouse/pull/48393) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Update time zones. The following were updated: Africa/Cairo, Africa/Casablanca, Africa/El_Aaiun, America/Bogota, America/Cambridge_Bay, America/Ciudad_Juarez, America/Godthab, America/Inuvik, America/Iqaluit, America/Nuuk, America/Ojinaga, America/Pangnirtung, America/Rankin_Inlet, America/Resolute, America/Whitehorse, America/Yellowknife, Asia/Gaza, Asia/Hebron, Asia/Kuala_Lumpur, Asia/Singapore, Canada/Yukon, Egypt, Europe/Kirov, Europe/Volgograd, Singapore. [#48572](https://github.com/ClickHouse/ClickHouse/pull/48572) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Support for CRC32 checksum in HDFS. Fix performance issues. [#48614](https://github.com/ClickHouse/ClickHouse/pull/48614) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Remove remainders of GCC support. [#48671](https://github.com/ClickHouse/ClickHouse/pull/48671) ([Robert Schulze](https://github.com/rschu1ze)).
+* Add CI run with new analyzer infrastructure enabled. [#48719](https://github.com/ClickHouse/ClickHouse/pull/48719) ([Dmitry Novik](https://github.com/novikd)).
+* Not for changelog. [#48879](https://github.com/ClickHouse/ClickHouse/pull/48879) ([larryluogit](https://github.com/larryluogit)).
+* After the recent update, the `dockerd` requires `--tlsverify=false` together with the http port explicitly. [#48924](https://github.com/ClickHouse/ClickHouse/pull/48924) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Run more functional tests concurrently. [#48970](https://github.com/ClickHouse/ClickHouse/pull/48970) ([alesapin](https://github.com/alesapin)).
+* Fix glibc compatibility check: replace `preadv` from musl. [#49144](https://github.com/ClickHouse/ClickHouse/pull/49144) ([alesapin](https://github.com/alesapin)).
+* Use position independent encoding/code for sanitizers (at least msan :D) build to avoid issues with maximum relocation size. [#49145](https://github.com/ClickHouse/ClickHouse/pull/49145) ([alesapin](https://github.com/alesapin)).
+
+#### Bug Fix (user-visible misbehavior in an official stable release)
+
+* Fix system.query_views_log for MVs that are pushed from background threads [#46668](https://github.com/ClickHouse/ClickHouse/pull/46668) ([Azat Khuzhin](https://github.com/azat)).
+* Fix several `RENAME COLUMN` bugs [#46946](https://github.com/ClickHouse/ClickHouse/pull/46946) ([alesapin](https://github.com/alesapin)).
+* Fix minor hiliting issues in clickhouse-format [#47610](https://github.com/ClickHouse/ClickHouse/pull/47610) ([Natasha Murashkina](https://github.com/murfel)).
+* Fix crash for uploading parts which size is greater then INT_MAX to S3 [#47693](https://github.com/ClickHouse/ClickHouse/pull/47693) ([Azat Khuzhin](https://github.com/azat)).
+* Fix overflow in sparkbar function [#48121](https://github.com/ClickHouse/ClickHouse/pull/48121) ([Vladimir C](https://github.com/vdimir)).
+* Fix race in StorageS3 [#48190](https://github.com/ClickHouse/ClickHouse/pull/48190) ([Anton Popov](https://github.com/CurtizJ)).
+* Remove a feature [#48195](https://github.com/ClickHouse/ClickHouse/pull/48195) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Fix alter formatting (minor) [#48289](https://github.com/ClickHouse/ClickHouse/pull/48289) ([Natasha Murashkina](https://github.com/murfel)).
+* Fix cpu usage in rabbitmq (was worsened in 23.2 after [#44404](https://github.com/ClickHouse/ClickHouse/issues/44404)) [#48311](https://github.com/ClickHouse/ClickHouse/pull/48311) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Fix ThreadPool for DistributedSink and use StrongTypedef for CurrentMetrics/ProfileEvents/StatusInfo to avoid further errors [#48314](https://github.com/ClickHouse/ClickHouse/pull/48314) ([Azat Khuzhin](https://github.com/azat)).
+* Fix crash in EXPLAIN PIPELINE for Merge over Distributed [#48320](https://github.com/ClickHouse/ClickHouse/pull/48320) ([Azat Khuzhin](https://github.com/azat)).
+* Check node for Backup Restore concurrency [#48342](https://github.com/ClickHouse/ClickHouse/pull/48342) ([SmitaRKulkarni](https://github.com/SmitaRKulkarni)).
+* close client [#48347](https://github.com/ClickHouse/ClickHouse/pull/48347) ([Yakov Olkhovskiy](https://github.com/yakov-olkhovskiy)).
+* Fix serializing LowCardinality as Arrow dictionary [#48361](https://github.com/ClickHouse/ClickHouse/pull/48361) ([Kruglov Pavel](https://github.com/Avogar)).
+* Reset downloader for cache file segment in TemporaryFileStream [#48386](https://github.com/ClickHouse/ClickHouse/pull/48386) ([Vladimir C](https://github.com/vdimir)).
+* Fix possible SYSTEM SYNC REPLICA stuck in case of DROP/REPLACE PARTITION [#48391](https://github.com/ClickHouse/ClickHouse/pull/48391) ([Azat Khuzhin](https://github.com/azat)).
+* ClickHouse startup error when loading a distributed table that depends on a dictionary [#48419](https://github.com/ClickHouse/ClickHouse/pull/48419) ([MikhailBurdukov](https://github.com/MikhailBurdukov)).
+* Don't check dependencies when renaming system tables automatically [#48431](https://github.com/ClickHouse/ClickHouse/pull/48431) ([Raúl Marín](https://github.com/Algunenano)).
+* Some fixes for parallel replicas [#48433](https://github.com/ClickHouse/ClickHouse/pull/48433) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)).
+* Update only affected rows in KV storage [#48435](https://github.com/ClickHouse/ClickHouse/pull/48435) ([Antonio Andelic](https://github.com/antonio2368)).
+* Fix possible segfault in cache [#48469](https://github.com/ClickHouse/ClickHouse/pull/48469) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* toTimeZone function throw an error when no constant string is provided [#48471](https://github.com/ClickHouse/ClickHouse/pull/48471) ([Jordi Villar](https://github.com/jrdi)).
+* Fix logical error with IPv4 in Protobuf, add support for Date32 [#48486](https://github.com/ClickHouse/ClickHouse/pull/48486) ([Kruglov Pavel](https://github.com/Avogar)).
+* "changed" flag in system.settings is calculated incorrectly for settings with multiple values [#48516](https://github.com/ClickHouse/ClickHouse/pull/48516) ([MikhailBurdukov](https://github.com/MikhailBurdukov)).
+* Fix storage `Memory` with enabled compression [#48517](https://github.com/ClickHouse/ClickHouse/pull/48517) ([Anton Popov](https://github.com/CurtizJ)).
+* Fix bracketed-paste mode messing up password input in client reconnect [#48528](https://github.com/ClickHouse/ClickHouse/pull/48528) ([Michael Kolupaev](https://github.com/al13n321)).
+* Avoid sending `nullptr` to `memcpy` in `copyStringInArena` [#48532](https://github.com/ClickHouse/ClickHouse/pull/48532) ([Antonio Andelic](https://github.com/antonio2368)).
+* Fix nested map for keys of IP and UUID types [#48556](https://github.com/ClickHouse/ClickHouse/pull/48556) ([Yakov Olkhovskiy](https://github.com/yakov-olkhovskiy)).
+* Fix uncaught exception in case of parallel loader for hashed dictionaries [#48571](https://github.com/ClickHouse/ClickHouse/pull/48571) ([Azat Khuzhin](https://github.com/azat)).
+* `groupArray` returns cannot be nullable [#48593](https://github.com/ClickHouse/ClickHouse/pull/48593) ([lgbo](https://github.com/lgbo-ustc)).
+* Fix bug in Keeper when a node is not created with scheme `auth` in ACL sometimes. [#48595](https://github.com/ClickHouse/ClickHouse/pull/48595) ([Aleksei Filatov](https://github.com/aalexfvk)).
+* Fix IPv4 comparable with UInt [#48611](https://github.com/ClickHouse/ClickHouse/pull/48611) ([Yakov Olkhovskiy](https://github.com/yakov-olkhovskiy)).
+* Fix possible error from cache [#48636](https://github.com/ClickHouse/ClickHouse/pull/48636) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Fix async inserts with empty data [#48663](https://github.com/ClickHouse/ClickHouse/pull/48663) ([Anton Popov](https://github.com/CurtizJ)).
+* Fix table dependencies in case of failed RENAME TABLE [#48683](https://github.com/ClickHouse/ClickHouse/pull/48683) ([Azat Khuzhin](https://github.com/azat)).
+* Fix zero-copy-replication on encrypted disks. [#48741](https://github.com/ClickHouse/ClickHouse/pull/48741) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Fix skip_unavailable_shards in case of unavailable hosts [#48771](https://github.com/ClickHouse/ClickHouse/pull/48771) ([Azat Khuzhin](https://github.com/azat)).
+* Fix key condition on duplicate primary keys [#48838](https://github.com/ClickHouse/ClickHouse/pull/48838) ([Amos Bird](https://github.com/amosbird)).
+* Fix for race in ZooKeeper when joining send_thread/receive_thread [#48849](https://github.com/ClickHouse/ClickHouse/pull/48849) ([Alexander Gololobov](https://github.com/davenger)).
+* Fix unexpected part name error when trying to drop a ignored detached part with zero copy replication [#48862](https://github.com/ClickHouse/ClickHouse/pull/48862) ([Michael Lex](https://github.com/mlex)).
+* Fix reading Date32 Parquet/Arrow column into not Date32 column [#48864](https://github.com/ClickHouse/ClickHouse/pull/48864) ([Kruglov Pavel](https://github.com/Avogar)).
+* Fix UNKNOWN_IDENTIFIER error while select from table with row policy and column with dots [#48976](https://github.com/ClickHouse/ClickHouse/pull/48976) ([Kruglov Pavel](https://github.com/Avogar)).
+* Fix aggregate empty string error [#48999](https://github.com/ClickHouse/ClickHouse/pull/48999) ([LiuNeng](https://github.com/liuneng1994)).
+* Fix postgres database setting [#49100](https://github.com/ClickHouse/ClickHouse/pull/49100) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Fix flaky test_cache_with_full_disk_space [#49110](https://github.com/ClickHouse/ClickHouse/pull/49110) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Fix "prepared statement insert already exists" [#49154](https://github.com/ClickHouse/ClickHouse/pull/49154) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Fix replace[Regexp]{One,All}() with const haystacks [#49220](https://github.com/ClickHouse/ClickHouse/pull/49220) ([Robert Schulze](https://github.com/rschu1ze)).
+
+#### Build Improvement
+
+* Fixed hashing issue in creating partition IDs for s390x. [#48134](https://github.com/ClickHouse/ClickHouse/pull/48134) ([Harry Lee](https://github.com/HarryLeeIBM)).
+
+#### NO CL ENTRY
+
+* NO CL ENTRY:  'Revert "Randomize JIT settings in tests"'. [#48277](https://github.com/ClickHouse/ClickHouse/pull/48277) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* NO CL ENTRY:  'Fix test "02494_query_cache_drop.sql"'. [#48358](https://github.com/ClickHouse/ClickHouse/pull/48358) ([Anton Popov](https://github.com/CurtizJ)).
+* NO CL ENTRY:  'Revert "Check simple dictionary key is native unsigned integer"'. [#48732](https://github.com/ClickHouse/ClickHouse/pull/48732) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* NO CL ENTRY:  'Revert "Make Schema inference works for CREATE AS SELECT"'. [#48758](https://github.com/ClickHouse/ClickHouse/pull/48758) ([pufit](https://github.com/pufit)).
+* NO CL ENTRY:  'Revert "Add MemoryTracker for the background tasks"'. [#48760](https://github.com/ClickHouse/ClickHouse/pull/48760) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* NO CL ENTRY:  'Revert "Added tests for ClickHouse apps help and fixed help issues"'. [#48991](https://github.com/ClickHouse/ClickHouse/pull/48991) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* NO CL ENTRY:  'Revert "Adapt marks count for prefetch read pool"'. [#49068](https://github.com/ClickHouse/ClickHouse/pull/49068) ([Nikita Taranov](https://github.com/nickitat)).
+
+#### NOT FOR CHANGELOG / INSIGNIFICANT
+
+* merge and mutation make thread group for setting memory trackers right [#47104](https://github.com/ClickHouse/ClickHouse/pull/47104) ([Sema Checherinda](https://github.com/CheSema)).
+* Query plan: update sort description [#47319](https://github.com/ClickHouse/ClickHouse/pull/47319) ([Igor Nikonov](https://github.com/devcrafter)).
+* Sqllogic [#47784](https://github.com/ClickHouse/ClickHouse/pull/47784) ([Sema Checherinda](https://github.com/CheSema)).
+* Fix race between DROP MatView and RESTART REPLICAS [#47863](https://github.com/ClickHouse/ClickHouse/pull/47863) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Merge [#35113](https://github.com/ClickHouse/ClickHouse/issues/35113) [#47934](https://github.com/ClickHouse/ClickHouse/pull/47934) ([Antonio Andelic](https://github.com/antonio2368)).
+* Add a test for ClientInfo initial_query_start_time in inter-server mode [#48036](https://github.com/ClickHouse/ClickHouse/pull/48036) ([Azat Khuzhin](https://github.com/azat)).
+* Make custom key for parallel replicas work in new analyzer [#48054](https://github.com/ClickHouse/ClickHouse/pull/48054) ([Antonio Andelic](https://github.com/antonio2368)).
+* throw exception while non-parametric functions having parameters [#48115](https://github.com/ClickHouse/ClickHouse/pull/48115) ([save-my-heart](https://github.com/save-my-heart)).
+* Move FunctionsJSON implementation to header file [#48142](https://github.com/ClickHouse/ClickHouse/pull/48142) ([DimasKovas](https://github.com/DimasKovas)).
+* Use ThreadPool in PipelineExecutor [#48146](https://github.com/ClickHouse/ClickHouse/pull/48146) ([Azat Khuzhin](https://github.com/azat)).
+* Add sanity checks for writing number in variable length format (resubmit) [#48154](https://github.com/ClickHouse/ClickHouse/pull/48154) ([Azat Khuzhin](https://github.com/azat)).
+* Try fix 02151_hash_table_sizes_stats.sh test [#48178](https://github.com/ClickHouse/ClickHouse/pull/48178) ([Nikita Taranov](https://github.com/nickitat)).
+* Add scripts for sparse checkout of some contribs [#48183](https://github.com/ClickHouse/ClickHouse/pull/48183) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Do not take lock for shared context in setTempDataOnDisk [#48219](https://github.com/ClickHouse/ClickHouse/pull/48219) ([Vladimir C](https://github.com/vdimir)).
+* parseDateTime[InJodaSyntax](): Require format argument [#48222](https://github.com/ClickHouse/ClickHouse/pull/48222) ([Robert Schulze](https://github.com/rschu1ze)).
+* Do not  partially cancel processors added from expand pipeline. [#48231](https://github.com/ClickHouse/ClickHouse/pull/48231) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Fix some tests [#48267](https://github.com/ClickHouse/ClickHouse/pull/48267) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Fix compiling examples without Hive [#48269](https://github.com/ClickHouse/ClickHouse/pull/48269) ([Azat Khuzhin](https://github.com/azat)).
+* In messages, put values into quotes [#48271](https://github.com/ClickHouse/ClickHouse/pull/48271) ([Vadim Chekan](https://github.com/vchekan)).
+* Fix 01710_projection_optimize_materialize flakiness [#48276](https://github.com/ClickHouse/ClickHouse/pull/48276) ([Azat Khuzhin](https://github.com/azat)).
+* Fix UB (signed integer overflow) in StorageMergeTree::backupData() [#48278](https://github.com/ClickHouse/ClickHouse/pull/48278) ([Azat Khuzhin](https://github.com/azat)).
+* Update version after release [#48279](https://github.com/ClickHouse/ClickHouse/pull/48279) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Update version_date.tsv and changelogs after v23.3.1.2823-lts [#48281](https://github.com/ClickHouse/ClickHouse/pull/48281) ([robot-clickhouse](https://github.com/robot-clickhouse)).
+* Small follow-up to [#48017](https://github.com/ClickHouse/ClickHouse/issues/48017) [#48292](https://github.com/ClickHouse/ClickHouse/pull/48292) ([Robert Schulze](https://github.com/rschu1ze)).
+* Try to update arrow library to release 11.0.0 [#48294](https://github.com/ClickHouse/ClickHouse/pull/48294) ([Kruglov Pavel](https://github.com/Avogar)).
+* fix test numbers again 2 [#48295](https://github.com/ClickHouse/ClickHouse/pull/48295) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Fix: copy forgotten show_secrets in FormatSettings semi-copy-ctor [#48297](https://github.com/ClickHouse/ClickHouse/pull/48297) ([Natasha Murashkina](https://github.com/murfel)).
+* Do not remove inputs from maybe compiled DAG. [#48303](https://github.com/ClickHouse/ClickHouse/pull/48303) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Update version_date.tsv and changelogs after v22.3.20.29-lts [#48304](https://github.com/ClickHouse/ClickHouse/pull/48304) ([robot-clickhouse](https://github.com/robot-clickhouse)).
+* Update version_date.tsv and changelogs after v22.12.6.22-stable, v22.3.20.29-lts [#48305](https://github.com/ClickHouse/ClickHouse/pull/48305) ([robot-clickhouse](https://github.com/robot-clickhouse)).
+* Merging [#46323](https://github.com/ClickHouse/ClickHouse/issues/46323) [#48312](https://github.com/ClickHouse/ClickHouse/pull/48312) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Follow-up to [#47863](https://github.com/ClickHouse/ClickHouse/issues/47863) [#48315](https://github.com/ClickHouse/ClickHouse/pull/48315) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* test / some complex query (it fails with analyzer enabled) [#48324](https://github.com/ClickHouse/ClickHouse/pull/48324) ([Denny Crane](https://github.com/den-crane)).
+* Fix constraints after merge [#48328](https://github.com/ClickHouse/ClickHouse/pull/48328) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Add logging for concurrency checks for backups [#48337](https://github.com/ClickHouse/ClickHouse/pull/48337) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Update version_date.tsv and changelogs after v23.1.6.42-stable [#48345](https://github.com/ClickHouse/ClickHouse/pull/48345) ([robot-clickhouse](https://github.com/robot-clickhouse)).
+* Update version_date.tsv and changelogs after v23.2.5.46-stable [#48346](https://github.com/ClickHouse/ClickHouse/pull/48346) ([robot-clickhouse](https://github.com/robot-clickhouse)).
+* Fix lambda type resolution [#48355](https://github.com/ClickHouse/ClickHouse/pull/48355) ([Dmitry Novik](https://github.com/novikd)).
+* Avoid abort in protobuf library in debug build [#48356](https://github.com/ClickHouse/ClickHouse/pull/48356) ([Kruglov Pavel](https://github.com/Avogar)).
+* Batch fix for projections analysis with analyzer. [#48357](https://github.com/ClickHouse/ClickHouse/pull/48357) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Fix tests with explain and analyzer where names changed. [#48360](https://github.com/ClickHouse/ClickHouse/pull/48360) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Small follow-up to [#45912](https://github.com/ClickHouse/ClickHouse/issues/45912) [#48373](https://github.com/ClickHouse/ClickHouse/pull/48373) ([Robert Schulze](https://github.com/rschu1ze)).
+* Update version_date.tsv and changelogs after v22.8.16.32-lts [#48376](https://github.com/ClickHouse/ClickHouse/pull/48376) ([robot-clickhouse](https://github.com/robot-clickhouse)).
+* Add script for a slack bot that reports broken tests [#48382](https://github.com/ClickHouse/ClickHouse/pull/48382) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Fix flaky `test_keeper_mntr_data_size` [#48384](https://github.com/ClickHouse/ClickHouse/pull/48384) ([Antonio Andelic](https://github.com/antonio2368)).
+* WITH FILL clarification and cleanup [#48395](https://github.com/ClickHouse/ClickHouse/pull/48395) ([Igor Nikonov](https://github.com/devcrafter)).
+* Cleanup mess in .clang-tidy [#48396](https://github.com/ClickHouse/ClickHouse/pull/48396) ([Robert Schulze](https://github.com/rschu1ze)).
+* Fix test_backup_all [#48400](https://github.com/ClickHouse/ClickHouse/pull/48400) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Find big allocations without memory limits checks  [#48401](https://github.com/ClickHouse/ClickHouse/pull/48401) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Fix issue with krb5 and building w/ OpenSSL [#48407](https://github.com/ClickHouse/ClickHouse/pull/48407) ([Boris Kuschel](https://github.com/bkuschel)).
+* Make CI slack bot less noisy [#48409](https://github.com/ClickHouse/ClickHouse/pull/48409) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* AST fuzzer: Fix assertion in TopK serialization [#48412](https://github.com/ClickHouse/ClickHouse/pull/48412) ([Robert Schulze](https://github.com/rschu1ze)).
+* Fix possible flakiness of lightweight delete tests (due to index granularity randomization) [#48413](https://github.com/ClickHouse/ClickHouse/pull/48413) ([Azat Khuzhin](https://github.com/azat)).
+* Fix flaky `test_keeper_snapshots` [#48417](https://github.com/ClickHouse/ClickHouse/pull/48417) ([Antonio Andelic](https://github.com/antonio2368)).
+* Update sort desc: more efficient original node search in ActionsDAG [#48427](https://github.com/ClickHouse/ClickHouse/pull/48427) ([Igor Nikonov](https://github.com/devcrafter)).
+* test for [#16399](https://github.com/ClickHouse/ClickHouse/issues/16399) [#48439](https://github.com/ClickHouse/ClickHouse/pull/48439) ([Denny Crane](https://github.com/den-crane)).
+* Better exception messages from Keeper client [#48444](https://github.com/ClickHouse/ClickHouse/pull/48444) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Small documentation follow-up to [#47246](https://github.com/ClickHouse/ClickHouse/issues/47246) [#48463](https://github.com/ClickHouse/ClickHouse/pull/48463) ([Robert Schulze](https://github.com/rschu1ze)).
+* Update 00002_log_and_exception_messages_formatting.sql [#48467](https://github.com/ClickHouse/ClickHouse/pull/48467) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Avoid operation on uninitialised data in readDateTimeTextImpl [#48472](https://github.com/ClickHouse/ClickHouse/pull/48472) ([Kruglov Pavel](https://github.com/Avogar)).
+* Add reading step for system zookeeper. Analyze path from filter DAG. [#48485](https://github.com/ClickHouse/ClickHouse/pull/48485) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Fix deadlock due to debug tracking of memory allocations [#48487](https://github.com/ClickHouse/ClickHouse/pull/48487) ([Azat Khuzhin](https://github.com/azat)).
+* Register datediff and trim aliases in system.functions [#48489](https://github.com/ClickHouse/ClickHouse/pull/48489) ([Robert Schulze](https://github.com/rschu1ze)).
+* Change error code [#48490](https://github.com/ClickHouse/ClickHouse/pull/48490) ([Anton Popov](https://github.com/CurtizJ)).
+* Update 00002_log_and_exception_messages_formatting.sql [#48499](https://github.com/ClickHouse/ClickHouse/pull/48499) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Fix query cache with sparse columns [#48500](https://github.com/ClickHouse/ClickHouse/pull/48500) ([Anton Popov](https://github.com/CurtizJ)).
+* Use std::string_view to get rid of strlen [#48509](https://github.com/ClickHouse/ClickHouse/pull/48509) ([ltrk2](https://github.com/ltrk2)).
+* Fix bytesSize() of zk SetRequest [#48512](https://github.com/ClickHouse/ClickHouse/pull/48512) ([Sergei Trifonov](https://github.com/serxa)).
+* Remove dead code and unused dependencies [#48518](https://github.com/ClickHouse/ClickHouse/pull/48518) ([ltrk2](https://github.com/ltrk2)).
+* Use forward declaration of ThreadPool [#48519](https://github.com/ClickHouse/ClickHouse/pull/48519) ([Azat Khuzhin](https://github.com/azat)).
+* Use std::string_view instead of strlen [#48520](https://github.com/ClickHouse/ClickHouse/pull/48520) ([ltrk2](https://github.com/ltrk2)).
+* Use std::string::starts_with instead of a roll your own variant [#48521](https://github.com/ClickHouse/ClickHouse/pull/48521) ([ltrk2](https://github.com/ltrk2)).
+* Fix flaky `test_alternative_keeper_config` [#48533](https://github.com/ClickHouse/ClickHouse/pull/48533) ([Antonio Andelic](https://github.com/antonio2368)).
+* Use one ThreadGroup while pushing to materialized views (and some refactoring for ThreadGroup) [#48543](https://github.com/ClickHouse/ClickHouse/pull/48543) ([Azat Khuzhin](https://github.com/azat)).
+* Fix some tests [#48550](https://github.com/ClickHouse/ClickHouse/pull/48550) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Fix 02477_projection_materialize_and_zero_copy flakiness (due to index granularity randomization) [#48551](https://github.com/ClickHouse/ClickHouse/pull/48551) ([Azat Khuzhin](https://github.com/azat)).
+* Better exception message for ZSTD [#48552](https://github.com/ClickHouse/ClickHouse/pull/48552) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Remove misleading comment and block [#48562](https://github.com/ClickHouse/ClickHouse/pull/48562) ([Sergei Trifonov](https://github.com/serxa)).
+* Update 02207_allow_plaintext_and_no_password.sh [#48566](https://github.com/ClickHouse/ClickHouse/pull/48566) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* bugfix: compare Bits and sizeof(Arithmetic) * 8 [#48569](https://github.com/ClickHouse/ClickHouse/pull/48569) ([caipengxiang](https://github.com/awfeequdng)).
+* Remove superfluous includes of logger_userful.h from headers [#48570](https://github.com/ClickHouse/ClickHouse/pull/48570) ([Azat Khuzhin](https://github.com/azat)).
+* Remove slow test from debug builds [#48574](https://github.com/ClickHouse/ClickHouse/pull/48574) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Don't use type conversion with String query parameters [#48577](https://github.com/ClickHouse/ClickHouse/pull/48577) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Fix TSan report in Kerberos [#48579](https://github.com/ClickHouse/ClickHouse/pull/48579) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Add second_deadlock_stack=1 for TSan on CI and fix some lock-order-inversion problems [#48596](https://github.com/ClickHouse/ClickHouse/pull/48596) ([Azat Khuzhin](https://github.com/azat)).
+* Fix LOGICAL_ERROR in executable table function [#48605](https://github.com/ClickHouse/ClickHouse/pull/48605) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Fix flakiness of test_store_cleanup in case of image rebuild [#48610](https://github.com/ClickHouse/ClickHouse/pull/48610) ([Azat Khuzhin](https://github.com/azat)).
+* Remove strange code [#48612](https://github.com/ClickHouse/ClickHouse/pull/48612) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Minor refactoring of formatDateTime() [#48627](https://github.com/ClickHouse/ClickHouse/pull/48627) ([Robert Schulze](https://github.com/rschu1ze)).
+* Better handling of values too large for VarInt encoding [#48628](https://github.com/ClickHouse/ClickHouse/pull/48628) ([Robert Schulze](https://github.com/rschu1ze)).
+* refine some messages of exception in regexp tree [#48632](https://github.com/ClickHouse/ClickHouse/pull/48632) ([Han Fei](https://github.com/hanfei1991)).
+* Partially revert e0252db8d and fix pr-bugfix labeling [#48637](https://github.com/ClickHouse/ClickHouse/pull/48637) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Fix build src/Interpreters/InterpreterInsertQuery.h [#48638](https://github.com/ClickHouse/ClickHouse/pull/48638) ([Vladimir C](https://github.com/vdimir)).
+* Fix build ThreadGroupPtr [#48641](https://github.com/ClickHouse/ClickHouse/pull/48641) ([Vladimir C](https://github.com/vdimir)).
+* Fix flaky test test_drop_replica_and_achieve_quorum [#48642](https://github.com/ClickHouse/ClickHouse/pull/48642) ([Kruglov Pavel](https://github.com/Avogar)).
+* fix 02504_regexp_dictionary_table_source [#48662](https://github.com/ClickHouse/ClickHouse/pull/48662) ([Han Fei](https://github.com/hanfei1991)).
+* Remove strange code from MutateTask [#48666](https://github.com/ClickHouse/ClickHouse/pull/48666) ([alesapin](https://github.com/alesapin)).
+* SonarCloud: C++ Reporting Standards [#48668](https://github.com/ClickHouse/ClickHouse/pull/48668) ([Julio Jimenez](https://github.com/juliojimenez)).
+* Remove lock for duplicated parts UUIDs (allow_experimental_query_deduplication=1) [#48670](https://github.com/ClickHouse/ClickHouse/pull/48670) ([Azat Khuzhin](https://github.com/azat)).
+* show result of minio listings for test test_attach_detach_partition [#48674](https://github.com/ClickHouse/ClickHouse/pull/48674) ([Sema Checherinda](https://github.com/CheSema)).
+* Fix tests for analyzer [#48675](https://github.com/ClickHouse/ClickHouse/pull/48675) ([Igor Nikonov](https://github.com/devcrafter)).
+* Call IProcessor::onCancel() once [#48687](https://github.com/ClickHouse/ClickHouse/pull/48687) ([Igor Nikonov](https://github.com/devcrafter)).
+* Update MergeTree syntax for optional index granularity argument [#48692](https://github.com/ClickHouse/ClickHouse/pull/48692) ([Robert Schulze](https://github.com/rschu1ze)).
+* Add test for old bug [#7826](https://github.com/ClickHouse/ClickHouse/issues/7826) [#48697](https://github.com/ClickHouse/ClickHouse/pull/48697) ([Robert Schulze](https://github.com/rschu1ze)).
+* Fix flaky `test_keeper_session` [#48699](https://github.com/ClickHouse/ClickHouse/pull/48699) ([Antonio Andelic](https://github.com/antonio2368)).
+* Better messages formatting in the CI Slack bot [#48712](https://github.com/ClickHouse/ClickHouse/pull/48712) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Add trusted contributors [#48715](https://github.com/ClickHouse/ClickHouse/pull/48715) ([Aleksei Filatov](https://github.com/aalexfvk)).
+* Do not remove broken detached parts on startup [#48730](https://github.com/ClickHouse/ClickHouse/pull/48730) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Remove `-Wshadow` suppression which leaked into global namespace [#48737](https://github.com/ClickHouse/ClickHouse/pull/48737) ([Robert Schulze](https://github.com/rschu1ze)).
+* VarInt coding: Always perform sanity check [#48740](https://github.com/ClickHouse/ClickHouse/pull/48740) ([Robert Schulze](https://github.com/rschu1ze)).
+* Try to fix flaky 02455_one_row_from_csv_memory_usage [#48756](https://github.com/ClickHouse/ClickHouse/pull/48756) ([Dmitry Novik](https://github.com/novikd)).
+* insert UInt32 Hashvalue in reverse order on big endian machine [#48764](https://github.com/ClickHouse/ClickHouse/pull/48764) ([Suzy Wang](https://github.com/SuzyWangIBMer)).
+* Limit size of messages from the CI slack bot [#48766](https://github.com/ClickHouse/ClickHouse/pull/48766) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Update README.md [#48776](https://github.com/ClickHouse/ClickHouse/pull/48776) ([Tyler Hannan](https://github.com/tylerhannan)).
+* Remove duplicate definition of SingleEndpointHTTPSessionPool [#48779](https://github.com/ClickHouse/ClickHouse/pull/48779) ([JaySon](https://github.com/JaySon-Huang)).
+* Fix flaky test_version_update_after_mutation/test.py::test_upgrade_while_mutation [#48783](https://github.com/ClickHouse/ClickHouse/pull/48783) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Fix flaky test test_backup_all [#48789](https://github.com/ClickHouse/ClickHouse/pull/48789) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Fix a confusing warning about interserver mode [#48793](https://github.com/ClickHouse/ClickHouse/pull/48793) ([Alexander Tokmakov](https://github.com/tavplubix)).
+* Store clusters from ClusterDiscovery in separate map [#48795](https://github.com/ClickHouse/ClickHouse/pull/48795) ([Vladimir C](https://github.com/vdimir)).
+* Reimplement [#48790](https://github.com/ClickHouse/ClickHouse/issues/48790) [#48797](https://github.com/ClickHouse/ClickHouse/pull/48797) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Allow running integration tests without spark [#48803](https://github.com/ClickHouse/ClickHouse/pull/48803) ([Vitaly Baranov](https://github.com/vitlibar)).
+* forbid gwpsan in debug mode to rescue stress tests [#48804](https://github.com/ClickHouse/ClickHouse/pull/48804) ([Han Fei](https://github.com/hanfei1991)).
+* Simplify FileCacheFactory [#48805](https://github.com/ClickHouse/ClickHouse/pull/48805) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Fix double whitespace in exception message [#48815](https://github.com/ClickHouse/ClickHouse/pull/48815) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Add a test for [#38128](https://github.com/ClickHouse/ClickHouse/issues/38128) [#48817](https://github.com/ClickHouse/ClickHouse/pull/48817) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Remove excessive logging [#48826](https://github.com/ClickHouse/ClickHouse/pull/48826) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* remove duplicate indentwith in clang-format [#48834](https://github.com/ClickHouse/ClickHouse/pull/48834) ([cluster](https://github.com/infdahai)).
+* Try fix flacky test_concurrent_alter_move_and_drop [#48843](https://github.com/ClickHouse/ClickHouse/pull/48843) ([Sergei Trifonov](https://github.com/serxa)).
+* fix the race wait loading parts [#48844](https://github.com/ClickHouse/ClickHouse/pull/48844) ([Sema Checherinda](https://github.com/CheSema)).
+* suppress assert of progress for test_system_replicated_fetches [#48856](https://github.com/ClickHouse/ClickHouse/pull/48856) ([Han Fei](https://github.com/hanfei1991)).
+* Fix: do not run test_store_cleanup_disk_s3 in parallel [#48863](https://github.com/ClickHouse/ClickHouse/pull/48863) ([Igor Nikonov](https://github.com/devcrafter)).
+* Update README.md [#48883](https://github.com/ClickHouse/ClickHouse/pull/48883) ([Tyler Hannan](https://github.com/tylerhannan)).
+* Fix test reference files for join using nullable column [#48893](https://github.com/ClickHouse/ClickHouse/pull/48893) ([Vladimir C](https://github.com/vdimir)).
+* bitNot marked as NO_SANITIZE_UNDEFINED [#48899](https://github.com/ClickHouse/ClickHouse/pull/48899) ([Vladimir C](https://github.com/vdimir)).
+* Fix order by in test_storage_delta [#48903](https://github.com/ClickHouse/ClickHouse/pull/48903) ([Vladimir C](https://github.com/vdimir)).
+* Fix segfault when set is not built yet [#48904](https://github.com/ClickHouse/ClickHouse/pull/48904) ([Alexander Gololobov](https://github.com/davenger)).
+* A non significant change (does not affect anything): add support for signed integers in the maskBits function [#48920](https://github.com/ClickHouse/ClickHouse/pull/48920) ([caipengxiang](https://github.com/awfeequdng)).
+* Follow-up to [#48866](https://github.com/ClickHouse/ClickHouse/issues/48866) [#48929](https://github.com/ClickHouse/ClickHouse/pull/48929) ([Robert Schulze](https://github.com/rschu1ze)).
+* Un-flake 01079_new_range_reader_segfault [#48934](https://github.com/ClickHouse/ClickHouse/pull/48934) ([Robert Schulze](https://github.com/rschu1ze)).
+* Add building stage to the fasttests report, respect existing status on rerun [#48935](https://github.com/ClickHouse/ClickHouse/pull/48935) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Update Settings.h [#48948](https://github.com/ClickHouse/ClickHouse/pull/48948) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Update cluster.py [#48949](https://github.com/ClickHouse/ClickHouse/pull/48949) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Docs: Replace annoying three spaces in enumerations by a single space [#48951](https://github.com/ClickHouse/ClickHouse/pull/48951) ([Robert Schulze](https://github.com/rschu1ze)).
+* Fix flaky 02706_arrow_different_dictionaries [#48952](https://github.com/ClickHouse/ClickHouse/pull/48952) ([Kruglov Pavel](https://github.com/Avogar)).
+* Use default `{replica}`, `{shard}` arguments in Replicated engine [#48961](https://github.com/ClickHouse/ClickHouse/pull/48961) ([Nikolay Degterinsky](https://github.com/evillique)).
+* Rename quantileApprox -> quantileGK [#48969](https://github.com/ClickHouse/ClickHouse/pull/48969) ([Vladimir C](https://github.com/vdimir)).
+* Don't throw logical error when column is not found in Parquet/Arrow schema [#48987](https://github.com/ClickHouse/ClickHouse/pull/48987) ([Kruglov Pavel](https://github.com/Avogar)).
+* Reimplement [#48986](https://github.com/ClickHouse/ClickHouse/issues/48986) [#49005](https://github.com/ClickHouse/ClickHouse/pull/49005) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Dont allow bad changelogs [#49006](https://github.com/ClickHouse/ClickHouse/pull/49006) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Update README.md [#49007](https://github.com/ClickHouse/ClickHouse/pull/49007) ([Nick-71](https://github.com/Nick-71)).
+* Remove outdated test [#49014](https://github.com/ClickHouse/ClickHouse/pull/49014) ([alesapin](https://github.com/alesapin)).
+* Fix typo [#49027](https://github.com/ClickHouse/ClickHouse/pull/49027) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Fix assertion after [#48636](https://github.com/ClickHouse/ClickHouse/issues/48636) [#49029](https://github.com/ClickHouse/ClickHouse/pull/49029) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Fix build error for big-endian platforms [#49037](https://github.com/ClickHouse/ClickHouse/pull/49037) ([ltrk2](https://github.com/ltrk2)).
+* Update version_date.tsv and changelogs after v22.8.17.17-lts [#49046](https://github.com/ClickHouse/ClickHouse/pull/49046) ([robot-clickhouse](https://github.com/robot-clickhouse)).
+* Update version_date.tsv and changelogs after v23.1.7.30-stable [#49047](https://github.com/ClickHouse/ClickHouse/pull/49047) ([robot-clickhouse](https://github.com/robot-clickhouse)).
+* Update version_date.tsv and changelogs after v23.3.2.37-lts [#49048](https://github.com/ClickHouse/ClickHouse/pull/49048) ([robot-clickhouse](https://github.com/robot-clickhouse)).
+* Remove some code [#49054](https://github.com/ClickHouse/ClickHouse/pull/49054) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Remove some dead code in poco [#49075](https://github.com/ClickHouse/ClickHouse/pull/49075) ([Robert Schulze](https://github.com/rschu1ze)).
+* Prevent false positive report by static analyzer [#49078](https://github.com/ClickHouse/ClickHouse/pull/49078) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
+* Update version_date.tsv and changelogs after v23.2.6.34-stable [#49080](https://github.com/ClickHouse/ClickHouse/pull/49080) ([robot-clickhouse](https://github.com/robot-clickhouse)).
+* Enforce documentation change for a new-feature PR [#49090](https://github.com/ClickHouse/ClickHouse/pull/49090) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Update clickhouse-test [#49094](https://github.com/ClickHouse/ClickHouse/pull/49094) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Disable long 02581 in debug, enable with sanitizers [#49105](https://github.com/ClickHouse/ClickHouse/pull/49105) ([Alexander Gololobov](https://github.com/davenger)).
+* Fix flaky integration test test_async_query_sending [#49107](https://github.com/ClickHouse/ClickHouse/pull/49107) ([Kruglov Pavel](https://github.com/Avogar)).
+* Correct functional test to reflect interoperability [#49108](https://github.com/ClickHouse/ClickHouse/pull/49108) ([ltrk2](https://github.com/ltrk2)).
+* Cleanup build guide [#49119](https://github.com/ClickHouse/ClickHouse/pull/49119) ([Robert Schulze](https://github.com/rschu1ze)).
+* Fix building iceberg without avro [#49125](https://github.com/ClickHouse/ClickHouse/pull/49125) ([Azat Khuzhin](https://github.com/azat)).
+* Add slash for close tag of user_defined_zookeeper_path [#49131](https://github.com/ClickHouse/ClickHouse/pull/49131) ([Hollin](https://github.com/Hooollin)).
+* Improve some lambdas [#49133](https://github.com/ClickHouse/ClickHouse/pull/49133) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Do not randomize prefetch settings for debug build [#49134](https://github.com/ClickHouse/ClickHouse/pull/49134) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Don't throw LOGICAL_ERROR when reading from remote if there is no local replica [#49136](https://github.com/ClickHouse/ClickHouse/pull/49136) ([Raúl Marín](https://github.com/Algunenano)).
+* Docs: Make caption of processors_profile_log page consistent with other pages [#49138](https://github.com/ClickHouse/ClickHouse/pull/49138) ([Robert Schulze](https://github.com/rschu1ze)).
+* Improve test reports [#49151](https://github.com/ClickHouse/ClickHouse/pull/49151) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Add a note regarding private/public repo to logs [#49152](https://github.com/ClickHouse/ClickHouse/pull/49152) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* suppress two timeout tests [#49175](https://github.com/ClickHouse/ClickHouse/pull/49175) ([Han Fei](https://github.com/hanfei1991)).
+* Document makeDateTime() and its variants [#49183](https://github.com/ClickHouse/ClickHouse/pull/49183) ([Robert Schulze](https://github.com/rschu1ze)).
+* Fix after [#49110](https://github.com/ClickHouse/ClickHouse/issues/49110) [#49206](https://github.com/ClickHouse/ClickHouse/pull/49206) ([Kseniia Sumarokova](https://github.com/kssenii)).
+
diff --git a/docs/en/development/build.md b/docs/en/development/build.md
index e3a63da6a3e..a55d44bdf93 100644
--- a/docs/en/development/build.md
+++ b/docs/en/development/build.md
@@ -22,7 +22,7 @@ The minimum recommended Ubuntu version for development is 22.04 LTS.
 ### Install Prerequisites {#install-prerequisites}
 
 ``` bash
-sudo apt-get install git cmake ccache python3 ninja-build yasm gawk
+sudo apt-get install git cmake ccache python3 ninja-build nasm yasm gawk
 ```
 
 ### Install and Use the Clang compiler
@@ -72,7 +72,7 @@ cmake -S . -B build
 cmake --build build  # or: `cd build; ninja`
 ```
 
-To create an executable, run `cmake --build --target clickhouse` (or: `cd build; ninja clickhouse`).
+To create an executable, run `cmake --build build --target clickhouse` (or: `cd build; ninja clickhouse`).
 This will create executable `build/programs/clickhouse` which can be used with `client` or `server` arguments.
 
 ## Building on Any Linux {#how-to-build-clickhouse-on-any-linux}
@@ -92,7 +92,7 @@ If all the components are installed, you may build in the same way as the steps
 Example for OpenSUSE Tumbleweed:
 
 ``` bash
-sudo zypper install git cmake ninja clang-c++ python lld yasm gawk
+sudo zypper install git cmake ninja clang-c++ python lld nasm yasm gawk
 git clone --recursive https://github.com/ClickHouse/ClickHouse.git
 mkdir build
 cmake -S . -B build
@@ -103,7 +103,7 @@ Example for Fedora Rawhide:
 
 ``` bash
 sudo yum update
-sudo yum --nogpg install git cmake make clang python3 ccache yasm gawk
+sudo yum --nogpg install git cmake make clang python3 ccache nasm yasm gawk
 git clone --recursive https://github.com/ClickHouse/ClickHouse.git
 mkdir build
 cmake -S . -B build
diff --git a/docs/en/operations/settings/constraints-on-settings.md b/docs/en/operations/settings/constraints-on-settings.md
index 83ef46053a4..1895a79cd3e 100644
--- a/docs/en/operations/settings/constraints-on-settings.md
+++ b/docs/en/operations/settings/constraints-on-settings.md
@@ -40,7 +40,7 @@ If the user tries to violate the constraints an exception is thrown and the sett
 There are supported few types of constraints: `min`, `max`, `readonly` (with alias `const`) and `changeable_in_readonly`. The `min` and `max` constraints specify upper and lower boundaries for a numeric setting and can be used in combination. The `readonly` or `const` constraint specifies that the user cannot change the corresponding setting at all. The `changeable_in_readonly` constraint type allows user to change the setting within `min`/`max` range even if `readonly` setting is set to 1, otherwise settings are not allow to be changed in `readonly=1` mode. Note that `changeable_in_readonly` is supported only if `settings_constraints_replace_previous` is enabled:
 ``` xml
 <access_control_improvements>
-  <settings_constraints_replace_previous>true<settings_constraints_replace_previous>
+  <settings_constraints_replace_previous>true</settings_constraints_replace_previous>
 </access_control_improvements>
 ```
 
diff --git a/docs/en/operations/settings/settings.md b/docs/en/operations/settings/settings.md
index 66a24ac3fca..c6fdcf317c3 100644
--- a/docs/en/operations/settings/settings.md
+++ b/docs/en/operations/settings/settings.md
@@ -890,7 +890,7 @@ Write time that processor spent during execution/waiting for data to `system.pro
 
 See also:
 
-- [`system.processors_profile_log`](../../operations/system-tables/processors_profile_log.md#system-processors_profile_log)
+- [`system.processors_profile_log`](../../operations/system-tables/processors_profile_log.md)
 - [`EXPLAIN PIPELINE`](../../sql-reference/statements/explain.md#explain-pipeline)
 
 ## max_insert_block_size {#settings-max_insert_block_size}
diff --git a/docs/en/operations/system-tables/processors_profile_log.md b/docs/en/operations/system-tables/processors_profile_log.md
index e849525e495..a6ff15642a1 100644
--- a/docs/en/operations/system-tables/processors_profile_log.md
+++ b/docs/en/operations/system-tables/processors_profile_log.md
@@ -1,4 +1,4 @@
-# system.processors_profile_log {#system-processors_profile_log}
+# processors_profile_log
 
 This table contains profiling on processors level (that you can find in [`EXPLAIN PIPELINE`](../../sql-reference/statements/explain.md#explain-pipeline)).
 
@@ -73,4 +73,4 @@ Here you can see:
 
 **See Also**
 
-- [`EXPLAIN PIPELINE`](../../sql-reference/statements/explain.md#explain-pipeline)
\ No newline at end of file
+- [`EXPLAIN PIPELINE`](../../sql-reference/statements/explain.md#explain-pipeline)
diff --git a/docs/en/sql-reference/aggregate-functions/reference/kolmogorovsmirnovtest.md b/docs/en/sql-reference/aggregate-functions/reference/kolmogorovsmirnovtest.md
new file mode 100644
index 00000000000..3da9645181e
--- /dev/null
+++ b/docs/en/sql-reference/aggregate-functions/reference/kolmogorovsmirnovtest.md
@@ -0,0 +1,118 @@
+---
+slug: /en/sql-reference/aggregate-functions/reference/kolmogorovsmirnovtest
+sidebar_position: 300
+sidebar_label: kolmogorovSmirnovTest
+---
+
+# kolmogorovSmirnovTest
+
+Applies Kolmogorov-Smirnov's test to samples from two populations.
+
+**Syntax**
+
+``` sql
+kolmogorovSmirnovTest([alternative, computation_method])(sample_data, sample_index)
+```
+
+Values of both samples are in the `sample_data` column. If `sample_index` equals to 0 then the value in that row belongs to the sample from the first population. Otherwise it belongs to the sample from the second population.
+Samples must belong to continuous, one-dimensional probability distributions.
+
+**Arguments**
+
+- `sample_data` — Sample data. [Integer](../../../sql-reference/data-types/int-uint.md), [Float](../../../sql-reference/data-types/float.md) or [Decimal](../../../sql-reference/data-types/decimal.md).
+- `sample_index` — Sample index. [Integer](../../../sql-reference/data-types/int-uint.md).
+
+**Parameters**
+
+- `alternative` — alternative hypothesis. (Optional, default: `'two-sided'`.) [String](../../../sql-reference/data-types/string.md).
+    Let F(x) and G(x) be the CDFs of the first and second distributions respectively.
+    - `'two-sided'`
+        The null hypothesis is that samples come from the same distribution, e.g. F(x) = G(x) for all x.
+        And the alternative is that the distributions are not identical.
+    - `'greater'`
+        The null hypothesis is that values in the first sample are *stohastically smaller* than those in the second one,
+        e.g. the CDF of first distribution lies above and hence to the left of that for the second one.
+        Which in fact means that F(x) >= G(x) for all x. And the alternative in this case is that F(x) < G(x) for at least one x.
+    - `'less'`.
+        The null hypothesis is that values in the first sample are *stohastically greater* than those in the second one,
+        e.g. the CDF of first distribution lies below and hence to the right of that for the second one.
+        Which in fact means that F(x) <= G(x) for all x. And the alternative in this case is that F(x) > G(x) for at least one x.
+- `computation_method` — the method used to compute p-value. (Optional, default: `'auto'`.) [String](../../../sql-reference/data-types/string.md).
+    - `'exact'` - calculation is performed using precise probability distribution of the test statistics. Compute intensive and wasteful except for small samples.
+    - `'asymp'` (`'asymptotic'`) - calculation is performed using an approximation. For large sample sizes, the exact and asymptotic p-values are very similar.
+    - `'auto'`  - the `'exact'` method is used when a maximum number of samples is less than 10'000.
+
+
+**Returned values**
+
+[Tuple](../../../sql-reference/data-types/tuple.md) with two elements:
+
+- calculated statistic. [Float64](../../../sql-reference/data-types/float.md).
+- calculated p-value. [Float64](../../../sql-reference/data-types/float.md).
+
+
+**Example**
+
+Query:
+
+``` sql
+SELECT kolmogorovSmirnovTest('less', 'exact')(value, num)
+FROM
+(
+    SELECT
+        randNormal(0, 10) AS value,
+        0 AS num
+    FROM numbers(10000)
+    UNION ALL
+    SELECT
+        randNormal(0, 10) AS value,
+        1 AS num
+    FROM numbers(10000)
+)
+```
+
+Result:
+
+``` text
+┌─kolmogorovSmirnovTest('less', 'exact')(value, num)─┐
+│ (0.009899999999999996,0.37528595205132287)         │
+└────────────────────────────────────────────────────┘
+```
+
+Note:
+P-value is bigger than 0.05 (for confidence level of 95%), so null hypothesis is not rejected.
+
+
+Query:
+
+``` sql
+SELECT kolmogorovSmirnovTest('two-sided', 'exact')(value, num)
+FROM
+(
+    SELECT
+        randStudentT(10) AS value,
+        0 AS num
+    FROM numbers(100)
+    UNION ALL
+    SELECT
+        randNormal(0, 10) AS value,
+        1 AS num
+    FROM numbers(100)
+)
+```
+
+Result:
+
+``` text
+┌─kolmogorovSmirnovTest('two-sided', 'exact')(value, num)─┐
+│ (0.4100000000000002,6.61735760482795e-8)                │
+└─────────────────────────────────────────────────────────┘
+```
+
+Note:
+P-value is less than 0.05 (for confidence level of 95%), so null hypothesis is rejected.
+
+
+**See Also**
+
+- [Kolmogorov-Smirnov'test](https://en.wikipedia.org/wiki/Kolmogorov%E2%80%93Smirnov_test)
diff --git a/docs/en/sql-reference/data-types/index.md b/docs/en/sql-reference/data-types/index.md
index c61a3069db6..2ad8ac4bb23 100644
--- a/docs/en/sql-reference/data-types/index.md
+++ b/docs/en/sql-reference/data-types/index.md
@@ -27,7 +27,7 @@ ClickHouse data types include:
 - **Aggregation function types**: use [`SimpleAggregateFunction`](./simpleaggregatefunction.md) and [`AggregateFunction`](./aggregatefunction.md) for storing the intermediate status of aggregate function results
 - **Nested data structures**: A [`Nested` data structure](./nested-data-structures/index.md) is like a table inside a cell
 - **Tuples**: A [`Tuple` of elements](./tuple.md), each having an individual type.
-- **Nullable**: [`Nullbale`](./nullable.md) allows you to store a value as `NULL` when a value is "missing" (instead of the column gettings its default value for the data type)
+- **Nullable**: [`Nullable`](./nullable.md) allows you to store a value as `NULL` when a value is "missing" (instead of the column gettings its default value for the data type)
 - **IP addresses**: use [`IPv4`](./domains/ipv4.md) and [`IPv6`](./domains/ipv6.md) to efficiently store IP addresses
 - **Geo types**: for[ geographical data](./geo.md), including `Point`, `Ring`, `Polygon` and `MultiPolygon`
 - **Special data types**: including [`Expression`](./special-data-types/expression.md), [`Set`](./special-data-types/set.md), [`Nothing`](./special-data-types/nothing.md) and [`Interval`](./special-data-types/interval.md)
\ No newline at end of file
diff --git a/docs/en/sql-reference/dictionaries/index.md b/docs/en/sql-reference/dictionaries/index.md
index 48a8ce45d33..189673cdae7 100644
--- a/docs/en/sql-reference/dictionaries/index.md
+++ b/docs/en/sql-reference/dictionaries/index.md
@@ -1658,6 +1658,7 @@ Example of settings:
         <password></password>
         <db>test</db>
         <collection>dictionary_source</collection>
+        <options>ssl=true</options>
     </mongodb>
 </source>
 ```
@@ -1672,6 +1673,7 @@ SOURCE(MONGODB(
     password ''
     db 'test'
     collection 'dictionary_source'
+    options 'ssl=true'
 ))
 ```
 
@@ -1683,6 +1685,8 @@ Setting fields:
 - `password` – Password of the MongoDB user.
 - `db` – Name of the database.
 - `collection` – Name of the collection.
+- `options` -  MongoDB connection string options (optional parameter).
+
 
 ### Redis
 
diff --git a/docs/en/sql-reference/functions/date-time-functions.md b/docs/en/sql-reference/functions/date-time-functions.md
index c22b46a7eea..15644b54c2b 100644
--- a/docs/en/sql-reference/functions/date-time-functions.md
+++ b/docs/en/sql-reference/functions/date-time-functions.md
@@ -24,6 +24,90 @@ SELECT
 └─────────────────────┴────────────┴────────────┴─────────────────────┘
 ```
 
+## makeDate
+
+Creates a [Date](../../sql-reference/data-types/date.md) from a year, month and day argument.
+
+**Syntax**
+
+``` sql
+makeDate(year, month, day)
+```
+
+**Arguments**
+
+- `year` — Year. [Integer](../../sql-reference/data-types/int-uint.md), [Float](../../sql-reference/data-types/float.md) or [Decimal](../../sql-reference/data-types/decimal.md).
+- `month` — Month. [Integer](../../sql-reference/data-types/int-uint.md), [Float](../../sql-reference/data-types/float.md) or [Decimal](../../sql-reference/data-types/decimal.md).
+- `day` — Day. [Integer](../../sql-reference/data-types/int-uint.md), [Float](../../sql-reference/data-types/float.md) or [Decimal](../../sql-reference/data-types/decimal.md).
+
+**Returned value**
+
+- A date created from the arguments.
+
+Type: [Date](../../sql-reference/data-types/date.md).
+
+**Example**
+
+``` sql
+SELECT makeDate(2023, 2, 28) AS Date;
+```
+
+Result:
+
+``` text
+┌───────date─┐
+│ 2023-02-28 │
+└────────────┘
+```
+
+## makeDate32
+
+Like [makeDate](#makeDate) but produces a [Date32](../../sql-reference/data-types/date32.md).
+
+## makeDateTime
+
+Creates a [DateTime](../../sql-reference/data-types/datetime.md) from a year, month, day, hour, minute and second argument.
+
+**Syntax**
+
+``` sql
+makeDateTime(year, month, day, hour, minute, second[, timezone])
+```
+
+**Arguments**
+
+- `year` — Year. [Integer](../../sql-reference/data-types/int-uint.md), [Float](../../sql-reference/data-types/float.md) or [Decimal](../../sql-reference/data-types/decimal.md).
+- `month` — Month. [Integer](../../sql-reference/data-types/int-uint.md), [Float](../../sql-reference/data-types/float.md) or [Decimal](../../sql-reference/data-types/decimal.md).
+- `day` — Day. [Integer](../../sql-reference/data-types/int-uint.md), [Float](../../sql-reference/data-types/float.md) or [Decimal](../../sql-reference/data-types/decimal.md).
+- `hour` — Hour. [Integer](../../sql-reference/data-types/int-uint.md), [Float](../../sql-reference/data-types/float.md) or [Decimal](../../sql-reference/data-types/decimal.md).
+- `minute` — Minute. [Integer](../../sql-reference/data-types/int-uint.md), [Float](../../sql-reference/data-types/float.md) or [Decimal](../../sql-reference/data-types/decimal.md).
+- `second` — Second. [Integer](../../sql-reference/data-types/int-uint.md), [Float](../../sql-reference/data-types/float.md) or [Decimal](../../sql-reference/data-types/decimal.md).
+- `timezone` — [Timezone](../../operations/server-configuration-parameters/settings.md#server_configuration_parameters-timezone) for the returned value (optional).
+
+**Returned value**
+
+- A date with time created from the arguments.
+
+Type: [DateTime](../../sql-reference/data-types/datetime.md).
+
+**Example**
+
+``` sql
+SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;
+```
+
+Result:
+
+``` text
+┌────────────DateTime─┐
+│ 2023-02-28 17:12:33 │
+└─────────────────────┘
+```
+
+## makeDateTime64
+
+Like [makeDateTime](#makedatetime) but produces a [DateTime64](../../sql-reference/data-types/datetime64.md).
+
 ## timeZone
 
 Returns the timezone of the server.
diff --git a/docs/en/sql-reference/statements/alter/partition.md b/docs/en/sql-reference/statements/alter/partition.md
index 2fb20e4e462..52e99d93109 100644
--- a/docs/en/sql-reference/statements/alter/partition.md
+++ b/docs/en/sql-reference/statements/alter/partition.md
@@ -109,7 +109,7 @@ For the query to run successfully, the following conditions must be met:
 
 - Both tables must have the same structure.
 - Both tables must have the same partition key, the same order by key and the same primary key.
-- Both tables must have the same storage policy (a disk where the partition is stored should be available for both tables).
+- Both tables must have the same storage policy.
 
 ## REPLACE PARTITION
 
@@ -123,7 +123,7 @@ For the query to run successfully, the following conditions must be met:
 
 - Both tables must have the same structure.
 - Both tables must have the same partition key, the same order by key and the same primary key.
-- Both tables must have the same storage policy (a disk where the partition is stored should be available for both tables).
+- Both tables must have the same storage policy.
 
 ## MOVE PARTITION TO TABLE
 
@@ -137,7 +137,7 @@ For the query to run successfully, the following conditions must be met:
 
 - Both tables must have the same structure.
 - Both tables must have the same partition key, the same order by key and the same primary key.
-- Both tables must have the same storage policy (a disk where the partition is stored should be available for both tables).
+- Both tables must have the same storage policy.
 - Both tables must be the same engine family (replicated or non-replicated).
 
 ## CLEAR COLUMN IN PARTITION
diff --git a/docs/en/sql-reference/statements/create/user.md b/docs/en/sql-reference/statements/create/user.md
index 3548ef7cc07..22322062128 100644
--- a/docs/en/sql-reference/statements/create/user.md
+++ b/docs/en/sql-reference/statements/create/user.md
@@ -92,6 +92,20 @@ There are multiple ways of user identification:
     CREATE USER name4 IDENTIFIED WITH double_sha1_hash BY 'CCD3A959D6A004B9C3807B728BC2E55B67E10518'
     ```
 
+5. The type of the password can also be omitted:
+
+    ```sql
+    CREATE USER name4 IDENTIFIED BY 'my_password'
+    ```
+
+    In this case, ClickHouse will use the default password type specified in the server configuration:
+
+    ```xml
+    <default_password_type>sha256_password</default_password_type>
+    ```
+
+    The available password types are: `plaintext_password`, `sha256_password`, `double_sha1_password`.
+
 ## User Host
 
 User host is a host from which a connection to ClickHouse server could be established. The host can be specified in the `HOST` query section in the following ways:
diff --git a/docs/ru/sql-reference/aggregate-functions/reference/kolmogorovsmirnovtest.md b/docs/ru/sql-reference/aggregate-functions/reference/kolmogorovsmirnovtest.md
new file mode 100644
index 00000000000..2f8c6bb6760
--- /dev/null
+++ b/docs/ru/sql-reference/aggregate-functions/reference/kolmogorovsmirnovtest.md
@@ -0,0 +1,117 @@
+---
+slug: /ru/sql-reference/aggregate-functions/reference/kolmogorovsmirnovtest
+sidebar_position: 300
+sidebar_label: kolmogorovSmirnovTest
+---
+
+# kolmogorovSmirnovTest {#kolmogorovSmirnovTest}
+
+Проводит статистический тест Колмогорова-Смирнова для двух независимых выборок.
+
+**Синтаксис**
+
+``` sql
+kolmogorovSmirnovTest([alternative, computation_method])(sample_data, sample_index)
+```
+
+Значения выборок берутся из столбца `sample_data`. Если  `sample_index` равно 0, то значение из этой строки принадлежит первой выборке. Во всех остальных случаях значение принадлежит второй выборке.
+Выборки должны принадлежать непрерывным одномерным распределениям.
+
+**Аргументы**
+
+-   `sample_data` — данные выборок. [Integer](../../../sql-reference/data-types/int-uint.md), [Float](../../../sql-reference/data-types/float.md) or [Decimal](../../../sql-reference/data-types/decimal.md).
+-   `sample_index` — индексы выборок. [Integer](../../../sql-reference/data-types/int-uint.md).
+
+**Параметры**
+
+- `alternative` — альтернативная гипотеза (Необязательный параметр, по умолчанию: `'two-sided'`.) [String](../../../sql-reference/data-types/string.md).
+    Пусть F(x) и G(x) - функции распределения первой и второй выборки соотвественно.
+    - `'two-sided'`
+        Нулевая гипотеза состоит в том, что выборки происходит из одного и того же распределение, то есть F(x) = G(x) для любого x.
+        Альтернатива - выборки принадлежат разным распределениям.
+    - `'greater'`
+        Нулевая гипотеза состоит в том, что элементы первой выборки в асимптотически почти наверное меньше элементов из второй выборки,
+        то есть функция распределения первой выборки лежит выше и соотвественно левее, чем функция распределения второй выборки.
+        Таким образом это означает, что F(x) >= G(x) for любого x, а альтернатива в этом случае состоит в том, что F(x) < G(x) хотя бы для одного x.
+    - `'less'`.
+        Нулевая гипотеза состоит в том, что элементы первой выборки в асимптотически почти наверное больше элементов из второй выборки,
+        то есть функция распределения первой выборки лежит ниже и соотвественно правее, чем функция распределения второй выборки.
+        Таким образом это означает, что F(x) <= G(x) for любого x, а альтернатива в этом случае состоит в том, что F(x) > G(x) хотя бы для одного x.
+- `computation_method` — метод, используемый для вычисления p-value. (Необязательный параметр, по умолчанию: `'auto'`.) [String](../../../sql-reference/data-types/string.md).
+    - `'exact'` - вычисление производится с помощью вычисления точного распределения статистики. Требует большого количества вычислительных ресурсов и расточительно для больших выборок.
+    - `'asymp'`(`'asymptotic'`) - используется приближенное вычисление. Для больших выборок приближенный результат и точный почти идентичны.
+    - `'auto'`  - значение вычисляется точно (с помощью метода `'exact'`), если максимальный размер двух выборок не превышает 10'000.
+
+**Возвращаемые значения**
+
+[Кортеж](../../../sql-reference/data-types/tuple.md) с двумя элементами:
+
+-   вычисленное статистики. [Float64](../../../sql-reference/data-types/float.md).
+-   вычисленное p-value. [Float64](../../../sql-reference/data-types/float.md).
+
+
+**Пример**
+
+Запрос:
+
+``` sql
+SELECT kolmogorovSmirnovTest('less', 'exact')(value, num)
+FROM
+(
+    SELECT
+        randNormal(0, 10) AS value,
+        0 AS num
+    FROM numbers(10000)
+    UNION ALL
+    SELECT
+        randNormal(0, 10) AS value,
+        1 AS num
+    FROM numbers(10000)
+)
+```
+
+Результат:
+
+``` text
+┌─kolmogorovSmirnovTest('less', 'exact')(value, num)─┐
+│ (0.009899999999999996,0.37528595205132287)         │
+└────────────────────────────────────────────────────┘
+```
+
+Заметки:
+P-value больше чем 0.05 (для уровня значимости 95%), то есть нулевая гипотеза не отвергается.
+
+
+Запрос:
+
+``` sql
+SELECT kolmogorovSmirnovTest('two-sided', 'exact')(value, num)
+FROM
+(
+    SELECT
+        randStudentT(10) AS value,
+        0 AS num
+    FROM numbers(100)
+    UNION ALL
+    SELECT
+        randNormal(0, 10) AS value,
+        1 AS num
+    FROM numbers(100)
+)
+```
+
+Результат:
+
+``` text
+┌─kolmogorovSmirnovTest('two-sided', 'exact')(value, num)─┐
+│ (0.4100000000000002,6.61735760482795e-8)                │
+└─────────────────────────────────────────────────────────┘
+```
+
+Заметки:
+P-value меньше чем 0.05 (для уровня значимости 95%), то есть нулевая гипотеза отвергается.
+
+
+**Смотрите также**
+
+- [Критерий согласия Колмогорова-Смирнова](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D1%82%D0%B5%D1%80%D0%B8%D0%B9_%D1%81%D0%BE%D0%B3%D0%BB%D0%B0%D1%81%D0%B8%D1%8F_%D0%9A%D0%BE%D0%BB%D0%BC%D0%BE%D0%B3%D0%BE%D1%80%D0%BE%D0%B2%D0%B0)
diff --git a/programs/local/LocalServer.cpp b/programs/local/LocalServer.cpp
index 5768e744f94..bbfd73af476 100644
--- a/programs/local/LocalServer.cpp
+++ b/programs/local/LocalServer.cpp
@@ -26,6 +26,7 @@
 #include <Common/TLDListsHolder.h>
 #include <Common/quoteString.h>
 #include <Common/randomSeed.h>
+#include <Common/ThreadPool.h>
 #include <Loggers/Loggers.h>
 #include <IO/ReadBufferFromFile.h>
 #include <IO/ReadBufferFromString.h>
diff --git a/programs/server/config.xml b/programs/server/config.xml
index 7a75d7251a9..fb2f3400b45 100644
--- a/programs/server/config.xml
+++ b/programs/server/config.xml
@@ -476,6 +476,11 @@
     <allow_no_password>1</allow_no_password>
     <allow_implicit_no_password>1</allow_implicit_no_password>
 
+    <!-- When a user does not specify a password type in the CREATE USER query, the default password type is used.
+         Accepted values are: 'plaintext_password', 'sha256_password', and 'double_sha1_password'.
+      -->
+    <default_password_type>sha256_password</default_password_type>
+
     <!-- Complexity requirements for user passwords. -->
     <!-- <password_complexity>
         <rule>
@@ -1293,7 +1298,7 @@
 
     <!-- Path in ZooKeeper to store user-defined SQL functions created by the command CREATE FUNCTION.
      If not specified they will be stored locally. -->
-    <!-- <user_defined_zookeeper_path>/clickhouse/user_defined<user_defined_zookeeper_path> -->
+    <!-- <user_defined_zookeeper_path>/clickhouse/user_defined</user_defined_zookeeper_path> -->
 
     <!-- Uncomment if you want data to be compressed 30-100% better.
          Don't do that if you just started using ClickHouse.
diff --git a/src/Access/AccessControl.cpp b/src/Access/AccessControl.cpp
index 875f4965e0b..f8e7fe3be82 100644
--- a/src/Access/AccessControl.cpp
+++ b/src/Access/AccessControl.cpp
@@ -271,6 +271,7 @@ void AccessControl::setUpFromMainConfig(const Poco::Util::AbstractConfiguration
     setImplicitNoPasswordAllowed(config_.getBool("allow_implicit_no_password", true));
     setNoPasswordAllowed(config_.getBool("allow_no_password", true));
     setPlaintextPasswordAllowed(config_.getBool("allow_plaintext_password", true));
+    setDefaultPasswordTypeFromConfig(config_.getString("default_password_type", "sha256_password"));
     setPasswordComplexityRulesFromConfig(config_);
 
     /// Optional improvements in access control system.
@@ -653,6 +654,27 @@ bool AccessControl::isPlaintextPasswordAllowed() const
     return allow_plaintext_password;
 }
 
+void AccessControl::setDefaultPasswordTypeFromConfig(const String & type_)
+{
+    for (auto check_type : collections::range(AuthenticationType::MAX))
+    {
+        const auto & info = AuthenticationTypeInfo::get(check_type);
+
+        if (type_ == info.name && info.is_password)
+        {
+            default_password_type = check_type;
+            return;
+        }
+    }
+
+    throw Exception(ErrorCodes::UNKNOWN_ELEMENT_IN_CONFIG, "Unknown password type in 'default_password_type' in config");
+}
+
+AuthenticationType AccessControl::getDefaultPasswordType() const
+{
+    return default_password_type;
+}
+
 void AccessControl::setPasswordComplexityRulesFromConfig(const Poco::Util::AbstractConfiguration & config_)
 {
     password_rules->setPasswordComplexityRulesFromConfig(config_);
diff --git a/src/Access/AccessControl.h b/src/Access/AccessControl.h
index 957a2483cd1..0e172c4a601 100644
--- a/src/Access/AccessControl.h
+++ b/src/Access/AccessControl.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Access/MultipleAccessStorage.h>
+#include <Access/Common/AuthenticationType.h>
 #include <Common/SettingsChanges.h>
 #include <Common/ZooKeeper/Common.h>
 #include <base/scope_guard.h>
@@ -147,8 +148,11 @@ public:
     void setPlaintextPasswordAllowed(const bool allow_plaintext_password_);
     bool isPlaintextPasswordAllowed() const;
 
-    /// Check complexity requirements for plaintext passwords
+    /// Default password type when the user does not specify it.
+    void setDefaultPasswordTypeFromConfig(const String & type_);
+    AuthenticationType getDefaultPasswordType() const;
 
+    /// Check complexity requirements for passwords
     void setPasswordComplexityRulesFromConfig(const Poco::Util::AbstractConfiguration & config_);
     void setPasswordComplexityRules(const std::vector<std::pair<String, String>> & rules_);
     void checkPasswordComplexityRules(const String & password_) const;
@@ -242,6 +246,7 @@ private:
     std::atomic_bool select_from_system_db_requires_grant = false;
     std::atomic_bool select_from_information_schema_requires_grant = false;
     std::atomic_bool settings_constraints_replace_previous = false;
+    std::atomic<AuthenticationType> default_password_type = AuthenticationType::SHA256_PASSWORD;
 };
 
 }
diff --git a/src/Access/Authentication.cpp b/src/Access/Authentication.cpp
index b9bc0ee961c..ecef436da9d 100644
--- a/src/Access/Authentication.cpp
+++ b/src/Access/Authentication.cpp
@@ -1,5 +1,5 @@
 #include <Access/Authentication.h>
-#include <Access/Common/AuthenticationData.h>
+#include <Access/AuthenticationData.h>
 #include <Access/Credentials.h>
 #include <Access/ExternalAuthenticators.h>
 #include <Access/LDAPClient.h>
diff --git a/src/Access/Authentication.h b/src/Access/Authentication.h
index ab787851cb2..d1e00a28ebb 100644
--- a/src/Access/Authentication.h
+++ b/src/Access/Authentication.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Access/Common/AuthenticationData.h>
+#include <Access/AuthenticationData.h>
 #include <Common/Exception.h>
 #include <base/types.h>
 
diff --git a/src/Access/Common/AuthenticationData.cpp b/src/Access/AuthenticationData.cpp
similarity index 52%
rename from src/Access/Common/AuthenticationData.cpp
rename to src/Access/AuthenticationData.cpp
index 0a22eeb92b3..376649811f8 100644
--- a/src/Access/Common/AuthenticationData.cpp
+++ b/src/Access/AuthenticationData.cpp
@@ -1,11 +1,26 @@
-#include <Access/Common/AuthenticationData.h>
+#include <Access/AccessControl.h>
+#include <Access/AuthenticationData.h>
 #include <Common/Exception.h>
+#include <Interpreters/Context.h>
+#include <Interpreters/evaluateConstantExpression.h>
+#include <Parsers/ASTExpressionList.h>
+#include <Parsers/ASTLiteral.h>
+#include <Storages/checkAndGetLiteralArgument.h>
+
 #include <Common/OpenSSLHelpers.h>
 #include <Poco/SHA1Engine.h>
 #include <base/types.h>
 #include <boost/algorithm/hex.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
 
+#include "config.h"
+
+#if USE_SSL
+#     include <openssl/crypto.h>
+#     include <openssl/rand.h>
+#     include <openssl/err.h>
+#endif
+
 
 namespace DB
 {
@@ -15,62 +30,9 @@ namespace ErrorCodes
     extern const int BAD_ARGUMENTS;
     extern const int LOGICAL_ERROR;
     extern const int NOT_IMPLEMENTED;
+    extern const int OPENSSL_ERROR;
 }
 
-
-const AuthenticationTypeInfo & AuthenticationTypeInfo::get(AuthenticationType type_)
-{
-    static constexpr auto make_info = [](const char * raw_name_)
-    {
-        String init_name = raw_name_;
-        boost::to_lower(init_name);
-        return AuthenticationTypeInfo{raw_name_, std::move(init_name)};
-    };
-
-    switch (type_)
-    {
-        case AuthenticationType::NO_PASSWORD:
-        {
-            static const auto info = make_info("NO_PASSWORD");
-            return info;
-        }
-        case AuthenticationType::PLAINTEXT_PASSWORD:
-        {
-            static const auto info = make_info("PLAINTEXT_PASSWORD");
-            return info;
-        }
-        case AuthenticationType::SHA256_PASSWORD:
-        {
-            static const auto info = make_info("SHA256_PASSWORD");
-            return info;
-        }
-        case AuthenticationType::DOUBLE_SHA1_PASSWORD:
-        {
-            static const auto info = make_info("DOUBLE_SHA1_PASSWORD");
-            return info;
-        }
-        case AuthenticationType::LDAP:
-        {
-            static const auto info = make_info("LDAP");
-            return info;
-        }
-        case AuthenticationType::KERBEROS:
-        {
-            static const auto info = make_info("KERBEROS");
-            return info;
-        }
-        case AuthenticationType::SSL_CERTIFICATE:
-        {
-            static const auto info = make_info("SSL_CERTIFICATE");
-            return info;
-        }
-        case AuthenticationType::MAX:
-            break;
-    }
-    throw Exception(ErrorCodes::LOGICAL_ERROR, "Unknown authentication type: {}", static_cast<int>(type_));
-}
-
-
 AuthenticationData::Digest AuthenticationData::Util::encodeSHA256(std::string_view text [[maybe_unused]])
 {
 #if USE_SSL
@@ -225,4 +187,172 @@ void AuthenticationData::setSSLCertificateCommonNames(boost::container::flat_set
     ssl_certificate_common_names = std::move(common_names_);
 }
 
+std::shared_ptr<ASTAuthenticationData> AuthenticationData::toAST() const
+{
+    auto node = std::make_shared<ASTAuthenticationData>();
+    auto auth_type = getType();
+    node->type = auth_type;
+
+    switch (auth_type)
+    {
+        case AuthenticationType::PLAINTEXT_PASSWORD:
+        {
+            node->contains_password = true;
+            node->children.push_back(std::make_shared<ASTLiteral>(getPassword()));
+            break;
+        }
+        case AuthenticationType::SHA256_PASSWORD:
+        {
+            node->contains_hash = true;
+            node->children.push_back(std::make_shared<ASTLiteral>(getPasswordHashHex()));
+
+            if (!getSalt().empty())
+                node->children.push_back(std::make_shared<ASTLiteral>(getSalt()));
+            break;
+        }
+        case AuthenticationType::DOUBLE_SHA1_PASSWORD:
+        {
+            node->contains_hash = true;
+            node->children.push_back(std::make_shared<ASTLiteral>(getPasswordHashHex()));
+            break;
+        }
+        case AuthenticationType::LDAP:
+        {
+            node->children.push_back(std::make_shared<ASTLiteral>(getLDAPServerName()));
+            break;
+        }
+        case AuthenticationType::KERBEROS:
+        {
+            const auto & realm = getKerberosRealm();
+
+            if (!realm.empty())
+                node->children.push_back(std::make_shared<ASTLiteral>(realm));
+
+            break;
+        }
+        case AuthenticationType::SSL_CERTIFICATE:
+        {
+            for (const auto & name : getSSLCertificateCommonNames())
+                node->children.push_back(std::make_shared<ASTLiteral>(name));
+
+            break;
+        }
+
+        case AuthenticationType::NO_PASSWORD: [[fallthrough]];
+        case AuthenticationType::MAX:
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "AST: Unexpected authentication type {}", toString(auth_type));
+    }
+
+    return node;
+}
+
+
+AuthenticationData AuthenticationData::fromAST(const ASTAuthenticationData & query, ContextPtr context, bool check_password_rules)
+{
+    if (query.type && *query.type == AuthenticationType::NO_PASSWORD)
+        return AuthenticationData();
+
+    size_t args_size = query.children.size();
+    ASTs args(args_size);
+    for (size_t i = 0; i < args_size; ++i)
+        args[i] = evaluateConstantExpressionAsLiteral(query.children[i], context);
+
+    if (query.contains_password)
+    {
+        if (!query.type && !context)
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot get default password type without context");
+
+        if (check_password_rules && !context)
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot check password complexity rules without context");
+
+        /// NOTE: We will also extract bcrypt workfactor from context
+
+        String value = checkAndGetLiteralArgument<String>(args[0], "password");
+
+        AuthenticationType current_type;
+
+        if (query.type)
+            current_type = *query.type;
+        else
+            current_type = context->getAccessControl().getDefaultPasswordType();
+
+        AuthenticationData auth_data(current_type);
+
+        if (check_password_rules)
+            context->getAccessControl().checkPasswordComplexityRules(value);
+
+        if (query.type == AuthenticationType::SHA256_PASSWORD)
+        {
+#if USE_SSL
+            ///random generator FIPS complaint
+            uint8_t key[32];
+            if (RAND_bytes(key, sizeof(key)) != 1)
+            {
+                char buf[512] = {0};
+                ERR_error_string_n(ERR_get_error(), buf, sizeof(buf));
+                throw Exception(ErrorCodes::OPENSSL_ERROR, "Cannot generate salt for password. OpenSSL {}", buf);
+            }
+
+            String salt;
+            salt.resize(sizeof(key) * 2);
+            char * buf_pos = salt.data();
+            for (uint8_t k : key)
+            {
+                writeHexByteUppercase(k, buf_pos);
+                buf_pos += 2;
+            }
+            value.append(salt);
+            auth_data.setSalt(salt);
+#else
+            throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
+                            "SHA256 passwords support is disabled, because ClickHouse was built without SSL library");
+#endif
+        }
+
+        auth_data.setPassword(value);
+        return auth_data;
+    }
+
+    AuthenticationData auth_data(*query.type);
+
+    if (query.contains_hash)
+    {
+        String value = checkAndGetLiteralArgument<String>(args[0], "hash");
+        auth_data.setPasswordHashHex(value);
+
+        if (query.type == AuthenticationType::SHA256_PASSWORD && args_size == 2)
+        {
+            String parsed_salt = checkAndGetLiteralArgument<String>(args[1], "salt");
+            auth_data.setSalt(parsed_salt);
+        }
+    }
+    else if (query.type == AuthenticationType::LDAP)
+    {
+        String value = checkAndGetLiteralArgument<String>(args[0], "ldap_server_name");
+        auth_data.setLDAPServerName(value);
+    }
+    else if (query.type == AuthenticationType::KERBEROS)
+    {
+        if (!args.empty())
+        {
+            String value = checkAndGetLiteralArgument<String>(args[0], "kerberos_realm");
+            auth_data.setKerberosRealm(value);
+        }
+    }
+    else if (query.type == AuthenticationType::SSL_CERTIFICATE)
+    {
+        boost::container::flat_set<String> common_names;
+        for (const auto & arg : args)
+            common_names.insert(checkAndGetLiteralArgument<String>(arg, "common_name"));
+
+        auth_data.setSSLCertificateCommonNames(std::move(common_names));
+    }
+    else
+    {
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Unexpected ASTAuthenticationData structure");
+    }
+
+    return auth_data;
+}
+
 }
diff --git a/src/Access/Common/AuthenticationData.h b/src/Access/AuthenticationData.h
similarity index 73%
rename from src/Access/Common/AuthenticationData.h
rename to src/Access/AuthenticationData.h
index ced9fcd4b6d..4db643742a6 100644
--- a/src/Access/Common/AuthenticationData.h
+++ b/src/Access/AuthenticationData.h
@@ -1,5 +1,9 @@
 #pragma once
 
+#include <Access/Common/AuthenticationType.h>
+#include <Parsers/Access/ASTAuthenticationData.h>
+#include <Interpreters/Context_fwd.h>
+
 #include <base/types.h>
 #include <boost/container/flat_set.hpp>
 #include <vector>
@@ -7,47 +11,6 @@
 namespace DB
 {
 
-enum class AuthenticationType
-{
-    /// User doesn't have to enter password.
-    NO_PASSWORD,
-
-    /// Password is stored as is.
-    PLAINTEXT_PASSWORD,
-
-    /// Password is encrypted in SHA256 hash.
-    SHA256_PASSWORD,
-
-    /// SHA1(SHA1(password)).
-    /// This kind of hash is used by the `mysql_native_password` authentication plugin.
-    DOUBLE_SHA1_PASSWORD,
-
-    /// Password is checked by a [remote] LDAP server. Connection will be made at each authentication attempt.
-    LDAP,
-
-    /// Kerberos authentication performed through GSS-API negotiation loop.
-    KERBEROS,
-
-    /// Authentication is done in SSL by checking user certificate.
-    /// Certificates may only be trusted if 'strict' SSL mode is enabled.
-    SSL_CERTIFICATE,
-
-    MAX,
-};
-
-struct AuthenticationTypeInfo
-{
-    const char * const raw_name;
-    const String name; /// Lowercased with underscores, e.g. "sha256_password".
-    static const AuthenticationTypeInfo & get(AuthenticationType type_);
-};
-
-inline String toString(AuthenticationType type_)
-{
-    return AuthenticationTypeInfo::get(type_).raw_name;
-}
-
-
 /// Stores data for checking password when a user logins.
 class AuthenticationData
 {
@@ -94,6 +57,9 @@ public:
     friend bool operator ==(const AuthenticationData & lhs, const AuthenticationData & rhs);
     friend bool operator !=(const AuthenticationData & lhs, const AuthenticationData & rhs) { return !(lhs == rhs); }
 
+    static AuthenticationData fromAST(const ASTAuthenticationData & query, ContextPtr context, bool check_password_rules);
+    std::shared_ptr<ASTAuthenticationData> toAST() const;
+
     struct Util
     {
         static Digest stringToDigest(std::string_view text) { return Digest(text.data(), text.data() + text.size()); }
diff --git a/src/Access/Common/AuthenticationType.cpp b/src/Access/Common/AuthenticationType.cpp
new file mode 100644
index 00000000000..062b82bfcae
--- /dev/null
+++ b/src/Access/Common/AuthenticationType.cpp
@@ -0,0 +1,66 @@
+#include <Access/Common/AuthenticationType.h>
+#include <Common/Exception.h>
+#include <boost/algorithm/string/case_conv.hpp>
+
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+
+const AuthenticationTypeInfo & AuthenticationTypeInfo::get(AuthenticationType type_)
+{
+    static constexpr auto make_info = [](const char * raw_name_, bool is_password_ = false)
+    {
+        String init_name = raw_name_;
+        boost::to_lower(init_name);
+        return AuthenticationTypeInfo{raw_name_, std::move(init_name), is_password_};
+    };
+
+    switch (type_)
+    {
+        case AuthenticationType::NO_PASSWORD:
+        {
+            static const auto info = make_info("NO_PASSWORD");
+            return info;
+        }
+        case AuthenticationType::PLAINTEXT_PASSWORD:
+        {
+            static const auto info = make_info("PLAINTEXT_PASSWORD", true);
+            return info;
+        }
+        case AuthenticationType::SHA256_PASSWORD:
+        {
+            static const auto info = make_info("SHA256_PASSWORD", true);
+            return info;
+        }
+        case AuthenticationType::DOUBLE_SHA1_PASSWORD:
+        {
+            static const auto info = make_info("DOUBLE_SHA1_PASSWORD", true);
+            return info;
+        }
+        case AuthenticationType::LDAP:
+        {
+            static const auto info = make_info("LDAP");
+            return info;
+        }
+        case AuthenticationType::KERBEROS:
+        {
+            static const auto info = make_info("KERBEROS");
+            return info;
+        }
+        case AuthenticationType::SSL_CERTIFICATE:
+        {
+            static const auto info = make_info("SSL_CERTIFICATE");
+            return info;
+        }
+        case AuthenticationType::MAX:
+            break;
+    }
+    throw Exception(ErrorCodes::LOGICAL_ERROR, "Unknown authentication type: {}", static_cast<int>(type_));
+}
+
+}
diff --git a/src/Access/Common/AuthenticationType.h b/src/Access/Common/AuthenticationType.h
new file mode 100644
index 00000000000..ce73fb1d48c
--- /dev/null
+++ b/src/Access/Common/AuthenticationType.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <base/types.h>
+
+namespace DB
+{
+
+enum class AuthenticationType
+{
+    /// User doesn't have to enter password.
+    NO_PASSWORD,
+
+    /// Password is stored as is.
+    PLAINTEXT_PASSWORD,
+
+    /// Password is encrypted in SHA256 hash.
+    SHA256_PASSWORD,
+
+    /// SHA1(SHA1(password)).
+    /// This kind of hash is used by the `mysql_native_password` authentication plugin.
+    DOUBLE_SHA1_PASSWORD,
+
+    /// Password is checked by a [remote] LDAP server. Connection will be made at each authentication attempt.
+    LDAP,
+
+    /// Kerberos authentication performed through GSS-API negotiation loop.
+    KERBEROS,
+
+    /// Authentication is done in SSL by checking user certificate.
+    /// Certificates may only be trusted if 'strict' SSL mode is enabled.
+    SSL_CERTIFICATE,
+
+    MAX,
+};
+
+struct AuthenticationTypeInfo
+{
+    const char * const raw_name;
+    const String name; /// Lowercased with underscores, e.g. "sha256_password".
+    bool is_password;
+    static const AuthenticationTypeInfo & get(AuthenticationType type_);
+};
+
+inline String toString(AuthenticationType type_)
+{
+    return AuthenticationTypeInfo::get(type_).raw_name;
+}
+
+}
diff --git a/src/Access/User.h b/src/Access/User.h
index 958d8bb486f..4b4bf90137f 100644
--- a/src/Access/User.h
+++ b/src/Access/User.h
@@ -2,7 +2,7 @@
 
 #include <Access/IAccessEntity.h>
 #include <Access/AccessRights.h>
-#include <Access/Common/AuthenticationData.h>
+#include <Access/AuthenticationData.h>
 #include <Access/Common/AllowedClientHosts.h>
 #include <Access/GrantedRoles.h>
 #include <Access/RolesOrUsersSet.h>
diff --git a/src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.h b/src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.h
index 737f37b1fba..33a9966ee2c 100644
--- a/src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.h
+++ b/src/AggregateFunctions/AggregateFunctionKolmogorovSmirnovTest.h
@@ -91,9 +91,9 @@ struct KolmogorovSmirnov : public StatisticalSample<Float64, Float64>
         UInt64 ny_g = n2 / g;
 
         if (method == "auto")
-            method = std::max(n1, n2) <= 10000 ? "exact" : "asymp";
+            method = std::max(n1, n2) <= 10000 ? "exact" : "asymptotic";
         else if (method == "exact" && nx_g >= std::numeric_limits<Int32>::max() / ny_g)
-            method = "asymp";
+            method = "asymptotic";
 
         Float64 p_value = std::numeric_limits<Float64>::infinity();
 
@@ -143,7 +143,7 @@ struct KolmogorovSmirnov : public StatisticalSample<Float64, Float64>
             }
             p_value = c[n1];
         }
-        else if (method == "asymp")
+        else if (method == "asymp" || method == "asymptotic")
         {
             Float64 n = std::min(n1, n2);
             Float64 m = std::max(n1, n2);
@@ -242,9 +242,9 @@ public:
                 throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Aggregate function {} require second parameter to be a String", getName());
 
         method = params[1].get<String>();
-        if (method != "auto" && method != "exact" && method != "asymp")
+        if (method != "auto" && method != "exact" && method != "asymp" && method != "asymptotic")
             throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unknown method in aggregate function {}. "
-                    "It must be one of: 'auto', 'exact', 'asymp'", getName());
+                    "It must be one of: 'auto', 'exact', 'asymp' (or 'asymptotic')", getName());
     }
 
     String getName() const override
diff --git a/src/AggregateFunctions/AggregateFunctionMinMaxAny.h b/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
index b984772c8ea..d2d21b20753 100644
--- a/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
+++ b/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
@@ -47,7 +47,7 @@ private:
     using ColVecType = ColumnVectorOrDecimal<T>;
 
     bool has_value = false; /// We need to remember if at least one value has been passed. This is necessary for AggregateFunctionIf.
-    T value;
+    T value = T{};
 
 public:
     static constexpr bool is_nullable = false;
diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index c03b7f16a2a..13320ad90b6 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -163,15 +163,11 @@ public:
         if constexpr (std::is_same_v<Data, QuantileTiming<Value>>)
         {
             /// QuantileTiming only supports unsigned integers. Too large values are also meaningless.
-#ifdef OS_DARWIN
 #   pragma clang diagnostic push
 #   pragma clang diagnostic ignored "-Wimplicit-const-int-float-conversion"
-#endif
             if (isNaN(value) || value > std::numeric_limits<Int64>::max() || value < 0)
                 return;
-#ifdef OS_DARWIN
 #   pragma clang diagnostic pop
-#endif
         }
 
         if constexpr (has_second_arg)
diff --git a/src/AggregateFunctions/fuzzers/aggregate_function_state_deserialization_fuzzer.cpp b/src/AggregateFunctions/fuzzers/aggregate_function_state_deserialization_fuzzer.cpp
index 39f57e00c48..2ea01e1d5bc 100644
--- a/src/AggregateFunctions/fuzzers/aggregate_function_state_deserialization_fuzzer.cpp
+++ b/src/AggregateFunctions/fuzzers/aggregate_function_state_deserialization_fuzzer.cpp
@@ -13,6 +13,7 @@
 
 #include <AggregateFunctions/registerAggregateFunctions.h>
 
+#include <base/scope_guard.h>
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t * data, size_t size)
 try
diff --git a/src/Analyzer/Passes/QueryAnalysisPass.cpp b/src/Analyzer/Passes/QueryAnalysisPass.cpp
index 8afb9078fae..0daef082be2 100644
--- a/src/Analyzer/Passes/QueryAnalysisPass.cpp
+++ b/src/Analyzer/Passes/QueryAnalysisPass.cpp
@@ -4081,12 +4081,12 @@ ProjectionNames QueryAnalyzer::resolveMatcher(QueryTreeNodePtr & matcher_node, I
                 if (apply_transformer_was_used || replace_transformer_was_used)
                     continue;
 
-                replace_transformer_was_used = true;
-
                 auto replace_expression = replace_transformer->findReplacementExpression(column_name);
                 if (!replace_expression)
                     continue;
 
+                replace_transformer_was_used = true;
+
                 if (replace_transformer->isStrict())
                     strict_transformer_to_used_column_names[replace_transformer].insert(column_name);
 
@@ -6679,7 +6679,9 @@ void QueryAnalyzer::resolveQuery(const QueryTreeNodePtr & query_node, Identifier
 
     bool is_rollup_or_cube = query_node_typed.isGroupByWithRollup() || query_node_typed.isGroupByWithCube();
 
-    if (query_node_typed.isGroupByWithGroupingSets() && query_node_typed.isGroupByWithTotals())
+    if (query_node_typed.isGroupByWithGroupingSets()
+        && query_node_typed.isGroupByWithTotals()
+        && query_node_typed.getGroupBy().getNodes().size() != 1)
         throw Exception(ErrorCodes::NOT_IMPLEMENTED, "WITH TOTALS and GROUPING SETS are not supported together");
 
     if (query_node_typed.isGroupByWithGroupingSets() && is_rollup_or_cube)
diff --git a/src/Client/ClientBase.cpp b/src/Client/ClientBase.cpp
index a17e720c1e0..7ae75ba250d 100644
--- a/src/Client/ClientBase.cpp
+++ b/src/Client/ClientBase.cpp
@@ -34,6 +34,7 @@
 #include <Parsers/ASTCreateQuery.h>
 #include <Parsers/ASTCreateFunctionQuery.h>
 #include <Parsers/Access/ASTCreateUserQuery.h>
+#include <Parsers/Access/ASTAuthenticationData.h>
 #include <Parsers/ASTDropQuery.h>
 #include <Parsers/ASTSelectQuery.h>
 #include <Parsers/ASTSetQuery.h>
@@ -1612,10 +1613,15 @@ void ClientBase::processParsedSingleQuery(const String & full_query, const Strin
 
     if (const auto * create_user_query = parsed_query->as<ASTCreateUserQuery>())
     {
-        if (!create_user_query->attach && create_user_query->temporary_password_for_checks)
+        if (!create_user_query->attach && create_user_query->auth_data)
         {
-            global_context->getAccessControl().checkPasswordComplexityRules(create_user_query->temporary_password_for_checks.value());
-            create_user_query->temporary_password_for_checks.reset();
+            if (const auto * auth_data = create_user_query->auth_data->as<ASTAuthenticationData>())
+            {
+                auto password = auth_data->getPassword();
+
+                if (password)
+                    global_context->getAccessControl().checkPasswordComplexityRules(*password);
+            }
         }
     }
 
diff --git a/src/Common/AsynchronousMetrics.cpp b/src/Common/AsynchronousMetrics.cpp
index 6c55bfe3d97..ac2180103c5 100644
--- a/src/Common/AsynchronousMetrics.cpp
+++ b/src/Common/AsynchronousMetrics.cpp
@@ -67,8 +67,15 @@ AsynchronousMetrics::AsynchronousMetrics(
     openFileIfExists("/proc/uptime", uptime);
     openFileIfExists("/proc/net/dev", net_dev);
 
-    openFileIfExists("/sys/fs/cgroup/memory/memory.limit_in_bytes", cgroupmem_limit_in_bytes);
-    openFileIfExists("/sys/fs/cgroup/memory/memory.usage_in_bytes", cgroupmem_usage_in_bytes);
+    /// CGroups v2
+    openFileIfExists("/sys/fs/cgroup/memory.max", cgroupmem_limit_in_bytes);
+    openFileIfExists("/sys/fs/cgroup/memory.current", cgroupmem_usage_in_bytes);
+
+    /// CGroups v1
+    if (!cgroupmem_limit_in_bytes)
+        openFileIfExists("/sys/fs/cgroup/memory/memory.limit_in_bytes", cgroupmem_limit_in_bytes);
+    if (!cgroupmem_usage_in_bytes)
+        openFileIfExists("/sys/fs/cgroup/memory/memory.usage_in_bytes", cgroupmem_usage_in_bytes);
 
     openSensors();
     openBlockDevices();
@@ -900,33 +907,25 @@ void AsynchronousMetrics::update(TimePoint update_time)
 
     if (cgroupmem_limit_in_bytes && cgroupmem_usage_in_bytes)
     {
-        try {
+        try
+        {
             cgroupmem_limit_in_bytes->rewind();
             cgroupmem_usage_in_bytes->rewind();
 
-            uint64_t cgroup_mem_limit_in_bytes = 0;
-            uint64_t cgroup_mem_usage_in_bytes = 0;
+            uint64_t limit = 0;
+            uint64_t usage = 0;
 
-            readText(cgroup_mem_limit_in_bytes, *cgroupmem_limit_in_bytes);
-            readText(cgroup_mem_usage_in_bytes, *cgroupmem_usage_in_bytes);
+            tryReadText(limit, *cgroupmem_limit_in_bytes);
+            tryReadText(usage, *cgroupmem_usage_in_bytes);
 
-            if (cgroup_mem_limit_in_bytes && cgroup_mem_usage_in_bytes)
-            {
-                new_values["CgroupMemoryTotal"] = { cgroup_mem_limit_in_bytes, "The total amount of memory in cgroup, in bytes." };
-                new_values["CgroupMemoryUsed"] = { cgroup_mem_usage_in_bytes, "The amount of memory used in cgroup, in bytes." };
-            }
-            else
-            {
-                LOG_DEBUG(log, "Cannot read statistics about the cgroup memory total and used. Total got '{}', Used got '{}'.",
-                    cgroup_mem_limit_in_bytes, cgroup_mem_usage_in_bytes);
-            }
+            new_values["CGroupMemoryTotal"] = { limit, "The total amount of memory in cgroup, in bytes. If stated zero, the limit is the same as OSMemoryTotal." };
+            new_values["CGroupMemoryUsed"] = { usage, "The amount of memory used in cgroup, in bytes." };
         }
         catch (...)
         {
             tryLogCurrentException(__PRETTY_FUNCTION__);
         }
     }
-
     if (meminfo)
     {
         try
diff --git a/src/Common/Documentation.cpp b/src/Common/Documentation.cpp
new file mode 100644
index 00000000000..862ecb6054c
--- /dev/null
+++ b/src/Common/Documentation.cpp
@@ -0,0 +1,30 @@
+#include <Common/Documentation.h>
+
+namespace DB
+{
+
+std::string Documentation::examplesAsString() const
+{
+    std::string res;
+    for (const auto & [example_name, example_query] : examples)
+    {
+        res += example_name + ":\n\n";
+        res += "```sql\n";
+        res += example_query + "\n";
+        res += "```\n";
+    }
+    return res;
+}
+
+std::string Documentation::categoriesAsString() const
+{
+    if (categories.empty())
+        return "";
+
+    std::string res = categories[0];
+    for (size_t i = 1; i < categories.size(); ++i)
+        res += ", " + categories[i];
+    return res;
+}
+
+}
diff --git a/src/Common/Documentation.h b/src/Common/Documentation.h
index 0b0eacbeccd..c71aa8772ed 100644
--- a/src/Common/Documentation.h
+++ b/src/Common/Documentation.h
@@ -42,27 +42,44 @@ namespace DB
   *
   * Documentation does not support multiple languages.
   * The only available language is English.
+  *
+  * TODO: Allow to specify Syntax, Argument(s) and a Returned Value.
+  * TODO: Organize Examples as a struct of ExampleName, ExampleQuery and ExampleResult.
   */
 struct Documentation
 {
     using Description = std::string;
+
+    using Syntax = std::string;
+
+    using Argument = std::string;
+    using Arguments = std::vector<Argument>;
+
+    using ReturnedValue = std::string;
+
     using ExampleName = std::string;
     using ExampleQuery = std::string;
     using Examples = std::map<ExampleName, ExampleQuery>;
+
     using Category = std::string;
     using Categories = std::vector<Category>;
 
+    using Related = std::string;
+
     Description description;
     Examples examples;
     Categories categories;
 
-    Documentation(Description description_) : description(std::move(description_)) {}
+    Documentation(Description description_) : description(std::move(description_)) {} /// NOLINT
     Documentation(Description description_, Examples examples_) : description(std::move(description_)), examples(std::move(examples_)) {}
     Documentation(Description description_, Examples examples_, Categories categories_)
         : description(std::move(description_)), examples(std::move(examples_)), categories(std::move(categories_)) {}
 
     /// TODO: Please remove this constructor. Documentation should always be non-empty.
-    Documentation() {}
+    Documentation() = default;
+
+    std::string examplesAsString() const;
+    std::string categoriesAsString() const;
 };
 
 }
diff --git a/src/Common/ProfileEvents.cpp b/src/Common/ProfileEvents.cpp
index da096085d5b..166db25e14c 100644
--- a/src/Common/ProfileEvents.cpp
+++ b/src/Common/ProfileEvents.cpp
@@ -10,6 +10,7 @@
     M(InsertQuery, "Same as Query, but only for INSERT queries.") \
     M(AsyncInsertQuery, "Same as InsertQuery, but only for asynchronous INSERT queries.") \
     M(AsyncInsertBytes, "Data size in bytes of asynchronous INSERT queries.") \
+    M(AsyncInsertRows, "Number of rows inserted by asynchronous INSERT queries.") \
     M(AsyncInsertCacheHits, "Number of times a duplicate hash id has been found in asynchronous INSERT hash id cache.") \
     M(FailedQuery, "Number of failed queries.") \
     M(FailedSelectQuery, "Same as FailedQuery, but only for SELECT queries.") \
diff --git a/src/Compression/CompressionCodecDeflateQpl.cpp b/src/Compression/CompressionCodecDeflateQpl.cpp
index 29d90b7dbd6..70ae8e54d97 100644
--- a/src/Compression/CompressionCodecDeflateQpl.cpp
+++ b/src/Compression/CompressionCodecDeflateQpl.cpp
@@ -7,6 +7,7 @@
 #include <Parsers/ASTIdentifier.h>
 #include <Poco/Logger.h>
 #include <Common/logger_useful.h>
+#include "libaccel_config.h"
 
 namespace DB
 {
@@ -16,11 +17,6 @@ namespace ErrorCodes
     extern const int CANNOT_DECOMPRESS;
 }
 
-std::array<qpl_job *, DeflateQplJobHWPool::MAX_HW_JOB_NUMBER> DeflateQplJobHWPool::hw_job_ptr_pool;
-std::array<std::atomic_bool, DeflateQplJobHWPool::MAX_HW_JOB_NUMBER> DeflateQplJobHWPool::hw_job_ptr_locks;
-bool DeflateQplJobHWPool::job_pool_ready = false;
-std::unique_ptr<uint8_t[]> DeflateQplJobHWPool::hw_jobs_buffer;
-
 DeflateQplJobHWPool & DeflateQplJobHWPool::instance()
 {
     static DeflateQplJobHWPool pool;
@@ -28,47 +24,69 @@ DeflateQplJobHWPool & DeflateQplJobHWPool::instance()
 }
 
 DeflateQplJobHWPool::DeflateQplJobHWPool()
-    : random_engine(std::random_device()())
-    , distribution(0, MAX_HW_JOB_NUMBER - 1)
+    : max_hw_jobs(0)
+    , random_engine(std::random_device()())
 {
     Poco::Logger * log = &Poco::Logger::get("DeflateQplJobHWPool");
-    UInt32 job_size = 0;
     const char * qpl_version = qpl_get_library_version();
 
-    /// Get size required for saving a single qpl job object
-    qpl_get_job_size(qpl_path_hardware, &job_size);
-    /// Allocate entire buffer for storing all job objects
-    hw_jobs_buffer = std::make_unique<uint8_t[]>(job_size * MAX_HW_JOB_NUMBER);
-    /// Initialize pool for storing all job object pointers
-    /// Reallocate buffer by shifting address offset for each job object.
-    for (UInt32 index = 0; index < MAX_HW_JOB_NUMBER; ++index)
+    // loop all configured workqueue size to get maximum job number.
+    accfg_ctx * ctx_ptr = nullptr;
+    auto ctx_status = accfg_new(&ctx_ptr);
+    if (ctx_status == 0)
     {
-        qpl_job * qpl_job_ptr = reinterpret_cast<qpl_job *>(hw_jobs_buffer.get() + index * job_size);
-        if (auto status = qpl_init_job(qpl_path_hardware, qpl_job_ptr); status != QPL_STS_OK)
+        auto * dev_ptr = accfg_device_get_first(ctx_ptr);
+        while (dev_ptr != nullptr)
+        {
+            for (auto * wq_ptr = accfg_wq_get_first(dev_ptr); wq_ptr != nullptr; wq_ptr = accfg_wq_get_next(wq_ptr))
+                max_hw_jobs += accfg_wq_get_size(wq_ptr);
+            dev_ptr = accfg_device_get_next(dev_ptr);
+        }
+    }
+    else
+    {
+        job_pool_ready = false;
+        LOG_WARNING(log, "Initialization of hardware-assisted DeflateQpl codec failed, falling back to software DeflateQpl codec. Failed to create new libaccel_config context -> status: {}, QPL Version: {}.", ctx_status, qpl_version);
+        return;
+    }
+
+    if (max_hw_jobs == 0)
+    {
+        job_pool_ready = false;
+        LOG_WARNING(log, "Initialization of hardware-assisted DeflateQpl codec failed, falling back to software DeflateQpl codec. Failed to get available workqueue size -> total_wq_size: {}, QPL Version: {}.", max_hw_jobs, qpl_version);
+        return;
+    }
+    distribution = std::uniform_int_distribution<int>(0, max_hw_jobs - 1);
+    /// Get size required for saving a single qpl job object
+    qpl_get_job_size(qpl_path_hardware, &per_job_size);
+    /// Allocate job buffer pool for storing all job objects
+    hw_jobs_buffer = std::make_unique<uint8_t[]>(per_job_size * max_hw_jobs);
+    hw_job_ptr_locks = std::make_unique<std::atomic_bool[]>(max_hw_jobs);
+    /// Initialize all job objects in job buffer pool
+    for (UInt32 index = 0; index < max_hw_jobs; ++index)
+    {
+        qpl_job * job_ptr = reinterpret_cast<qpl_job *>(hw_jobs_buffer.get() + index * per_job_size);
+        if (auto status = qpl_init_job(qpl_path_hardware, job_ptr); status != QPL_STS_OK)
         {
             job_pool_ready = false;
-            LOG_WARNING(log, "Initialization of hardware-assisted DeflateQpl codec failed: {} , falling back to software DeflateQpl codec. Please check if Intel In-Memory Analytics Accelerator (IAA) is properly set up. QPL Version: {}.", static_cast<UInt32>(status), qpl_version);
+            LOG_WARNING(log, "Initialization of hardware-assisted DeflateQpl codec failed, falling back to software DeflateQpl codec. Failed to Initialize qpl job -> status: {}, QPL Version: {}.", static_cast<UInt32>(status), qpl_version);
             return;
         }
-        hw_job_ptr_pool[index] = qpl_job_ptr;
         unLockJob(index);
     }
 
     job_pool_ready = true;
-    LOG_DEBUG(log, "Hardware-assisted DeflateQpl codec is ready! QPL Version: {}",qpl_version);
+    LOG_DEBUG(log, "Hardware-assisted DeflateQpl codec is ready! QPL Version: {}, max_hw_jobs: {}",qpl_version, max_hw_jobs);
 }
 
 DeflateQplJobHWPool::~DeflateQplJobHWPool()
 {
-    for (UInt32 i = 0; i < MAX_HW_JOB_NUMBER; ++i)
+    for (UInt32 i = 0; i < max_hw_jobs; ++i)
     {
-        if (hw_job_ptr_pool[i])
-        {
-            while (!tryLockJob(i));
-            qpl_fini_job(hw_job_ptr_pool[i]);
-            unLockJob(i);
-            hw_job_ptr_pool[i] = nullptr;
-        }
+        qpl_job * job_ptr = reinterpret_cast<qpl_job *>(hw_jobs_buffer.get() + i * per_job_size);
+        while (!tryLockJob(i));
+        qpl_fini_job(job_ptr);
+        unLockJob(i);
     }
     job_pool_ready = false;
 }
@@ -83,14 +101,14 @@ qpl_job * DeflateQplJobHWPool::acquireJob(UInt32 & job_id)
         {
             index = distribution(random_engine);
             retry++;
-            if (retry > MAX_HW_JOB_NUMBER)
+            if (retry > max_hw_jobs)
             {
                 return nullptr;
             }
         }
-        job_id = MAX_HW_JOB_NUMBER - index;
-        assert(index < MAX_HW_JOB_NUMBER);
-        return hw_job_ptr_pool[index];
+        job_id = max_hw_jobs - index;
+        assert(index < max_hw_jobs);
+        return reinterpret_cast<qpl_job *>(hw_jobs_buffer.get() + index * per_job_size);
     }
     else
         return nullptr;
@@ -99,19 +117,19 @@ qpl_job * DeflateQplJobHWPool::acquireJob(UInt32 & job_id)
 void DeflateQplJobHWPool::releaseJob(UInt32 job_id)
 {
     if (isJobPoolReady())
-        unLockJob(MAX_HW_JOB_NUMBER - job_id);
+        unLockJob(max_hw_jobs - job_id);
 }
 
 bool DeflateQplJobHWPool::tryLockJob(UInt32 index)
 {
     bool expected = false;
-    assert(index < MAX_HW_JOB_NUMBER);
+    assert(index < max_hw_jobs);
     return hw_job_ptr_locks[index].compare_exchange_strong(expected, true);
 }
 
 void DeflateQplJobHWPool::unLockJob(UInt32 index)
 {
-    assert(index < MAX_HW_JOB_NUMBER);
+    assert(index < max_hw_jobs);
     hw_job_ptr_locks[index].store(false);
 }
 
diff --git a/src/Compression/CompressionCodecDeflateQpl.h b/src/Compression/CompressionCodecDeflateQpl.h
index 3171a898311..7a1a764295d 100644
--- a/src/Compression/CompressionCodecDeflateQpl.h
+++ b/src/Compression/CompressionCodecDeflateQpl.h
@@ -24,22 +24,23 @@ public:
     static DeflateQplJobHWPool & instance();
 
     qpl_job * acquireJob(UInt32 & job_id);
-    static void releaseJob(UInt32 job_id);
-    static const bool & isJobPoolReady() { return job_pool_ready; }
+    void releaseJob(UInt32 job_id);
+    const bool & isJobPoolReady() { return job_pool_ready; }
 
 private:
-    static bool tryLockJob(UInt32 index);
-    static void unLockJob(UInt32 index);
+    bool tryLockJob(UInt32 index);
+    void unLockJob(UInt32 index);
 
+    /// size of each job objects
+    UInt32 per_job_size;
     /// Maximum jobs running in parallel supported by IAA hardware
-    static constexpr auto MAX_HW_JOB_NUMBER = 1024;
+    UInt32 max_hw_jobs;
     /// Entire buffer for storing all job objects
-    static std::unique_ptr<uint8_t[]> hw_jobs_buffer;
-    /// Job pool for storing all job object pointers
-    static std::array<qpl_job *, MAX_HW_JOB_NUMBER> hw_job_ptr_pool;
+    std::unique_ptr<uint8_t[]> hw_jobs_buffer;
     /// Locks for accessing each job object pointers
-    static std::array<std::atomic_bool, MAX_HW_JOB_NUMBER> hw_job_ptr_locks;
-    static bool job_pool_ready;
+    std::unique_ptr<std::atomic_bool[]> hw_job_ptr_locks;
+
+    bool job_pool_ready;
     std::mt19937 random_engine;
     std::uniform_int_distribution<int> distribution;
 };
diff --git a/src/Core/Settings.h b/src/Core/Settings.h
index 101f6f1f934..aa5e69ce571 100644
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@@ -71,6 +71,7 @@ class IColumn;
     M(UInt64, idle_connection_timeout, 3600, "Close idle TCP connections after specified number of seconds.", 0) \
     M(UInt64, distributed_connections_pool_size, 1024, "Maximum number of connections with one remote server in the pool.", 0) \
     M(UInt64, connections_with_failover_max_tries, DBMS_CONNECTION_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES, "The maximum number of attempts to connect to replicas.", 0) \
+    M(UInt64, s3_strict_upload_part_size, 0, "The exact size of part to upload during multipart upload to S3 (some implementations does not supports variable size parts).", 0) \
     M(UInt64, s3_min_upload_part_size, 16*1024*1024, "The minimum size of part to upload during multipart upload to S3.", 0) \
     M(UInt64, s3_max_upload_part_size, 5ull*1024*1024*1024, "The maximum size of part to upload during multipart upload to S3.", 0) \
     M(UInt64, s3_upload_part_size_multiply_factor, 2, "Multiply s3_min_upload_part_size by this factor each time s3_multiply_parts_count_threshold parts were uploaded from a single write to S3.", 0) \
@@ -709,6 +710,8 @@ class IColumn;
     \
     M(String, workload, "default", "Name of workload to be used to access resources", 0) \
     \
+    M(Bool, parallelize_output_from_storages, false, "Parallelize output for reading step from storage. It allows parallelizing query processing right after reading from storage if possible", 0) \
+    \
     /** Experimental functions */ \
     M(Bool, allow_experimental_funnel_functions, false, "Enable experimental functions for funnel analysis.", 0) \
     M(Bool, allow_experimental_nlp_functions, false, "Enable experimental functions for natural language processing.", 0) \
diff --git a/src/Databases/PostgreSQL/DatabasePostgreSQL.cpp b/src/Databases/PostgreSQL/DatabasePostgreSQL.cpp
index 8c267ea929b..4b42d799661 100644
--- a/src/Databases/PostgreSQL/DatabasePostgreSQL.cpp
+++ b/src/Databases/PostgreSQL/DatabasePostgreSQL.cpp
@@ -17,6 +17,7 @@
 #include <Databases/PostgreSQL/fetchPostgreSQLTableStructure.h>
 #include <Common/quoteString.h>
 #include <Common/filesystemHelpers.h>
+#include <Common/logger_useful.h>
 #include <filesystem>
 
 namespace fs = std::filesystem;
@@ -51,6 +52,7 @@ DatabasePostgreSQL::DatabasePostgreSQL(
     , configuration(configuration_)
     , pool(std::move(pool_))
     , cache_tables(cache_tables_)
+    , log(&Poco::Logger::get("DatabasePostgreSQL(" + dbname_ + ")"))
 {
     cleaner_task = getContext()->getSchedulePool().createTask("PostgreSQLCleanerTask", [this]{ removeOutdatedTables(); });
     cleaner_task->deactivate();
@@ -192,7 +194,10 @@ StoragePtr DatabasePostgreSQL::fetchTable(const String & table_name, ContextPtr,
                 ColumnsDescription{columns_info->columns}, ConstraintsDescription{}, String{}, configuration.schema, configuration.on_conflict);
 
         if (cache_tables)
+        {
+            LOG_TEST(log, "Cached table `{}`", table_name);
             cached_tables[table_name] = storage;
+        }
 
         return storage;
     }
diff --git a/src/Databases/PostgreSQL/DatabasePostgreSQL.h b/src/Databases/PostgreSQL/DatabasePostgreSQL.h
index 08583f4b6d9..31fa036c0ee 100644
--- a/src/Databases/PostgreSQL/DatabasePostgreSQL.h
+++ b/src/Databases/PostgreSQL/DatabasePostgreSQL.h
@@ -73,6 +73,7 @@ private:
     mutable Tables cached_tables;
     std::unordered_set<std::string> detached_or_dropped;
     BackgroundSchedulePool::TaskHolder cleaner_task;
+    Poco::Logger * log;
 
     String getTableNameForLogs(const String & table_name) const;
 
diff --git a/src/Dictionaries/MongoDBDictionarySource.cpp b/src/Dictionaries/MongoDBDictionarySource.cpp
index 922e1e71bbb..b7e342f3c80 100644
--- a/src/Dictionaries/MongoDBDictionarySource.cpp
+++ b/src/Dictionaries/MongoDBDictionarySource.cpp
@@ -3,13 +3,13 @@
 #include "DictionaryStructure.h"
 #include "registerDictionaries.h"
 #include <Storages/ExternalDataSourceConfiguration.h>
-
+#include <Storages/StorageMongoDBSocketFactory.h>
 
 namespace DB
 {
 
 static const std::unordered_set<std::string_view> dictionary_allowed_keys = {
-    "host", "port", "user", "password", "db", "database", "uri", "collection", "name", "method"};
+    "host", "port", "user", "password", "db", "database", "uri", "collection", "name", "method", "options"};
 
 void registerDictionarySourceMongoDB(DictionarySourceFactory & factory)
 {
@@ -51,6 +51,7 @@ void registerDictionarySourceMongoDB(DictionarySourceFactory & factory)
             config.getString(config_prefix + ".method", ""),
             configuration.database,
             config.getString(config_prefix + ".collection"),
+            config.getString(config_prefix + ".options", ""),
             sample_block);
     };
 
@@ -98,6 +99,7 @@ MongoDBDictionarySource::MongoDBDictionarySource(
     const std::string & method_,
     const std::string & db_,
     const std::string & collection_,
+    const std::string & options_,
     const Block & sample_block_)
     : dict_struct{dict_struct_}
     , uri{uri_}
@@ -108,13 +110,15 @@ MongoDBDictionarySource::MongoDBDictionarySource(
     , method{method_}
     , db{db_}
     , collection{collection_}
+    , options(options_)
     , sample_block{sample_block_}
     , connection{std::make_shared<Poco::MongoDB::Connection>()}
 {
+
+    StorageMongoDBSocketFactory socket_factory;
     if (!uri.empty())
     {
         // Connect with URI.
-        Poco::MongoDB::Connection::SocketFactory socket_factory;
         connection->connect(uri, socket_factory);
 
         Poco::URI poco_uri(connection->uri());
@@ -140,8 +144,10 @@ MongoDBDictionarySource::MongoDBDictionarySource(
     }
     else
     {
-        // Connect with host/port/user/etc.
-        connection->connect(host, port);
+        // Connect with host/port/user/etc through constructing the uri
+        std::string uri_constructed("mongodb://" + host + ":" + std::to_string(port) + "/" + db + (options.empty() ? "" : "?" + options));
+        connection->connect(uri_constructed, socket_factory);
+
         if (!user.empty())
         {
             Poco::MongoDB::Database poco_db(db);
@@ -154,7 +160,9 @@ MongoDBDictionarySource::MongoDBDictionarySource(
 
 MongoDBDictionarySource::MongoDBDictionarySource(const MongoDBDictionarySource & other)
     : MongoDBDictionarySource{
-        other.dict_struct, other.uri, other.host, other.port, other.user, other.password, other.method, other.db, other.collection, other.sample_block}
+        other.dict_struct, other.uri, other.host, other.port, other.user, other.password, other.method, other.db,
+        other.collection, other.options, other.sample_block
+    }
 {
 }
 
diff --git a/src/Dictionaries/MongoDBDictionarySource.h b/src/Dictionaries/MongoDBDictionarySource.h
index 4c7ae649f09..fefcb1bff9f 100644
--- a/src/Dictionaries/MongoDBDictionarySource.h
+++ b/src/Dictionaries/MongoDBDictionarySource.h
@@ -41,6 +41,7 @@ public:
         const std::string & method_,
         const std::string & db_,
         const std::string & collection_,
+        const std::string & options,
         const Block & sample_block_);
 
     MongoDBDictionarySource(const MongoDBDictionarySource & other);
@@ -80,6 +81,7 @@ private:
     const std::string method;
     std::string db;
     const std::string collection;
+    const std::string options;
     Block sample_block;
 
     std::shared_ptr<Poco::MongoDB::Connection> connection;
diff --git a/src/Disks/IO/CachedOnDiskReadBufferFromFile.cpp b/src/Disks/IO/CachedOnDiskReadBufferFromFile.cpp
index 68efd3f5d78..4114ffcc522 100644
--- a/src/Disks/IO/CachedOnDiskReadBufferFromFile.cpp
+++ b/src/Disks/IO/CachedOnDiskReadBufferFromFile.cpp
@@ -1,6 +1,7 @@
 #include "CachedOnDiskReadBufferFromFile.h"
 
 #include <Disks/IO/createReadBufferFromFileBase.h>
+#include <Disks/ObjectStorages/Cached/CachedObjectStorage.h>
 #include <IO/ReadBufferFromFile.h>
 #include <base/scope_guard.h>
 #include <Common/assert_cast.h>
@@ -115,27 +116,25 @@ void CachedOnDiskReadBufferFromFile::initialize(size_t offset, size_t size)
 
     if (settings.read_from_filesystem_cache_if_exists_otherwise_bypass_cache)
     {
-        file_segments_holder.emplace(cache->get(cache_key, offset, size));
+        file_segments = cache->get(cache_key, offset, size);
     }
     else
     {
         CreateFileSegmentSettings create_settings(is_persistent ? FileSegmentKind::Persistent : FileSegmentKind::Regular);
-        file_segments_holder.emplace(cache->getOrSet(cache_key, offset, size, create_settings));
+        file_segments = cache->getOrSet(cache_key, offset, size, create_settings);
     }
 
     /**
      * Segments in returned list are ordered in ascending order and represent a full contiguous
      * interval (no holes). Each segment in returned list has state: DOWNLOADED, DOWNLOADING or EMPTY.
      */
-    if (file_segments_holder->file_segments.empty())
+    if (file_segments->empty())
         throw Exception(ErrorCodes::LOGICAL_ERROR, "List of file segments cannot be empty");
 
     LOG_TEST(
         log,
         "Having {} file segments to read: {}, current offset: {}",
-        file_segments_holder->file_segments.size(), file_segments_holder->toString(), file_offset_of_buffer_end);
-
-    current_file_segment_it = file_segments_holder->file_segments.begin();
+        file_segments->size(), file_segments->toString(), file_offset_of_buffer_end);
 
     initialized = true;
 }
@@ -165,7 +164,7 @@ CachedOnDiskReadBufferFromFile::getCacheReadBuffer(const FileSegment & file_segm
 }
 
 CachedOnDiskReadBufferFromFile::ImplementationBufferPtr
-CachedOnDiskReadBufferFromFile::getRemoteFSReadBuffer(FileSegment & file_segment, ReadType read_type_)
+CachedOnDiskReadBufferFromFile::getRemoteReadBuffer(FileSegment & file_segment, ReadType read_type_)
 {
     switch (read_type_)
     {
@@ -202,7 +201,7 @@ CachedOnDiskReadBufferFromFile::getRemoteFSReadBuffer(FileSegment & file_segment
             }
             else
             {
-                chassert(remote_fs_segment_reader->getFileOffsetOfBufferEnd() == file_segment.getCurrentWriteOffset());
+                chassert(remote_fs_segment_reader->getFileOffsetOfBufferEnd() == file_segment.getCurrentWriteOffset(false));
             }
 
             return remote_fs_segment_reader;
@@ -239,27 +238,27 @@ bool CachedOnDiskReadBufferFromFile::canStartFromCache(size_t current_offset, co
     /// requested_range:    [__________]
     ///                     ^
     ///                     current_offset
-    size_t first_non_downloaded_offset = file_segment.getFirstNonDownloadedOffset();
+    size_t first_non_downloaded_offset = file_segment.getFirstNonDownloadedOffset(true);
     return first_non_downloaded_offset > current_offset;
 }
 
 CachedOnDiskReadBufferFromFile::ImplementationBufferPtr
-CachedOnDiskReadBufferFromFile::getReadBufferForFileSegment(FileSegmentPtr & file_segment)
+CachedOnDiskReadBufferFromFile::getReadBufferForFileSegment(FileSegment & file_segment)
 {
-    auto download_state = file_segment->state();
+    auto download_state = file_segment.state();
 
     if (settings.read_from_filesystem_cache_if_exists_otherwise_bypass_cache)
     {
         if (download_state == FileSegment::State::DOWNLOADED)
         {
             read_type = ReadType::CACHED;
-            return getCacheReadBuffer(*file_segment);
+            return getCacheReadBuffer(file_segment);
         }
         else
         {
             LOG_TEST(log, "Bypassing cache because `read_from_filesystem_cache_if_exists_otherwise_bypass_cache` option is used");
             read_type = ReadType::REMOTE_FS_READ_BYPASS_CACHE;
-            return getRemoteFSReadBuffer(*file_segment, read_type);
+            return getRemoteReadBuffer(file_segment, read_type);
         }
     }
 
@@ -267,15 +266,15 @@ CachedOnDiskReadBufferFromFile::getReadBufferForFileSegment(FileSegmentPtr & fil
     {
         switch (download_state)
         {
-            case FileSegment::State::SKIP_CACHE:
+            case FileSegment::State::DETACHED:
             {
-                LOG_TRACE(log, "Bypassing cache because file segment state is `SKIP_CACHE`");
+                LOG_TRACE(log, "Bypassing cache because file segment state is `DETACHED`");
                 read_type = ReadType::REMOTE_FS_READ_BYPASS_CACHE;
-                return getRemoteFSReadBuffer(*file_segment, read_type);
+                return getRemoteReadBuffer(file_segment, read_type);
             }
             case FileSegment::State::DOWNLOADING:
             {
-                if (canStartFromCache(file_offset_of_buffer_end, *file_segment))
+                if (canStartFromCache(file_offset_of_buffer_end, file_segment))
                 {
                     ///                      segment{k} state: DOWNLOADING
                     /// cache:           [______|___________
@@ -286,21 +285,21 @@ CachedOnDiskReadBufferFromFile::getReadBufferForFileSegment(FileSegmentPtr & fil
                     ///                     file_offset_of_buffer_end
 
                     read_type = ReadType::CACHED;
-                    return getCacheReadBuffer(*file_segment);
+                    return getCacheReadBuffer(file_segment);
                 }
 
-                download_state = file_segment->wait();
+                download_state = file_segment.wait(file_offset_of_buffer_end);
                 continue;
             }
             case FileSegment::State::DOWNLOADED:
             {
                 read_type = ReadType::CACHED;
-                return getCacheReadBuffer(*file_segment);
+                return getCacheReadBuffer(file_segment);
             }
             case FileSegment::State::EMPTY:
             case FileSegment::State::PARTIALLY_DOWNLOADED:
             {
-                if (canStartFromCache(file_offset_of_buffer_end, *file_segment))
+                if (canStartFromCache(file_offset_of_buffer_end, file_segment))
                 {
                     ///                      segment{k} state: PARTIALLY_DOWNLOADED
                     /// cache:           [______|___________
@@ -311,13 +310,13 @@ CachedOnDiskReadBufferFromFile::getReadBufferForFileSegment(FileSegmentPtr & fil
                     ///                     file_offset_of_buffer_end
 
                     read_type = ReadType::CACHED;
-                    return getCacheReadBuffer(*file_segment);
+                    return getCacheReadBuffer(file_segment);
                 }
 
-                auto downloader_id = file_segment->getOrSetDownloader();
-                if (downloader_id == file_segment->getCallerId())
+                auto downloader_id = file_segment.getOrSetDownloader();
+                if (downloader_id == file_segment.getCallerId())
                 {
-                    if (canStartFromCache(file_offset_of_buffer_end, *file_segment))
+                    if (canStartFromCache(file_offset_of_buffer_end, file_segment))
                     {
                         ///                      segment{k}
                         /// cache:           [______|___________
@@ -328,11 +327,12 @@ CachedOnDiskReadBufferFromFile::getReadBufferForFileSegment(FileSegmentPtr & fil
                         ///                     file_offset_of_buffer_end
 
                         read_type = ReadType::CACHED;
-                        file_segment->resetDownloader();
-                        return getCacheReadBuffer(*file_segment);
+                        file_segment.resetDownloader();
+                        return getCacheReadBuffer(file_segment);
                     }
 
-                    if (file_segment->getCurrentWriteOffset() < file_offset_of_buffer_end)
+                    auto current_write_offset = file_segment.getCurrentWriteOffset(false);
+                    if (current_write_offset < file_offset_of_buffer_end)
                     {
                         ///                   segment{1}
                         /// cache:         [_____|___________
@@ -342,25 +342,25 @@ CachedOnDiskReadBufferFromFile::getReadBufferForFileSegment(FileSegmentPtr & fil
                         ///                           ^
                         ///                           file_offset_of_buffer_end
 
-                        LOG_TEST(log, "Predownload. File segment info: {}", file_segment->getInfoForLog());
-                        chassert(file_offset_of_buffer_end > file_segment->getCurrentWriteOffset());
-                        bytes_to_predownload = file_offset_of_buffer_end - file_segment->getCurrentWriteOffset();
-                        chassert(bytes_to_predownload < file_segment->range().size());
+                        LOG_TEST(log, "Predownload. File segment info: {}", file_segment.getInfoForLog());
+                        chassert(file_offset_of_buffer_end > current_write_offset);
+                        bytes_to_predownload = file_offset_of_buffer_end - current_write_offset;
+                        chassert(bytes_to_predownload < file_segment.range().size());
                     }
 
                     read_type = ReadType::REMOTE_FS_READ_AND_PUT_IN_CACHE;
-                    return getRemoteFSReadBuffer(*file_segment, read_type);
+                    return getRemoteReadBuffer(file_segment, read_type);
                 }
 
-                download_state = file_segment->state();
+                download_state = file_segment.state();
                 continue;
             }
             case FileSegment::State::PARTIALLY_DOWNLOADED_NO_CONTINUATION:
             {
-                if (canStartFromCache(file_offset_of_buffer_end, *file_segment))
+                if (canStartFromCache(file_offset_of_buffer_end, file_segment))
                 {
                     read_type = ReadType::CACHED;
-                    return getCacheReadBuffer(*file_segment);
+                    return getCacheReadBuffer(file_segment);
                 }
                 else
                 {
@@ -368,7 +368,7 @@ CachedOnDiskReadBufferFromFile::getReadBufferForFileSegment(FileSegmentPtr & fil
                         log,
                         "Bypassing cache because file segment state is `PARTIALLY_DOWNLOADED_NO_CONTINUATION` and downloaded part already used");
                     read_type = ReadType::REMOTE_FS_READ_BYPASS_CACHE;
-                    return getRemoteFSReadBuffer(*file_segment, read_type);
+                    return getRemoteReadBuffer(file_segment, read_type);
                 }
             }
         }
@@ -376,12 +376,12 @@ CachedOnDiskReadBufferFromFile::getReadBufferForFileSegment(FileSegmentPtr & fil
 }
 
 CachedOnDiskReadBufferFromFile::ImplementationBufferPtr
-CachedOnDiskReadBufferFromFile::getImplementationBuffer(FileSegmentPtr & file_segment)
+CachedOnDiskReadBufferFromFile::getImplementationBuffer(FileSegment & file_segment)
 {
-    chassert(!file_segment->isDownloader());
-    chassert(file_offset_of_buffer_end >= file_segment->range().left);
+    chassert(!file_segment.isDownloader());
+    chassert(file_offset_of_buffer_end >= file_segment.range().left);
 
-    auto range = file_segment->range();
+    auto range = file_segment.range();
     bytes_to_predownload = 0;
 
     Stopwatch watch(CLOCK_MONOTONIC);
@@ -393,17 +393,18 @@ CachedOnDiskReadBufferFromFile::getImplementationBuffer(FileSegmentPtr & file_se
         ProfileEvents::FileSegmentWaitReadBufferMicroseconds, watch.elapsedMicroseconds());
 
     [[maybe_unused]] auto download_current_segment = read_type == ReadType::REMOTE_FS_READ_AND_PUT_IN_CACHE;
-    chassert(download_current_segment == file_segment->isDownloader());
+    chassert(download_current_segment == file_segment.isDownloader());
 
-    chassert(file_segment->range() == range);
+    chassert(file_segment.range() == range);
     chassert(file_offset_of_buffer_end >= range.left && file_offset_of_buffer_end <= range.right);
 
     LOG_TEST(
         log,
-        "Current file segment: {}, read type: {}, current file offset: {}",
-        range.toString(),
+        "Current read type: {}, read offset: {}, impl read range: {}, file segment: {}",
         toString(read_type),
-        file_offset_of_buffer_end);
+        file_offset_of_buffer_end,
+        read_buffer_for_file_segment->getFileOffsetOfBufferEnd(),
+        file_segment.getInfoForLog());
 
     read_buffer_for_file_segment->setReadUntilPosition(range.right + 1); /// [..., range.right]
 
@@ -445,11 +446,11 @@ CachedOnDiskReadBufferFromFile::getImplementationBuffer(FileSegmentPtr & file_se
         }
         case ReadType::REMOTE_FS_READ_AND_PUT_IN_CACHE:
         {
-            chassert(file_segment->isDownloader());
+            chassert(file_segment.isDownloader());
 
             if (bytes_to_predownload)
             {
-                size_t current_write_offset = file_segment->getCurrentWriteOffset();
+                const size_t current_write_offset = file_segment.getCurrentWriteOffset(false);
                 read_buffer_for_file_segment->seek(current_write_offset, SEEK_SET);
             }
             else
@@ -459,7 +460,7 @@ CachedOnDiskReadBufferFromFile::getImplementationBuffer(FileSegmentPtr & file_se
                 assert(read_buffer_for_file_segment->getFileOffsetOfBufferEnd() == file_offset_of_buffer_end);
             }
 
-            auto current_write_offset = file_segment->getCurrentWriteOffset();
+            const auto current_write_offset = file_segment.getCurrentWriteOffset(false);
             if (current_write_offset != static_cast<size_t>(read_buffer_for_file_segment->getPosition()))
             {
                 throw Exception(
@@ -470,7 +471,7 @@ CachedOnDiskReadBufferFromFile::getImplementationBuffer(FileSegmentPtr & file_se
                     current_write_offset,
                     read_buffer_for_file_segment->getPosition(),
                     read_buffer_for_file_segment->getFileOffsetOfBufferEnd(),
-                    file_segment->getInfoForLog());
+                    file_segment.getInfoForLog());
             }
 
             break;
@@ -484,52 +485,46 @@ CachedOnDiskReadBufferFromFile::getImplementationBuffer(FileSegmentPtr & file_se
 
 bool CachedOnDiskReadBufferFromFile::completeFileSegmentAndGetNext()
 {
-    LOG_TEST(log, "Completed segment: {}", (*current_file_segment_it)->range().toString());
+    auto * current_file_segment = &file_segments->front();
+    auto completed_range = current_file_segment->range();
 
     if (enable_logging)
-        appendFilesystemCacheLog((*current_file_segment_it)->range(), read_type);
+        appendFilesystemCacheLog(completed_range, read_type);
 
-    auto file_segment_it = current_file_segment_it++;
-    auto & file_segment = *file_segment_it;
-
-    [[maybe_unused]] const auto & range = file_segment->range();
-    chassert(file_offset_of_buffer_end > range.right);
-
-    LOG_TEST(
-        log,
-        "Removing file segment: {}, downloader: {}, state: {}",
-        file_segment->range().toString(),
-        file_segment->getDownloader(),
-        file_segment->state());
-
-    /// Do not hold pointer to file segment if it is not needed anymore
-    /// so can become releasable and can be evicted from cache.
-    file_segment->completeWithoutState();
-    file_segments_holder->file_segments.erase(file_segment_it);
-
-    if (current_file_segment_it == file_segments_holder->file_segments.end())
-        return false;
-
-    implementation_buffer = getImplementationBuffer(*current_file_segment_it);
+    chassert(file_offset_of_buffer_end > completed_range.right);
 
     if (read_type == ReadType::CACHED)
-        (*current_file_segment_it)->incrementHitsCount();
+    {
+        chassert(current_file_segment->getDownloadedSize(true) == current_file_segment->range().size());
+    }
+
+    file_segments->popFront();
+    if (file_segments->empty())
+        return false;
+
+    current_file_segment = &file_segments->front();
+    current_file_segment->use();
+    implementation_buffer = getImplementationBuffer(*current_file_segment);
+
+    if (read_type == ReadType::CACHED)
+        current_file_segment->incrementHitsCount();
+
+    LOG_TEST(
+        log, "New segment range: {}, old range: {}",
+        current_file_segment->range().toString(), completed_range.toString());
 
-    LOG_TEST(log, "New segment: {}", (*current_file_segment_it)->range().toString());
     return true;
 }
 
 CachedOnDiskReadBufferFromFile::~CachedOnDiskReadBufferFromFile()
 {
-    if (enable_logging
-        && file_segments_holder
-        && current_file_segment_it != file_segments_holder->file_segments.end())
+    if (enable_logging && file_segments && !file_segments->empty())
     {
-        appendFilesystemCacheLog((*current_file_segment_it)->range(), read_type);
+        appendFilesystemCacheLog(file_segments->front().range(), read_type);
     }
 }
 
-void CachedOnDiskReadBufferFromFile::predownload(FileSegmentPtr & file_segment)
+void CachedOnDiskReadBufferFromFile::predownload(FileSegment & file_segment)
 {
     Stopwatch predownload_watch(CLOCK_MONOTONIC);
     SCOPE_EXIT({
@@ -548,9 +543,10 @@ void CachedOnDiskReadBufferFromFile::predownload(FileSegmentPtr & file_segment)
         /// download from offset a'' < a', but return buffer from offset a'.
         LOG_TEST(log, "Bytes to predownload: {}, caller_id: {}", bytes_to_predownload, FileSegment::getCallerId());
 
-        chassert(static_cast<size_t>(implementation_buffer->getPosition()) == file_segment->getCurrentWriteOffset());
-        size_t current_offset = file_segment->getCurrentWriteOffset();
-        const auto & current_range = file_segment->range();
+        /// chassert(implementation_buffer->getFileOffsetOfBufferEnd() == file_segment.getCurrentWriteOffset(false));
+        chassert(static_cast<size_t>(implementation_buffer->getPosition()) == file_segment.getCurrentWriteOffset(false));
+        size_t current_offset = file_segment.getCurrentWriteOffset(false);
+        const auto & current_range = file_segment.range();
 
         while (true)
         {
@@ -575,7 +571,7 @@ void CachedOnDiskReadBufferFromFile::predownload(FileSegmentPtr & file_segment)
                         "current download offset: {}, expected: {}, eof: {}",
                         bytes_to_predownload,
                         current_range.toString(),
-                        file_segment->getCurrentWriteOffset(),
+                        file_segment.getCurrentWriteOffset(false),
                         file_offset_of_buffer_end,
                         implementation_buffer->eof());
 
@@ -585,7 +581,7 @@ void CachedOnDiskReadBufferFromFile::predownload(FileSegmentPtr & file_segment)
                 {
                     nextimpl_working_buffer_offset = implementation_buffer->offset();
 
-                    auto current_write_offset = file_segment->getCurrentWriteOffset();
+                    auto current_write_offset = file_segment.getCurrentWriteOffset(false);
                     if (current_write_offset != static_cast<size_t>(implementation_buffer->getPosition())
                         || current_write_offset != file_offset_of_buffer_end)
                     {
@@ -597,7 +593,7 @@ void CachedOnDiskReadBufferFromFile::predownload(FileSegmentPtr & file_segment)
                             current_write_offset,
                             file_offset_of_buffer_end,
                             implementation_buffer->getPosition(),
-                            file_segment->getInfoForLog());
+                            file_segment.getInfoForLog());
                     }
                 }
 
@@ -609,15 +605,15 @@ void CachedOnDiskReadBufferFromFile::predownload(FileSegmentPtr & file_segment)
 
             ProfileEvents::increment(ProfileEvents::CachedReadBufferReadFromSourceBytes, current_impl_buffer_size);
 
-            bool continue_predownload = file_segment->reserve(current_predownload_size);
+            bool continue_predownload = file_segment.reserve(current_predownload_size);
             if (continue_predownload)
             {
                 LOG_TEST(log, "Left to predownload: {}, buffer size: {}", bytes_to_predownload, current_impl_buffer_size);
 
-                chassert(file_segment->getCurrentWriteOffset() == static_cast<size_t>(implementation_buffer->getPosition()));
+                chassert(file_segment.getCurrentWriteOffset(false) == static_cast<size_t>(implementation_buffer->getPosition()));
 
-                bool success = writeCache(implementation_buffer->buffer().begin(), current_predownload_size, current_offset, *file_segment);
-                if (success)
+                continue_predownload = writeCache(implementation_buffer->buffer().begin(), current_predownload_size, current_offset, file_segment);
+                if (continue_predownload)
                 {
                     current_offset += current_predownload_size;
 
@@ -627,13 +623,8 @@ void CachedOnDiskReadBufferFromFile::predownload(FileSegmentPtr & file_segment)
                 else
                 {
                     LOG_TEST(log, "Bypassing cache because writeCache (in predownload) method failed");
-                    continue_predownload = false;
                 }
             }
-            else
-            {
-                file_segment->completeWithState(FileSegment::State::PARTIALLY_DOWNLOADED_NO_CONTINUATION);
-            }
 
             if (!continue_predownload)
             {
@@ -653,21 +644,21 @@ void CachedOnDiskReadBufferFromFile::predownload(FileSegmentPtr & file_segment)
                 /// TODO: allow seek more than once with seek avoiding.
 
                 bytes_to_predownload = 0;
+                file_segment.completePartAndResetDownloader();
+                chassert(file_segment.state() == FileSegment::State::PARTIALLY_DOWNLOADED_NO_CONTINUATION);
 
-                chassert(file_segment->state() == FileSegment::State::PARTIALLY_DOWNLOADED_NO_CONTINUATION
-                         || file_segment->state() == FileSegment::State::SKIP_CACHE);
-                LOG_TEST(log, "Bypassing cache because for {}", file_segment->getInfoForLog());
+                LOG_TEST(log, "Bypassing cache because for {}", file_segment.getInfoForLog());
 
                 read_type = ReadType::REMOTE_FS_READ_BYPASS_CACHE;
 
                 swap(*implementation_buffer);
                 resetWorkingBuffer();
 
-                implementation_buffer = getRemoteFSReadBuffer(*file_segment, read_type);
+                implementation_buffer = getRemoteReadBuffer(file_segment, read_type);
 
                 swap(*implementation_buffer);
 
-                implementation_buffer->setReadUntilPosition(file_segment->range().right + 1); /// [..., range.right]
+                implementation_buffer->setReadUntilPosition(file_segment.range().right + 1); /// [..., range.right]
                 implementation_buffer->seek(file_offset_of_buffer_end, SEEK_SET);
 
                 LOG_TRACE(
@@ -684,12 +675,12 @@ void CachedOnDiskReadBufferFromFile::predownload(FileSegmentPtr & file_segment)
 
 bool CachedOnDiskReadBufferFromFile::updateImplementationBufferIfNeeded()
 {
-    auto & file_segment = *current_file_segment_it;
-    auto current_read_range = file_segment->range();
-    auto current_state = file_segment->state();
+    auto & file_segment = file_segments->front();
+    const auto & current_read_range = file_segment.range();
+    auto current_state = file_segment.state();
 
     chassert(current_read_range.left <= file_offset_of_buffer_end);
-    chassert(!file_segment->isDownloader());
+    chassert(!file_segment.isDownloader());
 
     if (file_offset_of_buffer_end > current_read_range.right)
     {
@@ -708,7 +699,7 @@ bool CachedOnDiskReadBufferFromFile::updateImplementationBufferIfNeeded()
         ///                     ^
         ///                     file_offset_of_buffer_end
 
-        auto current_write_offset = file_segment->getCurrentWriteOffset();
+        auto current_write_offset = file_segment.getCurrentWriteOffset(true);
         bool cached_part_is_finished = current_write_offset == file_offset_of_buffer_end;
 
         LOG_TEST(log, "Current write offset: {}, file offset of buffer end: {}", current_write_offset, file_offset_of_buffer_end);
@@ -716,7 +707,7 @@ bool CachedOnDiskReadBufferFromFile::updateImplementationBufferIfNeeded()
         if (cached_part_is_finished)
         {
             /// TODO: makes sense to reuse local file reader if we return here with CACHED read type again?
-            implementation_buffer = getImplementationBuffer(*current_file_segment_it);
+            implementation_buffer = getImplementationBuffer(file_segment);
 
             return true;
         }
@@ -744,7 +735,7 @@ bool CachedOnDiskReadBufferFromFile::updateImplementationBufferIfNeeded()
         * to read by marks range given to him. Therefore, each nextImpl() call, in case of
         * READ_AND_PUT_IN_CACHE, starts with getOrSetDownloader().
         */
-        implementation_buffer = getImplementationBuffer(*current_file_segment_it);
+        implementation_buffer = getImplementationBuffer(file_segment);
     }
 
     return true;
@@ -795,15 +786,13 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
 {
     last_caller_id = FileSegment::getCallerId();
 
-    assertCorrectness();
-
     if (file_offset_of_buffer_end == read_until_position)
         return false;
 
     if (!initialized)
         initialize(file_offset_of_buffer_end, getTotalSizeToRead());
 
-    if (current_file_segment_it == file_segments_holder->file_segments.end())
+    if (file_segments->empty())
         return false;
 
     bool implementation_buffer_can_be_reused = false;
@@ -813,25 +802,25 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
             /// Save state of current file segment before it is completed.
             nextimpl_step_log_info = getInfoForLog();
 
-            if (current_file_segment_it == file_segments_holder->file_segments.end())
+            if (file_segments->empty())
                 return;
 
-            auto & file_segment = *current_file_segment_it;
+            auto & file_segment = file_segments->front();
 
             bool download_current_segment = read_type == ReadType::REMOTE_FS_READ_AND_PUT_IN_CACHE;
             if (download_current_segment)
             {
-                bool need_complete_file_segment = file_segment->isDownloader();
+                bool need_complete_file_segment = file_segment.isDownloader();
                 if (need_complete_file_segment)
                 {
                     if (!implementation_buffer_can_be_reused)
-                        file_segment->resetRemoteFileReader();
+                        file_segment.resetRemoteFileReader();
 
-                    file_segment->completePartAndResetDownloader();
+                    file_segment.completePartAndResetDownloader();
                 }
             }
 
-            chassert(!file_segment->isDownloader());
+            chassert(!file_segment.isDownloader());
         }
         catch (...)
         {
@@ -849,10 +838,10 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
     }
     else
     {
-        implementation_buffer = getImplementationBuffer(*current_file_segment_it);
+        implementation_buffer = getImplementationBuffer(file_segments->front());
 
         if (read_type == ReadType::CACHED)
-            (*current_file_segment_it)->incrementHitsCount();
+            file_segments->front().incrementHitsCount();
     }
 
     chassert(!internal_buffer.empty());
@@ -863,16 +852,16 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
     // the caller doesn't try to use this CachedOnDiskReadBufferFromFile after it threw an exception.)
     swap(*implementation_buffer);
 
-    auto & file_segment = *current_file_segment_it;
-    auto current_read_range = file_segment->range();
+    auto & file_segment = file_segments->front();
+    const auto & current_read_range = file_segment.range();
 
     LOG_TEST(
         log,
-        "Current count: {}, position: {}, buffer end: {}, file segment: {}",
-        implementation_buffer->count(),
-        implementation_buffer->getPosition(),
+        "Current read type: {}, read offset: {}, impl offset: {}, file segment: {}",
+        toString(read_type),
+        file_offset_of_buffer_end,
         implementation_buffer->getFileOffsetOfBufferEnd(),
-        file_segment->getInfoForLog());
+        file_segment.getInfoForLog());
 
     chassert(current_read_range.left <= file_offset_of_buffer_end);
     chassert(current_read_range.right >= file_offset_of_buffer_end);
@@ -890,12 +879,12 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
     }
 
     auto download_current_segment = read_type == ReadType::REMOTE_FS_READ_AND_PUT_IN_CACHE;
-    if (download_current_segment != file_segment->isDownloader())
+    if (download_current_segment != file_segment.isDownloader())
     {
         throw Exception(
             ErrorCodes::LOGICAL_ERROR,
             "Incorrect segment state. Having read type: {}, file segment info: {}",
-            toString(read_type), file_segment->getInfoForLog());
+            toString(read_type), file_segment.getInfoForLog());
     }
 
     if (!result)
@@ -937,7 +926,7 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
             log,
             "Read {} bytes, read type {}, position: {}, offset: {}, segment end: {}",
             size, toString(read_type), implementation_buffer->getPosition(),
-            implementation_buffer->getFileOffsetOfBufferEnd(), file_segment->range().right);
+            implementation_buffer->getFileOffsetOfBufferEnd(), file_segment.range().right);
 
         if (read_type == ReadType::CACHED)
         {
@@ -955,20 +944,20 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
     {
         if (download_current_segment)
         {
-            chassert(file_offset_of_buffer_end + size - 1 <= file_segment->range().right);
+            chassert(file_offset_of_buffer_end + size - 1 <= file_segment.range().right);
 
-            bool success = file_segment->reserve(size);
+            bool success = file_segment.reserve(size);
             if (success)
             {
-                chassert(file_segment->getCurrentWriteOffset() == static_cast<size_t>(implementation_buffer->getPosition()));
+                chassert(file_segment.getCurrentWriteOffset(false) == static_cast<size_t>(implementation_buffer->getPosition()));
 
-                success = writeCache(implementation_buffer->position(), size, file_offset_of_buffer_end, *file_segment);
+                success = writeCache(implementation_buffer->position(), size, file_offset_of_buffer_end, file_segment);
                 if (success)
                 {
-                    chassert(file_segment->getCurrentWriteOffset() <= file_segment->range().right + 1);
+                    chassert(file_segment.getCurrentWriteOffset(false) <= file_segment.range().right + 1);
                     chassert(
-                        std::next(current_file_segment_it) == file_segments_holder->file_segments.end()
-                        || file_segment->getCurrentWriteOffset() == implementation_buffer->getFileOffsetOfBufferEnd());
+                        /* last_file_segment */file_segments->size() == 1
+                        || file_segment.getCurrentWriteOffset(false) == implementation_buffer->getFileOffsetOfBufferEnd());
 
                     LOG_TEST(log, "Successfully written {} bytes", size);
 
@@ -980,20 +969,13 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
                 }
                 else
                 {
-                    chassert(file_segment->state() == FileSegment::State::PARTIALLY_DOWNLOADED_NO_CONTINUATION);
+                    chassert(file_segment.state() == FileSegment::State::PARTIALLY_DOWNLOADED_NO_CONTINUATION);
                     LOG_TRACE(log, "Bypassing cache because writeCache method failed");
                 }
             }
             else
             {
                 LOG_TRACE(log, "No space left in cache to reserve {} bytes, will continue without cache download", size);
-                file_segment->completeWithState(FileSegment::State::PARTIALLY_DOWNLOADED_NO_CONTINUATION);
-            }
-
-            if (!success)
-            {
-                read_type = ReadType::REMOTE_FS_READ_BYPASS_CACHE;
-                download_current_segment = false;
             }
         }
 
@@ -1003,7 +985,7 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
         /// Therefore need to resize to a smaller size. And resize must be done after write into cache.
         /// - If last file segment was read from local fs, then we could read more than
         /// file_segemnt->range().right, so resize is also needed.
-        if (std::next(current_file_segment_it) == file_segments_holder->file_segments.end())
+        if (file_segments->size() == 1)
         {
             size_t remaining_size_to_read
                 = std::min(current_read_range.right, read_until_position - 1) - file_offset_of_buffer_end + 1;
@@ -1023,17 +1005,17 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
 
     // No necessary because of the SCOPE_EXIT above, but useful for logging below.
     if (download_current_segment)
-        file_segment->completePartAndResetDownloader();
+        file_segment.completePartAndResetDownloader();
 
-    chassert(!file_segment->isDownloader());
+    chassert(!file_segment.isDownloader());
 
     LOG_TEST(
         log,
         "Key: {}. Returning with {} bytes, buffer position: {} (offset: {}, predownloaded: {}), "
-        "buffer available: {}, current range: {}, current offset: {}, file segment state: {}, "
+        "buffer available: {}, current range: {}, file offset of buffer end: {}, impl offset: {}, file segment state: {}, "
         "current write offset: {}, read_type: {}, reading until position: {}, started with offset: {}, "
         "remaining ranges: {}",
-        getHexUIntLowercase(cache_key),
+        cache_key.toString(),
         working_buffer.size(),
         getPosition(),
         offset(),
@@ -1041,12 +1023,13 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
         available(),
         current_read_range.toString(),
         file_offset_of_buffer_end,
-        FileSegment::stateToString(file_segment->state()),
-        file_segment->getCurrentWriteOffset(),
+        implementation_buffer->getFileOffsetOfBufferEnd(),
+        FileSegment::stateToString(file_segment.state()),
+        file_segment.getCurrentWriteOffset(false),
         toString(read_type),
         read_until_position,
         first_offset,
-        file_segments_holder->toString());
+        file_segments->toString());
 
     if (size == 0 && file_offset_of_buffer_end < read_until_position)
     {
@@ -1065,7 +1048,7 @@ bool CachedOnDiskReadBufferFromFile::nextImplStep()
             cache_file_size ? std::to_string(cache_file_size) : "None",
             cache_file_path,
             implementation_buffer->getFileOffsetOfBufferEnd(),
-            file_segment->getInfoForLog());
+            file_segment.getInfoForLog());
     }
 
     return result;
@@ -1113,13 +1096,13 @@ off_t CachedOnDiskReadBufferFromFile::seek(off_t offset, int whence)
     first_offset = file_offset_of_buffer_end = new_pos;
     resetWorkingBuffer();
 
-    // if (file_segments_holder && current_file_segment_it != file_segments_holder->file_segments.end())
+    // if (file_segments && current_file_segment_it != file_segments->file_segments.end())
     // {
-    //      auto & file_segments = file_segments_holder->file_segments;
+    //      auto & file_segments = file_segments->file_segments;
     //      LOG_TRACE(
     //          log,
     //          "Having {} file segments to read: {}, current offset: {}",
-    //          file_segments_holder->file_segments.size(), file_segments_holder->toString(), file_offset_of_buffer_end);
+    //          file_segments->file_segments.size(), file_segments->toString(), file_offset_of_buffer_end);
 
     //      auto it = std::upper_bound(
     //          file_segments.begin(),
@@ -1150,7 +1133,7 @@ off_t CachedOnDiskReadBufferFromFile::seek(off_t offset, int whence)
     //      }
     // }
 
-    file_segments_holder.reset();
+    file_segments.reset();
     implementation_buffer.reset();
     initialized = false;
 
@@ -1185,7 +1168,7 @@ void CachedOnDiskReadBufferFromFile::setReadUntilPosition(size_t position)
 
     file_offset_of_buffer_end = getPosition();
     resetWorkingBuffer();
-    file_segments_holder.reset();
+    file_segments.reset();
     implementation_buffer.reset();
     initialized = false;
 
@@ -1204,25 +1187,9 @@ off_t CachedOnDiskReadBufferFromFile::getPosition()
     return file_offset_of_buffer_end - available();
 }
 
-std::optional<size_t> CachedOnDiskReadBufferFromFile::getLastNonDownloadedOffset() const
-{
-    if (!file_segments_holder)
-        throw Exception(ErrorCodes::LOGICAL_ERROR, "File segments holder not initialized");
-
-    const auto & file_segments = file_segments_holder->file_segments;
-    for (auto it = file_segments.rbegin(); it != file_segments.rend(); ++it)
-    {
-        const auto & file_segment = *it;
-        if (file_segment->state() != FileSegment::State::DOWNLOADED)
-            return file_segment->range().right;
-    }
-
-    return std::nullopt;
-}
-
 void CachedOnDiskReadBufferFromFile::assertCorrectness() const
 {
-    if (FileCache::isReadOnly()
+    if (!CachedObjectStorage::canUseReadThroughCache()
         && !settings.read_from_filesystem_cache_if_exists_otherwise_bypass_cache)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "Cache usage is not allowed (query_id: {})", query_id);
 }
@@ -1230,16 +1197,16 @@ void CachedOnDiskReadBufferFromFile::assertCorrectness() const
 String CachedOnDiskReadBufferFromFile::getInfoForLog()
 {
     String current_file_segment_info;
-    if (current_file_segment_it != file_segments_holder->file_segments.end())
-        current_file_segment_info = (*current_file_segment_it)->getInfoForLog();
-    else
+    if (file_segments->empty())
         current_file_segment_info = "None";
+    else
+        current_file_segment_info = file_segments->front().getInfoForLog();
 
     return fmt::format(
         "Buffer path: {}, hash key: {}, file_offset_of_buffer_end: {}, read_until_position: {}, "
         "internal buffer end: {}, read_type: {}, last caller: {}, file segment info: {}",
         source_file_path,
-        getHexUIntLowercase(cache_key),
+        cache_key.toString(),
         file_offset_of_buffer_end,
         read_until_position,
         implementation_buffer ? std::to_string(implementation_buffer->getFileOffsetOfBufferEnd()) : "None",
diff --git a/src/Disks/IO/CachedOnDiskReadBufferFromFile.h b/src/Disks/IO/CachedOnDiskReadBufferFromFile.h
index d3c265a522b..bd8d5af7bcd 100644
--- a/src/Disks/IO/CachedOnDiskReadBufferFromFile.h
+++ b/src/Disks/IO/CachedOnDiskReadBufferFromFile.h
@@ -62,25 +62,28 @@ public:
 
 private:
     void initialize(size_t offset, size_t size);
+    void assertCorrectness() const;
 
-    ImplementationBufferPtr getImplementationBuffer(FileSegmentPtr & file_segment);
+    /**
+     * Return a list of file segments ordered in ascending order. This list represents
+     * a full contiguous interval (without holes).
+     */
+    FileSegmentsHolderPtr getFileSegments(size_t offset, size_t size) const;
 
-    ImplementationBufferPtr getReadBufferForFileSegment(FileSegmentPtr & file_segment);
+    ImplementationBufferPtr getImplementationBuffer(FileSegment & file_segment);
+
+    ImplementationBufferPtr getReadBufferForFileSegment(FileSegment & file_segment);
 
     ImplementationBufferPtr getCacheReadBuffer(const FileSegment & file_segment) const;
 
-    std::optional<size_t> getLastNonDownloadedOffset() const;
+    ImplementationBufferPtr getRemoteReadBuffer(FileSegment & file_segment, ReadType read_type_);
 
     bool updateImplementationBufferIfNeeded();
 
-    void predownload(FileSegmentPtr & file_segment);
+    void predownload(FileSegment & file_segment);
 
     bool nextImplStep();
 
-    void assertCorrectness() const;
-
-    std::shared_ptr<ReadBufferFromFileBase> getRemoteFSReadBuffer(FileSegment & file_segment, ReadType read_type_);
-
     size_t getTotalSizeToRead();
 
     bool completeFileSegmentAndGetNext();
@@ -107,8 +110,7 @@ private:
     /// Remote read buffer, which can only be owned by current buffer.
     FileSegment::RemoteFileReaderPtr remote_file_reader;
 
-    std::optional<FileSegmentsHolder> file_segments_holder;
-    FileSegments::iterator current_file_segment_it;
+    FileSegmentsHolderPtr file_segments;
 
     ImplementationBufferPtr implementation_buffer;
     bool initialized = false;
@@ -142,7 +144,7 @@ private:
     CurrentMetrics::Increment metric_increment{CurrentMetrics::FilesystemCacheReadBuffers};
     ProfileEvents::Counters current_file_segment_counters;
 
-    FileCache::QueryContextHolder query_context_holder;
+    FileCache::QueryContextHolderPtr query_context_holder;
 
     bool is_persistent;
 };
diff --git a/src/Disks/IO/CachedOnDiskWriteBufferFromFile.cpp b/src/Disks/IO/CachedOnDiskWriteBufferFromFile.cpp
index 169bbfac886..d72dcecb484 100644
--- a/src/Disks/IO/CachedOnDiskWriteBufferFromFile.cpp
+++ b/src/Disks/IO/CachedOnDiskWriteBufferFromFile.cpp
@@ -50,27 +50,29 @@ bool FileSegmentRangeWriter::write(const char * data, size_t size, size_t offset
             offset, expected_write_offset);
     }
 
-    auto & file_segments = file_segments_holder.file_segments;
+    FileSegment * file_segment;
 
-    if (file_segments.empty() || file_segments.back()->isDownloaded())
+    if (file_segments.empty() || file_segments.back().isDownloaded())
     {
-        allocateFileSegment(expected_write_offset, segment_kind);
+        file_segment = &allocateFileSegment(expected_write_offset, segment_kind);
+    }
+    else
+    {
+        file_segment = &file_segments.back();
     }
 
-    auto & file_segment = file_segments.back();
-
     SCOPE_EXIT({
-        if (file_segments.back()->isDownloader())
-            file_segments.back()->completePartAndResetDownloader();
+        if (file_segments.back().isDownloader())
+            file_segments.back().completePartAndResetDownloader();
     });
 
     while (size > 0)
     {
-        size_t available_size = file_segment->range().size() - file_segment->getDownloadedSize();
+        size_t available_size = file_segment->range().size() - file_segment->getDownloadedSize(false);
         if (available_size == 0)
         {
             completeFileSegment(*file_segment);
-            file_segment = allocateFileSegment(expected_write_offset, segment_kind);
+            file_segment = &allocateFileSegment(expected_write_offset, segment_kind);
             continue;
         }
 
@@ -86,7 +88,6 @@ bool FileSegmentRangeWriter::write(const char * data, size_t size, size_t offset
         bool reserved = file_segment->reserve(size_to_write);
         if (!reserved)
         {
-            file_segment->completeWithState(FileSegment::State::PARTIALLY_DOWNLOADED_NO_CONTINUATION);
             appendFilesystemCacheLog(*file_segment);
 
             LOG_DEBUG(
@@ -113,11 +114,10 @@ void FileSegmentRangeWriter::finalize()
     if (finalized)
         return;
 
-    auto & file_segments = file_segments_holder.file_segments;
     if (file_segments.empty())
         return;
 
-    completeFileSegment(*file_segments.back());
+    completeFileSegment(file_segments.back());
     finalized = true;
 }
 
@@ -134,24 +134,21 @@ FileSegmentRangeWriter::~FileSegmentRangeWriter()
     }
 }
 
-FileSegmentPtr & FileSegmentRangeWriter::allocateFileSegment(size_t offset, FileSegmentKind segment_kind)
+FileSegment & FileSegmentRangeWriter::allocateFileSegment(size_t offset, FileSegmentKind segment_kind)
 {
     /**
     * Allocate a new file segment starting `offset`.
     * File segment capacity will equal `max_file_segment_size`, but actual size is 0.
     */
 
-    std::lock_guard cache_lock(cache->mutex);
-
-    CreateFileSegmentSettings create_settings(segment_kind);
+    CreateFileSegmentSettings create_settings(segment_kind, false);
 
     /// We set max_file_segment_size to be downloaded,
     /// if we have less size to write, file segment will be resized in complete() method.
-    auto file_segment = cache->createFileSegmentForDownload(
-        key, offset, cache->max_file_segment_size, create_settings, cache_lock);
-
-    auto & file_segments = file_segments_holder.file_segments;
-    return *file_segments.insert(file_segments.end(), file_segment);
+    auto holder = cache->set(key, offset, cache->getMaxFileSegmentSize(), create_settings);
+    chassert(holder->size() == 1);
+    holder->moveTo(file_segments);
+    return file_segments.back();
 }
 
 void FileSegmentRangeWriter::appendFilesystemCacheLog(const FileSegment & file_segment)
@@ -159,7 +156,7 @@ void FileSegmentRangeWriter::appendFilesystemCacheLog(const FileSegment & file_s
     if (cache_log)
     {
         auto file_segment_range = file_segment.range();
-        size_t file_segment_right_bound = file_segment_range.left + file_segment.getDownloadedSize() - 1;
+        size_t file_segment_right_bound = file_segment_range.left + file_segment.getDownloadedSize(false) - 1;
 
         FilesystemCacheLogElement elem
         {
@@ -185,7 +182,7 @@ void FileSegmentRangeWriter::completeFileSegment(FileSegment & file_segment)
     if (file_segment.isDetached() || file_segment.isCompleted())
         return;
 
-    file_segment.completeWithoutState();
+    file_segment.complete();
     appendFilesystemCacheLog(file_segment);
 }
 
@@ -224,7 +221,7 @@ void CachedOnDiskWriteBufferFromFile::nextImpl()
     {
         /// If something was already written to cache, remove it.
         cache_writer.reset();
-        cache->removeIfExists(key);
+        cache->removeKeyIfExists(key);
 
         throw;
     }
diff --git a/src/Disks/IO/CachedOnDiskWriteBufferFromFile.h b/src/Disks/IO/CachedOnDiskWriteBufferFromFile.h
index 834e584c8db..194afe88d88 100644
--- a/src/Disks/IO/CachedOnDiskWriteBufferFromFile.h
+++ b/src/Disks/IO/CachedOnDiskWriteBufferFromFile.h
@@ -39,7 +39,7 @@ public:
     ~FileSegmentRangeWriter();
 
 private:
-    FileSegmentPtr & allocateFileSegment(size_t offset, FileSegmentKind segment_kind);
+    FileSegment & allocateFileSegment(size_t offset, FileSegmentKind segment_kind);
 
     void appendFilesystemCacheLog(const FileSegment & file_segment);
 
@@ -53,7 +53,7 @@ private:
     String query_id;
     String source_path;
 
-    FileSegmentsHolder file_segments_holder{};
+    FileSegmentsHolder file_segments{};
 
     size_t expected_write_offset = 0;
 
diff --git a/src/Disks/IO/ReadBufferFromRemoteFSGather.cpp b/src/Disks/IO/ReadBufferFromRemoteFSGather.cpp
index 8450e740ab5..344abcbc95b 100644
--- a/src/Disks/IO/ReadBufferFromRemoteFSGather.cpp
+++ b/src/Disks/IO/ReadBufferFromRemoteFSGather.cpp
@@ -3,6 +3,7 @@
 #include <IO/SeekableReadBuffer.h>
 
 #include <Disks/IO/CachedOnDiskReadBufferFromFile.h>
+#include <Disks/ObjectStorages/Cached/CachedObjectStorage.h>
 #include <Common/logger_useful.h>
 #include <iostream>
 #include <base/hex.h>
@@ -56,7 +57,7 @@ SeekableReadBufferPtr ReadBufferFromRemoteFSGather::createImplementationBuffer(c
 
     if (with_cache)
     {
-        auto cache_key = settings.remote_fs_cache->hash(object_path);
+        auto cache_key = settings.remote_fs_cache->createKeyForPath(object_path);
         return std::make_shared<CachedOnDiskReadBufferFromFile>(
             object_path,
             cache_key,
diff --git a/src/Disks/ObjectStorages/Cached/CachedObjectStorage.cpp b/src/Disks/ObjectStorages/Cached/CachedObjectStorage.cpp
index 851b6ba24c9..b8022e9ed3a 100644
--- a/src/Disks/ObjectStorages/Cached/CachedObjectStorage.cpp
+++ b/src/Disks/ObjectStorages/Cached/CachedObjectStorage.cpp
@@ -43,13 +43,7 @@ DataSourceDescription CachedObjectStorage::getDataSourceDescription() const
 
 FileCache::Key CachedObjectStorage::getCacheKey(const std::string & path) const
 {
-    return cache->hash(path);
-}
-
-String CachedObjectStorage::getCachePath(const std::string & path) const
-{
-    FileCache::Key cache_key = getCacheKey(path);
-    return cache->getPathInLocalCache(cache_key);
+    return cache->createKeyForPath(path);
 }
 
 std::string CachedObjectStorage::generateBlobNameForPath(const std::string & path)
@@ -62,7 +56,7 @@ ReadSettings CachedObjectStorage::patchSettings(const ReadSettings & read_settin
     ReadSettings modified_settings{read_settings};
     modified_settings.remote_fs_cache = cache;
 
-    if (FileCache::isReadOnly())
+    if (!canUseReadThroughCache())
         modified_settings.read_from_filesystem_cache_if_exists_otherwise_bypass_cache = true;
 
     return IObjectStorage::patchSettings(modified_settings);
@@ -192,7 +186,6 @@ std::unique_ptr<WriteBufferFromFileBase> CachedObjectStorage::writeObject( /// N
     if (cache_on_write)
     {
         auto key = getCacheKey(path_key_for_cache);
-        LOG_TEST(log, "Caching file `{}` to `{}` with key {}", object.absolute_path, getCachePath(path_key_for_cache), key.toString());
 
         return std::make_unique<CachedOnDiskWriteBufferFromFile>(
             std::move(implementation_buffer),
@@ -213,7 +206,7 @@ void CachedObjectStorage::removeCacheIfExists(const std::string & path_key_for_c
         return;
 
     /// Add try catch?
-    cache->removeIfExists(getCacheKey(path_key_for_cache));
+    cache->removeKeyIfExists(getCacheKey(path_key_for_cache));
 }
 
 void CachedObjectStorage::removeObject(const StoredObject & object)
@@ -308,4 +301,11 @@ String CachedObjectStorage::getObjectsNamespace() const
     return object_storage->getObjectsNamespace();
 }
 
+bool CachedObjectStorage::canUseReadThroughCache()
+{
+    return CurrentThread::isInitialized()
+        && CurrentThread::get().getQueryContext()
+        && !CurrentThread::getQueryId().empty();
+}
+
 }
diff --git a/src/Disks/ObjectStorages/Cached/CachedObjectStorage.h b/src/Disks/ObjectStorages/Cached/CachedObjectStorage.h
index e61142f4d04..276f6669bfa 100644
--- a/src/Disks/ObjectStorages/Cached/CachedObjectStorage.h
+++ b/src/Disks/ObjectStorages/Cached/CachedObjectStorage.h
@@ -113,11 +113,11 @@ public:
 
     WriteSettings getAdjustedSettingsFromMetadataFile(const WriteSettings & settings, const std::string & path) const override;
 
+    static bool canUseReadThroughCache();
+
 private:
     FileCache::Key getCacheKey(const std::string & path) const;
 
-    String getCachePath(const std::string & path) const;
-
     ReadSettings patchSettings(const ReadSettings & read_settings) const override;
 
     ObjectStoragePtr object_storage;
diff --git a/src/Disks/ObjectStorages/DiskObjectStorage.cpp b/src/Disks/ObjectStorages/DiskObjectStorage.cpp
index 0b57b14eb1c..bf5d0ab829d 100644
--- a/src/Disks/ObjectStorages/DiskObjectStorage.cpp
+++ b/src/Disks/ObjectStorages/DiskObjectStorage.cpp
@@ -15,6 +15,7 @@
 #include <Disks/ObjectStorages/DiskObjectStorageRemoteMetadataRestoreHelper.h>
 #include <Disks/ObjectStorages/DiskObjectStorageTransaction.h>
 #include <Disks/FakeDiskTransaction.h>
+#include <Common/ThreadPool.h>
 #include <Poco/Util/AbstractConfiguration.h>
 #include <Interpreters/Context.h>
 
diff --git a/src/Disks/ObjectStorages/S3/diskSettings.cpp b/src/Disks/ObjectStorages/S3/diskSettings.cpp
index 529466a83c2..e34d646dfd4 100644
--- a/src/Disks/ObjectStorages/S3/diskSettings.cpp
+++ b/src/Disks/ObjectStorages/S3/diskSettings.cpp
@@ -128,7 +128,7 @@ std::unique_ptr<S3::Client> getClient(
     if (uri.key.back() != '/')
         throw Exception(ErrorCodes::BAD_ARGUMENTS, "S3 path must ends with '/', but '{}' doesn't.", uri.key);
 
-    client_configuration.connectTimeoutMs = config.getUInt(config_prefix + ".connect_timeout_ms", 10000);
+    client_configuration.connectTimeoutMs = config.getUInt(config_prefix + ".connect_timeout_ms", 1000);
     client_configuration.requestTimeoutMs = config.getUInt(config_prefix + ".request_timeout_ms", 30000);
     client_configuration.maxConnections = config.getUInt(config_prefix + ".max_connections", 100);
     client_configuration.endpointOverride = uri.endpoint;
diff --git a/src/Functions/FunctionStringReplace.h b/src/Functions/FunctionStringReplace.h
index 6199e146210..4d723a5632c 100644
--- a/src/Functions/FunctionStringReplace.h
+++ b/src/Functions/FunctionStringReplace.h
@@ -47,7 +47,9 @@ public:
 
     ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override
     {
-        const ColumnPtr column_haystack = arguments[0].column;
+        ColumnPtr column_haystack = arguments[0].column;
+        column_haystack = column_haystack->convertToFullColumnIfConst();
+
         const ColumnPtr column_needle = arguments[1].column;
         const ColumnPtr column_replacement = arguments[2].column;
 
diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h
index 46717923f7e..9c4085f9745 100644
--- a/src/Functions/FunctionsConversion.h
+++ b/src/Functions/FunctionsConversion.h
@@ -3301,7 +3301,7 @@ private:
         };
     }
 
-    WrapperType createMapToMapWrrapper(const DataTypes & from_kv_types, const DataTypes & to_kv_types) const
+    WrapperType createMapToMapWrapper(const DataTypes & from_kv_types, const DataTypes & to_kv_types) const
     {
         return [element_wrappers = getElementWrappers(from_kv_types, to_kv_types), from_kv_types, to_kv_types]
             (ColumnsWithTypeAndName & arguments, const DataTypePtr &, const ColumnNullable * nullable_source, size_t /*input_rows_count*/) -> ColumnPtr
@@ -3322,7 +3322,7 @@ private:
     }
 
     /// The case of: [(key1, value1), (key2, value2), ...]
-    WrapperType createArrayToMapWrrapper(const DataTypes & from_kv_types, const DataTypes & to_kv_types) const
+    WrapperType createArrayToMapWrapper(const DataTypes & from_kv_types, const DataTypes & to_kv_types) const
     {
         return [element_wrappers = getElementWrappers(from_kv_types, to_kv_types), from_kv_types, to_kv_types]
             (ColumnsWithTypeAndName & arguments, const DataTypePtr &, const ColumnNullable * nullable_source, size_t /*input_rows_count*/) -> ColumnPtr
@@ -3348,8 +3348,12 @@ private:
         if (const auto * from_tuple = checkAndGetDataType<DataTypeTuple>(from_type_untyped.get()))
         {
             if (from_tuple->getElements().size() != 2)
-                throw Exception(ErrorCodes::TYPE_MISMATCH, "CAST AS Map from tuple requeires 2 elements. "
-                    "Left type: {}, right type: {}", from_tuple->getName(), to_type->getName());
+                throw Exception(
+                    ErrorCodes::TYPE_MISMATCH,
+                    "CAST AS Map from tuple requires 2 elements. "
+                    "Left type: {}, right type: {}",
+                    from_tuple->getName(),
+                    to_type->getName());
 
             DataTypes from_kv_types;
             const auto & to_kv_types = to_type->getKeyValueTypes();
@@ -3370,14 +3374,18 @@ private:
         {
             const auto * nested_tuple = typeid_cast<const DataTypeTuple *>(from_array->getNestedType().get());
             if (!nested_tuple || nested_tuple->getElements().size() != 2)
-                throw Exception(ErrorCodes::TYPE_MISMATCH, "CAST AS Map from array requeires nested tuple of 2 elements. "
-                    "Left type: {}, right type: {}", from_array->getName(), to_type->getName());
+                throw Exception(
+                    ErrorCodes::TYPE_MISMATCH,
+                    "CAST AS Map from array requires nested tuple of 2 elements. "
+                    "Left type: {}, right type: {}",
+                    from_array->getName(),
+                    to_type->getName());
 
-            return createArrayToMapWrrapper(nested_tuple->getElements(), to_type->getKeyValueTypes());
+            return createArrayToMapWrapper(nested_tuple->getElements(), to_type->getKeyValueTypes());
         }
         else if (const auto * from_type = checkAndGetDataType<DataTypeMap>(from_type_untyped.get()))
         {
-            return createMapToMapWrrapper(from_type->getKeyValueTypes(), to_type->getKeyValueTypes());
+            return createMapToMapWrapper(from_type->getKeyValueTypes(), to_type->getKeyValueTypes());
         }
         else
         {
diff --git a/src/Functions/JSONPath/Parsers/ParserJSONPathMemberAccess.cpp b/src/Functions/JSONPath/Parsers/ParserJSONPathMemberAccess.cpp
index f0ed178e1c2..709ef89dd3c 100644
--- a/src/Functions/JSONPath/Parsers/ParserJSONPathMemberAccess.cpp
+++ b/src/Functions/JSONPath/Parsers/ParserJSONPathMemberAccess.cpp
@@ -1,9 +1,11 @@
 #include <Functions/JSONPath/ASTs/ASTJSONPathMemberAccess.h>
 #include <Functions/JSONPath/Parsers/ParserJSONPathMemberAccess.h>
 
+#include <Parsers/ASTIdentifier.h>
 #include <Parsers/ASTIdentifier_fwd.h>
 #include <Parsers/ExpressionElementParsers.h>
 #include <Parsers/Lexer.h>
+#include <Common/StringUtils/StringUtils.h>
 
 namespace DB
 {
@@ -16,18 +18,60 @@ namespace DB
  */
 bool ParserJSONPathMemberAccess::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
-    if (pos->type != TokenType::Dot)
+    // There's a special case, that a path member can begin with number
+    // some invalid cases as following
+    //   - ".123" is parsed as a number, not a dot and a number
+    //   - ".123abc" is parsed as two parts, a number ".123" and a token "abc"
+    //   - ".abc" is parsed as two parts. a dot and a token "abc"
+    // "$..123abc" is parsed into three parts, ".", ".123" and "abc"
+    if (pos->type != TokenType::Dot && pos->type != TokenType::Number)
         return false;
+    if (pos->type != TokenType::Number)
+    {
+        ++pos;
+        // Check the case "$..123abc"
+        if (pos->type == TokenType::Number)
+        {
+            return false;
+        }
+    }
 
-    ++pos;
-
-    if (pos->type != TokenType::BareWord && pos->type !=TokenType::QuotedIdentifier)
-        return false;
-
-    ParserIdentifier name_p;
     ASTPtr member_name;
-    if (!name_p.parse(pos, member_name, expected))
-        return false;
+
+    if (pos->type == TokenType::Number)[[unlikely]]
+    {
+        for (const auto * c = pos->begin; c != pos->end; ++c)
+        {
+            if (*c == '.' && c == pos->begin)
+                continue;
+            if (!isNumericASCII(*c))
+            {
+                return false;
+            }
+        }
+        const auto * last_begin = *pos->begin == '.' ? pos->begin + 1 : pos->begin;
+        const auto * last_end = pos->end;
+        ++pos;
+
+        if (pos.isValid() && pos->type == TokenType::BareWord && pos->begin == last_end)
+        {
+            member_name = std::make_shared<ASTIdentifier>(String(last_begin, pos->end));
+            ++pos;
+        }
+        else
+        {
+            return false;
+        }
+    }
+    else
+    {
+        if (pos->type != TokenType::BareWord && pos->type != TokenType::QuotedIdentifier)
+            return false;
+
+        ParserIdentifier name_p;
+        if (!name_p.parse(pos, member_name, expected))
+            return false;
+    }
 
     auto member_access = std::make_shared<ASTJSONPathMemberAccess>();
     node = member_access;
diff --git a/src/Functions/JSONPath/Parsers/ParserJSONPathMemberSquareBracketAccess.cpp b/src/Functions/JSONPath/Parsers/ParserJSONPathMemberSquareBracketAccess.cpp
new file mode 100644
index 00000000000..93e0639ccfe
--- /dev/null
+++ b/src/Functions/JSONPath/Parsers/ParserJSONPathMemberSquareBracketAccess.cpp
@@ -0,0 +1,44 @@
+#include "ParserJSONPathMemberSquareBracketAccess.h"
+#include <memory>
+#include <Functions/JSONPath/ASTs/ASTJSONPathMemberAccess.h>
+#include <IO/ReadBufferFromMemory.h>
+#include <IO/ReadHelpers.h>
+#include <Parsers/ASTIdentifier.h>
+#include <Parsers/ExpressionElementParsers.h>
+
+namespace DB
+{
+bool ParserJSONPathMemberSquareBracketAccess::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
+{
+    if (pos->type != TokenType::OpeningSquareBracket)
+        return false;
+    ++pos;
+    ASTPtr member_name;
+    if (pos->type == TokenType::BareWord || pos->type == TokenType::QuotedIdentifier)
+    {
+        ParserIdentifier name_p;
+        if (!name_p.parse(pos, member_name, expected))
+            return false;
+    }
+    else if (pos->type == TokenType::StringLiteral)
+    {
+        ReadBufferFromMemory in(pos->begin, pos->size());
+        String name;
+        readQuotedStringWithSQLStyle(name, in);
+        member_name = std::make_shared<ASTIdentifier>(name);
+        ++pos;
+    }
+    else
+    {
+        return false;
+    }
+    if (pos->type != TokenType::ClosingSquareBracket)
+    {
+        return false;
+    }
+    ++pos;
+    auto member_access = std::make_shared<ASTJSONPathMemberAccess>();
+    node = member_access;
+    return tryGetIdentifierNameInto(member_name, member_access->member_name);
+}
+}
diff --git a/src/Functions/JSONPath/Parsers/ParserJSONPathMemberSquareBracketAccess.h b/src/Functions/JSONPath/Parsers/ParserJSONPathMemberSquareBracketAccess.h
new file mode 100644
index 00000000000..b682ec5bb96
--- /dev/null
+++ b/src/Functions/JSONPath/Parsers/ParserJSONPathMemberSquareBracketAccess.h
@@ -0,0 +1,17 @@
+#pragma once
+#include <Parsers/IParserBase.h>
+// cases
+// - [ident]
+// - ['ident']
+// - ["ident"]
+namespace DB
+{
+class ParserJSONPathMemberSquareBracketAccess : public IParserBase
+{
+private:
+    const char * getName() const override { return "ParserJSONPathMemberSquareBracketAccess"; }
+    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
+public:
+    explicit ParserJSONPathMemberSquareBracketAccess() = default;
+};
+}
diff --git a/src/Functions/JSONPath/Parsers/ParserJSONPathQuery.cpp b/src/Functions/JSONPath/Parsers/ParserJSONPathQuery.cpp
index c18b2ad9b31..d8d633a1ec9 100644
--- a/src/Functions/JSONPath/Parsers/ParserJSONPathQuery.cpp
+++ b/src/Functions/JSONPath/Parsers/ParserJSONPathQuery.cpp
@@ -2,6 +2,7 @@
 #include <Functions/JSONPath/Parsers/ParserJSONPathQuery.h>
 #include <Functions/JSONPath/Parsers/ParserJSONPathRoot.h>
 #include <Functions/JSONPath/Parsers/ParserJSONPathMemberAccess.h>
+#include <Functions/JSONPath/Parsers/ParserJSONPathMemberSquareBracketAccess.h>
 #include <Functions/JSONPath/Parsers/ParserJSONPathRange.h>
 #include <Functions/JSONPath/Parsers/ParserJSONPathStar.h>
 
@@ -19,6 +20,7 @@ bool ParserJSONPathQuery::parseImpl(Pos & pos, ASTPtr & query, Expected & expect
 {
     query = std::make_shared<ASTJSONPathQuery>();
     ParserJSONPathMemberAccess parser_jsonpath_member_access;
+    ParserJSONPathMemberSquareBracketAccess parser_jsonpath_member_square_bracket_access;
     ParserJSONPathRange parser_jsonpath_range;
     ParserJSONPathStar parser_jsonpath_star;
     ParserJSONPathRoot parser_jsonpath_root;
@@ -32,6 +34,7 @@ bool ParserJSONPathQuery::parseImpl(Pos & pos, ASTPtr & query, Expected & expect
 
     ASTPtr accessor;
     while (parser_jsonpath_member_access.parse(pos, accessor, expected)
+           || parser_jsonpath_member_square_bracket_access.parse(pos, accessor, expected)
            || parser_jsonpath_range.parse(pos, accessor, expected)
            || parser_jsonpath_star.parse(pos, accessor, expected))
     {
diff --git a/src/Functions/caseWithExpression.cpp b/src/Functions/caseWithExpression.cpp
index c8b8dbd76cf..9547cd200b2 100644
--- a/src/Functions/caseWithExpression.cpp
+++ b/src/Functions/caseWithExpression.cpp
@@ -24,6 +24,9 @@ public:
 
     explicit FunctionCaseWithExpression(ContextPtr context_) : context(context_) {}
     bool isVariadic() const override { return true; }
+    bool useDefaultImplementationForConstants() const override { return false; }
+    bool useDefaultImplementationForNulls() const override { return false; }
+    bool useDefaultImplementationForNothing() const override { return false; }
     bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; }
     size_t getNumberOfArguments() const override { return 0; }
     String getName() const override { return name; }
diff --git a/src/Functions/concat.cpp b/src/Functions/concat.cpp
index 1bdd155aaa1..8fefc2d5b8a 100644
--- a/src/Functions/concat.cpp
+++ b/src/Functions/concat.cpp
@@ -205,6 +205,10 @@ public:
         {
             return FunctionFactory::instance().getImpl("arrayConcat", context)->build(arguments);
         }
+        else if (isMap(arguments.at(0).type))
+        {
+            return FunctionFactory::instance().getImpl("mapConcat", context)->build(arguments);
+        }
         else
             return std::make_unique<FunctionToFunctionBaseAdaptor>(
                 FunctionConcat::create(context), collections::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }), return_type);
diff --git a/src/Functions/makeDate.cpp b/src/Functions/makeDate.cpp
index 7ebca71af13..97271386286 100644
--- a/src/Functions/makeDate.cpp
+++ b/src/Functions/makeDate.cpp
@@ -50,8 +50,8 @@ public:
     bool useDefaultImplementationForConstants() const override { return true; }
 
 protected:
-    template <class AgrumentNames>
-    void checkRequiredArguments(const ColumnsWithTypeAndName & arguments, const AgrumentNames & argument_names, const size_t optional_argument_count) const
+    template <class ArgumentNames>
+    void checkRequiredArguments(const ColumnsWithTypeAndName & arguments, const ArgumentNames & argument_names, const size_t optional_argument_count) const
     {
         if (arguments.size() < argument_names.size() || arguments.size() > argument_names.size() + optional_argument_count)
             throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
@@ -67,8 +67,8 @@ protected:
         }
     }
 
-    template <class AgrumentNames>
-    void convertRequiredArguments(const ColumnsWithTypeAndName & arguments, const AgrumentNames & argument_names, Columns & converted_arguments) const
+    template <class ArgumentNames>
+    void convertRequiredArguments(const ColumnsWithTypeAndName & arguments, const ArgumentNames & argument_names, Columns & converted_arguments) const
     {
         const DataTypePtr converted_argument_type = std::make_shared<DataTypeFloat32>();
         converted_arguments.clear();
@@ -87,7 +87,7 @@ template <typename Traits>
 class FunctionMakeDate : public FunctionWithNumericParamsBase
 {
 private:
-    static constexpr std::array<const char*, 3> argument_names = {"year", "month", "day"};
+    static constexpr std::array argument_names = {"year", "month", "day"};
 
 public:
     static constexpr auto name = Traits::name;
@@ -112,7 +112,7 @@ public:
         Columns converted_arguments;
         convertRequiredArguments(arguments, argument_names, converted_arguments);
 
-        auto res_column = Traits::ReturnColumnType::create(input_rows_count);
+        auto res_column = Traits::ReturnDataType::ColumnType::create(input_rows_count);
         auto & result_data = res_column->getData();
 
         const auto & year_data = typeid_cast<const ColumnFloat32 &>(*converted_arguments[0]).getData();
@@ -150,7 +150,6 @@ struct MakeDateTraits
 {
     static constexpr auto name = "makeDate";
     using ReturnDataType = DataTypeDate;
-    using ReturnColumnType = ColumnDate;
 
     static constexpr auto MIN_YEAR = 1970;
     static constexpr auto MAX_YEAR = 2149;
@@ -163,7 +162,6 @@ struct MakeDate32Traits
 {
     static constexpr auto name = "makeDate32";
     using ReturnDataType = DataTypeDate32;
-    using ReturnColumnType = ColumnDate32;
 
     static constexpr auto MIN_YEAR = 1900;
     static constexpr auto MAX_YEAR = 2299;
@@ -174,7 +172,7 @@ struct MakeDate32Traits
 class FunctionMakeDateTimeBase : public FunctionWithNumericParamsBase
 {
 protected:
-    static constexpr std::array<const char*, 6> argument_names = {"year", "month", "day", "hour", "minute", "second"};
+    static constexpr std::array argument_names = {"year", "month", "day", "hour", "minute", "second"};
 
 public:
     bool isVariadic() const override { return true; }
@@ -197,13 +195,13 @@ protected:
     {
         ///  Note that hour, minute and second are checked against 99 to behave consistently with parsing DateTime from String
         ///  E.g. "select cast('1984-01-01 99:99:99' as DateTime);" returns "1984-01-05 04:40:39"
-        if (unlikely(std::isnan(year) || std::isnan(month) || std::isnan(day_of_month) ||
+        if (std::isnan(year) || std::isnan(month) || std::isnan(day_of_month) ||
             std::isnan(hour) || std::isnan(minute) || std::isnan(second) ||
             year < DATE_LUT_MIN_YEAR || month < 1 || month > 12 || day_of_month < 1 || day_of_month > 31 ||
-            hour < 0 || hour > 99 || minute < 0 || minute > 99 || second < 0 || second > 99))
+            hour < 0 || hour > 99 || minute < 0 || minute > 99 || second < 0 || second > 99) [[unlikely]]
             return minDateTime(lut);
 
-        if (unlikely(year > DATE_LUT_MAX_YEAR))
+        if (year > DATE_LUT_MAX_YEAR) [[unlikely]]
             return maxDateTime(lut);
 
         return lut.makeDateTime(
@@ -290,9 +288,9 @@ public:
             const auto second = second_data[i];
 
             auto date_time = dateTime(year, month, day, hour, minute, second, date_lut);
-            if (unlikely(date_time < 0))
+            if (date_time < 0) [[unlikely]]
                 date_time = 0;
-            else if (unlikely(date_time > 0x0ffffffffll))
+            else if (date_time > 0x0ffffffffll) [[unlikely]]
                 date_time = 0x0ffffffffll;
 
             result_data[i] = static_cast<UInt32>(date_time);
@@ -394,21 +392,21 @@ public:
             auto date_time = dateTime(year, month, day, hour, minute, second, date_lut);
 
             double fraction = 0;
-            if (unlikely(date_time == min_date_time))
+            if (date_time == min_date_time) [[unlikely]]
                 fraction = 0;
-            else if (unlikely(date_time == max_date_time))
+            else if (date_time == max_date_time) [[unlikely]]
                 fraction = 999999999;
             else
             {
                 fraction = fraction_data ? (*fraction_data)[i] : 0;
-                if (unlikely(std::isnan(fraction)))
+                if (std::isnan(fraction)) [[unlikely]]
                 {
                     date_time = min_date_time;
                     fraction = 0;
                 }
-                else if (unlikely(fraction < 0))
+                else if (fraction < 0) [[unlikely]]
                     fraction = 0;
-                else if (unlikely(fraction > max_fraction))
+                else if (fraction > max_fraction) [[unlikely]]
                     fraction = max_fraction;
             }
 
diff --git a/src/Functions/transform.cpp b/src/Functions/transform.cpp
index df0f13ed97c..33e03b541e9 100644
--- a/src/Functions/transform.cpp
+++ b/src/Functions/transform.cpp
@@ -1,24 +1,26 @@
 #include <mutex>
 #include <base/bit_cast.h>
 
-#include <Common/FieldVisitorDump.h>
-#include <Common/FieldVisitorConvertToNumber.h>
-#include <DataTypes/DataTypeArray.h>
-#include <Columns/ColumnString.h>
 #include <Columns/ColumnArray.h>
 #include <Columns/ColumnConst.h>
-#include <Columns/ColumnsNumber.h>
 #include <Columns/ColumnDecimal.h>
+#include <Columns/ColumnNullable.h>
+#include <Columns/ColumnString.h>
+#include <Columns/ColumnsNumber.h>
+#include <Core/DecimalFunctions.h>
+#include <DataTypes/DataTypeArray.h>
+#include <DataTypes/getLeastSupertype.h>
+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionHelpers.h>
+#include <Functions/IFunction.h>
+#include <Interpreters/castColumn.h>
+#include <Interpreters/convertFieldToType.h>
+#include <base/StringRef.h>
 #include <Common/Arena.h>
+#include <Common/FieldVisitorConvertToNumber.h>
+#include <Common/FieldVisitorDump.h>
 #include <Common/HashTable/HashMap.h>
 #include <Common/typeid_cast.h>
-#include <base/StringRef.h>
-#include <Functions/IFunction.h>
-#include <Functions/FunctionHelpers.h>
-#include <Functions/FunctionFactory.h>
-#include <DataTypes/getLeastSupertype.h>
-#include <Interpreters/convertFieldToType.h>
-
 
 namespace DB
 {
@@ -32,11 +34,9 @@ namespace ErrorCodes
 
 namespace
 {
-
-/** transform(x, from_array, to_array[, default]) - convert x according to an explicitly passed match.
+    /** transform(x, from_array, to_array[, default]) - convert x according to an explicitly passed match.
   */
-
-/** transform(x, [from...], [to...], default)
+    /** transform(x, [from...], [to...], default)
   * - converts the values according to the explicitly specified mapping.
   *
   * x - what to transform.
@@ -56,1147 +56,658 @@ namespace
   *
   * Note: the implementation is rather cumbersome.
   */
-class FunctionTransform : public IFunction
-{
-public:
-    static constexpr auto name = "transform";
-    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionTransform>(); }
-
-    String getName() const override
+    class FunctionTransform : public IFunction
     {
-        return name;
-    }
+    public:
+        static constexpr auto name = "transform";
+        static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionTransform>(); }
 
-    bool isVariadic() const override { return true; }
-    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
-    size_t getNumberOfArguments() const override { return 0; }
-    bool useDefaultImplementationForConstants() const override { return true; }
-    ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1, 2}; }
+        String getName() const override { return name; }
 
-    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
-    {
-        const auto args_size = arguments.size();
-        if (args_size != 3 && args_size != 4)
-            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Number of arguments for function {} doesn't match: "
-                "passed {}, should be 3 or 4", getName(), args_size);
+        bool isVariadic() const override { return true; }
+        bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
+        size_t getNumberOfArguments() const override { return 0; }
+        bool useDefaultImplementationForConstants() const override { return false; }
+        bool useDefaultImplementationForNulls() const override { return false; }
+        bool useDefaultImplementationForNothing() const override { return false; }
+        ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1, 2}; }
 
-        const DataTypePtr & type_x = arguments[0];
-
-        if (!type_x->isValueRepresentedByNumber() && !isString(type_x))
-            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                            "Unsupported type {} of first argument "
-                            "of function {}, must be numeric type or Date/DateTime or String",
-                            type_x->getName(), getName());
-
-        const DataTypeArray * type_arr_from = checkAndGetDataType<DataTypeArray>(arguments[1].get());
-
-        if (!type_arr_from)
-            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                            "Second argument of function {}, must be array of source values to transform from.",
-                            getName());
-
-        const auto type_arr_from_nested = type_arr_from->getNestedType();
-
-        if ((type_x->isValueRepresentedByNumber() != type_arr_from_nested->isValueRepresentedByNumber())
-            || (isString(type_x) != isString(type_arr_from_nested)))
+        DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
         {
-            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                            "First argument and elements of array "
-                            "of second argument of function {} must have compatible types: "
-                            "both numeric or both strings.", getName());
-        }
+            const auto args_size = arguments.size();
+            if (args_size != 3 && args_size != 4)
+                throw Exception(
+                    ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
+                    "Number of arguments for function {} doesn't match: "
+                    "passed {}, should be 3 or 4",
+                    getName(),
+                    args_size);
 
-        const DataTypeArray * type_arr_to = checkAndGetDataType<DataTypeArray>(arguments[2].get());
+            const DataTypePtr & type_x = arguments[0];
+            const auto & type_x_nn = removeNullable(type_x);
 
-        if (!type_arr_to)
-            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                            "Third argument of function {}, must be array of destination values to transform to.",
-                            getName());
+            if (!type_x_nn->isValueRepresentedByNumber() && !isString(type_x_nn) && !isNothing(type_x_nn))
+                throw Exception(
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                    "Unsupported type {} of first argument "
+                    "of function {}, must be numeric type or Date/DateTime or String",
+                    type_x->getName(),
+                    getName());
 
-        const DataTypePtr & type_arr_to_nested = type_arr_to->getNestedType();
+            const DataTypeArray * type_arr_from = checkAndGetDataType<DataTypeArray>(arguments[1].get());
 
-        if (args_size == 3)
-        {
-            if ((type_x->isValueRepresentedByNumber() != type_arr_to_nested->isValueRepresentedByNumber())
-                || (isString(type_x) != isString(type_arr_to_nested)))
-                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Function {} has signature: "
-                                "transform(T, Array(T), Array(U), U) -> U; "
-                                "or transform(T, Array(T), Array(T)) -> T; where T and U are types.", getName());
+            if (!type_arr_from)
+                throw Exception(
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                    "Second argument of function {}, must be array of source values to transform from.",
+                    getName());
 
-            return getLeastSupertype(DataTypes{type_x, type_arr_to_nested});
-        }
-        else
-        {
-            const DataTypePtr & type_default = arguments[3];
+            const auto type_arr_from_nested = type_arr_from->getNestedType();
 
-            if (!type_default->isValueRepresentedByNumber() && !isString(type_default))
-                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                                "Unsupported type {} of fourth argument (default value) "
-                                "of function {}, must be numeric type or Date/DateTime or String",
-                                type_default->getName(), getName());
-
-            bool default_is_string = WhichDataType(type_default).isString();
-            bool nested_is_string = WhichDataType(type_arr_to_nested).isString();
-
-            if ((type_default->isValueRepresentedByNumber() != type_arr_to_nested->isValueRepresentedByNumber())
-                || (default_is_string != nested_is_string))
-                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Function {} have signature: "
-                                "transform(T, Array(T), Array(U), U) -> U; "
-                                "or transform(T, Array(T), Array(T)) -> T; where T and U are types.", getName());
-
-            if (type_arr_to_nested->isValueRepresentedByNumber() && type_default->isValueRepresentedByNumber())
+            if ((type_x->isValueRepresentedByNumber() != type_arr_from_nested->isValueRepresentedByNumber())
+                || (isString(type_x) != isString(type_arr_from_nested)))
             {
-                /// We take the smallest common type for the elements of the array of values `to` and for `default`.
-                return getLeastSupertype(DataTypes{type_arr_to_nested, type_default});
+                throw Exception(
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                    "First argument and elements of array "
+                    "of second argument of function {} must have compatible types: "
+                    "both numeric or both strings.",
+                    getName());
             }
 
-            /// TODO More checks.
-            return type_arr_to_nested;
-        }
-    }
+            const DataTypeArray * type_arr_to = checkAndGetDataType<DataTypeArray>(arguments[2].get());
 
-    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
-    {
-        const ColumnConst * array_from = checkAndGetColumnConst<ColumnArray>(arguments[1].column.get());
-        const ColumnConst * array_to = checkAndGetColumnConst<ColumnArray>(arguments[2].column.get());
+            if (!type_arr_to)
+                throw Exception(
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                    "Third argument of function {}, must be array of destination values to transform to.",
+                    getName());
 
-        if (!array_from || !array_to)
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Second and third arguments of function {} must be constant arrays.", getName());
+            const DataTypePtr & type_arr_to_nested = type_arr_to->getNestedType();
 
-        initialize(array_from->getValue<Array>(), array_to->getValue<Array>(), arguments);
-
-        const auto * in = arguments.front().column.get();
-
-        if (isColumnConst(*in))
-            return executeConst(arguments, result_type, input_rows_count);
-
-        const IColumn * default_column = nullptr;
-        if (arguments.size() == 4)
-            default_column = arguments[3].column.get();
-
-        auto column_result = result_type->createColumn();
-        auto * out = column_result.get();
-
-        if (!executeNum<UInt8>(in, out, default_column)
-            && !executeNum<UInt16>(in, out, default_column)
-            && !executeNum<UInt32>(in, out, default_column)
-            && !executeNum<UInt64>(in, out, default_column)
-            && !executeNum<Int8>(in, out, default_column)
-            && !executeNum<Int16>(in, out, default_column)
-            && !executeNum<Int32>(in, out, default_column)
-            && !executeNum<Int64>(in, out, default_column)
-            && !executeNum<Float32>(in, out, default_column)
-            && !executeNum<Float64>(in, out, default_column)
-            && !executeDecimal<Decimal32>(in, out, default_column)
-            && !executeDecimal<Decimal64>(in, out, default_column)
-            && !executeString(in, out, default_column))
-        {
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of first argument of function {}", in->getName(), getName());
-        }
-
-        return column_result;
-    }
-
-private:
-    static ColumnPtr executeConst(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count)
-    {
-        /// Materialize the input column and compute the function as usual.
-
-        ColumnsWithTypeAndName args = arguments;
-        args[0].column = args[0].column->cloneResized(input_rows_count)->convertToFullColumnIfConst();
-
-        auto impl = FunctionToOverloadResolverAdaptor(std::make_shared<FunctionTransform>()).build(args);
-
-        return impl->execute(args, result_type, input_rows_count);
-    }
-
-    template <typename T>
-    bool executeNum(const IColumn * in_untyped, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        if (const auto in = checkAndGetColumn<ColumnVector<T>>(in_untyped))
-        {
-            if (!default_untyped)
+            if (args_size == 3)
             {
-                auto out = typeid_cast<ColumnVector<T> *>(out_untyped);
-                if (!out)
-                {
-                    throw Exception(ErrorCodes::ILLEGAL_COLUMN,
-                                    "Illegal column {} of elements "
-                                    "of array of third argument of function {}, must be {}",
-                                    out_untyped->getName(), getName(), in->getName());
-                }
+                if ((type_x->isValueRepresentedByNumber() != type_arr_to_nested->isValueRepresentedByNumber())
+                    || (isString(type_x) != isString(type_arr_to_nested)))
+                    throw Exception(
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                        "Function {} has signature: "
+                        "transform(T, Array(T), Array(U), U) -> U; "
+                        "or transform(T, Array(T), Array(T)) -> T; where T and U are types.",
+                        getName());
 
-                executeImplNumToNum<T>(in->getData(), out->getData());
-            }
-            else if (isColumnConst(*default_untyped))
-            {
-                if (!executeNumToNumWithConstDefault<T, UInt8>(in, out_untyped)
-                    && !executeNumToNumWithConstDefault<T, UInt16>(in, out_untyped)
-                    && !executeNumToNumWithConstDefault<T, UInt32>(in, out_untyped)
-                    && !executeNumToNumWithConstDefault<T, UInt64>(in, out_untyped)
-                    && !executeNumToNumWithConstDefault<T, Int8>(in, out_untyped)
-                    && !executeNumToNumWithConstDefault<T, Int16>(in, out_untyped)
-                    && !executeNumToNumWithConstDefault<T, Int32>(in, out_untyped)
-                    && !executeNumToNumWithConstDefault<T, Int64>(in, out_untyped)
-                    && !executeNumToNumWithConstDefault<T, Float32>(in, out_untyped)
-                    && !executeNumToNumWithConstDefault<T, Float64>(in, out_untyped)
-                    && !executeNumToDecimalWithConstDefault<T, Decimal32>(in, out_untyped)
-                    && !executeNumToDecimalWithConstDefault<T, Decimal64>(in, out_untyped)
-                    && !executeNumToStringWithConstDefault<T>(in, out_untyped))
-                {
-                    throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of elements of array of second argument of function {}",
-                        in->getName(), getName());
-                }
+                auto ret = tryGetLeastSupertype(DataTypes{type_arr_to_nested, type_x});
+                if (!ret)
+                    throw Exception(
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                        "Function {} has signature: "
+                        "transform(T, Array(T), Array(U), U) -> U; "
+                        "or transform(T, Array(T), Array(T)) -> T; where T and U are types.",
+                        getName());
+                checkAllowedType(ret);
+                return ret;
             }
             else
             {
-                if (!executeNumToNumWithNonConstDefault<T, UInt8>(in, out_untyped, default_untyped)
-                    && !executeNumToNumWithNonConstDefault<T, UInt16>(in, out_untyped, default_untyped)
-                    && !executeNumToNumWithNonConstDefault<T, UInt32>(in, out_untyped, default_untyped)
-                    && !executeNumToNumWithNonConstDefault<T, UInt64>(in, out_untyped, default_untyped)
-                    && !executeNumToNumWithNonConstDefault<T, Int8>(in, out_untyped, default_untyped)
-                    && !executeNumToNumWithNonConstDefault<T, Int16>(in, out_untyped, default_untyped)
-                    && !executeNumToNumWithNonConstDefault<T, Int32>(in, out_untyped, default_untyped)
-                    && !executeNumToNumWithNonConstDefault<T, Int64>(in, out_untyped, default_untyped)
-                    && !executeNumToNumWithNonConstDefault<T, Float32>(in, out_untyped, default_untyped)
-                    && !executeNumToNumWithNonConstDefault<T, Float64>(in, out_untyped, default_untyped)
-                    && !executeNumToDecimalWithNonConstDefault<T, Decimal32>(in, out_untyped, default_untyped)
-                    && !executeNumToDecimalWithNonConstDefault<T, Decimal64>(in, out_untyped, default_untyped)
-                    && !executeNumToStringWithNonConstDefault<T>(in, out_untyped, default_untyped))
-                {
-                    throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of elements of array of second argument of function {}",
-                        in->getName(), getName());
-                }
+                auto ret = tryGetLeastSupertype(DataTypes{type_arr_to_nested, arguments[3]});
+                if (!ret)
+                    throw Exception(
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                        "Function {} have signature: "
+                        "transform(T, Array(T), Array(U), U) -> U; "
+                        "or transform(T, Array(T), Array(T)) -> T; where T and U are types.",
+                        getName());
+                checkAllowedType(ret);
+                return ret;
             }
-
-            return true;
         }
 
-        return false;
-    }
-
-    template <typename T>
-    bool executeDecimal(const IColumn * in_untyped, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        if (const auto in = checkAndGetColumn<ColumnDecimal<T>>(in_untyped))
+        ColumnPtr
+        executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
         {
-            if (!default_untyped)
-            {
-                auto out = typeid_cast<ColumnDecimal<T> *>(out_untyped);
-                if (!out)
-                {
-                    throw Exception(ErrorCodes::ILLEGAL_COLUMN,
-                                    "Illegal column {} of elements "
-                                    "of array of third argument of function {}, must be {}",
-                                    out_untyped->getName(), getName(), in->getName());
-                }
+            initialize(arguments, result_type);
 
-                executeImplNumToNum<T>(in->getData(), out->getData());
+            const auto * in = arguments.front().column.get();
+
+            if (isColumnConst(*in))
+                return executeConst(arguments, result_type, input_rows_count);
+
+            ColumnPtr default_non_const;
+            if (!cache.default_column && arguments.size() == 4)
+                default_non_const = castColumn(arguments[3], result_type);
+
+            auto column_result = result_type->createColumn();
+            if (!executeNum<ColumnVector<UInt8>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnVector<UInt16>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnVector<UInt32>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnVector<UInt64>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnVector<Int8>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnVector<Int16>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnVector<Int32>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnVector<Int64>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnVector<Float32>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnVector<Float64>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnDecimal<Decimal32>>(in, *column_result, default_non_const)
+                && !executeNum<ColumnDecimal<Decimal64>>(in, *column_result, default_non_const)
+                && !executeString(in, *column_result, default_non_const))
+            {
+                throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of first argument of function {}", in->getName(), getName());
             }
-            else if (isColumnConst(*default_untyped))
+            return column_result;
+        }
+
+    private:
+        static ColumnPtr executeConst(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count)
+        {
+            /// Materialize the input column and compute the function as usual.
+
+            ColumnsWithTypeAndName args = arguments;
+            args[0].column = args[0].column->cloneResized(input_rows_count)->convertToFullColumnIfConst();
+
+            auto impl = FunctionToOverloadResolverAdaptor(std::make_shared<FunctionTransform>()).build(args);
+
+            return impl->execute(args, result_type, input_rows_count);
+        }
+
+        template <typename T>
+        bool executeNum(const IColumn * in_untyped, IColumn & column_result, const ColumnPtr default_non_const) const
+        {
+            const auto * const in = checkAndGetColumn<T>(in_untyped);
+            if (!in)
+                return false;
+            const auto & pod = in->getData();
+            UInt32 in_scale = 0;
+            if constexpr (std::is_same_v<ColumnDecimal<Decimal32>, T> || std::is_same_v<ColumnDecimal<Decimal64>, T>)
+                in_scale = in->getScale();
+
+            if (!executeNumToString(pod, column_result, default_non_const)
+                && !executeNumToNum<ColumnVector<UInt8>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnVector<UInt16>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnVector<UInt32>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnVector<UInt64>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnVector<Int8>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnVector<Int16>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnVector<Int32>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnVector<Int64>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnVector<Float32>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnVector<Float64>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnDecimal<Decimal32>>(pod, column_result, default_non_const, in_scale)
+                && !executeNumToNum<ColumnDecimal<Decimal64>>(pod, column_result, default_non_const, in_scale))
             {
-                if (!executeDecimalToNumWithConstDefault<T, UInt8>(in, out_untyped)
-                    && !executeDecimalToNumWithConstDefault<T, UInt16>(in, out_untyped)
-                    && !executeDecimalToNumWithConstDefault<T, UInt32>(in, out_untyped)
-                    && !executeDecimalToNumWithConstDefault<T, UInt64>(in, out_untyped)
-                    && !executeDecimalToNumWithConstDefault<T, Int8>(in, out_untyped)
-                    && !executeDecimalToNumWithConstDefault<T, Int16>(in, out_untyped)
-                    && !executeDecimalToNumWithConstDefault<T, Int32>(in, out_untyped)
-                    && !executeDecimalToNumWithConstDefault<T, Int64>(in, out_untyped)
-                    && !executeDecimalToNumWithConstDefault<T, Float32>(in, out_untyped)
-                    && !executeDecimalToNumWithConstDefault<T, Float64>(in, out_untyped)
-                    && !executeDecimalToDecimalWithConstDefault<T, Decimal32>(in, out_untyped)
-                    && !executeDecimalToDecimalWithConstDefault<T, Decimal64>(in, out_untyped)
-                    && !executeDecimalToStringWithConstDefault<T>(in, out_untyped))
-                {
-                    throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of elements of array of second argument of function {}",
-                                    in->getName(), getName());
-                }
-            }
-            else
-            {
-                if (!executeDecimalToNumWithNonConstDefault<T, UInt8>(in, out_untyped, default_untyped)
-                    && !executeDecimalToNumWithNonConstDefault<T, UInt16>(in, out_untyped, default_untyped)
-                    && !executeDecimalToNumWithNonConstDefault<T, UInt32>(in, out_untyped, default_untyped)
-                    && !executeDecimalToNumWithNonConstDefault<T, UInt64>(in, out_untyped, default_untyped)
-                    && !executeDecimalToNumWithNonConstDefault<T, Int8>(in, out_untyped, default_untyped)
-                    && !executeDecimalToNumWithNonConstDefault<T, Int16>(in, out_untyped, default_untyped)
-                    && !executeDecimalToNumWithNonConstDefault<T, Int32>(in, out_untyped, default_untyped)
-                    && !executeDecimalToNumWithNonConstDefault<T, Int64>(in, out_untyped, default_untyped)
-                    && !executeDecimalToNumWithNonConstDefault<T, Float32>(in, out_untyped, default_untyped)
-                    && !executeDecimalToNumWithNonConstDefault<T, Float64>(in, out_untyped, default_untyped)
-                    && !executeDecimalToDecimalWithNonConstDefault<T, Decimal32>(in, out_untyped, default_untyped)
-                    && !executeDecimalToDecimalWithNonConstDefault<T, Decimal64>(in, out_untyped, default_untyped)
-                    && !executeDecimalToStringWithNonConstDefault<T>(in, out_untyped, default_untyped))
-                {
-                    throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of elements of array of second argument of function {}",
-                                    in->getName(), getName());
-                }
-            }
-
-            return true;
-        }
-
-        return false;
-    }
-
-    bool executeString(const IColumn * in_untyped, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        if (const auto * in = checkAndGetColumn<ColumnString>(in_untyped))
-        {
-            if (!default_untyped)
-            {
-                if (!executeStringToString(in, out_untyped))
-                    throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of elements of array of second argument of function {}",
-                        in->getName(), getName());
-            }
-            else if (isColumnConst(*default_untyped))
-            {
-                if (!executeStringToNumWithConstDefault<UInt8>(in, out_untyped)
-                    && !executeStringToNumWithConstDefault<UInt16>(in, out_untyped)
-                    && !executeStringToNumWithConstDefault<UInt32>(in, out_untyped)
-                    && !executeStringToNumWithConstDefault<UInt64>(in, out_untyped)
-                    && !executeStringToNumWithConstDefault<Int8>(in, out_untyped)
-                    && !executeStringToNumWithConstDefault<Int16>(in, out_untyped)
-                    && !executeStringToNumWithConstDefault<Int32>(in, out_untyped)
-                    && !executeStringToNumWithConstDefault<Int64>(in, out_untyped)
-                    && !executeStringToNumWithConstDefault<Float32>(in, out_untyped)
-                    && !executeStringToNumWithConstDefault<Float64>(in, out_untyped)
-                    && !executeStringToDecimalWithConstDefault<Decimal32>(in, out_untyped)
-                    && !executeStringToDecimalWithConstDefault<Decimal64>(in, out_untyped)
-                    && !executeStringToStringWithConstDefault(in, out_untyped))
-                {
-                    throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of elements of array of second argument of function {}",
-                        in->getName(), getName());
-                }
-            }
-            else
-            {
-                if (!executeStringToNumWithNonConstDefault<UInt8>(in, out_untyped, default_untyped)
-                    && !executeStringToNumWithNonConstDefault<UInt16>(in, out_untyped, default_untyped)
-                    && !executeStringToNumWithNonConstDefault<UInt32>(in, out_untyped, default_untyped)
-                    && !executeStringToNumWithNonConstDefault<UInt64>(in, out_untyped, default_untyped)
-                    && !executeStringToNumWithNonConstDefault<Int8>(in, out_untyped, default_untyped)
-                    && !executeStringToNumWithNonConstDefault<Int16>(in, out_untyped, default_untyped)
-                    && !executeStringToNumWithNonConstDefault<Int32>(in, out_untyped, default_untyped)
-                    && !executeStringToNumWithNonConstDefault<Int64>(in, out_untyped, default_untyped)
-                    && !executeStringToNumWithNonConstDefault<Float32>(in, out_untyped, default_untyped)
-                    && !executeStringToNumWithNonConstDefault<Float64>(in, out_untyped, default_untyped)
-                    && !executeStringToDecimalWithNonConstDefault<Decimal32>(in, out_untyped, default_untyped)
-                    && !executeStringToDecimalWithNonConstDefault<Decimal64>(in, out_untyped, default_untyped)
-
-                    && !executeStringToStringWithNonConstDefault(in, out_untyped, default_untyped))
-                {
-                    throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of elements of array of second argument of function {}",
-                        in->getName(), getName());
-                }
-            }
-
-            return true;
-        }
-
-        return false;
-    }
-
-    template <typename T, typename U>
-    bool executeNumToNumWithConstDefault(const ColumnVector<T> * in, IColumn * out_untyped) const
-    {
-        auto out = typeid_cast<ColumnVector<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        executeImplNumToNumWithConstDefault<T, U>(in->getData(), out->getData(), static_cast<U>(cache.const_default_value.get<U>()));
-        return true;
-    }
-
-    template <typename T, typename U>
-    bool executeNumToDecimalWithConstDefault(const ColumnVector<T> * in, IColumn * out_untyped) const
-    {
-        auto out = typeid_cast<ColumnDecimal<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        executeImplNumToNumWithConstDefault<T, U>(in->getData(), out->getData(), cache.const_default_value.get<U>());
-        return true;
-    }
-
-
-    template <typename T, typename U>
-    bool executeDecimalToNumWithConstDefault(const ColumnDecimal<T> * in, IColumn * out_untyped) const
-    {
-        auto out = typeid_cast<ColumnVector<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        executeImplNumToNumWithConstDefault<T, U>(in->getData(), out->getData(), static_cast<U>(cache.const_default_value.get<U>()));
-        return true;
-    }
-
-    template <typename T, typename U>
-    bool executeDecimalToDecimalWithConstDefault(const ColumnDecimal<T> * in, IColumn * out_untyped) const
-    {
-        auto out = typeid_cast<ColumnDecimal<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        executeImplNumToNumWithConstDefault<T, U>(in->getData(), out->getData(), cache.const_default_value.get<U>());
-        return true;
-    }
-
-    template <typename T, typename U>
-    bool executeNumToNumWithNonConstDefault(const ColumnVector<T> * in, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        auto out = typeid_cast<ColumnVector<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        if (!executeNumToNumWithNonConstDefault2<T, U, UInt8>(in, out, default_untyped)
-            && !executeNumToNumWithNonConstDefault2<T, U, UInt16>(in, out, default_untyped)
-            && !executeNumToNumWithNonConstDefault2<T, U, UInt32>(in, out, default_untyped)
-            && !executeNumToNumWithNonConstDefault2<T, U, UInt64>(in, out, default_untyped)
-            && !executeNumToNumWithNonConstDefault2<T, U, Int8>(in, out, default_untyped)
-            && !executeNumToNumWithNonConstDefault2<T, U, Int16>(in, out, default_untyped)
-            && !executeNumToNumWithNonConstDefault2<T, U, Int32>(in, out, default_untyped)
-            && !executeNumToNumWithNonConstDefault2<T, U, Int64>(in, out, default_untyped)
-            && !executeNumToNumWithNonConstDefault2<T, U, Float32>(in, out, default_untyped)
-            && !executeNumToNumWithNonConstDefault2<T, U, Float64>(in, out, default_untyped))
-        {
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of fourth argument of function {}",
-                default_untyped->getName(), getName());
-        }
-
-        return true;
-    }
-
-    template <typename T, typename U>
-    bool executeNumToDecimalWithNonConstDefault(const ColumnVector<T> * in, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        auto out = typeid_cast<ColumnDecimal<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        if (!executeNumToDecimalWithNonConstDefault2<T, U, UInt8>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefault2<T, U, UInt16>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefault2<T, U, UInt32>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefault2<T, U, UInt64>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefault2<T, U, Int8>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefault2<T, U, Int16>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefault2<T, U, Int32>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefault2<T, U, Int64>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefault2<T, U, Float32>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefault2<T, U, Float64>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefaultDecimal2<T, U, Decimal32>(in, out, default_untyped)
-            && !executeNumToDecimalWithNonConstDefaultDecimal2<T, U, Decimal64>(in, out, default_untyped))
-        {
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of fourth argument of function {}",
-                default_untyped->getName(), getName());
-        }
-
-        return true;
-    }
-
-    template <typename T, typename U>
-    bool executeDecimalToNumWithNonConstDefault(const ColumnDecimal<T> * in, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        auto out = typeid_cast<ColumnVector<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        if (!executeDecimalToNumWithNonConstDefault2<T, U, UInt8>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefault2<T, U, UInt16>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefault2<T, U, UInt32>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefault2<T, U, UInt64>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefault2<T, U, Int8>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefault2<T, U, Int16>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefault2<T, U, Int32>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefault2<T, U, Int64>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefault2<T, U, Float32>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefault2<T, U, Float64>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefaultDecimal2<T, U, Decimal32>(in, out, default_untyped)
-            && !executeDecimalToNumWithNonConstDefaultDecimal2<T, U, Decimal64>(in, out, default_untyped))
-        {
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of fourth argument of function {}",
-                default_untyped->getName(), getName());
-        }
-
-        return true;
-    }
-
-    template <typename T, typename U>
-    bool executeDecimalToDecimalWithNonConstDefault(const ColumnDecimal<T> * in, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        auto out = typeid_cast<ColumnDecimal<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        if (!executeDecimalToDecimalWithNonConstDefault2<T, U, UInt8>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefault2<T, U, UInt16>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefault2<T, U, UInt32>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefault2<T, U, UInt64>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefault2<T, U, Int8>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefault2<T, U, Int16>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefault2<T, U, Int32>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefault2<T, U, Int64>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefault2<T, U, Float32>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefault2<T, U, Float64>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefaultDecimal2<T, U, Decimal32>(in, out, default_untyped)
-            && !executeDecimalToDecimalWithNonConstDefaultDecimal2<T, U, Decimal64>(in, out, default_untyped))
-        {
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of fourth argument of function {}",
-                default_untyped->getName(), getName());
-        }
-
-        return true;
-    }
-
-    template <typename T, typename U, typename V>
-    bool executeNumToNumWithNonConstDefault2(const ColumnVector<T> * in, ColumnVector<U> * out, const IColumn * default_untyped) const
-    {
-        auto col_default = checkAndGetColumn<ColumnVector<V>>(default_untyped);
-        if (!col_default)
-            return false;
-
-        executeImplNumToNumWithNonConstDefault<T, U, V>(in->getData(), out->getData(), col_default->getData());
-        return true;
-    }
-
-    template <typename T, typename U, typename V>
-    bool executeNumToDecimalWithNonConstDefault2(const ColumnVector<T> * in, ColumnDecimal<U> * out, const IColumn * default_untyped) const
-    {
-        auto col_default = checkAndGetColumn<ColumnVector<V>>(default_untyped);
-        if (!col_default)
-            return false;
-
-        executeImplNumToNumWithNonConstDefault<T, U, V>(in->getData(), out->getData(), col_default->getData());
-        return true;
-    }
-
-    template <typename T, typename U, typename V>
-    bool executeNumToDecimalWithNonConstDefaultDecimal2(const ColumnVector<T> * in, ColumnDecimal<U> * out, const IColumn * default_untyped) const
-    {
-        auto col_default = checkAndGetColumn<ColumnDecimal<V>>(default_untyped);
-        if (!col_default)
-            return false;
-
-        executeImplNumToNumWithNonConstDefault<T, U, V>(in->getData(), out->getData(), col_default->getData());
-        return true;
-    }
-
-    template <typename T, typename U, typename V>
-    bool executeDecimalToNumWithNonConstDefault2(const ColumnDecimal<T> * in, ColumnVector<U> * out, const IColumn * default_untyped) const
-    {
-        auto col_default = checkAndGetColumn<ColumnVector<V>>(default_untyped);
-        if (!col_default)
-            return false;
-
-        executeImplNumToNumWithNonConstDefault<T, U, V>(in->getData(), out->getData(), col_default->getData());
-        return true;
-    }
-
-    template <typename T, typename U, typename V>
-    bool executeDecimalToDecimalWithNonConstDefault2(const ColumnDecimal<T> * in, ColumnDecimal<U> * out, const IColumn * default_untyped) const
-    {
-        auto col_default = checkAndGetColumn<ColumnVector<V>>(default_untyped);
-        if (!col_default)
-            return false;
-
-        executeImplNumToNumWithNonConstDefault<T, U, V>(in->getData(), out->getData(), col_default->getData());
-        return true;
-    }
-
-    template <typename T, typename U, typename V>
-    bool executeDecimalToNumWithNonConstDefaultDecimal2(const ColumnDecimal<T> * in, ColumnVector<U> * out, const IColumn * default_untyped) const
-    {
-        auto col_default = checkAndGetColumn<ColumnDecimal<V>>(default_untyped);
-        if (!col_default)
-            return false;
-
-        executeImplNumToNumWithNonConstDefault<T, U, V>(in->getData(), out->getData(), col_default->getData());
-        return true;
-    }
-
-    template <typename T, typename U, typename V>
-    bool executeDecimalToDecimalWithNonConstDefaultDecimal2(const ColumnDecimal<T> * in, ColumnDecimal<U> * out, const IColumn * default_untyped) const
-    {
-        auto col_default = checkAndGetColumn<ColumnDecimal<V>>(default_untyped);
-        if (!col_default)
-            return false;
-
-        executeImplNumToNumWithNonConstDefault<T, U, V>(in->getData(), out->getData(), col_default->getData());
-        return true;
-    }
-
-    template <typename T>
-    bool executeNumToStringWithConstDefault(const ColumnVector<T> * in, IColumn * out_untyped) const
-    {
-        auto * out = typeid_cast<ColumnString *>(out_untyped);
-        if (!out)
-            return false;
-
-        const String & default_str = cache.const_default_value.get<const String &>();
-        StringRef default_string_ref{default_str.data(), default_str.size() + 1};
-        executeImplNumToStringWithConstDefault<T>(in->getData(), out->getChars(), out->getOffsets(), default_string_ref);
-        return true;
-    }
-
-    template <typename T>
-    bool executeDecimalToStringWithConstDefault(const ColumnDecimal<T> * in, IColumn * out_untyped) const
-    {
-        auto * out = typeid_cast<ColumnString *>(out_untyped);
-        if (!out)
-            return false;
-
-        const String & default_str = cache.const_default_value.get<const String &>();
-        StringRef default_string_ref{default_str.data(), default_str.size() + 1};
-        executeImplNumToStringWithConstDefault<T>(in->getData(), out->getChars(), out->getOffsets(), default_string_ref);
-        return true;
-    }
-
-    template <typename T>
-    bool executeNumToStringWithNonConstDefault(const ColumnVector<T> * in, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        auto * out = typeid_cast<ColumnString *>(out_untyped);
-        if (!out)
-            return false;
-
-        const auto * default_col = checkAndGetColumn<ColumnString>(default_untyped);
-        if (!default_col)
-        {
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of fourth argument of function {}",
-                default_untyped->getName(), getName());
-        }
-
-        executeImplNumToStringWithNonConstDefault<T>(
-            in->getData(),
-            out->getChars(), out->getOffsets(),
-            default_col->getChars(), default_col->getOffsets());
-
-        return true;
-    }
-
-    template <typename T>
-    bool executeDecimalToStringWithNonConstDefault(const ColumnDecimal<T> * in, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        auto * out = typeid_cast<ColumnString *>(out_untyped);
-        if (!out)
-            return false;
-
-        const auto * default_col = checkAndGetColumn<ColumnString>(default_untyped);
-        if (!default_col)
-        {
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of fourth argument of function {}",
-                            default_untyped->getName(), getName());
-        }
-
-        executeImplNumToStringWithNonConstDefault<T>(
-            in->getData(),
-            out->getChars(), out->getOffsets(),
-            default_col->getChars(), default_col->getOffsets());
-
-        return true;
-    }
-
-    template <typename U>
-    bool executeStringToNumWithConstDefault(const ColumnString * in, IColumn * out_untyped) const
-    {
-        auto out = typeid_cast<ColumnVector<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        executeImplStringToNumWithConstDefault<U>(
-            in->getChars(), in->getOffsets(), out->getData(), static_cast<U>(cache.const_default_value.get<U>()));
-        return true;
-    }
-
-    template <typename U>
-    bool executeStringToDecimalWithConstDefault(const ColumnString * in, IColumn * out_untyped) const
-    {
-        auto out = typeid_cast<ColumnDecimal<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        executeImplStringToNumWithConstDefault<U>(in->getChars(), in->getOffsets(), out->getData(), cache.const_default_value.get<U>());
-        return true;
-    }
-
-    template <typename U>
-    bool executeStringToNumWithNonConstDefault(const ColumnString * in, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        auto out = typeid_cast<ColumnVector<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        if (!executeStringToNumWithNonConstDefault2<U, UInt8>(in, out, default_untyped)
-            && !executeStringToNumWithNonConstDefault2<U, UInt16>(in, out, default_untyped)
-            && !executeStringToNumWithNonConstDefault2<U, UInt32>(in, out, default_untyped)
-            && !executeStringToNumWithNonConstDefault2<U, UInt64>(in, out, default_untyped)
-            && !executeStringToNumWithNonConstDefault2<U, Int8>(in, out, default_untyped)
-            && !executeStringToNumWithNonConstDefault2<U, Int16>(in, out, default_untyped)
-            && !executeStringToNumWithNonConstDefault2<U, Int32>(in, out, default_untyped)
-            && !executeStringToNumWithNonConstDefault2<U, Int64>(in, out, default_untyped)
-            && !executeStringToNumWithNonConstDefault2<U, Float32>(in, out, default_untyped)
-            && !executeStringToNumWithNonConstDefault2<U, Float64>(in, out, default_untyped))
-        {
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of fourth argument of function {}",
-                default_untyped->getName(), getName());
-        }
-
-        return true;
-    }
-
-    template <typename U>
-    bool executeStringToDecimalWithNonConstDefault(const ColumnString * in, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        auto out = typeid_cast<ColumnDecimal<U> *>(out_untyped);
-        if (!out)
-            return false;
-
-        if (!executeStringToDecimalWithNonConstDefault2<U, UInt8>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefault2<U, UInt16>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefault2<U, UInt32>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefault2<U, UInt64>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefault2<U, Int8>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefault2<U, Int16>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefault2<U, Int32>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefault2<U, Int64>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefault2<U, Float32>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefault2<U, Float64>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefaultDecimal2<U, Decimal32>(in, out, default_untyped)
-            && !executeStringToDecimalWithNonConstDefaultDecimal2<U, Decimal64>(in, out, default_untyped))
-        {
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of fourth argument of function {}",
-                            default_untyped->getName(), getName());
-        }
-
-        return true;
-    }
-
-
-    template <typename U, typename V>
-    bool executeStringToNumWithNonConstDefault2(const ColumnString * in, ColumnVector<U> * out, const IColumn * default_untyped) const
-    {
-        auto col_default = checkAndGetColumn<ColumnVector<V>>(default_untyped);
-        if (!col_default)
-            return false;
-
-        executeImplStringToNumWithNonConstDefault<U, V>(in->getChars(), in->getOffsets(), out->getData(), col_default->getData());
-        return true;
-    }
-
-    template <typename U, typename V>
-    bool executeStringToDecimalWithNonConstDefault2(const ColumnString * in, ColumnDecimal<U> * out, const IColumn * default_untyped) const
-    {
-        auto col_default = checkAndGetColumn<ColumnVector<V>>(default_untyped);
-        if (!col_default)
-            return false;
-
-        executeImplStringToNumWithNonConstDefault<U, V>(in->getChars(), in->getOffsets(), out->getData(), col_default->getData());
-        return true;
-    }
-
-    template <typename U, typename V>
-    bool executeStringToDecimalWithNonConstDefaultDecimal2(const ColumnString * in, ColumnDecimal<U> * out, const IColumn * default_untyped) const
-    {
-        auto col_default = checkAndGetColumn<ColumnDecimal<V>>(default_untyped);
-        if (!col_default)
-            return false;
-
-        executeImplStringToNumWithNonConstDefault<U, V>(in->getChars(), in->getOffsets(), out->getData(), col_default->getData());
-        return true;
-    }
-
-    bool executeStringToString(const ColumnString * in, IColumn * out_untyped) const
-    {
-        auto * out = typeid_cast<ColumnString *>(out_untyped);
-        if (!out)
-            return false;
-
-        executeImplStringToString(in->getChars(), in->getOffsets(), out->getChars(), out->getOffsets());
-        return true;
-    }
-
-    bool executeStringToStringWithConstDefault(const ColumnString * in, IColumn * out_untyped) const
-    {
-        auto * out = typeid_cast<ColumnString *>(out_untyped);
-        if (!out)
-            return false;
-
-        const String & default_str = cache.const_default_value.get<const String &>();
-        StringRef default_string_ref{default_str.data(), default_str.size() + 1};
-        executeImplStringToStringWithConstDefault(in->getChars(), in->getOffsets(), out->getChars(), out->getOffsets(), default_string_ref);
-        return true;
-    }
-
-    bool executeStringToStringWithNonConstDefault(const ColumnString * in, IColumn * out_untyped, const IColumn * default_untyped) const
-    {
-        auto * out = typeid_cast<ColumnString *>(out_untyped);
-        if (!out)
-            return false;
-
-        const auto * default_col = checkAndGetColumn<ColumnString>(default_untyped);
-        if (!default_col)
-        {
-            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of fourth argument of function {}",
-                default_untyped->getName(), getName());
-        }
-
-        executeImplStringToStringWithNonConstDefault(
-            in->getChars(), in->getOffsets(),
-            out->getChars(), out->getOffsets(),
-            default_col->getChars(), default_col->getOffsets());
-
-        return true;
-    }
-
-
-    template <typename T, typename U>
-    void executeImplNumToNumWithConstDefault(const PaddedPODArray<T> & src, PaddedPODArray<U> & dst, U dst_default) const
-    {
-        const auto & table = *cache.table_num_to_num;
-        size_t size = src.size();
-        dst.resize(size);
-        for (size_t i = 0; i < size; ++i)
-        {
-            const auto * it = table.find(bit_cast<UInt64>(src[i]));
-            if (it)
-            {
-                if constexpr (std::endian::native == std::endian::little)
-                    memcpy(&dst[i], &it->getMapped(), sizeof(dst[i]));
-                else
-                    memcpy(&dst[i], reinterpret_cast<const char *>(&it->getMapped()) + sizeof(UInt64) - sizeof(dst[i]), sizeof(dst[i]));
-            }
-            else
-                dst[i] = dst_default;
-        }
-    }
-
-    template <typename T, typename U, typename V>
-    void executeImplNumToNumWithNonConstDefault(const PaddedPODArray<T> & src, PaddedPODArray<U> & dst, const PaddedPODArray<V> & dst_default) const
-    {
-        const auto & table = *cache.table_num_to_num;
-        size_t size = src.size();
-        dst.resize(size);
-        for (size_t i = 0; i < size; ++i)
-        {
-            const auto * it = table.find(bit_cast<UInt64>(src[i]));
-            if (it)
-            {
-                if constexpr (std::endian::native == std::endian::little)
-                    memcpy(&dst[i], &it->getMapped(), sizeof(dst[i]));
-                else
-                    memcpy(&dst[i], reinterpret_cast<const char *>(&it->getMapped()) + sizeof(UInt64) - sizeof(dst[i]), sizeof(dst[i]));
-            }
-            else if constexpr (is_decimal<U>)
-                dst[i] = static_cast<typename U::NativeType>(dst_default[i]);
-            else
-                dst[i] = static_cast<U>(dst_default[i]); // NOLINT(bugprone-signed-char-misuse,cert-str34-c)
-        }
-    }
-
-    template <typename T>
-    void executeImplNumToNum(const PaddedPODArray<T> & src, PaddedPODArray<T> & dst) const
-    {
-        const auto & table = *cache.table_num_to_num;
-        size_t size = src.size();
-        dst.resize(size);
-        for (size_t i = 0; i < size; ++i)
-        {
-            const auto * it = table.find(bit_cast<UInt64>(src[i]));
-            if (it)
-            {
-                if constexpr (std::endian::native == std::endian::little)
-                    memcpy(&dst[i], &it->getMapped(), sizeof(dst[i]));
-                else
-                    memcpy(&dst[i], reinterpret_cast<const char *>(&it->getMapped()) + sizeof(UInt64) - sizeof(dst[i]), sizeof(dst[i]));
-            }
-            else
-                dst[i] = src[i];
-        }
-    }
-
-    template <typename T>
-    void executeImplNumToStringWithConstDefault(const PaddedPODArray<T> & src,
-        ColumnString::Chars & dst_data, ColumnString::Offsets & dst_offsets, StringRef dst_default) const
-    {
-        const auto & table = *cache.table_num_to_string;
-        size_t size = src.size();
-        dst_offsets.resize(size);
-        ColumnString::Offset current_dst_offset = 0;
-        for (size_t i = 0; i < size; ++i)
-        {
-            const auto * it = table.find(bit_cast<UInt64>(src[i]));
-            StringRef ref = it ? it->getMapped() : dst_default;
-            dst_data.resize(current_dst_offset + ref.size);
-            memcpy(&dst_data[current_dst_offset], ref.data, ref.size);
-            current_dst_offset += ref.size;
-            dst_offsets[i] = current_dst_offset;
-        }
-    }
-
-    template <typename T>
-    void executeImplNumToStringWithNonConstDefault(const PaddedPODArray<T> & src,
-        ColumnString::Chars & dst_data, ColumnString::Offsets & dst_offsets,
-        const ColumnString::Chars & dst_default_data, const ColumnString::Offsets & dst_default_offsets) const
-    {
-        const auto & table = *cache.table_num_to_string;
-        size_t size = src.size();
-        dst_offsets.resize(size);
-        ColumnString::Offset current_dst_offset = 0;
-        ColumnString::Offset current_dst_default_offset = 0;
-        for (size_t i = 0; i < size; ++i)
-        {
-            const auto * it = table.find(bit_cast<UInt64>(src[i]));
-            StringRef ref;
-
-            if (it)
-                ref = it->getMapped();
-            else
-            {
-                ref.data = reinterpret_cast<const char *>(&dst_default_data[current_dst_default_offset]);
-                ref.size = dst_default_offsets[i] - current_dst_default_offset;
-            }
-
-            dst_data.resize(current_dst_offset + ref.size);
-            memcpy(&dst_data[current_dst_offset], ref.data, ref.size);
-            current_dst_offset += ref.size;
-            current_dst_default_offset = dst_default_offsets[i];
-            dst_offsets[i] = current_dst_offset;
-        }
-    }
-
-    template <typename U>
-    void executeImplStringToNumWithConstDefault(
-        const ColumnString::Chars & src_data, const ColumnString::Offsets & src_offsets,
-        PaddedPODArray<U> & dst, U dst_default) const
-    {
-        const auto & table = *cache.table_string_to_num;
-        size_t size = src_offsets.size();
-        dst.resize(size);
-        ColumnString::Offset current_src_offset = 0;
-        for (size_t i = 0; i < size; ++i)
-        {
-            StringRef ref{&src_data[current_src_offset], src_offsets[i] - current_src_offset};
-            current_src_offset = src_offsets[i];
-            const auto * it = table.find(ref);
-            if (it)
-            {
-                if constexpr (std::endian::native == std::endian::little)
-                    memcpy(&dst[i], &it->getMapped(), sizeof(dst[i]));
-                else
-                    memcpy(&dst[i], reinterpret_cast<const char *>(&it->getMapped()) + sizeof(UInt64) - sizeof(dst[i]), sizeof(dst[i]));
-            }
-            else
-                dst[i] = dst_default;
-        }
-    }
-
-    template <typename U, typename V>
-    void executeImplStringToNumWithNonConstDefault(
-        const ColumnString::Chars & src_data, const ColumnString::Offsets & src_offsets,
-        PaddedPODArray<U> & dst, const PaddedPODArray<V> & dst_default) const
-    {
-        const auto & table = *cache.table_string_to_num;
-        size_t size = src_offsets.size();
-        dst.resize(size);
-        ColumnString::Offset current_src_offset = 0;
-        for (size_t i = 0; i < size; ++i)
-        {
-            StringRef ref{&src_data[current_src_offset], src_offsets[i] - current_src_offset};
-            current_src_offset = src_offsets[i];
-            const auto * it = table.find(ref);
-            if (it)
-            {
-                if constexpr (std::endian::native == std::endian::little)
-                    memcpy(&dst[i], &it->getMapped(), sizeof(dst[i]));
-                else
-                    memcpy(&dst[i], reinterpret_cast<const char *>(&it->getMapped()) + sizeof(UInt64) - sizeof(dst[i]), sizeof(dst[i]));
-            }
-            else if constexpr (is_decimal<U>)
-                dst[i] = static_cast<typename U::NativeType>(dst_default[i]);
-            else
-                dst[i] = static_cast<U>(dst_default[i]); // NOLINT(bugprone-signed-char-misuse,cert-str34-c)
-        }
-    }
-
-    template <bool with_default>
-    void executeImplStringToStringWithOrWithoutConstDefault(
-        const ColumnString::Chars & src_data, const ColumnString::Offsets & src_offsets,
-        ColumnString::Chars & dst_data, ColumnString::Offsets & dst_offsets, StringRef dst_default) const
-    {
-        const auto & table = *cache.table_string_to_string;
-        size_t size = src_offsets.size();
-        dst_offsets.resize(size);
-        ColumnString::Offset current_src_offset = 0;
-        ColumnString::Offset current_dst_offset = 0;
-        for (size_t i = 0; i < size; ++i)
-        {
-            StringRef src_ref{&src_data[current_src_offset], src_offsets[i] - current_src_offset};
-            current_src_offset = src_offsets[i];
-
-            const auto * it = table.find(src_ref);
-
-            StringRef dst_ref = it ? it->getMapped() : (with_default ? dst_default : src_ref);
-            dst_data.resize(current_dst_offset + dst_ref.size);
-            memcpy(&dst_data[current_dst_offset], dst_ref.data, dst_ref.size);
-            current_dst_offset += dst_ref.size;
-            dst_offsets[i] = current_dst_offset;
-        }
-    }
-
-    void executeImplStringToString(
-        const ColumnString::Chars & src_data, const ColumnString::Offsets & src_offsets,
-        ColumnString::Chars & dst_data, ColumnString::Offsets & dst_offsets) const
-    {
-        executeImplStringToStringWithOrWithoutConstDefault<false>(src_data, src_offsets, dst_data, dst_offsets, {});
-    }
-
-    void executeImplStringToStringWithConstDefault(
-        const ColumnString::Chars & src_data, const ColumnString::Offsets & src_offsets,
-        ColumnString::Chars & dst_data, ColumnString::Offsets & dst_offsets, StringRef dst_default) const
-    {
-        executeImplStringToStringWithOrWithoutConstDefault<true>(src_data, src_offsets, dst_data, dst_offsets, dst_default);
-    }
-
-    void executeImplStringToStringWithNonConstDefault(
-        const ColumnString::Chars & src_data, const ColumnString::Offsets & src_offsets,
-        ColumnString::Chars & dst_data, ColumnString::Offsets & dst_offsets,
-        const ColumnString::Chars & dst_default_data, const ColumnString::Offsets & dst_default_offsets) const
-    {
-        const auto & table = *cache.table_string_to_string;
-        size_t size = src_offsets.size();
-        dst_offsets.resize(size);
-        ColumnString::Offset current_src_offset = 0;
-        ColumnString::Offset current_dst_offset = 0;
-        ColumnString::Offset current_dst_default_offset = 0;
-        for (size_t i = 0; i < size; ++i)
-        {
-            StringRef src_ref{&src_data[current_src_offset], src_offsets[i] - current_src_offset};
-            current_src_offset = src_offsets[i];
-
-            const auto * it = table.find(src_ref);
-            StringRef dst_ref;
-
-            if (it)
-                dst_ref = it->getMapped();
-            else
-            {
-                dst_ref.data = reinterpret_cast<const char *>(&dst_default_data[current_dst_default_offset]);
-                dst_ref.size = dst_default_offsets[i] - current_dst_default_offset;
-            }
-
-            dst_data.resize(current_dst_offset + dst_ref.size);
-            memcpy(&dst_data[current_dst_offset], dst_ref.data, dst_ref.size);
-            current_dst_offset += dst_ref.size;
-            current_dst_default_offset = dst_default_offsets[i];
-            dst_offsets[i] = current_dst_offset;
-        }
-    }
-
-
-    /// Different versions of the hash tables to implement the mapping.
-
-    struct Cache
-    {
-        using NumToNum = HashMap<UInt64, UInt64, HashCRC32<UInt64>>;
-        using NumToString = HashMap<UInt64, StringRef, HashCRC32<UInt64>>;     /// Everywhere StringRef's with trailing zero.
-        using StringToNum = HashMap<StringRef, UInt64, StringRefHash>;
-        using StringToString = HashMap<StringRef, StringRef, StringRefHash>;
-
-        std::unique_ptr<NumToNum> table_num_to_num;
-        std::unique_ptr<NumToString> table_num_to_string;
-        std::unique_ptr<StringToNum> table_string_to_num;
-        std::unique_ptr<StringToString> table_string_to_string;
-
-        Arena string_pool;
-
-        Field const_default_value;    /// Null, if not specified.
-
-        std::atomic<bool> initialized{false};
-        std::mutex mutex;
-    };
-
-    mutable Cache cache;
-
-
-    static UInt64 bitCastToUInt64(const Field & x)
-    {
-        switch (x.getType())
-        {
-            case Field::Types::UInt64:      return x.get<UInt64>();
-            case Field::Types::Int64:       return x.get<Int64>();
-            case Field::Types::Float64:     return std::bit_cast<UInt64>(x.get<Float64>());
-            case Field::Types::Bool:        return x.get<bool>();
-            case Field::Types::Decimal32:   return x.get<DecimalField<Decimal32>>().getValue();
-            case Field::Types::Decimal64:   return x.get<DecimalField<Decimal64>>().getValue();
-            default:
-                throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unexpected type in function 'transform'");
-        }
-    }
-
-    /// Can be called from different threads. It works only on the first call.
-    void initialize(const Array & from, const Array & to, const ColumnsWithTypeAndName & arguments) const
-    {
-        if (cache.initialized)
-            return;
-
-        const size_t size = from.size();
-        if (0 == size)
-            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Empty arrays are illegal in function {}", getName());
-
-        std::lock_guard lock(cache.mutex);
-
-        if (cache.initialized)
-            return;
-
-        if (size != to.size())
-            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Second and third arguments of function {} must be arrays of same size", getName());
-
-        Array converted_to;
-        const Array * used_to = &to;
-
-        /// Whether the default value is set.
-
-        if (arguments.size() == 4)
-        {
-            const IColumn * default_col = arguments[3].column.get();
-            const ColumnConst * const_default_col = typeid_cast<const ColumnConst *>(default_col);
-
-            if (const_default_col)
-                cache.const_default_value = (*const_default_col)[0];
-
-            /// Do we need to convert the elements `to` and `default_value` to the smallest common type that is Float64?
-            bool default_col_is_float =
-                   checkColumn<ColumnFloat32>(default_col)
-                || checkColumn<ColumnFloat64>(default_col)
-                || checkColumnConst<ColumnFloat32>(default_col)
-                || checkColumnConst<ColumnFloat64>(default_col);
-
-            bool to_is_float = to[0].getType() == Field::Types::Float64;
-
-            if (default_col_is_float && !to_is_float)
-            {
-                converted_to.resize(size);
+                const size_t size = pod.size();
+                const auto & table = *cache.table_num_to_idx;
+                column_result.reserve(size);
                 for (size_t i = 0; i < size; ++i)
-                    converted_to[i] = applyVisitor(FieldVisitorConvertToNumber<Float64>(), to[i]);
-                used_to = &converted_to;
+                {
+                    const auto * it = table.find(bit_cast<UInt64>(pod[i]));
+                    if (it)
+                        column_result.insertFrom(*cache.to_columns, it->getMapped());
+                    else if (cache.default_column)
+                        column_result.insertFrom(*cache.default_column, 0);
+                    else if (default_non_const)
+                        column_result.insertFrom(*default_non_const, i);
+                    else
+                        column_result.insertFrom(*in, i);
+                }
             }
-            else if (!default_col_is_float && to_is_float)
+            return true;
+        }
+
+        template <typename T>
+        bool executeNumToString(const PaddedPODArray<T> & pod, IColumn & column_result, const ColumnPtr default_non_const) const
+        {
+            auto * out = typeid_cast<ColumnString *>(&column_result);
+            if (!out)
+                return false;
+            auto & out_offs = out->getOffsets();
+            const size_t size = pod.size();
+            out_offs.resize(size);
+            auto & out_chars = out->getChars();
+
+            const auto * to_col = reinterpret_cast<const ColumnString *>(cache.to_columns.get());
+            const auto & to_chars = to_col->getChars();
+            const auto & to_offs = to_col->getOffsets();
+            const auto & table = *cache.table_num_to_idx;
+
+            if (cache.default_column)
             {
-                if (const_default_col)
-                    cache.const_default_value = applyVisitor(FieldVisitorConvertToNumber<Float64>(), cache.const_default_value);
+                const auto * def = reinterpret_cast<const ColumnString *>(cache.default_column.get());
+                const auto & def_chars = def->getChars();
+                const auto & def_offs = def->getOffsets();
+                const auto * def_data = def_chars.data();
+                auto def_size = def_offs[0];
+                executeNumToStringHelper(table, pod, out_chars, out_offs, to_chars, to_offs, def_data, def_size, size);
+            }
+            else
+            {
+                const auto * def = reinterpret_cast<const ColumnString *>(default_non_const.get());
+                const auto & def_chars = def->getChars();
+                const auto & def_offs = def->getOffsets();
+                executeNumToStringHelper(table, pod, out_chars, out_offs, to_chars, to_offs, def_chars, def_offs, size);
+            }
+            return true;
+        }
+
+        template <typename Table, typename In, typename DefData, typename DefOffs>
+        void executeNumToStringHelper(
+            const Table & table,
+            const PaddedPODArray<In> & pod,
+            ColumnString::Chars & out_data,
+            ColumnString::Offsets & out_offsets,
+            const ColumnString::Chars & to_data,
+            const ColumnString::Offsets & to_offsets,
+            const DefData & def_data,
+            const DefOffs & def_offsets,
+            const size_t size) const
+        {
+            size_t out_cur_off = 0;
+            for (size_t i = 0; i < size; ++i)
+            {
+                const char8_t * to = nullptr;
+                size_t to_size = 0;
+                const auto * it = table.find(bit_cast<UInt64>(pod[i]));
+                if (it)
+                {
+                    const auto idx = it->getMapped();
+                    const auto start = to_offsets[idx - 1];
+                    to = &to_data[start];
+                    to_size = to_offsets[idx] - start;
+                }
+                else if constexpr (std::is_same_v<DefData, ColumnString::Chars>)
+                {
+                    const auto start = def_offsets[i - 1];
+                    to = &def_data[start];
+                    to_size = def_offsets[i] - start;
+                }
+                else
+                {
+                    to = def_data;
+                    to_size = def_offsets;
+                }
+                out_data.resize(out_cur_off + to_size);
+                memcpy(&out_data[out_cur_off], to, to_size);
+                out_cur_off += to_size;
+                out_offsets[i] = out_cur_off;
             }
         }
 
-        /// Note: Doesn't check the duplicates in the `from` array.
-
-        const IDataType & from_type = *arguments[0].type;
-
-        if (from[0].getType() != Field::Types::String)
+        template <typename T, typename U>
+        bool executeNumToNum(
+            const PaddedPODArray<U> & pod, IColumn & column_result, const ColumnPtr default_non_const, const UInt32 in_scale) const
         {
-            if (to[0].getType() != Field::Types::String)
+            auto * out = typeid_cast<T *>(&column_result);
+            if (!out)
+                return false;
+            auto & out_pod = out->getData();
+            const size_t size = pod.size();
+            out_pod.resize(size);
+            UInt32 out_scale = 0;
+            if constexpr (std::is_same_v<ColumnDecimal<Decimal32>, T> || std::is_same_v<ColumnDecimal<Decimal64>, T>)
+                out_scale = out->getScale();
+
+            const auto & to_pod = reinterpret_cast<const T *>(cache.to_columns.get())->getData();
+            const auto & table = *cache.table_num_to_idx;
+            if (cache.default_column)
             {
-                cache.table_num_to_num = std::make_unique<Cache::NumToNum>();
-                auto & table = *cache.table_num_to_num;
+                const auto const_def = reinterpret_cast<const T *>(cache.default_column.get())->getData()[0];
+                executeNumToNumHelper(table, pod, out_pod, to_pod, const_def, size, out_scale, out_scale);
+            }
+            else if (default_non_const)
+            {
+                const auto & nconst_def = reinterpret_cast<const T *>(default_non_const.get())->getData();
+                executeNumToNumHelper(table, pod, out_pod, to_pod, nconst_def, size, out_scale, out_scale);
+            }
+            else
+                executeNumToNumHelper(table, pod, out_pod, to_pod, pod, size, out_scale, in_scale);
+            return true;
+        }
+
+        template <typename Table, typename In, typename Out, typename Def>
+        void executeNumToNumHelper(
+            const Table & table,
+            const PaddedPODArray<In> & pod,
+            PaddedPODArray<Out> & out_pod,
+            const PaddedPODArray<Out> & to_pod,
+            const Def & def,
+            const size_t size,
+            const UInt32 out_scale,
+            const UInt32 def_scale) const
+        {
+            for (size_t i = 0; i < size; ++i)
+            {
+                const auto * it = table.find(bit_cast<UInt64>(pod[i]));
+                if (it)
+                {
+                    const auto idx = it->getMapped();
+                    out_pod[i] = to_pod[idx];
+                }
+                else if constexpr (std::is_same_v<Def, Out>)
+                    out_pod[i] = def;
+                else if constexpr (is_decimal<Out> && !is_decimal<typename Def::value_type>)
+                    out_pod[i] = DecimalUtils::decimalFromComponents<Out>(static_cast<typename Out::NativeType>(def[i]), 0, out_scale);
+                else if constexpr (is_decimal<Out>)
+                {
+                    if (def_scale == out_scale)
+                        out_pod[i] = static_cast<typename Out::NativeType>(def[i]);
+                    else
+                    {
+                        const auto whole = static_cast<typename Out::NativeType>(DecimalUtils::getWholePart(def[i], def_scale));
+                        const auto fract = static_cast<typename Out::NativeType>(DecimalUtils::getFractionalPart(def[i], def_scale));
+                        out_pod[i] = DecimalUtils::decimalFromComponents<Out>(whole, fract, out_scale);
+                    }
+                }
+                else
+                    out_pod[i] = static_cast<Out>(def[i]); // NOLINT(bugprone-signed-char-misuse,cert-str34-c)
+            }
+        }
+
+        bool executeString(const IColumn * in_untyped, IColumn & column_result, const ColumnPtr default_non_const) const
+        {
+            const auto * const in = checkAndGetColumn<ColumnString>(in_untyped);
+            if (!in)
+                return false;
+            const auto & data = in->getChars();
+            const auto & offsets = in->getOffsets();
+
+            if (!executeStringToString(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnVector<UInt8>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnVector<UInt16>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnVector<UInt32>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnVector<UInt64>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnVector<Int8>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnVector<Int16>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnVector<Int32>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnVector<Int64>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnVector<Float32>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnVector<Float64>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnDecimal<Decimal32>>(data, offsets, column_result, default_non_const)
+                && !executeStringToNum<ColumnDecimal<Decimal64>>(data, offsets, column_result, default_non_const))
+            {
+                const size_t size = offsets.size();
+                const auto & table = *cache.table_string_to_idx;
+                ColumnString::Offset current_offset = 0;
+                for (size_t i = 0; i < size; ++i)
+                {
+                    const StringRef ref{&data[current_offset], offsets[i] - current_offset};
+                    current_offset = offsets[i];
+                    const auto * it = table.find(ref);
+                    if (it)
+                        column_result.insertFrom(*cache.to_columns, it->getMapped());
+                    else if (cache.default_column)
+                        column_result.insertFrom(*cache.default_column, 0);
+                    else if (default_non_const)
+                        column_result.insertFrom(*default_non_const, 0);
+                    else
+                        column_result.insertFrom(*in, i);
+                }
+            }
+            return true;
+        }
+
+        bool executeStringToString(
+            const ColumnString::Chars & data,
+            const ColumnString::Offsets & offsets,
+            IColumn & column_result,
+            const ColumnPtr default_non_const) const
+        {
+            auto * out = typeid_cast<ColumnString *>(&column_result);
+            if (!out)
+                return false;
+            auto & out_offs = out->getOffsets();
+            const size_t size = offsets.size();
+            out_offs.resize(size);
+            auto & out_chars = out->getChars();
+
+            const auto * to_col = reinterpret_cast<const ColumnString *>(cache.to_columns.get());
+            const auto & to_chars = to_col->getChars();
+            const auto & to_offs = to_col->getOffsets();
+
+            const auto & table = *cache.table_string_to_idx;
+            if (cache.default_column)
+            {
+                const auto * def = reinterpret_cast<const ColumnString *>(cache.default_column.get());
+                const auto & def_chars = def->getChars();
+                const auto & def_offs = def->getOffsets();
+                const auto * def_data = def_chars.data();
+                auto def_size = def_offs[0];
+                executeStringToStringHelper(table, data, offsets, out_chars, out_offs, to_chars, to_offs, def_data, def_size, size);
+            }
+            else if (default_non_const)
+            {
+                const auto * def = reinterpret_cast<const ColumnString *>(default_non_const.get());
+                const auto & def_chars = def->getChars();
+                const auto & def_offs = def->getOffsets();
+                executeStringToStringHelper(table, data, offsets, out_chars, out_offs, to_chars, to_offs, def_chars, def_offs, size);
+            }
+            else
+            {
+                executeStringToStringHelper(table, data, offsets, out_chars, out_offs, to_chars, to_offs, data, offsets, size);
+            }
+            return true;
+        }
+
+        template <typename Table, typename DefData, typename DefOffs>
+        void executeStringToStringHelper(
+            const Table & table,
+            const ColumnString::Chars & data,
+            const ColumnString::Offsets & offsets,
+            ColumnString::Chars & out_data,
+            ColumnString::Offsets & out_offsets,
+            const ColumnString::Chars & to_data,
+            const ColumnString::Offsets & to_offsets,
+            const DefData & def_data,
+            const DefOffs & def_offsets,
+            const size_t size) const
+        {
+            ColumnString::Offset current_offset = 0;
+            size_t out_cur_off = 0;
+            for (size_t i = 0; i < size; ++i)
+            {
+                const char8_t * to = nullptr;
+                size_t to_size = 0;
+                const StringRef ref{&data[current_offset], offsets[i] - current_offset};
+                current_offset = offsets[i];
+                const auto * it = table.find(ref);
+                if (it)
+                {
+                    const auto idx = it->getMapped();
+                    const auto start = to_offsets[idx - 1];
+                    to = &to_data[start];
+                    to_size = to_offsets[idx] - start;
+                }
+                else if constexpr (std::is_same_v<DefData, ColumnString::Chars>)
+                {
+                    const auto start = def_offsets[i - 1];
+                    to = &def_data[start];
+                    to_size = def_offsets[i] - start;
+                }
+                else
+                {
+                    to = def_data;
+                    to_size = def_offsets;
+                }
+                out_data.resize(out_cur_off + to_size);
+                memcpy(&out_data[out_cur_off], to, to_size);
+                out_cur_off += to_size;
+                out_offsets[i] = out_cur_off;
+            }
+        }
+
+        template <typename T>
+        bool executeStringToNum(
+            const ColumnString::Chars & data,
+            const ColumnString::Offsets & offsets,
+            IColumn & column_result,
+            const ColumnPtr default_non_const) const
+        {
+            auto * out = typeid_cast<T *>(&column_result);
+            if (!out)
+                return false;
+            auto & out_pod = out->getData();
+            const size_t size = offsets.size();
+            out_pod.resize(size);
+
+            const auto & to_pod = reinterpret_cast<const T *>(cache.to_columns.get())->getData();
+            const auto & table = *cache.table_string_to_idx;
+            if (cache.default_column)
+            {
+                const auto const_def = reinterpret_cast<const T *>(cache.default_column.get())->getData()[0];
+                executeStringToNumHelper(table, data, offsets, out_pod, to_pod, const_def, size);
+            }
+            else
+            {
+                const auto & nconst_def = reinterpret_cast<const T *>(default_non_const.get())->getData();
+                executeStringToNumHelper(table, data, offsets, out_pod, to_pod, nconst_def, size);
+            }
+            return true;
+        }
+
+        template <typename Table, typename Out, typename Def>
+        void executeStringToNumHelper(
+            const Table & table,
+            const ColumnString::Chars & data,
+            const ColumnString::Offsets & offsets,
+            PaddedPODArray<Out> & out_pod,
+            const PaddedPODArray<Out> & to_pod,
+            const Def & def,
+            const size_t size) const
+        {
+            ColumnString::Offset current_offset = 0;
+            for (size_t i = 0; i < size; ++i)
+            {
+                const StringRef ref{&data[current_offset], offsets[i] - current_offset};
+                current_offset = offsets[i];
+                const auto * it = table.find(ref);
+                if (it)
+                {
+                    const auto idx = it->getMapped();
+                    out_pod[i] = to_pod[idx];
+                }
+                else if constexpr (std::is_same_v<Def, Out>)
+                    out_pod[i] = def;
+                else if constexpr (is_decimal<Out>)
+                    out_pod[i] = static_cast<typename Out::NativeType>(def[i]);
+                else
+                    out_pod[i] = static_cast<Out>(def[i]); // NOLINT(bugprone-signed-char-misuse,cert-str34-c)
+            }
+        }
+
+        /// Different versions of the hash tables to implement the mapping.
+
+        struct Cache
+        {
+            using NumToIdx = HashMap<UInt64, size_t, HashCRC32<UInt64>>;
+            using StringToIdx = HashMap<StringRef, size_t, StringRefHash>;
+
+            std::unique_ptr<NumToIdx> table_num_to_idx;
+            std::unique_ptr<StringToIdx> table_string_to_idx;
+
+            ColumnPtr to_columns;
+            ColumnPtr default_column;
+
+            Arena string_pool;
+
+            std::atomic<bool> initialized{false};
+            std::mutex mutex;
+        };
+
+        mutable Cache cache;
+
+
+        static UInt64 bitCastToUInt64(const Field & x)
+        {
+            switch (x.getType())
+            {
+                case Field::Types::UInt64:
+                    return x.get<UInt64>();
+                case Field::Types::Int64:
+                    return x.get<Int64>();
+                case Field::Types::Float64:
+                    return std::bit_cast<UInt64>(x.get<Float64>());
+                case Field::Types::Bool:
+                    return x.get<bool>();
+                case Field::Types::Decimal32:
+                    return x.get<DecimalField<Decimal32>>().getValue();
+                case Field::Types::Decimal64:
+                    return x.get<DecimalField<Decimal64>>().getValue();
+                default:
+                    throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unexpected type in function 'transform'");
+            }
+        }
+
+        static void checkAllowedType(const DataTypePtr & dt)
+        {
+            if (dt->isNullable())
+                checkAllowedTypeHelper(static_cast<const DataTypeNullable *>(dt.get())->getNestedType());
+            else
+                checkAllowedTypeHelper(dt);
+        }
+
+        static void checkAllowedTypeHelper(const DataTypePtr & dt)
+        {
+            if (isStringOrFixedString(dt))
+                return;
+            auto dtsize = dt->getMaximumSizeOfValueInMemory();
+            if (dtsize <= sizeof(UInt64))
+                return;
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unexpected type {} in function 'transform'", dt->getName());
+        }
+
+        /// Can be called from different threads. It works only on the first call.
+        void initialize(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type) const
+        {
+            const ColumnConst * array_from = checkAndGetColumnConst<ColumnArray>(arguments[1].column.get());
+            const ColumnConst * array_to = checkAndGetColumnConst<ColumnArray>(arguments[2].column.get());
+
+            if (!array_from || !array_to)
+                throw Exception(
+                    ErrorCodes::ILLEGAL_COLUMN, "Second and third arguments of function {} must be constant arrays.", getName());
+
+            if (cache.initialized)
+                return;
+
+            const auto & from = array_from->getValue<Array>();
+            const size_t size = from.size();
+            if (0 == size)
+                throw Exception(ErrorCodes::BAD_ARGUMENTS, "Empty arrays are illegal in function {}", getName());
+
+            std::lock_guard lock(cache.mutex);
+
+            if (cache.initialized)
+                return;
+
+            const auto & to = array_to->getValue<Array>();
+            if (size != to.size())
+                throw Exception(
+                    ErrorCodes::BAD_ARGUMENTS, "Second and third arguments of function {} must be arrays of same size", getName());
+
+            /// Whether the default value is set.
+
+            if (arguments.size() == 4)
+            {
+                const IColumn * default_col = arguments[3].column.get();
+                if (default_col && isColumnConst(*default_col))
+                {
+                    auto default_column = result_type->createColumn();
+                    if (!default_col->onlyNull())
+                    {
+                        Field f = convertFieldToType((*default_col)[0], *result_type);
+                        default_column->insert(f);
+                    }
+                    else
+                        default_column->insertDefault();
+                    cache.default_column = std::move(default_column);
+                }
+            }
+
+            /// Note: Doesn't check the duplicates in the `from` array.
+
+            const IDataType & from_type = *arguments[0].type;
+
+            if (from[0].getType() != Field::Types::String)
+            {
+                cache.table_num_to_idx = std::make_unique<Cache::NumToIdx>();
+                auto & table = *cache.table_num_to_idx;
                 for (size_t i = 0; i < size; ++i)
                 {
                     Field key = convertFieldToType(from[i], from_type);
@@ -1204,55 +715,31 @@ private:
                         continue;
 
                     /// Field may be of Float type, but for the purpose of bitwise equality we can treat them as UInt64
-                    table[bitCastToUInt64(key)] = bitCastToUInt64((*used_to)[i]);
+                    table[bitCastToUInt64(key)] = i;
                 }
             }
             else
             {
-                cache.table_num_to_string = std::make_unique<Cache::NumToString>();
-                auto & table = *cache.table_num_to_string;
-                for (size_t i = 0; i < size; ++i)
-                {
-                    Field key = convertFieldToType(from[i], from_type);
-                    if (key.isNull())
-                        continue;
-
-                    const String & str_to = to[i].get<const String &>();
-                    StringRef ref{cache.string_pool.insert(str_to.data(), str_to.size() + 1), str_to.size() + 1};
-                    table[bitCastToUInt64(key)] = ref;
-                }
-            }
-        }
-        else
-        {
-            if (to[0].getType() != Field::Types::String)
-            {
-                cache.table_string_to_num = std::make_unique<Cache::StringToNum>();
-                auto & table = *cache.table_string_to_num;
+                cache.table_string_to_idx = std::make_unique<Cache::StringToIdx>();
+                auto & table = *cache.table_string_to_idx;
                 for (size_t i = 0; i < size; ++i)
                 {
                     const String & str_from = from[i].get<const String &>();
                     StringRef ref{cache.string_pool.insert(str_from.data(), str_from.size() + 1), str_from.size() + 1};
-                    table[ref] = bitCastToUInt64((*used_to)[i]);
+                    table[ref] = i;
                 }
             }
-            else
-            {
-                cache.table_string_to_string = std::make_unique<Cache::StringToString>();
-                auto & table = *cache.table_string_to_string;
-                for (size_t i = 0; i < size; ++i)
-                {
-                    const String & str_from = from[i].get<const String &>();
-                    const String & str_to = to[i].get<const String &>();
-                    StringRef ref_from{cache.string_pool.insert(str_from.data(), str_from.size() + 1), str_from.size() + 1};
-                    StringRef ref_to{cache.string_pool.insert(str_to.data(), str_to.size() + 1), str_to.size() + 1};
-                    table[ref_from] = ref_to;
-                }
-            }
-        }
 
-        cache.initialized = true;
-    }
+            auto to_columns = result_type->createColumn();
+            for (size_t i = 0; i < size; ++i)
+            {
+                Field to_value = convertFieldToType(to[i], *result_type);
+                to_columns->insert(to_value);
+            }
+            cache.to_columns = std::move(to_columns);
+
+            cache.initialized = true;
+        }
 };
 
 }
diff --git a/src/IO/ReadBufferFromS3.cpp b/src/IO/ReadBufferFromS3.cpp
index e0bca52d333..93e2c46b080 100644
--- a/src/IO/ReadBufferFromS3.cpp
+++ b/src/IO/ReadBufferFromS3.cpp
@@ -203,11 +203,13 @@ off_t ReadBufferFromS3::seek(off_t offset_, int whence)
         return offset_;
 
     if (impl && restricted_seek)
+    {
         throw Exception(
-                        ErrorCodes::CANNOT_SEEK_THROUGH_FILE,
-                        "Seek is allowed only before first read attempt from the buffer (current offset: "
-                        "{}, new offset: {}, reading until position: {}, available: {})",
-                        getPosition(), offset_, read_until_position, available());
+            ErrorCodes::CANNOT_SEEK_THROUGH_FILE,
+            "Seek is allowed only before first read attempt from the buffer (current offset: "
+            "{}, new offset: {}, reading until position: {}, available: {})",
+            getPosition(), offset_, read_until_position, available());
+    }
 
     if (whence != SEEK_SET)
         throw Exception(ErrorCodes::CANNOT_SEEK_THROUGH_FILE, "Only SEEK_SET mode is allowed.");
diff --git a/src/IO/S3/PocoHTTPClient.cpp b/src/IO/S3/PocoHTTPClient.cpp
index 9aabc73fc66..ee14e251cb5 100644
--- a/src/IO/S3/PocoHTTPClient.cpp
+++ b/src/IO/S3/PocoHTTPClient.cpp
@@ -260,6 +260,7 @@ void PocoHTTPClient::makeRequestInternal(
     Poco::Logger * log = &Poco::Logger::get("AWSClient");
 
     auto uri = request.GetUri().GetURIString();
+#if 0
     auto provider_type = getProviderTypeFromURL(uri);
 
     if (provider_type == ProviderType::GCS)
@@ -269,6 +270,7 @@ void PocoHTTPClient::makeRequestInternal(
         request.DeleteHeader("amz-sdk-invocation-id");
         request.DeleteHeader("amz-sdk-request");
     }
+#endif
 
     if (enable_s3_requests_logging)
         LOG_TEST(log, "Make request to: {}", uri);
diff --git a/src/IO/WriteBufferFromS3.cpp b/src/IO/WriteBufferFromS3.cpp
index 4c1b1b65d19..19f25b1617f 100644
--- a/src/IO/WriteBufferFromS3.cpp
+++ b/src/IO/WriteBufferFromS3.cpp
@@ -85,7 +85,8 @@ WriteBufferFromS3::WriteBufferFromS3(
     , upload_settings(request_settings.getUploadSettings())
     , client_ptr(std::move(client_ptr_))
     , object_metadata(std::move(object_metadata_))
-    , upload_part_size(upload_settings.min_upload_part_size)
+    , strict_upload_part_size(upload_settings.strict_upload_part_size)
+    , current_upload_part_size(upload_settings.min_upload_part_size)
     , schedule(std::move(schedule_))
     , write_settings(write_settings_)
 {
@@ -100,28 +101,79 @@ void WriteBufferFromS3::nextImpl()
     /// Buffer in a bad state after exception
     if (temporary_buffer->tellp() == -1)
         allocateBuffer();
+    else
+        chassert(temporary_buffer->tellp() == static_cast<std::streamoff>(last_part_size));
+
+    if (strict_upload_part_size)
+        processWithStrictParts();
+    else
+        processWithDynamicParts();
+
+    waitForReadyBackGroundTasks();
+}
+
+void WriteBufferFromS3::processWithStrictParts()
+{
+    chassert(strict_upload_part_size > 0);
+
+    size_t buffer_size = offset();
+    size_t left_in_buffer = buffer_size;
+    size_t new_size = last_part_size + buffer_size;
+    size_t buffer_offset = 0;
+
+    if (new_size > strict_upload_part_size)
+    {
+        /// Data size will exceed fixed part size threshold for multipart upload, need to use multipart upload.
+        if (multipart_upload_id.empty())
+            createMultipartUpload();
+
+        while (new_size > strict_upload_part_size)
+        {
+            size_t to_write = strict_upload_part_size - last_part_size;
+            temporary_buffer->write(working_buffer.begin() + buffer_offset, to_write);
+            buffer_offset += to_write;
+
+            writePart();
+            allocateBuffer();
+
+            new_size -= strict_upload_part_size;
+            left_in_buffer -= to_write;
+        }
+    }
+
+    if (left_in_buffer)
+    {
+        temporary_buffer->write(working_buffer.begin() + buffer_offset, left_in_buffer);
+        last_part_size += left_in_buffer;
+    }
+
+    ProfileEvents::increment(ProfileEvents::WriteBufferFromS3Bytes, buffer_size);
+
+    if (write_settings.remote_throttler)
+        write_settings.remote_throttler->add(buffer_size, ProfileEvents::RemoteWriteThrottlerBytes, ProfileEvents::RemoteWriteThrottlerSleepMicroseconds);
+}
+
+void WriteBufferFromS3::processWithDynamicParts()
+{
+    chassert(current_upload_part_size > 0);
 
     size_t size = offset();
     temporary_buffer->write(working_buffer.begin(), size);
+    ProfileEvents::increment(ProfileEvents::WriteBufferFromS3Bytes, size);
+    last_part_size += size;
 
-    ProfileEvents::increment(ProfileEvents::WriteBufferFromS3Bytes, offset());
-    last_part_size += offset();
     if (write_settings.remote_throttler)
-        write_settings.remote_throttler->add(offset(), ProfileEvents::RemoteWriteThrottlerBytes, ProfileEvents::RemoteWriteThrottlerSleepMicroseconds);
+        write_settings.remote_throttler->add(size, ProfileEvents::RemoteWriteThrottlerBytes, ProfileEvents::RemoteWriteThrottlerSleepMicroseconds);
 
     /// Data size exceeds singlepart upload threshold, need to use multipart upload.
     if (multipart_upload_id.empty() && last_part_size > upload_settings.max_single_part_upload_size)
         createMultipartUpload();
 
-    chassert(upload_part_size > 0);
-    if (!multipart_upload_id.empty() && last_part_size > upload_part_size)
+    if (!multipart_upload_id.empty() && last_part_size > current_upload_part_size)
     {
         writePart();
-
         allocateBuffer();
     }
-
-    waitForReadyBackGroundTasks();
 }
 
 void WriteBufferFromS3::allocateBuffer()
@@ -335,14 +387,17 @@ void WriteBufferFromS3::fillUploadRequest(S3::UploadPartRequest & req)
     /// If we don't do it, AWS SDK can mistakenly set it to application/xml, see https://github.com/aws/aws-sdk-cpp/issues/1840
     req.SetContentType("binary/octet-stream");
 
-    /// Maybe increase `upload_part_size` (we need to increase it sometimes to keep `part_number` less or equal than `max_part_number`).
-    auto threshold = upload_settings.upload_part_size_multiply_parts_count_threshold;
-    if (!multipart_upload_id.empty() && (part_number % threshold == 0))
+    if (!strict_upload_part_size)
     {
-        auto max_upload_part_size = upload_settings.max_upload_part_size;
-        auto upload_part_size_multiply_factor = upload_settings.upload_part_size_multiply_factor;
-        upload_part_size *= upload_part_size_multiply_factor;
-        upload_part_size = std::min(upload_part_size, max_upload_part_size);
+        /// Maybe increase `current_upload_part_size` (we need to increase it sometimes to keep `part_number` less or equal than `max_part_number`).
+        auto threshold = upload_settings.upload_part_size_multiply_parts_count_threshold;
+        if (!multipart_upload_id.empty() && (part_number % threshold == 0))
+        {
+            auto max_upload_part_size = upload_settings.max_upload_part_size;
+            auto upload_part_size_multiply_factor = upload_settings.upload_part_size_multiply_factor;
+            current_upload_part_size *= upload_part_size_multiply_factor;
+            current_upload_part_size = std::min(current_upload_part_size, max_upload_part_size);
+        }
     }
 }
 
diff --git a/src/IO/WriteBufferFromS3.h b/src/IO/WriteBufferFromS3.h
index 5fa934b886e..e57b8c159a2 100644
--- a/src/IO/WriteBufferFromS3.h
+++ b/src/IO/WriteBufferFromS3.h
@@ -58,6 +58,9 @@ public:
 private:
     void allocateBuffer();
 
+    void processWithStrictParts();
+    void processWithDynamicParts();
+
     void createMultipartUpload();
     void writePart();
     void completeMultipartUpload();
@@ -86,7 +89,10 @@ private:
     const std::shared_ptr<const S3::Client> client_ptr;
     const std::optional<std::map<String, String>> object_metadata;
 
-    size_t upload_part_size = 0;
+    /// Strict/static Part size, no adjustments will be done on fly.
+    size_t strict_upload_part_size = 0;
+    /// Part size will be adjusted on fly (for bigger uploads)
+    size_t current_upload_part_size = 0;
     std::shared_ptr<Aws::StringStream> temporary_buffer; /// Buffer to accumulate data.
     size_t last_part_size = 0;
     size_t part_number = 0;
diff --git a/src/Interpreters/Access/InterpreterCreateUserQuery.cpp b/src/Interpreters/Access/InterpreterCreateUserQuery.cpp
index 0bde147fbb6..165937560cc 100644
--- a/src/Interpreters/Access/InterpreterCreateUserQuery.cpp
+++ b/src/Interpreters/Access/InterpreterCreateUserQuery.cpp
@@ -23,10 +23,12 @@ namespace
     void updateUserFromQueryImpl(
         User & user,
         const ASTCreateUserQuery & query,
+        const std::optional<AuthenticationData> auth_data,
         const std::shared_ptr<ASTUserNameWithHost> & override_name,
         const std::optional<RolesOrUsersSet> & override_default_roles,
         const std::optional<SettingsProfileElements> & override_settings,
         const std::optional<RolesOrUsersSet> & override_grantees,
+        bool allow_implicit_no_password,
         bool allow_no_password,
         bool allow_plaintext_password)
     {
@@ -37,10 +39,16 @@ namespace
         else if (query.names->size() == 1)
             user.setName(query.names->front()->toString());
 
-        if (query.auth_data)
-            user.auth_data = *query.auth_data;
+        if (!query.attach && !query.alter && !auth_data && !allow_implicit_no_password)
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                            "Authentication type NO_PASSWORD must "
+                            "be explicitly specified, check the setting allow_implicit_no_password "
+                            "in the server configuration");
 
-        if (query.auth_data || !query.alter)
+        if (auth_data)
+            user.auth_data = *auth_data;
+
+        if (auth_data || !query.alter)
         {
             auto auth_type = user.auth_data.getType();
             if (((auth_type == AuthenticationType::NO_PASSWORD) && !allow_no_password) ||
@@ -104,17 +112,9 @@ BlockIO InterpreterCreateUserQuery::execute()
     bool no_password_allowed = access_control.isNoPasswordAllowed();
     bool plaintext_password_allowed = access_control.isPlaintextPasswordAllowed();
 
-     if (!query.attach && !query.alter && !query.auth_data && !implicit_no_password_allowed)
-        throw Exception(ErrorCodes::BAD_ARGUMENTS,
-                        "Authentication type NO_PASSWORD must "
-                        "be explicitly specified, check the setting allow_implicit_no_password "
-                        "in the server configuration");
-
-    if (!query.attach && query.temporary_password_for_checks)
-    {
-        access_control.checkPasswordComplexityRules(query.temporary_password_for_checks.value());
-        query.temporary_password_for_checks.reset();
-    }
+    std::optional<AuthenticationData> auth_data;
+    if (query.auth_data)
+        auth_data = AuthenticationData::fromAST(*query.auth_data, getContext(), !query.attach);
 
     std::optional<RolesOrUsersSet> default_roles_from_query;
     if (query.default_roles)
@@ -148,7 +148,7 @@ BlockIO InterpreterCreateUserQuery::execute()
         auto update_func = [&](const AccessEntityPtr & entity) -> AccessEntityPtr
         {
             auto updated_user = typeid_cast<std::shared_ptr<User>>(entity->clone());
-            updateUserFromQueryImpl(*updated_user, query, {}, default_roles_from_query, settings_from_query, grantees_from_query, no_password_allowed, plaintext_password_allowed);
+            updateUserFromQueryImpl(*updated_user, query, auth_data, {}, default_roles_from_query, settings_from_query, grantees_from_query, implicit_no_password_allowed, no_password_allowed, plaintext_password_allowed);
             return updated_user;
         };
 
@@ -167,7 +167,7 @@ BlockIO InterpreterCreateUserQuery::execute()
         for (const auto & name : *query.names)
         {
             auto new_user = std::make_shared<User>();
-            updateUserFromQueryImpl(*new_user, query, name, default_roles_from_query, settings_from_query, RolesOrUsersSet::AllTag{}, no_password_allowed, plaintext_password_allowed);
+            updateUserFromQueryImpl(*new_user, query, auth_data, name, default_roles_from_query, settings_from_query, RolesOrUsersSet::AllTag{}, implicit_no_password_allowed, no_password_allowed, plaintext_password_allowed);
             new_users.emplace_back(std::move(new_user));
         }
 
@@ -197,7 +197,11 @@ BlockIO InterpreterCreateUserQuery::execute()
 
 void InterpreterCreateUserQuery::updateUserFromQuery(User & user, const ASTCreateUserQuery & query, bool allow_no_password, bool allow_plaintext_password)
 {
-    updateUserFromQueryImpl(user, query, {}, {}, {}, {}, allow_no_password, allow_plaintext_password);
+    std::optional<AuthenticationData> auth_data;
+    if (query.auth_data)
+        auth_data = AuthenticationData::fromAST(*query.auth_data, {}, !query.attach);
+
+    updateUserFromQueryImpl(user, query, auth_data, {}, {}, {}, {}, allow_no_password, allow_plaintext_password, true);
 }
 
 }
diff --git a/src/Interpreters/Access/InterpreterShowCreateAccessEntityQuery.cpp b/src/Interpreters/Access/InterpreterShowCreateAccessEntityQuery.cpp
index 7b9a8f98c8f..5508fa0f825 100644
--- a/src/Interpreters/Access/InterpreterShowCreateAccessEntityQuery.cpp
+++ b/src/Interpreters/Access/InterpreterShowCreateAccessEntityQuery.cpp
@@ -62,7 +62,7 @@ namespace
         }
 
         if (user.auth_data.getType() != AuthenticationType::NO_PASSWORD)
-            query->auth_data = user.auth_data;
+            query->auth_data = user.auth_data.toAST();
 
         if (!user.settings.empty())
         {
diff --git a/src/Interpreters/AsynchronousInsertLog.cpp b/src/Interpreters/AsynchronousInsertLog.cpp
index 916ec8f3d56..eeccd9ad92e 100644
--- a/src/Interpreters/AsynchronousInsertLog.cpp
+++ b/src/Interpreters/AsynchronousInsertLog.cpp
@@ -36,6 +36,7 @@ NamesAndTypesList AsynchronousInsertLogElement::getNamesAndTypes()
         {"format", std::make_shared<DataTypeLowCardinality>(std::make_shared<DataTypeString>())},
         {"query_id", std::make_shared<DataTypeString>()},
         {"bytes", std::make_shared<DataTypeUInt64>()},
+        {"rows", std::make_shared<DataTypeUInt64>()},
         {"exception", std::make_shared<DataTypeString>()},
         {"status", type_status},
 
@@ -71,6 +72,7 @@ void AsynchronousInsertLogElement::appendToBlock(MutableColumns & columns) const
     columns[i++]->insert(insert_query.format);
     columns[i++]->insert(query_id);
     columns[i++]->insert(bytes);
+    columns[i++]->insert(rows);
     columns[i++]->insert(exception);
     columns[i++]->insert(status);
 
diff --git a/src/Interpreters/AsynchronousInsertLog.h b/src/Interpreters/AsynchronousInsertLog.h
index e2fdd4c90a0..f1e39db1ded 100644
--- a/src/Interpreters/AsynchronousInsertLog.h
+++ b/src/Interpreters/AsynchronousInsertLog.h
@@ -24,6 +24,7 @@ struct AsynchronousInsertLogElement
     ASTPtr query;
     String query_id;
     UInt64 bytes{};
+    UInt64 rows{};
     String exception;
     Status status{};
 
diff --git a/src/Interpreters/AsynchronousInsertQueue.cpp b/src/Interpreters/AsynchronousInsertQueue.cpp
index b8de0246ae2..88233f58a54 100644
--- a/src/Interpreters/AsynchronousInsertQueue.cpp
+++ b/src/Interpreters/AsynchronousInsertQueue.cpp
@@ -40,6 +40,7 @@ namespace ProfileEvents
 {
     extern const Event AsyncInsertQuery;
     extern const Event AsyncInsertBytes;
+    extern const Event AsyncInsertRows;
     extern const Event FailedAsyncInsertQuery;
 }
 
@@ -444,7 +445,8 @@ try
     {
         auto buffer = std::make_unique<ReadBufferFromString>(entry->bytes);
         current_entry = entry;
-        total_rows += executor.execute(*buffer);
+        size_t num_rows = executor.execute(*buffer);
+        total_rows += num_rows;
         chunk_info->offsets.push_back(total_rows);
 
         /// Keep buffer, because it still can be used
@@ -459,6 +461,7 @@ try
             elem.query = key.query;
             elem.query_id = entry->query_id;
             elem.bytes = entry->bytes.size();
+            elem.rows = num_rows;
             elem.exception = current_exception;
             current_exception.clear();
 
@@ -479,6 +482,7 @@ try
 
     format->addBuffer(std::move(last_buffer));
     auto insert_query_id = insert_context->getCurrentQueryId();
+    ProfileEvents::increment(ProfileEvents::AsyncInsertRows, total_rows);
 
     auto finish_entries = [&]
     {
diff --git a/src/Interpreters/Cache/FileCache.cpp b/src/Interpreters/Cache/FileCache.cpp
index 046e388430f..2ba44f64d1f 100644
--- a/src/Interpreters/Cache/FileCache.cpp
+++ b/src/Interpreters/Cache/FileCache.cpp
@@ -1,20 +1,16 @@
 #include "FileCache.h"
 
 #include <Common/randomSeed.h>
-#include <Common/SipHash.h>
-#include <Common/logger_useful.h>
 #include <Interpreters/Cache/FileCacheSettings.h>
 #include <Interpreters/Cache/LRUFileCachePriority.h>
+#include <Interpreters/Context.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteBufferFromFile.h>
 #include <IO/ReadSettings.h>
 #include <IO/WriteBufferFromString.h>
 #include <IO/Operators.h>
 #include <pcg-random/pcg_random.hpp>
-#include <filesystem>
-
-
-namespace fs = std::filesystem;
+#include <base/hex.h>
 
 namespace DB
 {
@@ -24,207 +20,159 @@ namespace ErrorCodes
 }
 
 FileCache::FileCache(const FileCacheSettings & settings)
-    : cache_base_path(settings.base_path)
-    , max_size(settings.max_size)
-    , max_element_size(settings.max_elements)
-    , max_file_segment_size(settings.max_file_segment_size)
+    : max_file_segment_size(settings.max_file_segment_size)
     , allow_persistent_files(settings.do_not_evict_index_and_mark_files)
-    , enable_cache_hits_threshold(settings.enable_cache_hits_threshold)
-    , enable_filesystem_query_cache_limit(settings.enable_filesystem_query_cache_limit)
-    , enable_bypass_cache_with_threashold(settings.enable_bypass_cache_with_threashold)
-    , bypass_cache_threashold(settings.bypass_cache_threashold)
+    , bypass_cache_threshold(settings.enable_bypass_cache_with_threashold ? settings.bypass_cache_threashold : 0)
+    , delayed_cleanup_interval_ms(settings.delayed_cleanup_interval_ms)
     , log(&Poco::Logger::get("FileCache"))
-    , main_priority(std::make_unique<LRUFileCachePriority>())
-    , stash_priority(std::make_unique<LRUFileCachePriority>())
-    , max_stash_element_size(settings.max_elements)
+    , metadata(settings.base_path)
 {
+    main_priority = std::make_unique<LRUFileCachePriority>(settings.max_size, settings.max_elements);
+
+    if (settings.cache_hits_threshold)
+        stash = std::make_unique<HitsCountStash>(settings.cache_hits_threshold, settings.max_elements);
+
+    if (settings.enable_filesystem_query_cache_limit)
+        query_limit = std::make_unique<FileCacheQueryLimit>();
 }
 
-FileCache::Key FileCache::hash(const String & path)
+FileCache::Key FileCache::createKeyForPath(const String & path)
 {
-    return Key(sipHash128(path.data(), path.size()));
+    return Key(path);
+}
+
+const String & FileCache::getBasePath() const
+{
+    return metadata.getBaseDirectory();
 }
 
 String FileCache::getPathInLocalCache(const Key & key, size_t offset, FileSegmentKind segment_kind) const
 {
-    String file_suffix;
-    switch (segment_kind)
-    {
-        case FileSegmentKind::Persistent:
-            file_suffix = "_persistent";
-            break;
-        case FileSegmentKind::Temporary:
-            file_suffix = "_temporary";
-            break;
-        case FileSegmentKind::Regular:
-            file_suffix = "";
-            break;
-    }
-
-    auto key_str = key.toString();
-    return fs::path(cache_base_path)
-        / key_str.substr(0, 3)
-        / key_str
-        / (std::to_string(offset) + file_suffix);
+    return metadata.getPathInLocalCache(key, offset, segment_kind);
 }
 
 String FileCache::getPathInLocalCache(const Key & key) const
 {
-    auto key_str = key.toString();
-    return fs::path(cache_base_path) / key_str.substr(0, 3) / key_str;
+    return metadata.getPathInLocalCache(key);
 }
 
-void FileCache::removeKeyDirectoryIfExists(const Key & key, std::lock_guard<std::mutex> & /* cache_lock */) const
+void FileCache::assertInitialized() const
 {
-    /// Note: it is guaranteed that there is no concurrency here with files deletion
-    /// because cache key directories are create only in FileCache class under cache_lock.
-
-    auto key_str = key.toString();
-    auto key_prefix_path = fs::path(cache_base_path) / key_str.substr(0, 3);
-    auto key_path = key_prefix_path / key_str;
-
-    if (!fs::exists(key_path))
+    if (is_initialized)
         return;
 
-    fs::remove_all(key_path);
+    std::unique_lock lock(init_mutex);
+    if (is_initialized)
+        return;
 
-    if (fs::is_empty(key_prefix_path))
-        fs::remove(key_prefix_path);
-}
-
-static bool isQueryInitialized()
-{
-    return CurrentThread::isInitialized()
-        && CurrentThread::get().getQueryContext()
-        && !CurrentThread::getQueryId().empty();
-}
-
-bool FileCache::isReadOnly()
-{
-    return !isQueryInitialized();
-}
-
-void FileCache::assertInitialized(std::lock_guard<std::mutex> & /* cache_lock */) const
-{
+    if (init_exception)
+        std::rethrow_exception(init_exception);
     if (!is_initialized)
-    {
-        if (initialization_exception)
-            std::rethrow_exception(initialization_exception);
-        else
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Cache not initialized");
-    }
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Cache not initialized");
 }
 
 void FileCache::initialize()
 {
-    std::lock_guard cache_lock(mutex);
-    if (!is_initialized)
+    std::lock_guard lock(init_mutex);
+
+    if (is_initialized)
+        return;
+
+    try
     {
-        if (fs::exists(cache_base_path))
+        if (fs::exists(getBasePath()))
         {
-            try
-            {
-                loadCacheInfoIntoMemory(cache_lock);
-            }
-            catch (...)
-            {
-                initialization_exception = std::current_exception();
-                throw;
-            }
+            loadMetadata();
         }
         else
         {
-            fs::create_directories(cache_base_path);
+            fs::create_directories(getBasePath());
         }
-
-        is_initialized = true;
     }
-}
-
-void FileCache::useCell(
-    const FileSegmentCell & cell, FileSegments & result, std::lock_guard<std::mutex> & cache_lock)
-{
-    auto file_segment = cell.file_segment;
-
-    if (file_segment->isDownloaded())
+    catch (...)
     {
-        fs::path path = file_segment->getPathInLocalCache();
-        if (!fs::exists(path))
-        {
-            throw Exception(
-                ErrorCodes::LOGICAL_ERROR,
-                "File path does not exist, but file has DOWNLOADED state. {}",
-                file_segment->getInfoForLog());
-        }
-
-        if (fs::file_size(path) == 0)
-        {
-            throw Exception(
-                ErrorCodes::LOGICAL_ERROR,
-                "Cannot have zero size downloaded file segments. {}",
-                file_segment->getInfoForLog());
-        }
+        init_exception = std::current_exception();
+        tryLogCurrentException(__PRETTY_FUNCTION__);
+        throw;
     }
 
-    result.push_back(cell.file_segment);
+    is_initialized = true;
 
-    /**
-     * A cell receives a queue iterator on first successful space reservation attempt
-     * (space is reserved incrementally on each read buffer nextImpl() call).
-     */
-    if (cell.queue_iterator)
-    {
-        /// Move to the end of the queue. The iterator remains valid.
-        cell.queue_iterator->use(cache_lock);
-    }
+    cleanup_task = Context::getGlobalContextInstance()->getSchedulePool().createTask("FileCacheCleanup", [this]{ cleanupThreadFunc(); });
+    cleanup_task->activate();
+    cleanup_task->scheduleAfter(delayed_cleanup_interval_ms);
 }
 
-FileCache::FileSegmentCell * FileCache::getCell(
-    const Key & key, size_t offset, std::lock_guard<std::mutex> & /* cache_lock */)
-{
-    auto it = files.find(key);
-    if (it == files.end())
-        return nullptr;
-
-    auto & offsets = it->second;
-    auto cell_it = offsets.find(offset);
-    if (cell_it == offsets.end())
-        return nullptr;
-
-    return &cell_it->second;
-}
-
-FileSegments FileCache::getImpl(
-    const Key & key, const FileSegment::Range & range, std::lock_guard<std::mutex> & cache_lock)
+FileSegments FileCache::getImpl(const LockedKey & locked_key, const FileSegment::Range & range) const
 {
     /// Given range = [left, right] and non-overlapping ordered set of file segments,
     /// find list [segment1, ..., segmentN] of segments which intersect with given range.
 
-    FileSegments result;
-
-    if (enable_bypass_cache_with_threashold && (range.size() > bypass_cache_threashold))
+    if (bypass_cache_threshold && range.size() > bypass_cache_threshold)
     {
         auto file_segment = std::make_shared<FileSegment>(
-            range.left, range.size(), key, this, FileSegment::State::SKIP_CACHE, CreateFileSegmentSettings{});
-        {
-            std::unique_lock segment_lock(file_segment->mutex);
-            file_segment->detachAssumeStateFinalized(segment_lock);
-        }
-        result.emplace_back(file_segment);
-        return result;
+            locked_key.getKey(), range.left, range.size(), FileSegment::State::DETACHED);
+        return { file_segment };
     }
 
-    auto it = files.find(key);
-    if (it == files.end())
-        return {};
-
-    const auto & file_segments = it->second;
+    const auto & file_segments = *locked_key.getKeyMetadata();
     if (file_segments.empty())
-    {
-        files.erase(key);
-        removeKeyDirectoryIfExists(key, cache_lock);
         return {};
-    }
+
+    FileSegments result;
+    auto add_to_result = [&](const FileSegmentMetadata & file_segment_metadata)
+    {
+        FileSegmentPtr file_segment;
+        if (file_segment_metadata.valid())
+        {
+            file_segment = file_segment_metadata.file_segment;
+            if (file_segment->isDownloaded())
+            {
+                if (file_segment->getDownloadedSize(true) == 0)
+                {
+                    throw Exception(
+                        ErrorCodes::LOGICAL_ERROR,
+                        "Cannot have zero size downloaded file segments. {}",
+                        file_segment->getInfoForLog());
+                }
+
+#ifndef NDEBUG
+                /**
+                * Check that in-memory state of the cache is consistent with the state on disk.
+                * Check only in debug build, because such checks can be done often and can be quite
+                * expensive compared to overall query execution time.
+                */
+
+                fs::path path = file_segment->getPathInLocalCache();
+                if (!fs::exists(path))
+                {
+                    throw Exception(
+                        ErrorCodes::LOGICAL_ERROR,
+                        "File path does not exist, but file has DOWNLOADED state. {}",
+                        file_segment->getInfoForLog());
+                }
+
+                if (fs::file_size(path) == 0)
+                {
+                    throw Exception(
+                        ErrorCodes::LOGICAL_ERROR,
+                        "Cannot have zero size downloaded file segments. {}",
+                        file_segment->getInfoForLog());
+                }
+#endif
+            }
+        }
+        else
+        {
+            file_segment = std::make_shared<FileSegment>(
+                locked_key.getKey(),
+                file_segment_metadata.file_segment->offset(),
+                file_segment_metadata.file_segment->range().size(),
+                FileSegment::State::DETACHED);
+        }
+
+        result.push_back(file_segment);
+    };
 
     auto segment_it = file_segments.lower_bound(range.left);
     if (segment_it == file_segments.end())
@@ -236,27 +184,27 @@ FileSegments FileCache::getImpl(
         ///     ^                                        ^
         ///     range.left                               range.left
 
-        const auto & cell = file_segments.rbegin()->second;
-        if (cell.file_segment->range().right < range.left)
+        const auto & file_segment_metadata = *file_segments.rbegin()->second;
+        if (file_segment_metadata.file_segment->range().right < range.left)
             return {};
 
-        useCell(cell, result, cache_lock);
+        add_to_result(file_segment_metadata);
     }
     else /// segment_it <-- segmment{k}
     {
         if (segment_it != file_segments.begin())
         {
-            const auto & prev_cell = std::prev(segment_it)->second;
-            const auto & prev_cell_range = prev_cell.file_segment->range();
+            const auto & prev_file_segment_metadata = *std::prev(segment_it)->second;
+            const auto & prev_range = prev_file_segment_metadata.file_segment->range();
 
-            if (range.left <= prev_cell_range.right)
+            if (range.left <= prev_range.right)
             {
                 ///   segment{k-1}  segment{k}
                 ///   [________]   [_____
                 ///       [___________
                 ///       ^
                 ///       range.left
-                useCell(prev_cell, result, cache_lock);
+                add_to_result(prev_file_segment_metadata);
             }
         }
 
@@ -268,11 +216,11 @@ FileSegments FileCache::getImpl(
 
         while (segment_it != file_segments.end())
         {
-            const auto & cell = segment_it->second;
-            if (range.right < cell.file_segment->range().left)
+            const auto & file_segment_metadata = *segment_it->second;
+            if (range.right < file_segment_metadata.file_segment->range().left)
                 break;
 
-            useCell(cell, result, cache_lock);
+            add_to_result(file_segment_metadata);
             ++segment_it;
         }
     }
@@ -280,34 +228,32 @@ FileSegments FileCache::getImpl(
     return result;
 }
 
-FileSegments FileCache::splitRangeIntoCells(
-    const Key & key,
+FileSegments FileCache::splitRangeIntoFileSegments(
+    LockedKey & locked_key,
     size_t offset,
     size_t size,
     FileSegment::State state,
-    const CreateFileSegmentSettings & settings,
-    std::lock_guard<std::mutex> & cache_lock)
+    const CreateFileSegmentSettings & settings)
 {
     assert(size > 0);
 
     auto current_pos = offset;
     auto end_pos_non_included = offset + size;
 
-    size_t current_cell_size;
+    size_t current_file_segment_size;
     size_t remaining_size = size;
 
     FileSegments file_segments;
     while (current_pos < end_pos_non_included)
     {
-        current_cell_size = std::min(remaining_size, max_file_segment_size);
-        remaining_size -= current_cell_size;
+        current_file_segment_size = std::min(remaining_size, max_file_segment_size);
+        remaining_size -= current_file_segment_size;
 
-        auto * cell = addCell(key, current_pos, current_cell_size, state, settings, cache_lock);
-        if (cell)
-            file_segments.push_back(cell->file_segment);
-        assert(cell);
+        auto file_segment_metadata_it = addFileSegment(
+            locked_key, current_pos, current_file_segment_size, state, settings, nullptr);
+        file_segments.push_back(file_segment_metadata_it->second->file_segment);
 
-        current_pos += current_cell_size;
+        current_pos += current_file_segment_size;
     }
 
     assert(file_segments.empty() || offset + size - 1 == file_segments.back()->range().right);
@@ -315,12 +261,11 @@ FileSegments FileCache::splitRangeIntoCells(
 }
 
 void FileCache::fillHolesWithEmptyFileSegments(
+    LockedKey & locked_key,
     FileSegments & file_segments,
-    const Key & key,
     const FileSegment::Range & range,
     bool fill_with_detached_file_segments,
-    const CreateFileSegmentSettings & settings,
-    std::lock_guard<std::mutex> & cache_lock)
+    const CreateFileSegmentSettings & settings)
 {
     /// There are segments [segment1, ..., segmentN]
     /// (non-overlapping, non-empty, ascending-ordered) which (maybe partially)
@@ -330,7 +275,9 @@ void FileCache::fillHolesWithEmptyFileSegments(
     /// [____________________]         -- requested range
     ///     [____]  [_]   [_________]  -- intersecting cache [segment1, ..., segmentN]
     ///
-    /// For each such hole create a cell with file segment state EMPTY.
+    /// For each such hole create a file_segment_metadata with file segment state EMPTY.
+
+    assert(!file_segments.empty());
 
     auto it = file_segments.begin();
     auto segment_range = (*it)->range();
@@ -366,16 +313,16 @@ void FileCache::fillHolesWithEmptyFileSegments(
 
         if (fill_with_detached_file_segments)
         {
-            auto file_segment = std::make_shared<FileSegment>(current_pos, hole_size, key, this, FileSegment::State::EMPTY, settings);
-            {
-                std::unique_lock segment_lock(file_segment->mutex);
-                file_segment->detachAssumeStateFinalized(segment_lock);
-            }
+            auto file_segment = std::make_shared<FileSegment>(
+                locked_key.getKey(), current_pos, hole_size, FileSegment::State::DETACHED, settings);
+
             file_segments.insert(it, file_segment);
         }
         else
         {
-            file_segments.splice(it, splitRangeIntoCells(key, current_pos, hole_size, FileSegment::State::EMPTY, settings, cache_lock));
+            auto split = splitRangeIntoFileSegments(
+                locked_key, current_pos, hole_size, FileSegment::State::EMPTY, settings);
+            file_segments.splice(it, std::move(split));
         }
 
         current_pos = segment_range.right + 1;
@@ -393,655 +340,481 @@ void FileCache::fillHolesWithEmptyFileSegments(
 
         if (fill_with_detached_file_segments)
         {
-            auto file_segment = std::make_shared<FileSegment>(current_pos, hole_size, key, this, FileSegment::State::EMPTY, settings);
-            {
-                std::unique_lock segment_lock(file_segment->mutex);
-                file_segment->detachAssumeStateFinalized(segment_lock);
-            }
+            auto file_segment = std::make_shared<FileSegment>(
+                locked_key.getKey(), current_pos, hole_size, FileSegment::State::DETACHED, settings);
+
             file_segments.insert(file_segments.end(), file_segment);
         }
         else
         {
-            file_segments.splice(
-                file_segments.end(),
-                splitRangeIntoCells(key, current_pos, hole_size, FileSegment::State::EMPTY, settings, cache_lock));
+            auto split = splitRangeIntoFileSegments(
+                locked_key, current_pos, hole_size, FileSegment::State::EMPTY, settings);
+            file_segments.splice(file_segments.end(), std::move(split));
         }
     }
 }
 
-FileSegmentsHolder FileCache::getOrSet(const Key & key, size_t offset, size_t size, const CreateFileSegmentSettings & settings)
-{
-    std::lock_guard cache_lock(mutex);
-
-    assertInitialized(cache_lock);
-
-#ifndef NDEBUG
-    assertCacheCorrectness(key, cache_lock);
-#endif
-
-    FileSegment::Range range(offset, offset + size - 1);
-    /// Get all segments which intersect with the given range.
-    auto file_segments = getImpl(key, range, cache_lock);
-
-    if (file_segments.empty())
-    {
-        file_segments = splitRangeIntoCells(key, offset, size, FileSegment::State::EMPTY, settings, cache_lock);
-    }
-    else
-    {
-        fillHolesWithEmptyFileSegments(file_segments, key, range, /* fill_with_detached */false, settings, cache_lock);
-    }
-    assert(!file_segments.empty());
-    return FileSegmentsHolder(std::move(file_segments));
-}
-
-FileSegmentsHolder FileCache::set(const Key & key, size_t offset, size_t size, const CreateFileSegmentSettings & settings)
-{
-    std::lock_guard cache_lock(mutex);
-
-    auto it = files.find(key);
-    if (it != files.end())
-        throw Exception(ErrorCodes::LOGICAL_ERROR, "File {} already exists", key.toString());
-
-    if (settings.unbounded)
-    {
-        /// If the file is unbounded, we can create a single cell for it.
-        FileSegments file_segments;
-        if (auto * cell = addCell(key, offset, size, FileSegment::State::EMPTY, settings, cache_lock))
-            file_segments.push_back(cell->file_segment);
-        else
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot add cell for file {}", key.toString());
-        return FileSegmentsHolder(std::move(file_segments));
-    }
-    return FileSegmentsHolder(splitRangeIntoCells(key, offset, size, FileSegment::State::EMPTY, settings, cache_lock));
-}
-
-FileSegmentsHolder FileCache::get(const Key & key, size_t offset, size_t size)
-{
-    std::lock_guard cache_lock(mutex);
-
-    assertInitialized(cache_lock);
-
-#ifndef NDEBUG
-    assertCacheCorrectness(key, cache_lock);
-#endif
-
-    FileSegment::Range range(offset, offset + size - 1);
-
-    /// Get all segments which intersect with the given range.
-    auto file_segments = getImpl(key, range, cache_lock);
-
-    if (file_segments.empty())
-    {
-        auto file_segment = std::make_shared<FileSegment>(
-            offset, size, key, this, FileSegment::State::EMPTY, CreateFileSegmentSettings{});
-        {
-            std::unique_lock segment_lock(file_segment->mutex);
-            file_segment->detachAssumeStateFinalized(segment_lock);
-        }
-        file_segments = { file_segment };
-    }
-    else
-    {
-        fillHolesWithEmptyFileSegments(file_segments, key, range, /* fill_with_detached */true, {}, cache_lock);
-    }
-
-    return FileSegmentsHolder(std::move(file_segments));
-}
-
-FileCache::FileSegmentCell * FileCache::addCell(
-    const Key & key, size_t offset, size_t size,
-    FileSegment::State state, const CreateFileSegmentSettings & settings,
-    std::lock_guard<std::mutex> & cache_lock)
-{
-    /// Create a file segment cell and put it in `files` map by [key][offset].
-
-    if (!size)
-        return nullptr; /// Empty files are not cached.
-
-    if (files[key].contains(offset))
-        throw Exception(
-            ErrorCodes::LOGICAL_ERROR,
-            "Cache cell already exists for key: `{}`, offset: {}, size: {}.\nCurrent cache structure: {}",
-            key.toString(), offset, size, dumpStructureUnlocked(key, cache_lock));
-
-    auto skip_or_download = [&]() -> FileSegmentPtr
-    {
-        FileSegment::State result_state = state;
-        if (state == FileSegment::State::EMPTY && enable_cache_hits_threshold)
-        {
-            auto record = stash_records.find({key, offset});
-
-            if (record == stash_records.end())
-            {
-                auto priority_iter = stash_priority->add(key, offset, 0, cache_lock);
-                stash_records.insert({{key, offset}, priority_iter});
-
-                if (stash_priority->getElementsNum(cache_lock) > max_stash_element_size)
-                {
-                    auto remove_priority_iter = stash_priority->getLowestPriorityWriteIterator(cache_lock);
-                    stash_records.erase({remove_priority_iter->key(), remove_priority_iter->offset()});
-                    remove_priority_iter->removeAndGetNext(cache_lock);
-                }
-
-                /// For segments that do not reach the download threshold,
-                /// we do not download them, but directly read them
-                result_state = FileSegment::State::SKIP_CACHE;
-            }
-            else
-            {
-                auto priority_iter = record->second;
-                priority_iter->use(cache_lock);
-
-                result_state = priority_iter->hits() >= enable_cache_hits_threshold
-                    ? FileSegment::State::EMPTY
-                    : FileSegment::State::SKIP_CACHE;
-            }
-        }
-
-        return std::make_shared<FileSegment>(offset, size, key, this, result_state, settings);
-    };
-
-    FileSegmentCell cell(skip_or_download(), this, cache_lock);
-    auto & offsets = files[key];
-
-    if (offsets.empty())
-    {
-        auto key_path = getPathInLocalCache(key);
-
-        if (!fs::exists(key_path))
-            fs::create_directories(key_path);
-    }
-
-    auto [it, inserted] = offsets.insert({offset, std::move(cell)});
-    if (!inserted)
-        throw Exception(
-            ErrorCodes::LOGICAL_ERROR,
-            "Failed to insert into cache key: `{}`, offset: {}, size: {}",
-            key.toString(), offset, size);
-
-    return &(it->second);
-}
-
-FileSegmentPtr FileCache::createFileSegmentForDownload(
+FileSegmentsHolderPtr FileCache::set(
     const Key & key,
     size_t offset,
     size_t size,
-    const CreateFileSegmentSettings & settings,
-    std::lock_guard<std::mutex> & cache_lock)
+    const CreateFileSegmentSettings & settings)
 {
-#ifndef NDEBUG
-    assertCacheCorrectness(key, cache_lock);
-#endif
+    assertInitialized();
 
-    if (!settings.unbounded && size > max_file_segment_size)
-        throw Exception(ErrorCodes::LOGICAL_ERROR, "Requested size exceeds max file segment size");
+    auto locked_key = metadata.lockKeyMetadata(key, CacheMetadata::KeyNotFoundPolicy::CREATE_EMPTY);
+    FileSegment::Range range(offset, offset + size - 1);
 
-    auto * cell = getCell(key, offset, cache_lock);
-    if (cell)
-        throw Exception(
-            ErrorCodes::LOGICAL_ERROR,
-            "Cache cell already exists for key `{}` and offset {}",
-            key.toString(), offset);
+    auto file_segments = getImpl(*locked_key, range);
+    if (!file_segments.empty())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Having intersection with already existing cache");
 
-    cell = addCell(key, offset, size, FileSegment::State::EMPTY, settings, cache_lock);
-
-    if (!cell)
-        throw Exception(ErrorCodes::LOGICAL_ERROR, "Failed to add a new cell for download");
-
-    return cell->file_segment;
-}
-
-bool FileCache::tryReserve(const Key & key, size_t offset, size_t size, std::lock_guard<std::mutex> & cache_lock)
-{
-    auto query_context = enable_filesystem_query_cache_limit ? getCurrentQueryContext(cache_lock) : nullptr;
-    if (!query_context)
+    if (settings.unbounded)
     {
-        return tryReserveForMainList(key, offset, size, nullptr, cache_lock);
+        /// If the file is unbounded, we can create a single file_segment_metadata for it.
+        auto file_segment_metadata_it = addFileSegment(
+            *locked_key, offset, size, FileSegment::State::EMPTY, settings, nullptr);
+        file_segments = {file_segment_metadata_it->second->file_segment};
     }
-    /// The maximum cache capacity of the request is not reached, thus the
-    //// cache block is evicted from the main LRU queue by tryReserveForMainList().
-    else if (query_context->getCacheSize() + size <= query_context->getMaxCacheSize())
-    {
-        return tryReserveForMainList(key, offset, size, query_context, cache_lock);
-    }
-    /// When skip_download_if_exceeds_query_cache is true, there is no need
-    /// to evict old data, skip the cache and read directly from remote fs.
-    else if (query_context->isSkipDownloadIfExceed())
-    {
-        return false;
-    }
-    /// The maximum cache size of the query is reached, the cache will be
-    /// evicted from the history cache accessed by the current query.
     else
     {
-        size_t removed_size = 0;
-        size_t queue_size = main_priority->getElementsNum(cache_lock);
+        file_segments = splitRangeIntoFileSegments(
+            *locked_key, offset, size, FileSegment::State::EMPTY, settings);
+    }
 
-        auto * cell_for_reserve = getCell(key, offset, cache_lock);
+    return std::make_unique<FileSegmentsHolder>(std::move(file_segments));
+}
 
-        struct Segment
+FileSegmentsHolderPtr FileCache::getOrSet(
+    const Key & key,
+    size_t offset,
+    size_t size,
+    const CreateFileSegmentSettings & settings)
+{
+    assertInitialized();
+
+    FileSegment::Range range(offset, offset + size - 1);
+
+    auto locked_key = metadata.lockKeyMetadata(key, CacheMetadata::KeyNotFoundPolicy::CREATE_EMPTY);
+
+    /// Get all segments which intersect with the given range.
+    auto file_segments = getImpl(*locked_key, range);
+    if (file_segments.empty())
+    {
+        file_segments = splitRangeIntoFileSegments(
+            *locked_key, offset, size, FileSegment::State::EMPTY, settings);
+    }
+    else
+    {
+        fillHolesWithEmptyFileSegments(
+            *locked_key, file_segments, range, /* fill_with_detached */false, settings);
+    }
+
+    chassert(!file_segments.empty());
+    return std::make_unique<FileSegmentsHolder>(std::move(file_segments));
+}
+
+FileSegmentsHolderPtr FileCache::get(const Key & key, size_t offset, size_t size)
+{
+    assertInitialized();
+
+    auto locked_key = metadata.lockKeyMetadata(key, CacheMetadata::KeyNotFoundPolicy::RETURN_NULL);
+    if (locked_key)
+    {
+        FileSegment::Range range(offset, offset + size - 1);
+
+        /// Get all segments which intersect with the given range.
+        auto file_segments = getImpl(*locked_key, range);
+        if (!file_segments.empty())
         {
-            Key key;
-            size_t offset;
-            size_t size;
+            fillHolesWithEmptyFileSegments(
+                *locked_key, file_segments, range, /* fill_with_detached */true, CreateFileSegmentSettings{});
 
-            Segment(Key key_, size_t offset_, size_t size_)
-                : key(key_), offset(offset_), size(size_) {}
-        };
+            return std::make_unique<FileSegmentsHolder>(std::move(file_segments));
+        }
+    }
 
-        std::vector<Segment> ghost;
-        std::vector<FileSegmentCell *> trash;
-        std::vector<FileSegmentCell *> to_evict;
+    return std::make_unique<FileSegmentsHolder>(FileSegments{
+        std::make_shared<FileSegment>(key, offset, size, FileSegment::State::DETACHED)});
+}
 
-        auto is_overflow = [&]
+KeyMetadata::iterator FileCache::addFileSegment(
+    LockedKey & locked_key,
+    size_t offset,
+    size_t size,
+    FileSegment::State state,
+    const CreateFileSegmentSettings & settings,
+    const CacheGuard::Lock * lock)
+{
+    /// Create a file_segment_metadata and put it in `files` map by [key][offset].
+
+    chassert(size > 0); /// Empty file segments in cache are not allowed.
+
+    const auto & key = locked_key.getKey();
+    if (locked_key.tryGetByOffset(offset))
+    {
+        throw Exception(
+            ErrorCodes::LOGICAL_ERROR,
+            "Cache entry already exists for key: `{}`, offset: {}, size: {}.",
+            key, offset, size);
+    }
+
+    FileSegment::State result_state;
+
+    /// `stash` - a queue of "stashed" key-offset pairs. Implements counting of
+    /// cache entries and allows caching only if cache hit threadhold is reached.
+    if (stash && state == FileSegment::State::EMPTY)
+    {
+        if (!lock)
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Using stash requires cache_lock");
+
+        KeyAndOffset stash_key(key, offset);
+
+        auto record_it = stash->records.find(stash_key);
+        if (record_it == stash->records.end())
         {
-            return (max_size != 0 && main_priority->getCacheSize(cache_lock) + size - removed_size > max_size)
-            || (max_element_size != 0 && queue_size > max_element_size)
-            || (query_context->getCacheSize() + size - removed_size > query_context->getMaxCacheSize());
-        };
+            auto & stash_records = stash->records;
 
-        /// Select the cache from the LRU queue held by query for expulsion.
-        for (auto iter = query_context->getPriority()->getLowestPriorityWriteIterator(cache_lock); iter->valid();)
+            stash_records.emplace(
+                stash_key, stash->queue->add(locked_key.getKeyMetadata(), offset, 0, *lock));
+
+            if (stash->queue->getElementsCount(*lock) > stash->queue->getElementsLimit())
+                stash->queue->pop(*lock);
+
+            result_state = FileSegment::State::DETACHED;
+        }
+        else
         {
-            if (!is_overflow())
-                break;
+            result_state = record_it->second->use(*lock) >= stash->hits_threshold
+                ? FileSegment::State::EMPTY
+                : FileSegment::State::DETACHED;
+        }
+    }
+    else
+    {
+        result_state = state;
+    }
 
-            auto * cell = getCell(iter->key(), iter->offset(), cache_lock);
+    PriorityIterator cache_it;
+    if (state == FileSegment::State::DOWNLOADED)
+    {
+        cache_it = main_priority->add(locked_key.getKeyMetadata(), offset, size, *lock);
+    }
 
-            if (!cell)
-            {
-                /// The cache corresponding to this record may be swapped out by
-                /// other queries, so it has become invalid.
-                removed_size += iter->size();
-                ghost.push_back(Segment(iter->key(), iter->offset(), iter->size()));
-                /// next()
-                iter->removeAndGetNext(cache_lock);
-            }
-            else
-            {
-                size_t cell_size = cell->size();
-                assert(iter->size() == cell_size);
+    try
+    {
+        auto file_segment = std::make_shared<FileSegment>(
+            key, offset, size, result_state, settings, this, locked_key.getKeyMetadata(), cache_it);
+        auto file_segment_metadata = std::make_shared<FileSegmentMetadata>(std::move(file_segment));
 
-                if (cell->releasable())
-                {
-                    auto & file_segment = cell->file_segment;
+        auto [file_segment_metadata_it, inserted] = locked_key.getKeyMetadata()->emplace(offset, file_segment_metadata);
+        if (!inserted)
+        {
+            if (cache_it)
+                cache_it->remove(*lock);
 
-                    if (file_segment->isPersistent() && allow_persistent_files)
-                    {
-                        LOG_DEBUG(log, "File segment will not be removed, because it is persistent: {}", file_segment->getInfoForLog());
-                        continue;
-                    }
-
-                    std::lock_guard segment_lock(file_segment->mutex);
-
-                    switch (file_segment->download_state)
-                    {
-                        case FileSegment::State::DOWNLOADED:
-                        {
-                            to_evict.push_back(cell);
-                            break;
-                        }
-                        default:
-                        {
-                            trash.push_back(cell);
-                            break;
-                        }
-                    }
-                    removed_size += cell_size;
-                    --queue_size;
-                }
-
-                iter->next();
-            }
+            throw Exception(
+                ErrorCodes::LOGICAL_ERROR,
+                "Failed to insert {}:{}: entry already exists", key, offset);
         }
 
-        auto remove_file_segment = [&](FileSegmentPtr file_segment, size_t file_segment_size)
-        {
-            query_context->remove(file_segment->key(), file_segment->offset(), file_segment_size, cache_lock);
-            remove(file_segment, cache_lock);
-        };
-
-        assert(trash.empty());
-        for (auto & cell : trash)
-        {
-            if (auto file_segment = cell->file_segment)
-                remove_file_segment(file_segment, cell->size());
-        }
-
-        for (auto & entry : ghost)
-            query_context->remove(entry.key, entry.offset, entry.size, cache_lock);
-
-        if (is_overflow())
-            return false;
-
-        if (cell_for_reserve)
-        {
-            auto queue_iterator = cell_for_reserve->queue_iterator;
-            if (queue_iterator)
-                queue_iterator->updateSize(size, cache_lock);
-            else
-                cell_for_reserve->queue_iterator = main_priority->add(key, offset, size, cache_lock);
-        }
-
-        for (auto & cell : to_evict)
-        {
-            if (auto file_segment = cell->file_segment)
-                remove_file_segment(file_segment, cell->size());
-        }
-
-        query_context->reserve(key, offset, size, cache_lock);
-        return true;
+        return file_segment_metadata_it;
+    }
+    catch (...)
+    {
+        if (cache_it)
+            cache_it->remove(*lock);
+        throw;
     }
 }
 
-bool FileCache::tryReserveForMainList(
-    const Key & key, size_t offset, size_t size, QueryContextPtr query_context, std::lock_guard<std::mutex> & cache_lock)
+bool FileCache::tryReserve(FileSegment & file_segment, size_t size)
 {
-    auto removed_size = 0;
-    size_t queue_size = main_priority->getElementsNum(cache_lock);
-    assert(queue_size <= max_element_size);
+    assertInitialized();
+    auto cache_lock = cache_guard.lock();
 
-    /// Since space reservation is incremental, cache cell already exists if it's state is EMPTY.
-    /// And it cache cell does not exist on startup -- as we first check for space and then add a cell.
-    auto * cell_for_reserve = getCell(key, offset, cache_lock);
+    /// In case of per query cache limit (by default disabled), we add/remove entries from both
+    /// (main_priority and query_priority) priority queues, but iterate entries in order of query_priority,
+    /// while checking the limits in both.
+    Priority * query_priority = nullptr;
 
-    /// A cell acquires a LRUQueue iterator on first successful space reservation attempt.
-    /// cell_for_reserve can be nullptr here when we call tryReserve() from loadCacheInfoIntoMemory().
-    if (!cell_for_reserve || !cell_for_reserve->queue_iterator)
+    auto query_context = query_limit ? query_limit->tryGetQueryContext(cache_lock) : nullptr;
+    if (query_context)
+    {
+        query_priority = &query_context->getPriority();
+
+        const bool query_limit_exceeded = query_priority->getSize(cache_lock) + size > query_priority->getSizeLimit();
+        if (query_limit_exceeded && !query_context->recacheOnFileCacheQueryLimitExceeded())
+            return false;
+    }
+
+    size_t queue_size = main_priority->getElementsCount(cache_lock);
+    chassert(queue_size <= main_priority->getElementsLimit());
+
+    /// A file_segment_metadata acquires a LRUQueue iterator on first successful space reservation attempt.
+    auto queue_iterator = file_segment.getQueueIterator();
+    if (queue_iterator)
+        chassert(file_segment.getReservedSize() > 0);
+    else
         queue_size += 1;
 
-    auto is_overflow = [&]
+    size_t removed_size = 0;
+
+    class EvictionCandidates final : public std::vector<FileSegmentMetadataPtr>
     {
-        /// max_size == 0 means unlimited cache size, max_element_size means unlimited number of cache elements.
-        return (max_size != 0 && main_priority->getCacheSize(cache_lock) + size - removed_size > max_size)
-            || (max_element_size != 0 && queue_size > max_element_size);
+    public:
+        explicit EvictionCandidates(KeyMetadataPtr key_metadata_) : key_metadata(key_metadata_) {}
+
+        KeyMetadata & getMetadata() { return *key_metadata; }
+
+        void add(FileSegmentMetadataPtr candidate)
+        {
+            candidate->removal_candidate = true;
+            push_back(candidate);
+        }
+
+        ~EvictionCandidates()
+        {
+            for (const auto & candidate : *this)
+                candidate->removal_candidate = false;
+        }
+
+    private:
+        KeyMetadataPtr key_metadata;
     };
 
-    std::vector<FileSegmentCell *> to_evict;
-    std::vector<FileSegmentCell *> trash;
+    std::unordered_map<Key, EvictionCandidates> to_delete;
 
-    for (auto it = main_priority->getLowestPriorityReadIterator(cache_lock); it->valid(); it->next())
+    auto iterate_func = [&](LockedKey & locked_key, FileSegmentMetadataPtr segment_metadata)
     {
-        const auto & entry_key = it->key();
-        auto entry_offset = it->offset();
+        chassert(segment_metadata->file_segment->assertCorrectness());
 
-        if (!is_overflow())
-            break;
+        const bool is_persistent = allow_persistent_files && segment_metadata->file_segment->isPersistent();
+        const bool releasable = segment_metadata->releasable() && !is_persistent;
 
-        auto * cell = getCell(entry_key, entry_offset, cache_lock);
-        if (!cell)
-            throw Exception(
-                ErrorCodes::LOGICAL_ERROR,
-                "Cache became inconsistent. Key: {}, offset: {}",
-                key.toString(), offset);
-
-        size_t cell_size = cell->size();
-        assert(it->size() == cell_size);
-
-        /// It is guaranteed that cell is not removed from cache as long as
-        /// pointer to corresponding file segment is hold by any other thread.
-
-        if (cell->releasable())
+        if (releasable)
         {
-            auto & file_segment = cell->file_segment;
-
-            if (file_segment->isPersistent() && allow_persistent_files)
-            {
-                LOG_DEBUG(log, "File segment will not be removed, because it is persistent: {}", file_segment->getInfoForLog());
-                continue;
-            }
-
-            std::lock_guard segment_lock(file_segment->mutex);
-
-            switch (file_segment->download_state)
-            {
-                case FileSegment::State::DOWNLOADED:
-                {
-                    /// Cell will actually be removed only if
-                    /// we managed to reserve enough space.
-
-                    to_evict.push_back(cell);
-                    break;
-                }
-                default:
-                {
-                    trash.push_back(cell);
-                    break;
-                }
-            }
-
-            removed_size += cell_size;
+            removed_size += segment_metadata->size();
             --queue_size;
+
+            auto segment = segment_metadata->file_segment;
+            if (segment->state() == FileSegment::State::DOWNLOADED)
+            {
+                const auto & key = segment->key();
+                auto it = to_delete.find(key);
+                if (it == to_delete.end())
+                    it = to_delete.emplace(key, locked_key.getKeyMetadata()).first;
+                it->second.add(segment_metadata);
+                return PriorityIterationResult::CONTINUE;
+            }
+
+            /// TODO: we can resize if partially downloaded instead.
+            locked_key.removeFileSegment(segment->offset(), segment->lock());
+            return PriorityIterationResult::REMOVE_AND_CONTINUE;
+        }
+        return PriorityIterationResult::CONTINUE;
+    };
+
+    if (query_priority)
+    {
+        auto is_query_priority_overflow = [&]
+        {
+            const size_t new_size = query_priority->getSize(cache_lock) + size - removed_size;
+            return new_size > query_priority->getSizeLimit();
+        };
+
+        query_priority->iterate(
+            [&](LockedKey & locked_key, FileSegmentMetadataPtr segment_metadata)
+            { return is_query_priority_overflow() ? iterate_func(locked_key, segment_metadata) : PriorityIterationResult::BREAK; },
+            cache_lock);
+
+        if (is_query_priority_overflow())
+            return false;
+    }
+
+    auto is_main_priority_overflow = [&]
+    {
+        /// max_size == 0 means unlimited cache size,
+        /// max_element_size means unlimited number of cache elements.
+        return (main_priority->getSizeLimit() != 0 && main_priority->getSize(cache_lock) + size - removed_size > main_priority->getSizeLimit())
+            || (main_priority->getElementsLimit() != 0 && queue_size > main_priority->getElementsLimit());
+    };
+
+    main_priority->iterate(
+        [&](LockedKey & locked_key, FileSegmentMetadataPtr segment_metadata)
+        { return is_main_priority_overflow() ? iterate_func(locked_key, segment_metadata) : PriorityIterationResult::BREAK; },
+        cache_lock);
+
+    if (is_main_priority_overflow())
+        return false;
+
+    if (!file_segment.getKeyMetadata()->createBaseDirectory())
+        return false;
+
+    for (auto & [current_key, deletion_info] : to_delete)
+    {
+        auto locked_key = deletion_info.getMetadata().tryLock();
+        if (!locked_key)
+            continue; /// key could become invalid after we released the key lock above, just skip it.
+
+        for (auto it = deletion_info.begin(); it != deletion_info.end();)
+        {
+            chassert((*it)->releasable());
+
+            auto segment = (*it)->file_segment;
+            locked_key->removeFileSegment(segment->offset(), segment->lock());
+            segment->getQueueIterator()->remove(cache_lock);
+
+            if (query_context)
+                query_context->remove(current_key, segment->offset(), cache_lock);
+
+            it = deletion_info.erase(it);
         }
     }
 
-    /// This case is very unlikely, can happen in case of exception from
-    /// file_segment->complete(), which would be a logical error.
-    assert(trash.empty());
-    for (auto & cell : trash)
+    /// queue_iteratir is std::nullopt here if no space has been reserved yet, a file_segment_metadata
+    /// acquires queue iterator on first successful space reservation attempt.
+    /// If queue iterator already exists, we need to update the size after each space reservation.
+    if (queue_iterator)
     {
-        if (auto file_segment = cell->file_segment)
-            remove(file_segment, cache_lock);
+        queue_iterator->updateSize(size);
     }
-
-    if (is_overflow())
-        return false;
-
-    /// cache cell is nullptr on server startup because we first check for space and then add a cell.
-    if (cell_for_reserve)
+    else
     {
-        /// queue_iteratir is std::nullopt here if no space has been reserved yet, a cache cell
-        /// acquires queue iterator on first successful space reservation attempt.
-        /// If queue iterator already exists, we need to update the size after each space reservation.
-        auto queue_iterator = cell_for_reserve->queue_iterator;
-        if (queue_iterator)
-            queue_iterator->updateSize(size, cache_lock);
-        else
-            cell_for_reserve->queue_iterator = main_priority->add(key, offset, size, cache_lock);
+        /// Space reservation is incremental, so file_segment_metadata is created first (with state empty),
+        /// and getQueueIterator() is assigned on first space reservation attempt.
+        file_segment.setQueueIterator(main_priority->add(
+            file_segment.getKeyMetadata(), file_segment.offset(), size, cache_lock));
     }
 
-    for (auto & cell : to_evict)
-    {
-        if (auto file_segment = cell->file_segment)
-            remove(file_segment, cache_lock);
-    }
-
-    if (main_priority->getCacheSize(cache_lock) > (1ull << 63))
-        throw Exception(ErrorCodes::LOGICAL_ERROR, "Cache became inconsistent. There must be a bug");
-
     if (query_context)
-        query_context->reserve(key, offset, size, cache_lock);
+    {
+        auto query_queue_it = query_context->tryGet(file_segment.key(), file_segment.offset(), cache_lock);
+        if (query_queue_it)
+            query_queue_it->updateSize(size);
+        else
+            query_context->add(file_segment, cache_lock);
+    }
 
+    if (main_priority->getSize(cache_lock) > (1ull << 63))
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Cache became inconsistent. There must be a bug");
+
+    file_segment.reserved_size += size;
     return true;
 }
 
-void FileCache::removeIfExists(const Key & key)
+void FileCache::removeKeyIfExists(const Key & key)
 {
-    std::lock_guard cache_lock(mutex);
+    assertInitialized();
 
-    assertInitialized(cache_lock);
-
-    auto it = files.find(key);
-    if (it == files.end())
+    auto locked_key = metadata.lockKeyMetadata(key, CacheMetadata::KeyNotFoundPolicy::RETURN_NULL);
+    if (!locked_key)
         return;
 
-    auto & offsets = it->second;
-
-    std::vector<FileSegmentCell *> to_remove;
-    to_remove.reserve(offsets.size());
-
-    for (auto & [offset, cell] : offsets)
-        to_remove.push_back(&cell);
-
-    bool some_cells_were_skipped = false;
-    for (auto & cell : to_remove)
-    {
-        /// In ordinary case we remove data from cache when it's not used by anyone.
-        /// But if we have multiple replicated zero-copy tables on the same server
-        /// it became possible to start removing something from cache when it is used
-        /// by other "zero-copy" tables. That is why it's not an error.
-        if (!cell->releasable())
-        {
-            some_cells_were_skipped = true;
-            continue;
-        }
-
-        auto file_segment = cell->file_segment;
-        if (file_segment)
-        {
-            std::unique_lock<std::mutex> segment_lock(file_segment->mutex);
-            file_segment->detach(cache_lock, segment_lock);
-            remove(file_segment->key(), file_segment->offset(), cache_lock, segment_lock);
-        }
-    }
-
-    if (!some_cells_were_skipped)
-    {
-        files.erase(key);
-        removeKeyDirectoryIfExists(key, cache_lock);
-    }
+    /// In ordinary case we remove data from cache when it's not used by anyone.
+    /// But if we have multiple replicated zero-copy tables on the same server
+    /// it became possible to start removing something from cache when it is used
+    /// by other "zero-copy" tables. That is why it's not an error.
+    locked_key->removeAllReleasable();
 }
 
-void FileCache::removeIfReleasable()
+void FileCache::removeAllReleasable()
 {
-    /// Try remove all cached files by cache_base_path.
+    assertInitialized();
+
     /// Only releasable file segments are evicted.
     /// `remove_persistent_files` defines whether non-evictable by some criteria files
     /// (they do not comply with the cache eviction policy) should also be removed.
 
-    std::lock_guard cache_lock(mutex);
+    auto lock = cache_guard.lock();
 
-    std::vector<FileSegmentPtr> to_remove;
-    for (auto it = main_priority->getLowestPriorityReadIterator(cache_lock); it->valid(); it->next())
+    main_priority->iterate([&](LockedKey & locked_key, FileSegmentMetadataPtr segment_metadata)
     {
-        const auto & key = it->key();
-        auto offset = it->offset();
-
-        auto * cell = getCell(key, offset, cache_lock);
-        if (!cell)
+        if (segment_metadata->releasable())
         {
-            throw Exception(
-                ErrorCodes::LOGICAL_ERROR,
-                "Cache is in inconsistent state: LRU queue contains entries with no cache cell");
+            auto file_segment = segment_metadata->file_segment;
+            locked_key.removeFileSegment(file_segment->offset(), file_segment->lock());
+            return PriorityIterationResult::REMOVE_AND_CONTINUE;
         }
+        return PriorityIterationResult::CONTINUE;
+    }, lock);
 
-        if (cell->releasable())
-        {
-            auto file_segment = cell->file_segment;
-
-            if (file_segment)
-            {
-                to_remove.emplace_back(file_segment);
-            }
-        }
-    }
-
-    for (auto & file_segment : to_remove)
+    if (stash)
     {
-        std::unique_lock segment_lock(file_segment->mutex);
-        file_segment->detach(cache_lock, segment_lock);
-        remove(file_segment->key(), file_segment->offset(), cache_lock, segment_lock);
-    }
-
-    /// Remove all access information.
-    stash_records.clear();
-    stash_priority->removeAll(cache_lock);
-
-#ifndef NDEBUG
-    assertCacheCorrectness(cache_lock);
-#endif
-}
-
-void FileCache::remove(FileSegmentPtr file_segment, std::lock_guard<std::mutex> & cache_lock)
-{
-    std::unique_lock segment_lock(file_segment->mutex);
-    remove(file_segment->key(), file_segment->offset(), cache_lock, segment_lock);
-}
-
-void FileCache::remove(
-    Key key, size_t offset,
-    std::lock_guard<std::mutex> & cache_lock, std::unique_lock<std::mutex> & /* segment_lock */)
-{
-    LOG_DEBUG(log, "Remove from cache. Key: {}, offset: {}", key.toString(), offset);
-
-    String cache_file_path;
-
-    {
-        auto * cell = getCell(key, offset, cache_lock);
-        if (!cell)
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "No cache cell for key: {}, offset: {}", key.toString(), offset);
-
-        if (cell->queue_iterator)
-        {
-            cell->queue_iterator->removeAndGetNext(cache_lock);
-        }
-
-        cache_file_path = cell->file_segment->getPathInLocalCache();
-    }
-
-    auto & offsets = files[key];
-    offsets.erase(offset);
-
-    if (fs::exists(cache_file_path))
-    {
-        try
-        {
-            fs::remove(cache_file_path);
-
-            if (is_initialized && offsets.empty())
-            {
-                files.erase(key);
-                removeKeyDirectoryIfExists(key, cache_lock);
-            }
-        }
-        catch (...)
-        {
-            throw Exception(
-                ErrorCodes::LOGICAL_ERROR,
-                "Removal of cached file failed. Key: {}, offset: {}, path: {}, error: {}",
-                key.toString(), offset, cache_file_path, getCurrentExceptionMessage(false));
-        }
+        /// Remove all access information.
+        stash->records.clear();
+        stash->queue->removeAll(lock);
     }
 }
 
-void FileCache::loadCacheInfoIntoMemory(std::lock_guard<std::mutex> & cache_lock)
+void FileCache::loadMetadata()
 {
-    Key key;
+    auto lock = cache_guard.lock();
+
     UInt64 offset = 0;
     size_t size = 0;
-    std::vector<std::pair<IFileCachePriority::WriteIterator, std::weak_ptr<FileSegment>>> queue_entries;
+    std::vector<std::pair<PriorityIterator, std::weak_ptr<FileSegment>>> queue_entries;
 
     /// cache_base_path / key_prefix / key / offset
-    if (!files.empty())
+    if (!metadata.empty())
+    {
         throw Exception(
             ErrorCodes::LOGICAL_ERROR,
             "Cache initialization is partially made. "
             "This can be a result of a failed first attempt to initialize cache. "
             "Please, check log for error messages");
+    }
 
-    fs::directory_iterator key_prefix_it{cache_base_path};
-    for (; key_prefix_it != fs::directory_iterator(); ++key_prefix_it)
+    size_t total_size = 0;
+    for (auto key_prefix_it = fs::directory_iterator{metadata.getBaseDirectory()};
+         key_prefix_it != fs::directory_iterator();)
     {
-        if (!key_prefix_it->is_directory())
+        const fs::path key_prefix_directory = key_prefix_it->path();
+        key_prefix_it++;
+
+        if (!fs::is_directory(key_prefix_directory))
         {
-            if (key_prefix_it->path().filename() != "status")
-                LOG_DEBUG(log, "Unexpected file {} (not a directory), will skip it", key_prefix_it->path().string());
+            if (key_prefix_directory.filename() != "status")
+            {
+                LOG_WARNING(
+                    log, "Unexpected file {} (not a directory), will skip it",
+                    key_prefix_directory.string());
+            }
             continue;
         }
 
-        fs::directory_iterator key_it{key_prefix_it->path()};
-        for (; key_it != fs::directory_iterator(); ++key_it)
+        if (fs::is_empty(key_prefix_directory))
         {
-            if (!key_it->is_directory())
+            LOG_DEBUG(log, "Removing empty key prefix directory: {}", key_prefix_directory.string());
+            fs::remove(key_prefix_directory);
+            continue;
+        }
+
+        for (fs::directory_iterator key_it{key_prefix_directory}; key_it != fs::directory_iterator();)
+        {
+            const fs::path key_directory = key_it->path();
+            ++key_it;
+
+            if (!fs::is_directory(key_directory))
             {
-                LOG_DEBUG(log, "Unexpected file: {}. Expected a directory", key_it->path().string());
+                LOG_DEBUG(
+                    log,
+                    "Unexpected file: {} (not a directory). Expected a directory",
+                    key_directory.string());
                 continue;
             }
 
-            key = Key(unhexUInt<UInt128>(key_it->path().filename().string().data()));
-            fs::directory_iterator offset_it{key_it->path()};
-            for (; offset_it != fs::directory_iterator(); ++offset_it)
+            if (fs::is_empty(key_directory))
+            {
+                LOG_DEBUG(log, "Removing empty key directory: {}", key_directory.string());
+                fs::remove(key_directory);
+                continue;
+            }
+
+            const auto key = Key(unhexUInt<UInt128>(key_directory.filename().string().data()));
+            auto locked_key = metadata.lockKeyMetadata(key, CacheMetadata::KeyNotFoundPolicy::CREATE_EMPTY, /* is_initial_load */true);
+
+            for (fs::directory_iterator offset_it{key_directory}; offset_it != fs::directory_iterator(); ++offset_it)
             {
                 auto offset_with_suffix = offset_it->path().filename().string();
                 auto delim_pos = offset_with_suffix.find('_');
@@ -1054,7 +827,9 @@ void FileCache::loadCacheInfoIntoMemory(std::lock_guard<std::mutex> & cache_lock
                 {
                     parsed = tryParse<UInt64>(offset, offset_with_suffix.substr(0, delim_pos));
                     if (offset_with_suffix.substr(delim_pos+1) == "persistent")
+                    {
                         segment_kind = FileSegmentKind::Persistent;
+                    }
                     if (offset_with_suffix.substr(delim_pos+1) == "temporary")
                     {
                         fs::remove(offset_it->path());
@@ -1075,21 +850,27 @@ void FileCache::loadCacheInfoIntoMemory(std::lock_guard<std::mutex> & cache_lock
                     continue;
                 }
 
-                if (tryReserve(key, offset, size, cache_lock))
+                if ((main_priority->getSizeLimit() == 0 || main_priority->getSize(lock) + size <= main_priority->getSizeLimit())
+                    && (main_priority->getElementsLimit() == 0 || main_priority->getElementsCount(lock) + 1 <= main_priority->getElementsLimit()))
                 {
-                    auto * cell = addCell(
-                        key, offset, size, FileSegment::State::DOWNLOADED,
-                        CreateFileSegmentSettings(segment_kind), cache_lock);
+                    auto file_segment_metadata_it = addFileSegment(
+                        *locked_key, offset, size, FileSegment::State::DOWNLOADED, CreateFileSegmentSettings(segment_kind), &lock);
 
-                    if (cell)
-                        queue_entries.emplace_back(cell->queue_iterator, cell->file_segment);
+                    const auto & file_segment_metadata = file_segment_metadata_it->second;
+                    chassert(file_segment_metadata->file_segment->assertCorrectness());
+                    total_size += size;
+
+                    queue_entries.emplace_back(
+                        file_segment_metadata->getQueueIterator(),
+                        file_segment_metadata->file_segment);
                 }
                 else
                 {
                     LOG_WARNING(
                         log,
-                        "Cache capacity changed (max size: {}, available: {}), cached file `{}` does not fit in cache anymore (size: {})",
-                        max_size, getAvailableCacheSizeUnlocked(cache_lock), key_it->path().string(), size);
+                        "Cache capacity changed (max size: {}, used: {}), "
+                        "cached file `{}` does not fit in cache anymore (size: {})",
+                        main_priority->getSizeLimit(), main_priority->getSize(lock), key_directory.string(), size);
 
                     fs::remove(offset_it->path());
                 }
@@ -1097,259 +878,142 @@ void FileCache::loadCacheInfoIntoMemory(std::lock_guard<std::mutex> & cache_lock
         }
     }
 
-    /// Shuffle cells to have random order in LRUQueue as at startup all cells have the same priority.
+    chassert(total_size == main_priority->getSize(lock));
+    chassert(total_size <= main_priority->getSizeLimit());
+
+    /// Shuffle file_segment_metadatas to have random order in LRUQueue
+    /// as at startup all file_segment_metadatas have the same priority.
     pcg64 generator(randomSeed());
     std::shuffle(queue_entries.begin(), queue_entries.end(), generator);
-    for (const auto & [it, file_segment] : queue_entries)
+    for (auto & [it, file_segment] : queue_entries)
     {
-        /// Cell cache size changed and, for example, 1st file segment fits into cache
+        /// Cache size changed and, for example, 1st file segment fits into cache
         /// and 2nd file segment will fit only if first was evicted, then first will be removed and
-        /// cell is nullptr here.
+        /// file_segment_metadata is nullptr here.
         if (file_segment.expired())
             continue;
 
-        it->use(cache_lock);
+        it->use(lock);
     }
+}
+
+FileCache::~FileCache()
+{
+    deactivateBackgroundOperations();
+}
+
+void FileCache::deactivateBackgroundOperations()
+{
+    if (cleanup_task)
+        cleanup_task->deactivate();
+}
+
+void FileCache::cleanup()
+{
+    metadata.doCleanup();
+}
+
+void FileCache::cleanupThreadFunc()
+{
 #ifndef NDEBUG
-    assertCacheCorrectness(cache_lock);
+    assertCacheCorrectness();
 #endif
-}
 
-void FileCache::reduceSizeToDownloaded(
-    const Key & key, size_t offset,
-    std::lock_guard<std::mutex> & cache_lock, std::unique_lock<std::mutex> & segment_lock)
-{
-    /**
-     * In case file was partially downloaded and it's download cannot be continued
-     * because of no space left in cache, we need to be able to cut cell's size to downloaded_size.
-     */
-
-    auto * cell = getCell(key, offset, cache_lock);
-
-    if (!cell)
+    try
     {
-        throw Exception(
-            ErrorCodes::LOGICAL_ERROR,
-            "No cell found for key: {}, offset: {}",
-            key.toString(), offset);
+        cleanup();
+    }
+    catch (...)
+    {
+        tryLogCurrentException(__PRETTY_FUNCTION__);
     }
 
-    const auto & file_segment = cell->file_segment;
-
-    size_t downloaded_size = file_segment->downloaded_size;
-    size_t full_size = file_segment->range().size();
-
-    if (downloaded_size == full_size)
-    {
-        throw Exception(
-            ErrorCodes::LOGICAL_ERROR,
-            "Nothing to reduce, file segment fully downloaded: {}",
-            file_segment->getInfoForLogUnlocked(segment_lock));
-    }
-
-    CreateFileSegmentSettings create_settings(file_segment->getKind());
-
-    cell->file_segment = std::make_shared<FileSegment>(
-        offset, downloaded_size, key, this, FileSegment::State::DOWNLOADED, create_settings);
-
-    chassert(cell->queue_iterator);
-    chassert(cell->queue_iterator->size() >= downloaded_size);
-    const ssize_t diff = cell->queue_iterator->size() - downloaded_size;
-    if (diff > 0)
-        cell->queue_iterator->updateSize(-diff, cache_lock);
-
-    chassert(file_segment->reserved_size == downloaded_size);
-    chassert(file_segment->reserved_size == cell->queue_iterator->size());
+    cleanup_task->scheduleAfter(delayed_cleanup_interval_ms);
 }
 
-bool FileCache::isLastFileSegmentHolder(
-    const Key & key, size_t offset,
-    std::lock_guard<std::mutex> & cache_lock, std::unique_lock<std::mutex> & /* segment_lock */)
+FileSegmentsHolderPtr FileCache::getSnapshot()
 {
-    auto * cell = getCell(key, offset, cache_lock);
-
-    if (!cell)
-        throw Exception(ErrorCodes::LOGICAL_ERROR, "No cell found for key: {}, offset: {}", key.toString(), offset);
-
-    /// The caller of this method is last file segment holder if use count is 2 (the second pointer is cache itself)
-    return cell->file_segment.use_count() == 2;
-}
-
-FileSegments FileCache::getSnapshot() const
-{
-    std::lock_guard cache_lock(mutex);
+    assertInitialized();
+#ifndef NDEBUG
+    assertCacheCorrectness();
+#endif
 
     FileSegments file_segments;
-
-    for (const auto & [key, cells_by_offset] : files)
+    metadata.iterate([&](const LockedKey & locked_key)
     {
-        for (const auto & [offset, cell] : cells_by_offset)
-            file_segments.push_back(FileSegment::getSnapshot(cell.file_segment, cache_lock));
-    }
-    return file_segments;
+        for (const auto & [_, file_segment_metadata] : locked_key)
+            file_segments.push_back(FileSegment::getSnapshot(file_segment_metadata->file_segment));
+    });
+    return std::make_unique<FileSegmentsHolder>(std::move(file_segments), /* complete_on_dtor */false);
+}
+
+FileSegmentsHolderPtr FileCache::getSnapshot(const Key & key)
+{
+    FileSegments file_segments;
+    auto locked_key = metadata.lockKeyMetadata(key, CacheMetadata::KeyNotFoundPolicy::THROW);
+    for (const auto & [_, file_segment_metadata] : *locked_key->getKeyMetadata())
+        file_segments.push_back(FileSegment::getSnapshot(file_segment_metadata->file_segment));
+    return std::make_unique<FileSegmentsHolder>(std::move(file_segments));
+}
+
+FileSegmentsHolderPtr FileCache::dumpQueue()
+{
+    assertInitialized();
+
+    FileSegments file_segments;
+    main_priority->iterate([&](LockedKey &, FileSegmentMetadataPtr segment_metadata)
+    {
+        file_segments.push_back(FileSegment::getSnapshot(segment_metadata->file_segment));
+        return PriorityIterationResult::CONTINUE;
+    }, cache_guard.lock());
+
+    return std::make_unique<FileSegmentsHolder>(std::move(file_segments));
 }
 
 std::vector<String> FileCache::tryGetCachePaths(const Key & key)
 {
-    std::lock_guard cache_lock(mutex);
+    assertInitialized();
+
+    auto locked_key = metadata.lockKeyMetadata(key, CacheMetadata::KeyNotFoundPolicy::RETURN_NULL);
+    if (!locked_key)
+        return {};
 
     std::vector<String> cache_paths;
 
-    const auto & cells_by_offset = files[key];
-
-    for (const auto & [offset, cell] : cells_by_offset)
+    for (const auto & [offset, file_segment_metadata] : *locked_key->getKeyMetadata())
     {
-        if (cell.file_segment->state() == FileSegment::State::DOWNLOADED)
-            cache_paths.push_back(getPathInLocalCache(key, offset, cell.file_segment->getKind()));
+        if (file_segment_metadata->file_segment->state() == FileSegment::State::DOWNLOADED)
+            cache_paths.push_back(metadata.getPathInLocalCache(key, offset, file_segment_metadata->file_segment->getKind()));
     }
-
     return cache_paths;
 }
 
 size_t FileCache::getUsedCacheSize() const
 {
-    std::lock_guard cache_lock(mutex);
-    return getUsedCacheSizeUnlocked(cache_lock);
-}
-
-size_t FileCache::getUsedCacheSizeUnlocked(std::lock_guard<std::mutex> & cache_lock) const
-{
-    return main_priority->getCacheSize(cache_lock);
-}
-
-size_t FileCache::getAvailableCacheSizeUnlocked(std::lock_guard<std::mutex> & cache_lock) const
-{
-    return max_size - getUsedCacheSizeUnlocked(cache_lock);
+    return main_priority->getSize(cache_guard.lock());
 }
 
 size_t FileCache::getFileSegmentsNum() const
 {
-    std::lock_guard cache_lock(mutex);
-    return getFileSegmentsNumUnlocked(cache_lock);
+    return main_priority->getElementsCount(cache_guard.lock());
 }
 
-size_t FileCache::getFileSegmentsNumUnlocked(std::lock_guard<std::mutex> & cache_lock) const
+void FileCache::assertCacheCorrectness()
 {
-    return main_priority->getElementsNum(cache_lock);
-}
-
-FileCache::FileSegmentCell::FileSegmentCell(
-    FileSegmentPtr file_segment_,
-    FileCache * cache,
-    std::lock_guard<std::mutex> & cache_lock)
-    : file_segment(file_segment_)
-{
-    /**
-     * Cell can be created with either DOWNLOADED or EMPTY file segment's state.
-     * File segment acquires DOWNLOADING state and creates LRUQueue iterator on first
-     * successful getOrSetDownaloder call.
-     */
-
-    switch (file_segment->download_state)
+    auto lock = cache_guard.lock();
+    main_priority->iterate([&](LockedKey &, FileSegmentMetadataPtr segment_metadata)
     {
-        case FileSegment::State::DOWNLOADED:
-        {
-            queue_iterator = cache->main_priority->add(
-                file_segment->key(), file_segment->offset(), file_segment->range().size(), cache_lock);
-            break;
-        }
-        case FileSegment::State::SKIP_CACHE:
-        case FileSegment::State::EMPTY:
-        case FileSegment::State::DOWNLOADING:
-        {
-            break;
-        }
-        default:
-            throw Exception(
-                ErrorCodes::LOGICAL_ERROR,
-                "Can create cell with either EMPTY, DOWNLOADED, DOWNLOADING state, got: {}",
-                FileSegment::stateToString(file_segment->download_state));
-    }
-}
-
-String FileCache::dumpStructure(const Key & key)
-{
-    std::lock_guard cache_lock(mutex);
-    return dumpStructureUnlocked(key, cache_lock);
-}
-
-String FileCache::dumpStructureUnlocked(const Key & key, std::lock_guard<std::mutex> &)
-{
-    WriteBufferFromOwnString result;
-    const auto & cells_by_offset = files[key];
-
-    for (const auto & [offset, cell] : cells_by_offset)
-        result << cell.file_segment->getInfoForLog() << "\n";
-
-    return result.str();
-}
-
-void FileCache::assertCacheCellsCorrectness(
-    const FileSegmentsByOffset & cells_by_offset, [[maybe_unused]] std::lock_guard<std::mutex> & cache_lock)
-{
-    for (const auto & [_, cell] : cells_by_offset)
-    {
-        const auto & file_segment = cell.file_segment;
-        file_segment->assertCorrectness();
-
-        if (file_segment->reserved_size != 0)
-        {
-            assert(cell.queue_iterator);
-            assert(main_priority->contains(file_segment->key(), file_segment->offset(), cache_lock));
-        }
-    }
-}
-
-void FileCache::assertCacheCorrectness(const Key & key, std::lock_guard<std::mutex> & cache_lock)
-{
-    assertCacheCellsCorrectness(files[key], cache_lock);
-    assertPriorityCorrectness(cache_lock);
-}
-
-void FileCache::assertCacheCorrectness(std::lock_guard<std::mutex> & cache_lock)
-{
-    for (const auto & [key, cells_by_offset] : files)
-        assertCacheCellsCorrectness(files[key], cache_lock);
-    assertPriorityCorrectness(cache_lock);
-}
-
-void FileCache::assertPriorityCorrectness(std::lock_guard<std::mutex> & cache_lock)
-{
-    [[maybe_unused]] size_t total_size = 0;
-    for (auto it = main_priority->getLowestPriorityReadIterator(cache_lock); it->valid(); it->next())
-    {
-        const auto & key = it->key();
-        auto offset = it->offset();
-        auto size = it->size();
-
-        auto * cell = getCell(key, offset, cache_lock);
-        if (!cell)
-        {
-            throw Exception(
-                ErrorCodes::LOGICAL_ERROR,
-                "Cache is in inconsistent state: LRU queue contains entries with no cache cell (assertCorrectness())");
-        }
-
-        if (cell->size() != size)
-        {
-            throw Exception(
-                ErrorCodes::LOGICAL_ERROR,
-                "Expected {} == {} size ({})",
-                cell->size(), size, cell->file_segment->getInfoForLog());
-        }
-
-        total_size += size;
-    }
-
-    assert(total_size == main_priority->getCacheSize(cache_lock));
-    assert(main_priority->getCacheSize(cache_lock) <= max_size);
-    assert(main_priority->getElementsNum(cache_lock) <= max_element_size);
+        const auto & file_segment = *segment_metadata->file_segment;
+        UNUSED(file_segment);
+        chassert(file_segment.assertCorrectness());
+        return PriorityIterationResult::CONTINUE;
+    }, lock);
 }
 
 FileCache::QueryContextHolder::QueryContextHolder(
     const String & query_id_,
     FileCache * cache_,
-    FileCache::QueryContextPtr context_)
+    FileCacheQueryLimit::QueryContextPtr context_)
     : query_id(query_id_)
     , cache(cache_)
     , context(context_)
@@ -1361,115 +1025,21 @@ FileCache::QueryContextHolder::~QueryContextHolder()
     /// If only the query_map and the current holder hold the context_query,
     /// the query has been completed and the query_context is released.
     if (context && context.use_count() == 2)
-        cache->removeQueryContext(query_id);
-}
-
-FileCache::QueryContextPtr FileCache::getCurrentQueryContext(std::lock_guard<std::mutex> & cache_lock)
-{
-    if (!isQueryInitialized())
-        return nullptr;
-
-    return getQueryContext(std::string(CurrentThread::getQueryId()), cache_lock);
-}
-
-FileCache::QueryContextPtr FileCache::getQueryContext(const String & query_id, std::lock_guard<std::mutex> & /* cache_lock */)
-{
-    auto query_iter = query_map.find(query_id);
-    return (query_iter == query_map.end()) ? nullptr : query_iter->second;
-}
-
-void FileCache::removeQueryContext(const String & query_id)
-{
-    std::lock_guard cache_lock(mutex);
-    auto query_iter = query_map.find(query_id);
-
-    if (query_iter == query_map.end())
     {
-        throw Exception(
-            ErrorCodes::LOGICAL_ERROR,
-            "Attempt to release query context that does not exist (query_id: {})",
-            query_id);
+        auto lock = cache->cache_guard.lock();
+        cache->query_limit->removeQueryContext(query_id, lock);
     }
-
-    query_map.erase(query_iter);
 }
 
-FileCache::QueryContextPtr FileCache::getOrSetQueryContext(
-    const String & query_id, const ReadSettings & settings, std::lock_guard<std::mutex> & cache_lock)
+FileCache::QueryContextHolderPtr FileCache::getQueryContextHolder(
+    const String & query_id, const ReadSettings & settings)
 {
-    if (query_id.empty())
-        return nullptr;
-
-    auto context = getQueryContext(query_id, cache_lock);
-    if (context)
-        return context;
-
-    auto query_context = std::make_shared<QueryContext>(settings.filesystem_cache_max_download_size, settings.skip_download_if_exceeds_query_cache);
-    auto query_iter = query_map.emplace(query_id, query_context).first;
-    return query_iter->second;
-}
-
-FileCache::QueryContextHolder FileCache::getQueryContextHolder(const String & query_id, const ReadSettings & settings)
-{
-    std::lock_guard cache_lock(mutex);
-
-    if (!enable_filesystem_query_cache_limit || settings.filesystem_cache_max_download_size == 0)
+    if (!query_limit || settings.filesystem_cache_max_download_size == 0)
         return {};
 
-    /// if enable_filesystem_query_cache_limit is true, and filesystem_cache_max_download_size large than zero,
-    /// we create context query for current query.
-    auto context = getOrSetQueryContext(query_id, settings, cache_lock);
-    return QueryContextHolder(query_id, this, context);
-}
-
-void FileCache::QueryContext::remove(const Key & key, size_t offset, size_t size, std::lock_guard<std::mutex> & cache_lock)
-{
-    if (cache_size < size)
-        throw Exception(ErrorCodes::LOGICAL_ERROR, "Deleted cache size exceeds existing cache size");
-
-    if (!skip_download_if_exceeds_query_cache)
-    {
-        auto record = records.find({key, offset});
-        if (record != records.end())
-        {
-            record->second->removeAndGetNext(cache_lock);
-            records.erase({key, offset});
-        }
-    }
-    cache_size -= size;
-}
-
-void FileCache::QueryContext::reserve(const Key & key, size_t offset, size_t size, std::lock_guard<std::mutex> & cache_lock)
-{
-    if (cache_size + size > max_cache_size)
-    {
-        throw Exception(
-            ErrorCodes::LOGICAL_ERROR,
-            "Reserved cache size exceeds the remaining cache size (key: {}, offset: {})",
-            key.toString(), offset);
-    }
-
-    if (!skip_download_if_exceeds_query_cache)
-    {
-        auto record = records.find({key, offset});
-        if (record == records.end())
-        {
-            auto queue_iter = priority->add(key, offset, 0, cache_lock);
-            record = records.insert({{key, offset}, queue_iter}).first;
-        }
-        record->second->updateSize(size, cache_lock);
-    }
-    cache_size += size;
-}
-
-void FileCache::QueryContext::use(const Key & key, size_t offset, std::lock_guard<std::mutex> & cache_lock)
-{
-    if (skip_download_if_exceeds_query_cache)
-        return;
-
-    auto record = records.find({key, offset});
-    if (record != records.end())
-        record->second->use(cache_lock);
+    auto lock = cache_guard.lock();
+    auto context = query_limit->getOrSetQueryContext(query_id, settings, lock);
+    return std::make_unique<QueryContextHolder>(query_id, this, std::move(context));
 }
 
 }
diff --git a/src/Interpreters/Cache/FileCache.h b/src/Interpreters/Cache/FileCache.h
index 83435b67562..2ceb6825a54 100644
--- a/src/Interpreters/Cache/FileCache.h
+++ b/src/Interpreters/Cache/FileCache.h
@@ -9,43 +9,52 @@
 #include <unordered_map>
 #include <unordered_set>
 #include <boost/functional/hash.hpp>
-#include <boost/noncopyable.hpp>
 
-#include <Core/Types.h>
-#include <Common/ThreadPool.h>
 #include <IO/ReadSettings.h>
-#include <Interpreters/Cache/IFileCachePriority.h>
-#include <Interpreters/Cache/FileCacheKey.h>
+
+#include <Core/BackgroundSchedulePool.h>
+#include <Interpreters/Cache/LRUFileCachePriority.h>
 #include <Interpreters/Cache/FileCache_fwd.h>
 #include <Interpreters/Cache/FileSegment.h>
+#include <Interpreters/Cache/Metadata.h>
+#include <Interpreters/Cache/QueryLimit.h>
+#include <Interpreters/Cache/FileCache_fwd_internal.h>
+#include <filesystem>
 
 
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int BAD_ARGUMENTS;
+}
+
 /// Local cache for remote filesystem files, represented as a set of non-overlapping non-empty file segments.
 /// Different caching algorithms are implemented using IFileCachePriority.
 class FileCache : private boost::noncopyable
 {
-
-friend class FileSegment;
-friend class IFileCachePriority;
-friend struct FileSegmentsHolder;
-friend class FileSegmentRangeWriter;
-
-struct QueryContext;
-using QueryContextPtr = std::shared_ptr<QueryContext>;
-
 public:
     using Key = DB::FileCacheKey;
+    using QueryLimit = DB::FileCacheQueryLimit;
+    using Priority = IFileCachePriority;
+    using PriorityEntry = IFileCachePriority::Entry;
+    using PriorityIterator = IFileCachePriority::Iterator;
+    using PriorityIterationResult = IFileCachePriority::IterationResult;
 
     explicit FileCache(const FileCacheSettings & settings);
 
-    ~FileCache() = default;
+    ~FileCache();
 
     void initialize();
 
-    const String & getBasePath() const { return cache_base_path; }
+    const String & getBasePath() const;
+
+    static Key createKeyForPath(const String & path);
+
+    String getPathInLocalCache(const Key & key, size_t offset, FileSegmentKind segment_kind) const;
+
+    String getPathInLocalCache(const Key & key) const;
 
     /**
      * Given an `offset` and `size` representing [offset, offset + size) bytes interval,
@@ -58,8 +67,7 @@ public:
      * As long as pointers to returned file segments are held
      * it is guaranteed that these file segments are not removed from cache.
      */
-    FileSegmentsHolder getOrSet(const Key & key, size_t offset, size_t size, const CreateFileSegmentSettings & settings);
-    FileSegmentsHolder set(const Key & key, size_t offset, size_t size, const CreateFileSegmentSettings & settings);
+    FileSegmentsHolderPtr getOrSet(const Key & key, size_t offset, size_t size, const CreateFileSegmentSettings & settings);
 
     /**
      * Segments in returned list are ordered in ascending order and represent a full contiguous
@@ -70,53 +78,40 @@ public:
      * with the destruction of the holder, while in getOrSet() EMPTY file segments can eventually change
      * it's state (and become DOWNLOADED).
      */
-    FileSegmentsHolder get(const Key & key, size_t offset, size_t size);
+    FileSegmentsHolderPtr get(const Key & key, size_t offset, size_t size);
+
+    FileSegmentsHolderPtr set(const Key & key, size_t offset, size_t size, const CreateFileSegmentSettings & settings);
 
     /// Remove files by `key`. Removes files which might be used at the moment.
-    void removeIfExists(const Key & key);
+    void removeKeyIfExists(const Key & key);
 
     /// Remove files by `key`. Will not remove files which are used at the moment.
-    void removeIfReleasable();
-
-    static Key hash(const String & path);
-
-    String getPathInLocalCache(const Key & key, size_t offset, FileSegmentKind segment_kind) const;
-
-    String getPathInLocalCache(const Key & key) const;
+    void removeAllReleasable();
 
     std::vector<String> tryGetCachePaths(const Key & key);
 
-    size_t capacity() const { return max_size; }
-
     size_t getUsedCacheSize() const;
 
     size_t getFileSegmentsNum() const;
 
-    static bool isReadOnly();
+    size_t getMaxFileSegmentSize() const { return max_file_segment_size; }
 
-    /**
-     * Create a file segment of exactly requested size with EMPTY state.
-     * Throw exception if requested size exceeds max allowed file segment size.
-     * This method is for protected usage: file segment range writer uses it
-     * to dynamically allocate file segments.
-     */
-    FileSegmentPtr createFileSegmentForDownload(
-         const Key & key,
-         size_t offset,
-         size_t size,
-         const CreateFileSegmentSettings & create_settings,
-         std::lock_guard<std::mutex> & cache_lock);
+    bool tryReserve(FileSegment & file_segment, size_t size);
 
-    FileSegments getSnapshot() const;
+    FileSegmentsHolderPtr getSnapshot();
 
-    /// For debug.
-    String dumpStructure(const Key & key);
+    FileSegmentsHolderPtr getSnapshot(const Key & key);
 
-    /// Save a query context information, and adopt different cache policies
-    /// for different queries through the context cache layer.
+    FileSegmentsHolderPtr dumpQueue();
+
+    void cleanup();
+
+    void deactivateBackgroundOperations();
+
+    /// For per query cache limit.
     struct QueryContextHolder : private boost::noncopyable
     {
-        QueryContextHolder(const String & query_id_, FileCache * cache_, QueryContextPtr context_);
+        QueryContextHolder(const String & query_id_, FileCache * cache_, QueryLimit::QueryContextPtr context_);
 
         QueryContextHolder() = default;
 
@@ -124,198 +119,95 @@ public:
 
         String query_id;
         FileCache * cache = nullptr;
-        QueryContextPtr context;
+        QueryLimit::QueryContextPtr context;
     };
+    using QueryContextHolderPtr = std::unique_ptr<QueryContextHolder>;
+    QueryContextHolderPtr getQueryContextHolder(const String & query_id, const ReadSettings & settings);
 
-    QueryContextHolder getQueryContextHolder(const String & query_id, const ReadSettings & settings);
+    CacheGuard::Lock lockCache() { return cache_guard.lock(); }
 
 private:
-    String cache_base_path;
+    using KeyAndOffset = FileCacheKeyAndOffset;
 
-    const size_t max_size;
-    const size_t max_element_size;
     const size_t max_file_segment_size;
-
     const bool allow_persistent_files;
-    const size_t enable_cache_hits_threshold;
-    const bool enable_filesystem_query_cache_limit;
+    const size_t bypass_cache_threshold = 0;
+    const size_t delayed_cleanup_interval_ms;
 
-    const bool enable_bypass_cache_with_threashold;
-    const size_t bypass_cache_threashold;
-
-    mutable std::mutex mutex;
     Poco::Logger * log;
 
-    bool is_initialized = false;
-    std::exception_ptr initialization_exception;
+    std::exception_ptr init_exception;
+    std::atomic<bool> is_initialized = false;
+    mutable std::mutex init_mutex;
 
-    void assertInitialized(std::lock_guard<std::mutex> & cache_lock) const;
+    CacheMetadata metadata;
 
-    bool tryReserve(const Key & key, size_t offset, size_t size, std::lock_guard<std::mutex> & cache_lock);
+    FileCachePriorityPtr main_priority;
+    mutable CacheGuard cache_guard;
 
-    void remove(
-        Key key,
-        size_t offset,
-        std::lock_guard<std::mutex> & cache_lock,
-        std::unique_lock<std::mutex> & segment_lock);
-
-    void remove(
-        FileSegmentPtr file_segment,
-        std::lock_guard<std::mutex> & cache_lock);
-
-    bool isLastFileSegmentHolder(
-        const Key & key,
-        size_t offset,
-        std::lock_guard<std::mutex> & cache_lock,
-        std::unique_lock<std::mutex> & segment_lock);
-
-    void reduceSizeToDownloaded(
-        const Key & key,
-        size_t offset,
-        std::lock_guard<std::mutex> & cache_lock,
-        std::unique_lock<std::mutex> & segment_lock);
-
-    struct FileSegmentCell : private boost::noncopyable
+    struct HitsCountStash
     {
-        FileSegmentPtr file_segment;
-
-        /// Iterator is put here on first reservation attempt, if successful.
-        IFileCachePriority::WriteIterator queue_iterator;
-
-        /// Pointer to file segment is always hold by the cache itself.
-        /// Apart from pointer in cache, it can be hold by cache users, when they call
-        /// getorSet(), but cache users always hold it via FileSegmentsHolder.
-        bool releasable() const { return file_segment.unique(); }
-
-        size_t size() const { return file_segment->reserved_size; }
-
-        FileSegmentCell(FileSegmentPtr file_segment_, FileCache * cache, std::lock_guard<std::mutex> & cache_lock);
-
-        FileSegmentCell(FileSegmentCell && other) noexcept
-            : file_segment(std::move(other.file_segment)), queue_iterator(std::move(other.queue_iterator)) {}
-    };
-
-    using AccessKeyAndOffset = std::pair<Key, size_t>;
-    struct KeyAndOffsetHash
-    {
-        std::size_t operator()(const AccessKeyAndOffset & key) const
+        HitsCountStash(size_t hits_threashold_, size_t queue_size_)
+            : hits_threshold(hits_threashold_), queue(std::make_unique<LRUFileCachePriority>(0, queue_size_))
         {
-            return std::hash<UInt128>()(key.first.key) ^ std::hash<UInt64>()(key.second);
+            if (!queue_size_)
+                throw Exception(ErrorCodes::BAD_ARGUMENTS, "Queue size for hits queue must be non-zero");
         }
+
+        const size_t hits_threshold;
+        FileCachePriorityPtr queue;
+        using Records = std::unordered_map<KeyAndOffset, PriorityIterator, FileCacheKeyAndOffsetHash>;
+        Records records;
     };
 
-    using FileSegmentsByOffset = std::map<size_t, FileSegmentCell>;
-    using CachedFiles = std::unordered_map<Key, FileSegmentsByOffset>;
-    using FileCacheRecords = std::unordered_map<AccessKeyAndOffset, IFileCachePriority::WriteIterator, KeyAndOffsetHash>;
+    /**
+     * A HitsCountStash allows to cache certain data only after it reached
+     * a certain hit rate, e.g. if hit rate it 5, then data is cached on 6th cache hit.
+     */
+    mutable std::unique_ptr<HitsCountStash> stash;
+    /**
+     * A QueryLimit allows to control cache write limit per query.
+     * E.g. if a query needs n bytes from cache, but it has only k bytes, where 0 <= k <= n
+     * then allowed loaded cache size is std::min(n - k, max_query_cache_size).
+     */
+    FileCacheQueryLimitPtr query_limit;
+    /**
+     * A background cleanup task.
+     * Clears removed cache entries from metadata.
+     */
+    BackgroundSchedulePool::TaskHolder cleanup_task;
 
-    CachedFiles files;
-    std::unique_ptr<IFileCachePriority> main_priority;
+    void assertInitialized() const;
 
-    FileCacheRecords stash_records;
-    std::unique_ptr<IFileCachePriority> stash_priority;
-    size_t max_stash_element_size;
+    void assertCacheCorrectness();
 
-    void loadCacheInfoIntoMemory(std::lock_guard<std::mutex> & cache_lock);
+    void loadMetadata();
 
-    FileSegments getImpl(const Key & key, const FileSegment::Range & range, std::lock_guard<std::mutex> & cache_lock);
+    FileSegments getImpl(const LockedKey & locked_key, const FileSegment::Range & range) const;
 
-    FileSegmentCell * getCell(const Key & key, size_t offset, std::lock_guard<std::mutex> & cache_lock);
-
-    /// Returns non-owned pointer to the cell stored in the `files` map.
-    /// Doesn't reserve any space.
-    FileSegmentCell * addCell(
-        const Key & key,
+    FileSegments splitRangeIntoFileSegments(
+        LockedKey & locked_key,
         size_t offset,
         size_t size,
         FileSegment::State state,
-        const CreateFileSegmentSettings & create_settings,
-        std::lock_guard<std::mutex> & cache_lock);
-
-    static void useCell(const FileSegmentCell & cell, FileSegments & result, std::lock_guard<std::mutex> & cache_lock);
-
-    bool tryReserveForMainList(
-        const Key & key,
-        size_t offset,
-        size_t size,
-        QueryContextPtr query_context,
-        std::lock_guard<std::mutex> & cache_lock);
-
-    FileSegments splitRangeIntoCells(
-        const Key & key,
-        size_t offset,
-        size_t size,
-        FileSegment::State state,
-        const CreateFileSegmentSettings & create_settings,
-        std::lock_guard<std::mutex> & cache_lock);
-
-    String dumpStructureUnlocked(const Key & key_, std::lock_guard<std::mutex> & cache_lock);
+        const CreateFileSegmentSettings & create_settings);
 
     void fillHolesWithEmptyFileSegments(
+        LockedKey & locked_key,
         FileSegments & file_segments,
-        const Key & key,
         const FileSegment::Range & range,
         bool fill_with_detached_file_segments,
-        const CreateFileSegmentSettings & settings,
-        std::lock_guard<std::mutex> & cache_lock);
+        const CreateFileSegmentSettings & settings);
 
-    size_t getUsedCacheSizeUnlocked(std::lock_guard<std::mutex> & cache_lock) const;
+    KeyMetadata::iterator addFileSegment(
+        LockedKey & locked_key,
+        size_t offset,
+        size_t size,
+        FileSegment::State state,
+        const CreateFileSegmentSettings & create_settings,
+        const CacheGuard::Lock *);
 
-    size_t getAvailableCacheSizeUnlocked(std::lock_guard<std::mutex> & cache_lock) const;
-
-    size_t getFileSegmentsNumUnlocked(std::lock_guard<std::mutex> & cache_lock) const;
-
-    void assertCacheCellsCorrectness(const FileSegmentsByOffset & cells_by_offset, std::lock_guard<std::mutex> & cache_lock);
-
-    void removeKeyDirectoryIfExists(const Key & key, std::lock_guard<std::mutex> & cache_lock) const;
-
-    /// Used to track and control the cache access of each query.
-    /// Through it, we can realize the processing of different queries by the cache layer.
-    struct QueryContext
-    {
-        FileCacheRecords records;
-        FileCachePriorityPtr priority;
-
-        size_t cache_size = 0;
-        size_t max_cache_size;
-
-        bool skip_download_if_exceeds_query_cache;
-
-        QueryContext(size_t max_cache_size_, bool skip_download_if_exceeds_query_cache_)
-            : max_cache_size(max_cache_size_)
-            , skip_download_if_exceeds_query_cache(skip_download_if_exceeds_query_cache_) {}
-
-        size_t getMaxCacheSize() const { return max_cache_size; }
-
-        size_t getCacheSize() const { return cache_size; }
-
-        FileCachePriorityPtr getPriority() const { return priority; }
-
-        bool isSkipDownloadIfExceed() const { return skip_download_if_exceeds_query_cache; }
-
-        void remove(const Key & key, size_t offset, size_t size, std::lock_guard<std::mutex> & cache_lock);
-
-        void reserve(const Key & key, size_t offset, size_t size, std::lock_guard<std::mutex> & cache_lock);
-
-        void use(const Key & key, size_t offset, std::lock_guard<std::mutex> & cache_lock);
-    };
-
-    using QueryContextMap = std::unordered_map<String, QueryContextPtr>;
-    QueryContextMap query_map;
-
-    QueryContextPtr getCurrentQueryContext(std::lock_guard<std::mutex> & cache_lock);
-
-    QueryContextPtr getQueryContext(const String & query_id, std::lock_guard<std::mutex> & cache_lock);
-
-    void removeQueryContext(const String & query_id);
-
-    QueryContextPtr getOrSetQueryContext(const String & query_id, const ReadSettings & settings, std::lock_guard<std::mutex> &);
-
-public:
-    void assertCacheCorrectness(const Key & key, std::lock_guard<std::mutex> & cache_lock);
-
-    void assertCacheCorrectness(std::lock_guard<std::mutex> & cache_lock);
-
-    void assertPriorityCorrectness(std::lock_guard<std::mutex> & cache_lock);
+    void cleanupThreadFunc();
 };
 
 }
diff --git a/src/Interpreters/Cache/FileCacheKey.cpp b/src/Interpreters/Cache/FileCacheKey.cpp
new file mode 100644
index 00000000000..f97cdc058aa
--- /dev/null
+++ b/src/Interpreters/Cache/FileCacheKey.cpp
@@ -0,0 +1,31 @@
+#include "FileCacheKey.h"
+
+#include <base/hex.h>
+#include <Common/SipHash.h>
+#include <Core/UUID.h>
+
+
+namespace DB
+{
+
+FileCacheKey::FileCacheKey(const std::string & path)
+    : key(sipHash128(path.data(), path.size()))
+{
+}
+
+FileCacheKey::FileCacheKey(const UInt128 & key_)
+    : key(key_)
+{
+}
+
+std::string FileCacheKey::toString() const
+{
+    return getHexUIntLowercase(key);
+}
+
+FileCacheKey FileCacheKey::random()
+{
+    return FileCacheKey(UUIDHelpers::generateV4().toUnderType());
+}
+
+}
diff --git a/src/Interpreters/Cache/FileCacheKey.h b/src/Interpreters/Cache/FileCacheKey.h
index 67e1466e2d4..bab8359732c 100644
--- a/src/Interpreters/Cache/FileCacheKey.h
+++ b/src/Interpreters/Cache/FileCacheKey.h
@@ -1,26 +1,37 @@
 #pragma once
 #include <Core/Types.h>
-#include <base/hex.h>
-#include <Core/UUID.h>
+#include <fmt/format.h>
 
 namespace DB
 {
 
 struct FileCacheKey
 {
-    UInt128 key;
+    using KeyHash = UInt128;
+    KeyHash key;
 
-    String toString() const { return getHexUIntLowercase(key); }
+    std::string toString() const;
 
     FileCacheKey() = default;
 
-    explicit FileCacheKey(const UInt128 & key_) : key(key_) { }
+    explicit FileCacheKey(const std::string & path);
 
-    static FileCacheKey random() { return FileCacheKey(UUIDHelpers::generateV4().toUnderType()); }
+    explicit FileCacheKey(const UInt128 & key_);
+
+    static FileCacheKey random();
 
     bool operator==(const FileCacheKey & other) const { return key == other.key; }
 };
 
+using FileCacheKeyAndOffset = std::pair<FileCacheKey, size_t>;
+struct FileCacheKeyAndOffsetHash
+{
+    std::size_t operator()(const FileCacheKeyAndOffset & key) const
+    {
+        return std::hash<UInt128>()(key.first.key) ^ std::hash<UInt64>()(key.second);
+    }
+};
+
 }
 
 namespace std
@@ -32,3 +43,13 @@ struct hash<DB::FileCacheKey>
 };
 
 }
+
+template <>
+struct fmt::formatter<DB::FileCacheKey> : fmt::formatter<std::string>
+{
+    template <typename FormatCtx>
+    auto format(const DB::FileCacheKey & key, FormatCtx & ctx) const
+    {
+        return fmt::formatter<std::string>::format(key.toString(), ctx);
+    }
+};
diff --git a/src/Interpreters/Cache/FileCacheSettings.cpp b/src/Interpreters/Cache/FileCacheSettings.cpp
index 9d5282047aa..1737defd316 100644
--- a/src/Interpreters/Cache/FileCacheSettings.cpp
+++ b/src/Interpreters/Cache/FileCacheSettings.cpp
@@ -30,24 +30,26 @@ void FileCacheSettings::loadFromConfig(const Poco::Util::AbstractConfiguration &
     if (path.empty())
         throw Exception(ErrorCodes::BAD_ARGUMENTS, "Disk Cache requires non-empty `path` field (cache base path) in config");
 
-    max_elements = config.getUInt64(config_prefix + ".max_elements", REMOTE_FS_OBJECTS_CACHE_DEFAULT_MAX_ELEMENTS);
+    max_elements = config.getUInt64(config_prefix + ".max_elements", FILECACHE_DEFAULT_MAX_ELEMENTS);
     if (config.has(config_prefix + ".max_file_segment_size"))
         max_file_segment_size = parseWithSizeSuffix<uint64_t>(config.getString(config_prefix + ".max_file_segment_size"));
     else
-        max_file_segment_size = REMOTE_FS_OBJECTS_CACHE_DEFAULT_MAX_FILE_SEGMENT_SIZE;
+        max_file_segment_size = FILECACHE_DEFAULT_MAX_FILE_SEGMENT_SIZE;
 
     cache_on_write_operations = config.getUInt64(config_prefix + ".cache_on_write_operations", false);
     enable_filesystem_query_cache_limit = config.getUInt64(config_prefix + ".enable_filesystem_query_cache_limit", false);
-    enable_cache_hits_threshold = config.getUInt64(config_prefix + ".enable_cache_hits_threshold", REMOTE_FS_OBJECTS_CACHE_ENABLE_HITS_THRESHOLD);
+    cache_hits_threshold = config.getUInt64(config_prefix + ".cache_hits_threshold", FILECACHE_DEFAULT_HITS_THRESHOLD);
 
     enable_bypass_cache_with_threashold = config.getUInt64(config_prefix + ".enable_bypass_cache_with_threashold", false);
 
     if (config.has(config_prefix + ".bypass_cache_threashold"))
         bypass_cache_threashold = parseWithSizeSuffix<uint64_t>(config.getString(config_prefix + ".bypass_cache_threashold"));
     else
-         bypass_cache_threashold = REMOTE_FS_OBJECTS_CACHE_BYPASS_THRESHOLD;
+         bypass_cache_threashold = FILECACHE_BYPASS_THRESHOLD;
 
     do_not_evict_index_and_mark_files = config.getUInt64(config_prefix + ".do_not_evict_index_and_mark_files", false);
+
+    delayed_cleanup_interval_ms = config.getUInt64(config_prefix + ".delayed_cleanup_interval_ms", FILECACHE_DELAYED_CLEANUP_INTERVAL_MS);
 }
 
 }
diff --git a/src/Interpreters/Cache/FileCacheSettings.h b/src/Interpreters/Cache/FileCacheSettings.h
index 689c3ef70fb..e316cc6d6fe 100644
--- a/src/Interpreters/Cache/FileCacheSettings.h
+++ b/src/Interpreters/Cache/FileCacheSettings.h
@@ -13,18 +13,19 @@ struct FileCacheSettings
     std::string base_path;
 
     size_t max_size = 0;
-    size_t max_elements = REMOTE_FS_OBJECTS_CACHE_DEFAULT_MAX_ELEMENTS;
-    size_t max_file_segment_size = REMOTE_FS_OBJECTS_CACHE_DEFAULT_MAX_FILE_SEGMENT_SIZE;
+    size_t max_elements = FILECACHE_DEFAULT_MAX_ELEMENTS;
+    size_t max_file_segment_size = FILECACHE_DEFAULT_MAX_FILE_SEGMENT_SIZE;
 
     bool cache_on_write_operations = false;
 
-    size_t enable_cache_hits_threshold = REMOTE_FS_OBJECTS_CACHE_ENABLE_HITS_THRESHOLD;
+    size_t cache_hits_threshold = FILECACHE_DEFAULT_HITS_THRESHOLD;
     bool enable_filesystem_query_cache_limit = false;
 
     bool do_not_evict_index_and_mark_files = true;
 
     bool enable_bypass_cache_with_threashold = false;
-    size_t bypass_cache_threashold = REMOTE_FS_OBJECTS_CACHE_BYPASS_THRESHOLD;
+    size_t bypass_cache_threashold = FILECACHE_BYPASS_THRESHOLD;
+    size_t delayed_cleanup_interval_ms = FILECACHE_DELAYED_CLEANUP_INTERVAL_MS;
 
     void loadFromConfig(const Poco::Util::AbstractConfiguration & config, const std::string & config_prefix);
 };
diff --git a/src/Interpreters/Cache/FileCache_fwd.h b/src/Interpreters/Cache/FileCache_fwd.h
index 72dc1144fb9..afd8d86074e 100644
--- a/src/Interpreters/Cache/FileCache_fwd.h
+++ b/src/Interpreters/Cache/FileCache_fwd.h
@@ -4,10 +4,11 @@
 namespace DB
 {
 
-static constexpr int REMOTE_FS_OBJECTS_CACHE_DEFAULT_MAX_FILE_SEGMENT_SIZE = 100 * 1024 * 1024;
-static constexpr int REMOTE_FS_OBJECTS_CACHE_DEFAULT_MAX_ELEMENTS = 1024 * 1024;
-static constexpr int REMOTE_FS_OBJECTS_CACHE_ENABLE_HITS_THRESHOLD = 0;
-static constexpr size_t REMOTE_FS_OBJECTS_CACHE_BYPASS_THRESHOLD = 256 * 1024 * 1024;;
+static constexpr int FILECACHE_DEFAULT_MAX_FILE_SEGMENT_SIZE = 100 * 1024 * 1024;
+static constexpr int FILECACHE_DEFAULT_MAX_ELEMENTS = 1024 * 1024;
+static constexpr int FILECACHE_DEFAULT_HITS_THRESHOLD = 0;
+static constexpr size_t FILECACHE_BYPASS_THRESHOLD = 256 * 1024 * 1024;
+static constexpr size_t FILECACHE_DELAYED_CLEANUP_INTERVAL_MS = 1000 * 60; /// 1 min
 
 class FileCache;
 using FileCachePtr = std::shared_ptr<FileCache>;
diff --git a/src/Interpreters/Cache/FileCache_fwd_internal.h b/src/Interpreters/Cache/FileCache_fwd_internal.h
new file mode 100644
index 00000000000..5ded018a674
--- /dev/null
+++ b/src/Interpreters/Cache/FileCache_fwd_internal.h
@@ -0,0 +1,26 @@
+#pragma once
+#include <list>
+
+namespace DB
+{
+
+class FileCache;
+using FileCachePtr = std::shared_ptr<FileCache>;
+
+class IFileCachePriority;
+using FileCachePriorityPtr = std::unique_ptr<IFileCachePriority>;
+
+class FileSegment;
+using FileSegmentPtr = std::shared_ptr<FileSegment>;
+using FileSegments = std::list<FileSegmentPtr>;
+
+struct FileSegmentMetadata;
+using FileSegmentMetadataPtr = std::shared_ptr<FileSegmentMetadata>;
+
+struct LockedKey;
+using LockedKeyPtr = std::shared_ptr<LockedKey>;
+
+struct KeyMetadata;
+using KeyMetadataPtr = std::shared_ptr<KeyMetadata>;
+
+}
diff --git a/src/Interpreters/Cache/FileSegment.cpp b/src/Interpreters/Cache/FileSegment.cpp
index 6ae25c681d4..b05847a1ce7 100644
--- a/src/Interpreters/Cache/FileSegment.cpp
+++ b/src/Interpreters/Cache/FileSegment.cpp
@@ -13,11 +13,6 @@
 
 namespace fs = std::filesystem;
 
-namespace CurrentMetrics
-{
-extern const Metric CacheDetachedFileSegments;
-}
-
 namespace DB
 {
 
@@ -32,23 +27,27 @@ String toString(FileSegmentKind kind)
 }
 
 FileSegment::FileSegment(
+        const Key & key_,
         size_t offset_,
         size_t size_,
-        const Key & key_,
-        FileCache * cache_,
         State download_state_,
-        const CreateFileSegmentSettings & settings)
-    : segment_range(offset_, offset_ + size_ - 1)
+        const CreateFileSegmentSettings & settings,
+        FileCache * cache_,
+        std::weak_ptr<KeyMetadata> key_metadata_,
+        Priority::Iterator queue_iterator_)
+    : file_key(key_)
+    , segment_range(offset_, offset_ + size_ - 1)
+    , segment_kind(settings.kind)
+    , is_unbound(settings.unbounded)
     , download_state(download_state_)
-    , file_key(key_)
+    , key_metadata(key_metadata_)
+    , queue_iterator(queue_iterator_)
     , cache(cache_)
 #ifndef NDEBUG
-    , log(&Poco::Logger::get(fmt::format("FileSegment({}) : {}", getHexUIntLowercase(key_), range().toString())))
+    , log(&Poco::Logger::get(fmt::format("FileSegment({}) : {}", key_.toString(), range().toString())))
 #else
     , log(&Poco::Logger::get("FileSegment"))
 #endif
-    , segment_kind(settings.kind)
-    , is_unbound(settings.unbounded)
 {
     /// On creation, file segment state can be EMPTY, DOWNLOADED, DOWNLOADING.
     switch (download_state)
@@ -60,15 +59,15 @@ FileSegment::FileSegment(
             break;
         }
         /// DOWNLOADED is used either on initial cache metadata load into memory on server startup
-        /// or on reduceSizeToDownloaded() -- when file segment object is updated.
+        /// or on shrinkFileSegmentToDownloadedSize() -- when file segment object is updated.
         case (State::DOWNLOADED):
         {
             reserved_size = downloaded_size = size_;
-            is_downloaded = true;
             chassert(fs::file_size(getPathInLocalCache()) == size_);
+            chassert(queue_iterator);
             break;
         }
-        case (State::SKIP_CACHE):
+        case (State::DETACHED):
         {
             break;
         }
@@ -76,82 +75,79 @@ FileSegment::FileSegment(
         {
             throw Exception(
                 ErrorCodes::LOGICAL_ERROR,
-                "Can only create cell with either EMPTY, DOWNLOADED or SKIP_CACHE state");
+                "Can only create file segment with either EMPTY, DOWNLOADED or DETACHED state");
         }
     }
 }
 
-String FileSegment::getPathInLocalCache() const
-{
-    chassert(cache);
-    return cache->getPathInLocalCache(key(), offset(), segment_kind);
-}
-
 FileSegment::State FileSegment::state() const
 {
-    std::unique_lock segment_lock(mutex);
+    auto lock = segment_guard.lock();
     return download_state;
 }
 
-void FileSegment::setDownloadState(State state)
+String FileSegment::getPathInLocalCache() const
+{
+    return getKeyMetadata()->getFileSegmentPath(*this);
+}
+
+void FileSegment::setDownloadState(State state, const FileSegmentGuard::Lock &)
 {
     LOG_TEST(log, "Updated state from {} to {}", stateToString(download_state), stateToString(state));
     download_state = state;
 }
 
-size_t FileSegment::getFirstNonDownloadedOffset() const
+size_t FileSegment::getReservedSize() const
 {
-    std::unique_lock segment_lock(mutex);
-    return getFirstNonDownloadedOffsetUnlocked(segment_lock);
+    auto lock = segment_guard.lock();
+    return reserved_size;
 }
 
-size_t FileSegment::getFirstNonDownloadedOffsetUnlocked(std::unique_lock<std::mutex> & segment_lock) const
+FileSegment::Priority::Iterator FileSegment::getQueueIterator() const
 {
-    return range().left + getDownloadedSizeUnlocked(segment_lock);
+    auto lock = segment_guard.lock();
+    return queue_iterator;
 }
 
-size_t FileSegment::getCurrentWriteOffset() const
+void FileSegment::setQueueIterator(Priority::Iterator iterator)
 {
-    std::unique_lock segment_lock(mutex);
-    return getCurrentWriteOffsetUnlocked(segment_lock);
+    auto lock = segment_guard.lock();
+    if (queue_iterator)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Queue iterator cannot be set twice");
+    queue_iterator = iterator;
 }
 
-size_t FileSegment::getCurrentWriteOffsetUnlocked(std::unique_lock<std::mutex> & segment_lock) const
+size_t FileSegment::getFirstNonDownloadedOffset(bool sync) const
 {
-    return getFirstNonDownloadedOffsetUnlocked(segment_lock);
+    return range().left + getDownloadedSize(sync);
 }
 
-size_t FileSegment::getDownloadedSize() const
+size_t FileSegment::getCurrentWriteOffset(bool sync) const
 {
-    std::unique_lock segment_lock(mutex);
-    return getDownloadedSizeUnlocked(segment_lock);
+    return getFirstNonDownloadedOffset(sync);
 }
 
-size_t FileSegment::getDownloadedSizeUnlocked(std::unique_lock<std::mutex> & /* segment_lock */) const
+size_t FileSegment::getDownloadedSize(bool sync) const
 {
-    if (download_state == State::DOWNLOADED)
+    if (sync)
+    {
+        std::lock_guard lock(download_mutex);
         return downloaded_size;
-
-    std::unique_lock download_lock(download_mutex);
+    }
     return downloaded_size;
 }
 
 void FileSegment::setDownloadedSize(size_t delta)
 {
-    std::unique_lock download_lock(download_mutex);
-    setDownloadedSizeUnlocked(download_lock, delta);
-}
-
-void FileSegment::setDownloadedSizeUnlocked(std::unique_lock<std::mutex> & /* download_lock */, size_t delta)
-{
+    auto lock = segment_guard.lock();
     downloaded_size += delta;
     assert(downloaded_size == std::filesystem::file_size(getPathInLocalCache()));
 }
 
 bool FileSegment::isDownloaded() const
 {
-    std::lock_guard segment_lock(mutex);
-    return is_downloaded;
+    auto lock = segment_guard.lock();
+    return download_state == State::DOWNLOADED;
 }
 
 String FileSegment::getCallerId()
@@ -166,70 +162,73 @@ String FileSegment::getCallerId()
 
 String FileSegment::getDownloader() const
 {
-    std::unique_lock segment_lock(mutex);
-    return getDownloaderUnlocked(segment_lock);
+    auto lock = segment_guard.lock();
+    return getDownloaderUnlocked(lock);
 }
 
-String FileSegment::getDownloaderUnlocked(std::unique_lock<std::mutex> & /* segment_lock */) const
+String FileSegment::getDownloaderUnlocked(const FileSegmentGuard::Lock &) const
 {
     return downloader_id;
 }
 
 String FileSegment::getOrSetDownloader()
 {
-    std::unique_lock segment_lock(mutex);
+    auto lock = segment_guard.lock();
 
-    assertNotDetachedUnlocked(segment_lock);
+    assertNotDetachedUnlocked(lock);
 
-    auto current_downloader = getDownloaderUnlocked(segment_lock);
+    auto current_downloader = getDownloaderUnlocked(lock);
 
     if (current_downloader.empty())
     {
-        bool allow_new_downloader = download_state == State::EMPTY || download_state == State::PARTIALLY_DOWNLOADED;
+        const auto caller_id = getCallerId();
+        bool allow_new_downloader = download_state == State::EMPTY || download_state == State::PARTIALLY_DOWNLOADED || !caller_id.starts_with("None");
         if (!allow_new_downloader)
             return "notAllowed:" + stateToString(download_state);
 
-        current_downloader = downloader_id = getCallerId();
-        setDownloadState(State::DOWNLOADING);
+        current_downloader = downloader_id = caller_id;
+        setDownloadState(State::DOWNLOADING, lock);
     }
 
     return current_downloader;
 }
 
-void FileSegment::resetDownloadingStateUnlocked([[maybe_unused]] std::unique_lock<std::mutex> & segment_lock)
+void FileSegment::resetDownloadingStateUnlocked(const FileSegmentGuard::Lock & lock)
 {
-    assert(isDownloaderUnlocked(segment_lock));
+    assert(isDownloaderUnlocked(lock));
     assert(download_state == State::DOWNLOADING);
 
-    size_t current_downloaded_size = getDownloadedSizeUnlocked(segment_lock);
+    size_t current_downloaded_size = getDownloadedSize(true);
     /// range().size() can equal 0 in case of write-though cache.
     if (!is_unbound && current_downloaded_size != 0 && current_downloaded_size == range().size())
-        setDownloadedUnlocked(segment_lock);
+        setDownloadedUnlocked(lock);
     else
-        setDownloadState(State::PARTIALLY_DOWNLOADED);
+        setDownloadState(State::PARTIALLY_DOWNLOADED, lock);
 }
 
 void FileSegment::resetDownloader()
 {
-    std::unique_lock segment_lock(mutex);
+    auto lock = segment_guard.lock();
 
-    assertNotDetachedUnlocked(segment_lock);
-    assertIsDownloaderUnlocked("resetDownloader", segment_lock);
+    SCOPE_EXIT({ cv.notify_all(); });
 
-    resetDownloadingStateUnlocked(segment_lock);
-    resetDownloaderUnlocked(segment_lock);
+    assertNotDetachedUnlocked(lock);
+    assertIsDownloaderUnlocked("resetDownloader", lock);
+
+    resetDownloadingStateUnlocked(lock);
+    resetDownloaderUnlocked(lock);
 }
 
-void FileSegment::resetDownloaderUnlocked(std::unique_lock<std::mutex> & /* segment_lock */)
+void FileSegment::resetDownloaderUnlocked(const FileSegmentGuard::Lock &)
 {
     LOG_TEST(log, "Resetting downloader from {}", downloader_id);
     downloader_id.clear();
 }
 
-void FileSegment::assertIsDownloaderUnlocked(const std::string & operation, std::unique_lock<std::mutex> & segment_lock) const
+void FileSegment::assertIsDownloaderUnlocked(const std::string & operation, const FileSegmentGuard::Lock & lock) const
 {
     auto caller = getCallerId();
-    auto current_downloader = getDownloaderUnlocked(segment_lock);
+    auto current_downloader = getDownloaderUnlocked(lock);
     LOG_TEST(log, "Downloader id: {}, caller id: {}, operation: {}", current_downloader, caller, operation);
 
     if (caller != current_downloader)
@@ -244,41 +243,53 @@ void FileSegment::assertIsDownloaderUnlocked(const std::string & operation, std:
 
 bool FileSegment::isDownloader() const
 {
-    std::unique_lock segment_lock(mutex);
-    return isDownloaderUnlocked(segment_lock);
+    auto lock = segment_guard.lock();
+    return isDownloaderUnlocked(lock);
 }
 
-bool FileSegment::isDownloaderUnlocked(std::unique_lock<std::mutex> & segment_lock) const
+bool FileSegment::isDownloaderUnlocked(const FileSegmentGuard::Lock & lock) const
 {
-    return getCallerId() == getDownloaderUnlocked(segment_lock);
+    return getCallerId() == getDownloaderUnlocked(lock);
 }
 
 FileSegment::RemoteFileReaderPtr FileSegment::getRemoteFileReader()
 {
-    std::unique_lock segment_lock(mutex);
-    assertIsDownloaderUnlocked("getRemoteFileReader", segment_lock);
+    auto lock = segment_guard.lock();
+    assertIsDownloaderUnlocked("getRemoteFileReader", lock);
     return remote_file_reader;
 }
 
+void FileSegment::resetRemoteFileReader()
+{
+    auto lock = segment_guard.lock();
+    assertIsDownloaderUnlocked("resetRemoteFileReader", lock);
+    remote_file_reader.reset();
+}
+
 FileSegment::RemoteFileReaderPtr FileSegment::extractRemoteFileReader()
 {
-    std::lock_guard cache_lock(cache->mutex);
-    std::unique_lock segment_lock(mutex);
-
-    if (!is_detached)
+    auto locked_key = lockKeyMetadata(false);
+    if (!locked_key)
     {
-        bool is_last_holder = cache->isLastFileSegmentHolder(key(), offset(), cache_lock, segment_lock);
-        if (!downloader_id.empty() || !is_last_holder)
-            return nullptr;
+        assert(isDetached());
+        return std::move(remote_file_reader);
     }
 
+    auto segment_lock = segment_guard.lock();
+
+    assert(download_state != State::DETACHED);
+
+    bool is_last_holder = locked_key->isLastOwnerOfFileSegment(offset());
+    if (!downloader_id.empty() || !is_last_holder)
+        return nullptr;
+
     return std::move(remote_file_reader);
 }
 
 void FileSegment::setRemoteFileReader(RemoteFileReaderPtr remote_file_reader_)
 {
-    std::unique_lock segment_lock(mutex);
-    assertIsDownloaderUnlocked("setRemoteFileReader", segment_lock);
+    auto lock = segment_guard.lock();
+    assertIsDownloaderUnlocked("setRemoteFileReader", lock);
 
     if (remote_file_reader)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "Remote file reader already exists");
@@ -286,54 +297,30 @@ void FileSegment::setRemoteFileReader(RemoteFileReaderPtr remote_file_reader_)
     remote_file_reader = remote_file_reader_;
 }
 
-void FileSegment::resetRemoteFileReader()
-{
-    std::unique_lock segment_lock(mutex);
-    assertIsDownloaderUnlocked("resetRemoteFileReader", segment_lock);
-
-    remote_file_reader.reset();
-}
-
-std::unique_ptr<WriteBufferFromFile> FileSegment::detachWriter()
-{
-    std::unique_lock segment_lock(mutex);
-
-    if (!cache_writer)
-    {
-        if (detached_writer)
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Writer is already detached");
-
-        auto download_path = getPathInLocalCache();
-        cache_writer = std::make_unique<WriteBufferFromFile>(download_path);
-    }
-    detached_writer = true;
-    return std::move(cache_writer);
-}
-
 void FileSegment::write(const char * from, size_t size, size_t offset)
 {
     if (!size)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "Writing zero size is not allowed");
 
     {
-        std::unique_lock segment_lock(mutex);
+        auto lock = segment_guard.lock();
 
-        assertIsDownloaderUnlocked("write", segment_lock);
-        assertNotDetachedUnlocked(segment_lock);
+        assertIsDownloaderUnlocked("write", lock);
+        assertNotDetachedUnlocked(lock);
 
         if (download_state != State::DOWNLOADING)
             throw Exception(
                 ErrorCodes::LOGICAL_ERROR,
                 "Expected DOWNLOADING state, got {}", stateToString(download_state));
 
-        size_t first_non_downloaded_offset = getFirstNonDownloadedOffsetUnlocked(segment_lock);
+        size_t first_non_downloaded_offset = getFirstNonDownloadedOffset(false);
         if (offset != first_non_downloaded_offset)
             throw Exception(
                 ErrorCodes::LOGICAL_ERROR,
                 "Attempt to write {} bytes to offset: {}, but current write offset is {}",
                 size, offset, first_non_downloaded_offset);
 
-        size_t current_downloaded_size = getDownloadedSizeUnlocked(segment_lock);
+        size_t current_downloaded_size = getDownloadedSize(false);
         chassert(reserved_size >= current_downloaded_size);
         size_t free_reserved_size = reserved_size - current_downloaded_size;
 
@@ -353,25 +340,7 @@ void FileSegment::write(const char * from, size_t size, size_t offset)
                     "Cache writer was finalized (downloaded size: {}, state: {})",
                     current_downloaded_size, stateToString(download_state));
 
-            if (detached_writer)
-                throw Exception(ErrorCodes::LOGICAL_ERROR, "Cache writer was detached");
-
-            auto download_path = getPathInLocalCache();
-
-            try
-            {
-                cache_writer = std::make_unique<WriteBufferFromFile>(download_path);
-            }
-            catch (Exception & e)
-            {
-                wrapWithCacheInfo(e, "while opening file in local cache", segment_lock);
-
-                setDownloadFailedUnlocked(segment_lock);
-
-                cv.notify_all();
-
-                throw;
-            }
+            cache_writer = std::make_unique<WriteBufferFromFile>(getPathInLocalCache());
         }
     }
 
@@ -379,7 +348,7 @@ void FileSegment::write(const char * from, size_t size, size_t offset)
     {
         cache_writer->write(from, size);
 
-        std::unique_lock download_lock(download_mutex);
+        std::lock_guard lock(download_mutex);
 
         cache_writer->next();
 
@@ -389,9 +358,8 @@ void FileSegment::write(const char * from, size_t size, size_t offset)
     }
     catch (ErrnoException & e)
     {
-        std::unique_lock segment_lock(mutex);
-
-        wrapWithCacheInfo(e, "while writing into cache", segment_lock);
+        auto lock = segment_guard.lock();
+        e.addMessage(fmt::format("{}, current cache state: {}", e.what(), getInfoForLogUnlocked(lock)));
 
         int code = e.getErrno();
         if (code == /* No space left on device */28 || code == /* Quota exceeded */122)
@@ -403,37 +371,26 @@ void FileSegment::write(const char * from, size_t size, size_t offset)
                 downloaded_size = file_size;
         }
 
-        setDownloadFailedUnlocked(segment_lock);
-
-        cv.notify_all();
+        setDownloadFailedUnlocked(lock);
         throw;
 
     }
     catch (Exception & e)
     {
-        std::unique_lock segment_lock(mutex);
-
-        wrapWithCacheInfo(e, "while writing into cache", segment_lock);
-
-        setDownloadFailedUnlocked(segment_lock);
-
-        cv.notify_all();
+        auto lock = segment_guard.lock();
+        e.addMessage(fmt::format("{}, current cache state: {}", e.what(), getInfoForLogUnlocked(lock)));
+        setDownloadFailedUnlocked(lock);
         throw;
     }
 
-    chassert(getFirstNonDownloadedOffset() == offset + size);
+    chassert(getFirstNonDownloadedOffset(false) == offset + size);
 }
 
-FileSegment::State FileSegment::wait()
+FileSegment::State FileSegment::wait(size_t offset)
 {
-    std::unique_lock segment_lock(mutex);
+    auto lock = segment_guard.lock();
 
-    if (is_detached)
-        throw Exception(
-            ErrorCodes::LOGICAL_ERROR,
-            "Cache file segment is in detached state, operation not allowed");
-
-    if (downloader_id.empty())
+    if (downloader_id.empty() || offset < getCurrentWriteOffset(true))
         return download_state;
 
     if (download_state == State::EMPTY)
@@ -443,15 +400,46 @@ FileSegment::State FileSegment::wait()
     {
         LOG_TEST(log, "{} waiting on: {}, current downloader: {}", getCallerId(), range().toString(), downloader_id);
 
-        chassert(!getDownloaderUnlocked(segment_lock).empty());
-        chassert(!isDownloaderUnlocked(segment_lock));
+        chassert(!getDownloaderUnlocked(lock).empty());
+        chassert(!isDownloaderUnlocked(lock));
 
-        cv.wait_for(segment_lock, std::chrono::seconds(60));
+        [[maybe_unused]] const auto ok = cv.wait_for(lock, std::chrono::seconds(60), [&, this]()
+        {
+            return download_state != State::DOWNLOADING || offset < getCurrentWriteOffset(true);
+        });
+        /// chassert(ok);
     }
 
     return download_state;
 }
 
+KeyMetadataPtr FileSegment::getKeyMetadata() const
+{
+    auto metadata = tryGetKeyMetadata();
+    if (metadata)
+        return metadata;
+    throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot lock key, key metadata is not set ({})", stateToString(download_state));
+}
+
+KeyMetadataPtr FileSegment::tryGetKeyMetadata() const
+{
+    auto metadata = key_metadata.lock();
+    if (metadata)
+        return metadata;
+    return nullptr;
+}
+
+LockedKeyPtr FileSegment::lockKeyMetadata(bool assert_exists) const
+{
+    if (assert_exists)
+        return getKeyMetadata()->lock();
+
+    auto metadata = tryGetKeyMetadata();
+    if (!metadata)
+        return nullptr;
+    return metadata->tryLock();
+}
+
 bool FileSegment::reserve(size_t size_to_reserve)
 {
     if (!size_to_reserve)
@@ -461,13 +449,12 @@ bool FileSegment::reserve(size_t size_to_reserve)
 
     bool is_file_segment_size_exceeded;
     {
-        std::unique_lock segment_lock(mutex);
+        auto lock = segment_guard.lock();
 
+        assertNotDetachedUnlocked(lock);
+        assertIsDownloaderUnlocked("reserve", lock);
 
-        assertNotDetachedUnlocked(segment_lock);
-        assertIsDownloaderUnlocked("reserve", segment_lock);
-
-        expected_downloaded_size = getDownloadedSizeUnlocked(segment_lock);
+        expected_downloaded_size = getDownloadedSize(false);
 
         is_file_segment_size_exceeded = expected_downloaded_size + size_to_reserve > range().size();
         if (is_file_segment_size_exceeded && !is_unbound)
@@ -490,32 +477,31 @@ bool FileSegment::reserve(size_t size_to_reserve)
     size_t already_reserved_size = reserved_size - expected_downloaded_size;
 
     bool reserved = already_reserved_size >= size_to_reserve;
+    if (reserved)
+        return reserved;
+
+    size_to_reserve = size_to_reserve - already_reserved_size;
+
+    /// This (resizable file segments) is allowed only for single threaded use of file segment.
+    /// Currently it is used only for temporary files through cache.
+    if (is_unbound && is_file_segment_size_exceeded)
+        segment_range.right = range().left + expected_downloaded_size + size_to_reserve;
+
+    reserved = cache->tryReserve(*this, size_to_reserve);
+
     if (!reserved)
-    {
-        std::lock_guard cache_lock(cache->mutex);
-        std::lock_guard segment_lock(mutex);
-
-        size_to_reserve = size_to_reserve - already_reserved_size;
-
-        if (is_unbound && is_file_segment_size_exceeded)
-        {
-            segment_range.right = range().left + expected_downloaded_size + size_to_reserve;
-        }
-
-        reserved = cache->tryReserve(key(), offset(), size_to_reserve, cache_lock);
-
-        if (reserved)
-            reserved_size += size_to_reserve;
-    }
+        setDownloadFailedUnlocked(segment_guard.lock());
 
     return reserved;
 }
 
-void FileSegment::setDownloadedUnlocked([[maybe_unused]] std::unique_lock<std::mutex> & segment_lock)
+void FileSegment::setDownloadedUnlocked(const FileSegmentGuard::Lock &)
 {
-    if (is_downloaded)
+    if (download_state == State::DOWNLOADED)
         return;
 
+    download_state = State::DOWNLOADED;
+
     if (cache_writer)
     {
         cache_writer->finalize();
@@ -523,19 +509,17 @@ void FileSegment::setDownloadedUnlocked([[maybe_unused]] std::unique_lock<std::m
         remote_file_reader.reset();
     }
 
-    download_state = State::DOWNLOADED;
-    is_downloaded = true;
-
-    assert(getDownloadedSizeUnlocked(segment_lock) > 0);
-    assert(fs::file_size(getPathInLocalCache()) > 0);
+    chassert(getDownloadedSize(false) > 0);
+    chassert(fs::file_size(getPathInLocalCache()) > 0);
 }
 
-void FileSegment::setDownloadFailedUnlocked(std::unique_lock<std::mutex> & segment_lock)
+void FileSegment::setDownloadFailedUnlocked(const FileSegmentGuard::Lock & lock)
 {
-    LOG_INFO(log, "Setting download as failed: {}", getInfoForLogUnlocked(segment_lock));
+    LOG_INFO(log, "Setting download as failed: {}", getInfoForLogUnlocked(lock));
 
-    setDownloadState(State::PARTIALLY_DOWNLOADED_NO_CONTINUATION);
-    resetDownloaderUnlocked(segment_lock);
+    SCOPE_EXIT({ cv.notify_all(); });
+
+    setDownloadState(State::PARTIALLY_DOWNLOADED_NO_CONTINUATION, lock);
 
     if (cache_writer)
     {
@@ -548,80 +532,60 @@ void FileSegment::setDownloadFailedUnlocked(std::unique_lock<std::mutex> & segme
 
 void FileSegment::completePartAndResetDownloader()
 {
-    std::unique_lock segment_lock(mutex);
-    completePartAndResetDownloaderUnlocked(segment_lock);
+    auto lock = segment_guard.lock();
+
+    SCOPE_EXIT({ cv.notify_all(); });
+
+    assertNotDetachedUnlocked(lock);
+    assertIsDownloaderUnlocked("completePartAndResetDownloader", lock);
+
+    chassert(download_state == State::DOWNLOADING
+             || download_state == State::PARTIALLY_DOWNLOADED_NO_CONTINUATION);
+
+    if (download_state == State::DOWNLOADING)
+        resetDownloadingStateUnlocked(lock);
+
+    resetDownloaderUnlocked(lock);
+
+    LOG_TEST(log, "Complete batch. ({})", getInfoForLogUnlocked(lock));
 }
 
-void FileSegment::completePartAndResetDownloaderUnlocked(std::unique_lock<std::mutex> & segment_lock)
+void FileSegment::complete()
 {
-    assertNotDetachedUnlocked(segment_lock);
-    assertIsDownloaderUnlocked("completePartAndResetDownloader", segment_lock);
-
-    resetDownloadingStateUnlocked(segment_lock);
-    resetDownloaderUnlocked(segment_lock);
-
-    LOG_TEST(log, "Complete batch. ({})", getInfoForLogUnlocked(segment_lock));
-    cv.notify_all();
-}
-
-void FileSegment::completeWithState(State state)
-{
-    std::lock_guard cache_lock(cache->mutex);
-    std::unique_lock segment_lock(mutex);
-
-    assertNotDetachedUnlocked(segment_lock);
-    assertIsDownloaderUnlocked("complete", segment_lock);
-
-    if (state != State::DOWNLOADED
-        && state != State::PARTIALLY_DOWNLOADED
-        && state != State::PARTIALLY_DOWNLOADED_NO_CONTINUATION)
-    {
-        cv.notify_all();
-        throw Exception(
-            ErrorCodes::LOGICAL_ERROR,
-            "Cannot complete file segment with state: {}", stateToString(state));
-    }
-
-    setDownloadState(state);
-    completeBasedOnCurrentState(cache_lock, segment_lock);
-}
-
-void FileSegment::completeWithoutState()
-{
-    std::lock_guard cache_lock(cache->mutex);
-    completeWithoutStateUnlocked(cache_lock);
-}
-
-void FileSegment::completeWithoutStateUnlocked(std::lock_guard<std::mutex> & cache_lock)
-{
-    std::unique_lock segment_lock(mutex);
-    completeBasedOnCurrentState(cache_lock, segment_lock);
-}
-
-void FileSegment::completeBasedOnCurrentState(std::lock_guard<std::mutex> & cache_lock, std::unique_lock<std::mutex> & segment_lock)
-{
-    if (is_detached)
+    if (isCompleted())
         return;
 
-    bool is_downloader = isDownloaderUnlocked(segment_lock);
-    bool is_last_holder = cache->isLastFileSegmentHolder(key(), offset(), cache_lock, segment_lock);
-    size_t current_downloaded_size = getDownloadedSizeUnlocked(segment_lock);
+    auto locked_key = lockKeyMetadata(false);
+    if (!locked_key)
+    {
+        /// If we failed to lock a key, it must be in detached state.
+        if (isDetached())
+            return;
+
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot complete file segment: {}", getInfoForLog());
+    }
+
+    auto segment_lock = segment_guard.lock();
+
+    if (isCompleted(false))
+        return;
+
+    const bool is_downloader = isDownloaderUnlocked(segment_lock);
+    const bool is_last_holder = locked_key->isLastOwnerOfFileSegment(offset());
+    const size_t current_downloaded_size = getDownloadedSize(true);
 
     SCOPE_EXIT({
         if (is_downloader)
-        {
             cv.notify_all();
-        }
     });
 
     LOG_TEST(
-        log,
-        "Complete based on current state (is_last_holder: {}, {})",
+        log, "Complete based on current state (is_last_holder: {}, {})",
         is_last_holder, getInfoForLogUnlocked(segment_lock));
 
     if (is_downloader)
     {
-        if (download_state == State::DOWNLOADING) /// != in case of completeWithState
+        if (download_state == State::DOWNLOADING)
             resetDownloadingStateUnlocked(segment_lock);
         resetDownloaderUnlocked(segment_lock);
     }
@@ -639,25 +603,18 @@ void FileSegment::completeBasedOnCurrentState(std::lock_guard<std::mutex> & cach
     if (segment_kind == FileSegmentKind::Temporary && is_last_holder)
     {
         LOG_TEST(log, "Removing temporary file segment: {}", getInfoForLogUnlocked(segment_lock));
-        detach(cache_lock, segment_lock);
-        setDownloadState(State::SKIP_CACHE);
-        cache->remove(key(), offset(), cache_lock, segment_lock);
+        detach(segment_lock, *locked_key);
+        setDownloadState(State::DETACHED, segment_lock);
+        locked_key->removeFileSegment(offset(), segment_lock);
         return;
     }
 
     switch (download_state)
     {
-        case State::SKIP_CACHE:
-        {
-            if (is_last_holder)
-                cache->remove(key(), offset(), cache_lock, segment_lock);
-            break;
-        }
         case State::DOWNLOADED:
         {
-            chassert(getDownloadedSizeUnlocked(segment_lock) == range().size());
-            chassert(getDownloadedSizeUnlocked(segment_lock) == fs::file_size(getPathInLocalCache()));
-            chassert(is_downloaded);
+            chassert(current_downloaded_size == range().size());
+            chassert(current_downloaded_size == fs::file_size(getPathInLocalCache()));
             chassert(!cache_writer);
             break;
         }
@@ -670,74 +627,71 @@ void FileSegment::completeBasedOnCurrentState(std::lock_guard<std::mutex> & cach
         case State::PARTIALLY_DOWNLOADED:
         case State::PARTIALLY_DOWNLOADED_NO_CONTINUATION:
         {
+            chassert(current_downloaded_size != range().size());
+
             if (is_last_holder)
             {
                 if (current_downloaded_size == 0)
                 {
-                    LOG_TEST(log, "Remove cell {} (nothing downloaded)", range().toString());
-
-                    setDownloadState(State::SKIP_CACHE);
-                    cache->remove(key(), offset(), cache_lock, segment_lock);
+                    LOG_TEST(log, "Remove file segment {} (nothing downloaded)", range().toString());
+                    locked_key->removeFileSegment(offset(), segment_lock);
                 }
                 else
                 {
-                    LOG_TEST(log, "Resize cell {} to downloaded: {}", range().toString(), current_downloaded_size);
+                    LOG_TEST(log, "Resize file segment {} to downloaded: {}", range().toString(), current_downloaded_size);
 
                     /**
-                    * Only last holder of current file segment can resize the cell,
+                    * Only last holder of current file segment can resize the file segment,
                     * because there is an invariant that file segments returned to users
                     * in FileSegmentsHolder represent a contiguous range, so we can resize
                     * it only when nobody needs it.
                     */
-                    setDownloadState(State::PARTIALLY_DOWNLOADED_NO_CONTINUATION);
 
                     /// Resize this file segment by creating a copy file segment with DOWNLOADED state,
                     /// but current file segment should remain PARRTIALLY_DOWNLOADED_NO_CONTINUATION and with detached state,
                     /// because otherwise an invariant that getOrSet() returns a contiguous range of file segments will be broken
                     /// (this will be crucial for other file segment holder, not for current one).
-                    cache->reduceSizeToDownloaded(key(), offset(), cache_lock, segment_lock);
+                    locked_key->shrinkFileSegmentToDownloadedSize(offset(), segment_lock);
+
+                    /// We mark current file segment with state DETACHED, even though the data is still in cache
+                    /// (but a separate file segment) because is_last_holder is satisfied, so it does not matter.
                 }
 
-                detachAssumeStateFinalized(segment_lock);
+                setDetachedState(segment_lock);
             }
             break;
         }
+        default:
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Unexpected state while completing file segment");
     }
 
-    is_completed = true;
     LOG_TEST(log, "Completed file segment: {}", getInfoForLogUnlocked(segment_lock));
 }
 
 String FileSegment::getInfoForLog() const
 {
-    std::unique_lock segment_lock(mutex);
-    return getInfoForLogUnlocked(segment_lock);
+    auto lock = segment_guard.lock();
+    return getInfoForLogUnlocked(lock);
 }
 
-String FileSegment::getInfoForLogUnlocked(std::unique_lock<std::mutex> & segment_lock) const
+String FileSegment::getInfoForLogUnlocked(const FileSegmentGuard::Lock &) const
 {
     WriteBufferFromOwnString info;
     info << "File segment: " << range().toString() << ", ";
     info << "key: " << key().toString() << ", ";
-    info << "state: " << download_state << ", ";
-    info << "downloaded size: " << getDownloadedSizeUnlocked(segment_lock) << ", ";
-    info << "reserved size: " << reserved_size << ", ";
+    info << "state: " << download_state.load() << ", ";
+    info << "downloaded size: " << getDownloadedSize(false) << ", ";
+    info << "reserved size: " << reserved_size.load() << ", ";
     info << "downloader id: " << (downloader_id.empty() ? "None" : downloader_id) << ", ";
-    info << "current write offset: " << getCurrentWriteOffsetUnlocked(segment_lock) << ", ";
-    info << "first non-downloaded offset: " << getFirstNonDownloadedOffsetUnlocked(segment_lock) << ", ";
+    info << "current write offset: " << getCurrentWriteOffset(false) << ", ";
+    info << "first non-downloaded offset: " << getFirstNonDownloadedOffset(false) << ", ";
     info << "caller id: " << getCallerId() << ", ";
-    info << "detached: " << is_detached << ", ";
     info << "kind: " << toString(segment_kind) << ", ";
     info << "unbound: " << is_unbound;
 
     return info.str();
 }
 
-void FileSegment::wrapWithCacheInfo(Exception & e, const String & message, std::unique_lock<std::mutex> & segment_lock) const
-{
-    e.addMessage(fmt::format("{}, current cache state: {}", message, getInfoForLogUnlocked(segment_lock)));
-}
-
 String FileSegment::stateToString(FileSegment::State state)
 {
     switch (state)
@@ -752,189 +706,167 @@ String FileSegment::stateToString(FileSegment::State state)
             return "PARTIALLY DOWNLOADED";
         case FileSegment::State::PARTIALLY_DOWNLOADED_NO_CONTINUATION:
             return "PARTIALLY DOWNLOADED NO CONTINUATION";
-        case FileSegment::State::SKIP_CACHE:
-            return "SKIP_CACHE";
+        case FileSegment::State::DETACHED:
+            return "DETACHED";
     }
     UNREACHABLE();
 }
 
-void FileSegment::assertCorrectness() const
+bool FileSegment::assertCorrectness() const
 {
-    std::unique_lock segment_lock(mutex);
-    assertCorrectnessUnlocked(segment_lock);
+    return assertCorrectnessUnlocked(segment_guard.lock());
 }
 
-void FileSegment::assertCorrectnessUnlocked(std::unique_lock<std::mutex> & segment_lock) const
+bool FileSegment::assertCorrectnessUnlocked(const FileSegmentGuard::Lock &) const
 {
-    auto current_downloader = getDownloaderUnlocked(segment_lock);
-    chassert(current_downloader.empty() == (download_state != FileSegment::State::DOWNLOADING));
-    chassert(!current_downloader.empty() == (download_state == FileSegment::State::DOWNLOADING));
-    chassert(download_state != FileSegment::State::DOWNLOADED || fs::file_size(getPathInLocalCache()) > 0);
-}
+    auto check_iterator = [this](const Priority::Iterator & it)
+    {
+        UNUSED(this);
+        if (!it)
+            return;
 
-void FileSegment::throwIfDetachedUnlocked(std::unique_lock<std::mutex> & segment_lock) const
-{
-    throw Exception(
-        ErrorCodes::LOGICAL_ERROR,
-        "Cache file segment is in detached state, operation not allowed. "
-        "It can happen when cache was concurrently dropped with SYSTEM DROP FILESYSTEM CACHE FORCE. "
-        "Please, retry. File segment info: {}", getInfoForLogUnlocked(segment_lock));
+        const auto & entry = it->getEntry();
+        UNUSED(entry);
+        chassert(entry.size == reserved_size);
+        chassert(entry.key == key());
+        chassert(entry.offset == offset());
+    };
+
+    if (download_state == State::DOWNLOADED)
+    {
+        chassert(downloader_id.empty());
+        chassert(downloaded_size == reserved_size);
+        chassert(std::filesystem::file_size(getPathInLocalCache()) > 0);
+        chassert(queue_iterator);
+        check_iterator(queue_iterator);
+    }
+    else
+    {
+        if (download_state == State::DOWNLOADED)
+        {
+            chassert(!downloader_id.empty());
+        }
+        else if (download_state == State::PARTIALLY_DOWNLOADED
+                 || download_state == State::EMPTY)
+        {
+            chassert(downloader_id.empty());
+        }
+
+        chassert(reserved_size >= downloaded_size);
+        chassert((reserved_size == 0) || queue_iterator);
+        check_iterator(queue_iterator);
+    }
+
+    return true;
 }
 
 void FileSegment::assertNotDetached() const
 {
-    std::unique_lock segment_lock(mutex);
-    assertNotDetachedUnlocked(segment_lock);
+    auto lock = segment_guard.lock();
+    assertNotDetachedUnlocked(lock);
 }
 
-void FileSegment::assertNotDetachedUnlocked(std::unique_lock<std::mutex> & segment_lock) const
+void FileSegment::assertNotDetachedUnlocked(const FileSegmentGuard::Lock & lock) const
 {
-    if (is_detached)
-        throwIfDetachedUnlocked(segment_lock);
-}
-
-void FileSegment::assertDetachedStatus(std::unique_lock<std::mutex> & segment_lock) const
-{
-    /// Detached file segment is allowed to have only a certain subset of states.
-    /// It should be either EMPTY or one of the finalized states.
-
-    if (download_state != State::EMPTY && !hasFinalizedStateUnlocked(segment_lock))
+    if (download_state == State::DETACHED)
     {
         throw Exception(
             ErrorCodes::LOGICAL_ERROR,
-            "Detached file segment has incorrect state: {}",
-            getInfoForLogUnlocked(segment_lock));
+            "Cache file segment is in detached state, operation not allowed. "
+            "It can happen when cache was concurrently dropped with SYSTEM DROP FILESYSTEM CACHE FORCE. "
+            "Please, retry. File segment info: {}", getInfoForLogUnlocked(lock));
     }
 }
 
-FileSegmentPtr FileSegment::getSnapshot(const FileSegmentPtr & file_segment, std::lock_guard<std::mutex> & /* cache_lock */)
+FileSegmentPtr FileSegment::getSnapshot(const FileSegmentPtr & file_segment)
 {
-    std::unique_lock segment_lock(file_segment->mutex);
+    auto lock = file_segment->segment_guard.lock();
 
     auto snapshot = std::make_shared<FileSegment>(
+        file_segment->key(),
         file_segment->offset(),
         file_segment->range().size(),
-        file_segment->key(),
-        nullptr,
-        State::EMPTY,
-        CreateFileSegmentSettings{});
+        State::DETACHED,
+        CreateFileSegmentSettings(file_segment->getKind(), file_segment->is_unbound));
 
     snapshot->hits_count = file_segment->getHitsCount();
+    snapshot->downloaded_size = file_segment->getDownloadedSize(false);
+    snapshot->download_state = file_segment->download_state.load();
     snapshot->ref_count = file_segment.use_count();
-    snapshot->downloaded_size = file_segment->getDownloadedSizeUnlocked(segment_lock);
-    snapshot->download_state = file_segment->download_state;
-    snapshot->segment_kind = file_segment->getKind();
-    snapshot->is_unbound = file_segment->is_unbound;
 
     return snapshot;
 }
 
-bool FileSegment::hasFinalizedStateUnlocked(std::unique_lock<std::mutex> & /* segment_lock */) const
-{
-    return download_state == State::DOWNLOADED
-        || download_state == State::PARTIALLY_DOWNLOADED_NO_CONTINUATION
-        || download_state == State::SKIP_CACHE;
-}
-
 bool FileSegment::isDetached() const
 {
-    std::unique_lock segment_lock(mutex);
-    return is_detached;
+    auto lock = segment_guard.lock();
+    return download_state == State::DETACHED;
 }
 
-bool FileSegment::isCompleted() const
+bool FileSegment::isCompleted(bool sync) const
 {
-    std::unique_lock segment_lock(mutex);
-    return is_completed;
+    auto is_completed_state = [this]() -> bool
+    {
+        return download_state == State::DOWNLOADED || download_state == State::DETACHED;
+    };
+
+    if (sync)
+    {
+        if (is_completed_state())
+            return true;
+
+        auto lock = segment_guard.lock();
+        return is_completed_state();
+    }
+
+    return is_completed_state();
 }
 
-void FileSegment::detach(std::lock_guard<std::mutex> & /* cache_lock */, std::unique_lock<std::mutex> & segment_lock)
+void FileSegment::setDetachedState(const FileSegmentGuard::Lock & lock)
 {
-    if (is_detached)
+    setDownloadState(State::DETACHED, lock);
+    key_metadata.reset();
+    cache = nullptr;
+}
+
+void FileSegment::detach(const FileSegmentGuard::Lock & lock, const LockedKey &)
+{
+    if (download_state == State::DETACHED)
         return;
 
-    if (download_state == State::DOWNLOADING)
-        resetDownloadingStateUnlocked(segment_lock);
-    else
-        setDownloadState(State::PARTIALLY_DOWNLOADED_NO_CONTINUATION);
-
-    resetDownloaderUnlocked(segment_lock);
-    detachAssumeStateFinalized(segment_lock);
+    resetDownloaderUnlocked(lock);
+    setDetachedState(lock);
 }
 
-void FileSegment::detachAssumeStateFinalized(std::unique_lock<std::mutex> & segment_lock)
+void FileSegment::use()
 {
-    is_detached = true;
-    CurrentMetrics::add(CurrentMetrics::CacheDetachedFileSegments);
-    LOG_TEST(log, "Detached file segment: {}", getInfoForLogUnlocked(segment_lock));
-}
-
-FileSegment::~FileSegment()
-{
-    std::unique_lock segment_lock(mutex);
-    if (is_detached)
-        CurrentMetrics::sub(CurrentMetrics::CacheDetachedFileSegments);
-}
-
-void FileSegmentsHolder::reset()
-{
-    /// In CacheableReadBufferFromRemoteFS file segment's downloader removes file segments from
-    /// FileSegmentsHolder right after calling file_segment->complete(), so on destruction here
-    /// remain only uncompleted file segments.
-
-    SCOPE_EXIT({
-        file_segments.clear();
-    });
-
-    FileCache * cache = nullptr;
-
-    for (auto file_segment_it = file_segments.begin(); file_segment_it != file_segments.end();)
+    if (!cache)
     {
-        auto current_file_segment_it = file_segment_it;
-        auto & file_segment = *current_file_segment_it;
-
-        if (!cache)
-            cache = file_segment->cache;
-
-        assert(cache == file_segment->cache); /// all segments should belong to the same cache
-
-        try
-        {
-            bool is_detached = false;
-
-            {
-                std::unique_lock segment_lock(file_segment->mutex);
-                is_detached = file_segment->isDetached(segment_lock);
-                if (is_detached)
-                    file_segment->assertDetachedStatus(segment_lock);
-            }
-
-            if (is_detached)
-            {
-                /// This file segment is not owned by cache, so it will be destructed
-                /// at this point, therefore no completion required.
-                file_segment_it = file_segments.erase(current_file_segment_it);
-                continue;
-            }
-
-            /// File segment pointer must be reset right after calling complete() and
-            /// under the same mutex, because complete() checks for segment pointers.
-            std::lock_guard cache_lock(cache->mutex);
-
-            file_segment->completeWithoutStateUnlocked(cache_lock);
-
-            file_segment_it = file_segments.erase(current_file_segment_it);
-        }
-        catch (...)
-        {
-            tryLogCurrentException(__PRETTY_FUNCTION__);
-        }
+        chassert(isCompleted(true));
+        return;
     }
+
+    auto it = getQueueIterator();
+    if (it)
+    {
+        auto cache_lock = cache->lockCache();
+        it->use(cache_lock);
+    }
+}
+
+FileSegments::iterator FileSegmentsHolder::completeAndPopFrontImpl()
+{
+    front().complete();
+    return file_segments.erase(file_segments.begin());
 }
 
 FileSegmentsHolder::~FileSegmentsHolder()
 {
-    reset();
+    if (!complete_on_dtor)
+        return;
+
+    for (auto file_segment_it = file_segments.begin(); file_segment_it != file_segments.end();)
+        file_segment_it = completeAndPopFrontImpl();
 }
 
 String FileSegmentsHolder::toString()
@@ -945,7 +877,7 @@ String FileSegmentsHolder::toString()
         if (!ranges.empty())
             ranges += ", ";
         ranges += file_segment->range().toString();
-        if (file_segment->is_unbound)
+        if (file_segment->isUnbound())
             ranges += "(unbound)";
     }
     return ranges;
diff --git a/src/Interpreters/Cache/FileSegment.h b/src/Interpreters/Cache/FileSegment.h
index 44bc5662c40..60883631177 100644
--- a/src/Interpreters/Cache/FileSegment.h
+++ b/src/Interpreters/Cache/FileSegment.h
@@ -2,13 +2,16 @@
 
 #include <boost/noncopyable.hpp>
 #include <Interpreters/Cache/FileCacheKey.h>
+#include <Interpreters/Cache/Guards.h>
 
 #include <IO/WriteBufferFromFile.h>
 #include <IO/ReadBufferFromFileBase.h>
 #include <IO/WriteBufferFromString.h>
 #include <IO/Operators.h>
+#include <IO/OpenedFileCache.h>
 #include <base/getThreadId.h>
-#include <list>
+#include <Interpreters/Cache/IFileCachePriority.h>
+#include <Interpreters/Cache/FileCache_fwd_internal.h>
 #include <queue>
 
 
@@ -22,14 +25,8 @@ extern const Metric CacheFileSegments;
 namespace DB
 {
 
-class FileCache;
 class ReadBufferFromFileBase;
 
-class FileSegment;
-using FileSegmentPtr = std::shared_ptr<FileSegment>;
-using FileSegments = std::list<FileSegmentPtr>;
-
-
 /*
  * FileSegmentKind is used to specify the eviction policy for file segments.
  */
@@ -61,17 +58,13 @@ struct CreateFileSegmentSettings
     CreateFileSegmentSettings() = default;
 
     explicit CreateFileSegmentSettings(FileSegmentKind kind_, bool unbounded_ = false)
-        : kind(kind_), unbounded(unbounded_)
-    {}
+        : kind(kind_), unbounded(unbounded_) {}
 };
 
 class FileSegment : private boost::noncopyable, public std::enable_shared_from_this<FileSegment>
 {
-
-friend class FileCache;
-friend struct FileSegmentsHolder;
-friend class FileSegmentRangeWriter;
-friend class StorageSystemFilesystemCache;
+friend struct LockedKey;
+friend class FileCache; /// Because of reserved_size in tryReserve().
 
 public:
     using Key = FileCacheKey;
@@ -79,6 +72,7 @@ public:
     using LocalCacheWriterPtr = std::unique_ptr<WriteBufferFromFile>;
     using Downloader = std::string;
     using DownloaderId = std::string;
+    using Priority = IFileCachePriority;
 
     enum class State
     {
@@ -111,18 +105,20 @@ public:
          * If file segment cannot possibly be downloaded (first space reservation attempt failed), mark
          * this file segment as out of cache scope.
          */
-        SKIP_CACHE,
+        DETACHED,
     };
 
     FileSegment(
+        const Key & key_,
         size_t offset_,
         size_t size_,
-        const Key & key_,
-        FileCache * cache_,
         State download_state_,
-        const CreateFileSegmentSettings & create_settings);
+        const CreateFileSegmentSettings & create_settings = {},
+        FileCache * cache_ = nullptr,
+        std::weak_ptr<KeyMetadata> key_metadata_ = std::weak_ptr<KeyMetadata>(),
+        Priority::Iterator queue_iterator_ = Priority::Iterator{});
 
-    ~FileSegment();
+    ~FileSegment() = default;
 
     State state() const;
 
@@ -158,11 +154,10 @@ public:
     size_t offset() const { return range().left; }
 
     FileSegmentKind getKind() const { return segment_kind; }
-    bool isPersistent() const { return segment_kind == FileSegmentKind::Persistent; }
-    bool isUnbound() const { return is_unbound; }
 
-    using UniqueId = std::pair<FileCacheKey, size_t>;
-    UniqueId getUniqueId() const { return std::pair(key(), offset()); }
+    bool isPersistent() const { return segment_kind == FileSegmentKind::Persistent; }
+
+    bool isUnbound() const { return is_unbound; }
 
     String getPathInLocalCache() const;
 
@@ -177,7 +172,7 @@ public:
     DownloaderId getDownloader() const;
 
     /// Wait for the change of state from DOWNLOADING to any other.
-    State wait();
+    State wait(size_t offset);
 
     bool isDownloaded() const;
 
@@ -187,11 +182,13 @@ public:
 
     void incrementHitsCount() { ++hits_count; }
 
-    size_t getCurrentWriteOffset() const;
+    size_t getCurrentWriteOffset(bool sync) const;
 
-    size_t getFirstNonDownloadedOffset() const;
+    size_t getFirstNonDownloadedOffset(bool sync) const;
 
-    size_t getDownloadedSize() const;
+    size_t getDownloadedSize(bool sync) const;
+
+    size_t getReservedSize() const;
 
     /// Now detached status can be used in the following cases:
     /// 1. there is only 1 remaining file segment holder
@@ -207,15 +204,43 @@ public:
     /// 2. Detached file segment can still be hold by some cache users, but it's state became
     /// immutable at the point it was detached, any non-const / stateful method will throw an
     /// exception.
-    void detach(std::lock_guard<std::mutex> & cache_lock, std::unique_lock<std::mutex> & segment_lock);
+    void detach(const FileSegmentGuard::Lock &, const LockedKey &);
 
-    static FileSegmentPtr getSnapshot(const FileSegmentPtr & file_segment, std::lock_guard<std::mutex> & cache_lock);
+    static FileSegmentPtr getSnapshot(const FileSegmentPtr & file_segment);
 
     bool isDetached() const;
 
-    bool isCompleted() const;
+    /// File segment has a completed state, if this state is final and
+    /// is not going to be changed. Completed states: DOWNALODED, DETACHED.
+    bool isCompleted(bool sync = false) const;
 
-    void assertCorrectness() const;
+    void use();
+
+    /**
+     * ========== Methods used by `cache` ========================
+     */
+
+    FileSegmentGuard::Lock lock() const { return segment_guard.lock(); }
+
+    Priority::Iterator getQueueIterator() const;
+
+    void setQueueIterator(Priority::Iterator iterator);
+
+    KeyMetadataPtr tryGetKeyMetadata() const;
+
+    KeyMetadataPtr getKeyMetadata() const;
+
+    bool assertCorrectness() const;
+
+    /**
+     * ========== Methods that must do cv.notify() ==================
+     */
+
+    void complete();
+
+    void completePartAndResetDownloader();
+
+    void resetDownloader();
 
     /**
      * ========== Methods for _only_ file segment's `downloader` ==================
@@ -233,16 +258,6 @@ public:
     /// Write data into reserved space.
     void write(const char * from, size_t size, size_t offset);
 
-    /// Complete file segment with a certain state.
-    void completeWithState(State state);
-
-    void completeWithoutState();
-
-    /// Complete file segment's part which was last written.
-    void completePartAndResetDownloader();
-
-    void resetDownloader();
-
     // Invariant: if state() != DOWNLOADING and remote file reader is present, the reader's
     // available() == 0, and getFileOffsetOfBufferEnd() == our getCurrentWriteOffset().
     //
@@ -252,125 +267,112 @@ public:
 
     RemoteFileReaderPtr extractRemoteFileReader();
 
-    void setRemoteFileReader(RemoteFileReaderPtr remote_file_reader_);
-
     void resetRemoteFileReader();
 
+    void setRemoteFileReader(RemoteFileReaderPtr remote_file_reader_);
+
     void setDownloadedSize(size_t delta);
 
-    LocalCacheWriterPtr detachWriter();
-
 private:
-    size_t getFirstNonDownloadedOffsetUnlocked(std::unique_lock<std::mutex> & segment_lock) const;
-    size_t getCurrentWriteOffsetUnlocked(std::unique_lock<std::mutex> & segment_lock) const;
-    size_t getDownloadedSizeUnlocked(std::unique_lock<std::mutex> & segment_lock) const;
+    String getDownloaderUnlocked(const FileSegmentGuard::Lock &) const;
+    bool isDownloaderUnlocked(const FileSegmentGuard::Lock & segment_lock) const;
+    void resetDownloaderUnlocked(const FileSegmentGuard::Lock &);
 
-    String getInfoForLogUnlocked(std::unique_lock<std::mutex> & segment_lock) const;
+    void setDownloadState(State state, const FileSegmentGuard::Lock &);
+    void resetDownloadingStateUnlocked(const FileSegmentGuard::Lock &);
+    void setDetachedState(const FileSegmentGuard::Lock &);
 
-    String getDownloaderUnlocked(std::unique_lock<std::mutex> & segment_lock) const;
-    void resetDownloaderUnlocked(std::unique_lock<std::mutex> & segment_lock);
-    void resetDownloadingStateUnlocked(std::unique_lock<std::mutex> & segment_lock);
+    String getInfoForLogUnlocked(const FileSegmentGuard::Lock &) const;
 
-    void setDownloadState(State state);
+    void setDownloadedUnlocked(const FileSegmentGuard::Lock &);
+    void setDownloadFailedUnlocked(const FileSegmentGuard::Lock &);
 
-    void setDownloadedUnlocked(std::unique_lock<std::mutex> & segment_lock);
-    void setDownloadFailedUnlocked(std::unique_lock<std::mutex> & segment_lock);
-    void setDownloadedSizeUnlocked(std::unique_lock<std::mutex> & /* download_lock */, size_t delta);
-
-    bool hasFinalizedStateUnlocked(std::unique_lock<std::mutex> & segment_lock) const;
-
-    bool isDownloaderUnlocked(std::unique_lock<std::mutex> & segment_lock) const;
-
-    bool isDetached(std::unique_lock<std::mutex> & /* segment_lock */) const { return is_detached; }
-    void detachAssumeStateFinalized(std::unique_lock<std::mutex> & segment_lock);
-    [[noreturn]] void throwIfDetachedUnlocked(std::unique_lock<std::mutex> & segment_lock) const;
-
-    void assertDetachedStatus(std::unique_lock<std::mutex> & segment_lock) const;
     void assertNotDetached() const;
-    void assertNotDetachedUnlocked(std::unique_lock<std::mutex> & segment_lock) const;
-    void assertIsDownloaderUnlocked(const std::string & operation, std::unique_lock<std::mutex> & segment_lock) const;
-    void assertCorrectnessUnlocked(std::unique_lock<std::mutex> & segment_lock) const;
+    void assertNotDetachedUnlocked(const FileSegmentGuard::Lock &) const;
+    void assertIsDownloaderUnlocked(const std::string & operation, const FileSegmentGuard::Lock &) const;
+    bool assertCorrectnessUnlocked(const FileSegmentGuard::Lock &) const;
 
-    /// completeWithoutStateUnlocked() is called from destructor of FileSegmentsHolder.
-    /// Function might check if the caller of the method
-    /// is the last alive holder of the segment. Therefore, completion and destruction
-    /// of the file segment pointer must be done under the same cache mutex.
-    void completeWithoutStateUnlocked(std::lock_guard<std::mutex> & cache_lock);
-    void completeBasedOnCurrentState(std::lock_guard<std::mutex> & cache_lock, std::unique_lock<std::mutex> & segment_lock);
-
-    void completePartAndResetDownloaderUnlocked(std::unique_lock<std::mutex> & segment_lock);
-
-    void wrapWithCacheInfo(Exception & e, const String & message, std::unique_lock<std::mutex> & segment_lock) const;
+    LockedKeyPtr lockKeyMetadata(bool assert_exists = true) const;
 
+    Key file_key;
     Range segment_range;
+    const FileSegmentKind segment_kind;
+    /// Size of the segment is not known until it is downloaded and
+    /// can be bigger than max_file_segment_size.
+    const bool is_unbound = false;
 
-    State download_state;
-
-    /// The one who prepares the download
-    DownloaderId downloader_id;
+    std::atomic<State> download_state;
+    DownloaderId downloader_id; /// The one who prepares the download
 
     RemoteFileReaderPtr remote_file_reader;
     LocalCacheWriterPtr cache_writer;
-    bool detached_writer = false;
 
     /// downloaded_size should always be less or equal to reserved_size
-    size_t downloaded_size = 0;
-    size_t reserved_size = 0;
-
-    /// global locking order rule:
-    /// 1. cache lock
-    /// 2. segment lock
-
-    mutable std::mutex mutex;
-    std::condition_variable cv;
-
-    /// Protects downloaded_size access with actual write into fs.
-    /// downloaded_size is not protected by download_mutex in methods which
-    /// can never be run in parallel to FileSegment::write() method
-    /// as downloaded_size is updated only in FileSegment::write() method.
-    /// Such methods are identified by isDownloader() check at their start,
-    /// e.g. they are executed strictly by the same thread, sequentially.
+    std::atomic<size_t> downloaded_size = 0;
+    std::atomic<size_t> reserved_size = 0;
     mutable std::mutex download_mutex;
 
-    Key file_key;
+    mutable FileSegmentGuard segment_guard;
+    std::weak_ptr<KeyMetadata> key_metadata;
+    mutable Priority::Iterator queue_iterator; /// Iterator is put here on first reservation attempt, if successful.
     FileCache * cache;
+    std::condition_variable cv;
 
     Poco::Logger * log;
 
-    /// "detached" file segment means that it is not owned by cache ("detached" from cache).
-    /// In general case, all file segments are owned by cache.
-    bool is_detached = false;
-    bool is_completed = false;
-
-    bool is_downloaded = false;
-
     std::atomic<size_t> hits_count = 0; /// cache hits.
     std::atomic<size_t> ref_count = 0; /// Used for getting snapshot state
 
-    FileSegmentKind segment_kind;
-
-    /// Size of the segment is not known until it is downloaded and can be bigger than max_file_segment_size.
-    bool is_unbound = false;
-
     CurrentMetrics::Increment metric_increment{CurrentMetrics::CacheFileSegments};
 };
 
+
 struct FileSegmentsHolder : private boost::noncopyable
 {
     FileSegmentsHolder() = default;
 
-    explicit FileSegmentsHolder(FileSegments && file_segments_) : file_segments(std::move(file_segments_)) {}
-
-    FileSegmentsHolder(FileSegmentsHolder && other) noexcept : file_segments(std::move(other.file_segments)) {}
-
-    void reset();
-    bool empty() const { return file_segments.empty(); }
+    explicit FileSegmentsHolder(FileSegments && file_segments_, bool complete_on_dtor_ = true)
+        : file_segments(std::move(file_segments_)), complete_on_dtor(complete_on_dtor_) {}
 
     ~FileSegmentsHolder();
 
+    bool empty() const { return file_segments.empty(); }
+
+    size_t size() const { return file_segments.size(); }
+
     String toString();
 
+    void popFront() { completeAndPopFrontImpl(); }
+
+    FileSegment & front() { return *file_segments.front(); }
+
+    FileSegment & back() { return *file_segments.back(); }
+
+    FileSegment & add(FileSegmentPtr && file_segment)
+    {
+        file_segments.push_back(file_segment);
+        return *file_segments.back();
+    }
+
+    FileSegments::iterator begin() { return file_segments.begin(); }
+    FileSegments::iterator end() { return file_segments.end(); }
+
+    FileSegments::const_iterator begin() const { return file_segments.begin(); }
+    FileSegments::const_iterator end() const { return file_segments.end(); }
+
+    void moveTo(FileSegmentsHolder & holder)
+    {
+        holder.file_segments.insert(holder.file_segments.end(), file_segments.begin(), file_segments.end());
+        file_segments.clear();
+    }
+
+private:
     FileSegments file_segments{};
+    const bool complete_on_dtor = true;
+
+    FileSegments::iterator completeAndPopFrontImpl();
 };
 
+using FileSegmentsHolderPtr = std::unique_ptr<FileSegmentsHolder>;
+
 }
diff --git a/src/Interpreters/Cache/Guards.h b/src/Interpreters/Cache/Guards.h
new file mode 100644
index 00000000000..0e06495bd82
--- /dev/null
+++ b/src/Interpreters/Cache/Guards.h
@@ -0,0 +1,117 @@
+#pragma once
+#include <mutex>
+#include <Interpreters/Cache/FileCache_fwd.h>
+#include <boost/noncopyable.hpp>
+#include <map>
+
+namespace DB
+{
+/**
+ * FileCache::get/getOrSet/set
+ * 1. CacheMetadataGuard::Lock (take key lock and release metadata lock)
+ * 2. KeyGuard::Lock (hold till the end of the method)
+ *
+ * FileCache::tryReserve
+ * 1. CacheGuard::Lock
+ * 2. KeyGuard::Lock (taken without metadata lock)
+ * 3. any number of KeyGuard::Lock's for files which are going to be evicted (taken via metadata lock)
+ *
+ * FileCache::removeIfExists
+ * 1. CacheGuard::Lock
+ * 2. KeyGuard::Lock (taken via metadata lock)
+ * 3. FileSegmentGuard::Lock
+ *
+ * FileCache::removeAllReleasable
+ * 1. CacheGuard::Lock
+ * 2. any number of KeyGuard::Lock's locks (takken via metadata lock), but at a moment of time only one key lock can be hold
+ * 3. FileSegmentGuard::Lock
+ *
+ * FileCache::getSnapshot (for all cache)
+ * 1. metadata lock
+ * 2. any number of KeyGuard::Lock's locks (takken via metadata lock), but at a moment of time only one key lock can be hold
+ * 3. FileSegmentGuard::Lock
+ *
+ * FileCache::getSnapshot(key)
+ * 1. KeyGuard::Lock (taken via metadata lock)
+ * 2. FileSegmentGuard::Lock
+ *
+ * FileSegment::complete
+ * 1. CacheGuard::Lock
+ * 2. KeyGuard::Lock (taken without metadata lock)
+ * 3. FileSegmentGuard::Lock
+ *
+ * Rules:
+ * 1. Priority of locking: CacheGuard::Lock > CacheMetadataGuard::Lock > KeyGuard::Lock > FileSegmentGuard::Lock
+ * 2. If we take more than one key lock at a moment of time, we need to take CacheGuard::Lock (example: tryReserve())
+ *
+ *
+ *                                 _CacheGuard_
+ *                                 1. FileCache::tryReserve
+ *                                 2. FileCache::removeIfExists(key)
+ *                                 3. FileCache::removeAllReleasable
+ *                                 4. FileSegment::complete
+ *
+ *             _KeyGuard_                                      _CacheMetadataGuard_
+ *             1. all from CacheGuard                          1. getOrSet/get/set
+ *             2. getOrSet/get/Set
+ *
+ * *This table does not include locks taken for introspection and system tables.
+ */
+
+/**
+ * Cache priority queue guard.
+ */
+struct CacheGuard : private boost::noncopyable
+{
+    struct Lock : public std::unique_lock<std::mutex>
+    {
+        explicit Lock(std::mutex & mutex_) : std::unique_lock<std::mutex>(mutex_) {}
+    };
+
+    Lock lock() { return Lock(mutex); }
+    std::mutex mutex;
+};
+
+/**
+ * Guard for cache metadata.
+ */
+struct CacheMetadataGuard : private boost::noncopyable
+{
+    struct Lock : public std::unique_lock<std::mutex>
+    {
+        explicit Lock(std::mutex & mutex_) : std::unique_lock<std::mutex>(mutex_) {}
+    };
+
+    Lock lock() { return Lock(mutex); }
+    std::mutex mutex;
+};
+
+/**
+ * Key guard. A separate guard for each cache key.
+ */
+struct KeyGuard : private boost::noncopyable
+{
+    struct Lock : public std::unique_lock<std::mutex>
+    {
+        explicit Lock(std::mutex & mutex_) : std::unique_lock<std::mutex>(mutex_) {}
+    };
+
+    Lock lock() { return Lock(mutex); }
+    std::mutex mutex;
+};
+
+/**
+ * Guard for a file segment.
+ */
+struct FileSegmentGuard : private boost::noncopyable
+{
+    struct Lock : public std::unique_lock<std::mutex>
+    {
+        explicit Lock(std::mutex & mutex_) : std::unique_lock<std::mutex>(mutex_) {}
+    };
+
+    Lock lock() { return Lock(mutex); }
+    std::mutex mutex;
+};
+
+}
diff --git a/src/Interpreters/Cache/IFileCachePriority.h b/src/Interpreters/Cache/IFileCachePriority.h
index af73fadebbf..4d5f67cc10c 100644
--- a/src/Interpreters/Cache/IFileCachePriority.h
+++ b/src/Interpreters/Cache/IFileCachePriority.h
@@ -5,33 +5,35 @@
 #include <Core/Types.h>
 #include <Common/Exception.h>
 #include <Interpreters/Cache/FileCacheKey.h>
+#include <Interpreters/Cache/Guards.h>
+#include <Interpreters/Cache/FileCache_fwd_internal.h>
 
 namespace DB
 {
 
-class IFileCachePriority;
-using FileCachePriorityPtr = std::shared_ptr<IFileCachePriority>;
-
 /// IFileCachePriority is used to maintain the priority of cached data.
-class IFileCachePriority
+class IFileCachePriority : private boost::noncopyable
 {
 public:
-    class IIterator;
     using Key = FileCacheKey;
-    using ReadIterator = std::unique_ptr<const IIterator>;
-    using WriteIterator = std::shared_ptr<IIterator>;
+    using KeyAndOffset = FileCacheKeyAndOffset;
 
-    struct FileCacheRecord
+    struct Entry
     {
-        Key key;
-        size_t offset;
-        size_t size;
-        size_t hits = 0;
+        Entry(const Key & key_, size_t offset_, size_t size_, KeyMetadataPtr key_metadata_)
+            : key(key_), offset(offset_), size(size_), key_metadata(key_metadata_) {}
 
-        FileCacheRecord(const Key & key_, size_t offset_, size_t size_) : key(key_), offset(offset_), size(size_) { }
+        Entry(const Entry & other)
+            : key(other.key), offset(other.offset), size(other.size.load()), hits(other.hits), key_metadata(other.key_metadata) {}
+
+        const Key key;
+        const size_t offset;
+        std::atomic<size_t> size;
+        size_t hits = 0;
+        const KeyMetadataPtr key_metadata;
     };
 
-    /// It provides an iterator to traverse the cache priority. Under normal circumstances,
+    /// Provides an iterator to traverse the cache priority. Under normal circumstances,
     /// the iterator can only return the records that have been directly swapped out.
     /// For example, in the LRU algorithm, it can traverse all records, but in the LRU-K, it
     /// can only traverse the records in the low priority queue.
@@ -40,56 +42,54 @@ public:
     public:
         virtual ~IIterator() = default;
 
-        virtual const Key & key() const = 0;
+        virtual size_t use(const CacheGuard::Lock &) = 0;
 
-        virtual size_t offset() const = 0;
+        virtual std::shared_ptr<IIterator> remove(const CacheGuard::Lock &) = 0;
 
-        virtual size_t size() const = 0;
+        virtual const Entry & getEntry() const = 0;
 
-        virtual size_t hits() const = 0;
+        virtual Entry & getEntry() = 0;
 
-        /// Point the iterator to the next higher priority cache record.
-        virtual void next() const = 0;
+        virtual void annul() = 0;
 
-        virtual bool valid() const = 0;
-
-        /// Mark a cache record as recently used, it will update the priority
-        /// of the cache record according to different cache algorithms.
-        virtual void use(std::lock_guard<std::mutex> &) = 0;
-
-        /// Deletes an existing cached record. And to avoid pointer suspension
-        /// the iterator should automatically point to the next record.
-        virtual void removeAndGetNext(std::lock_guard<std::mutex> &) = 0;
-
-        virtual void updateSize(ssize_t, std::lock_guard<std::mutex> &) = 0;
+        virtual void updateSize(int64_t size) = 0;
     };
 
-public:
+    using Iterator = std::shared_ptr<IIterator>;
+    using ConstIterator = std::shared_ptr<const IIterator>;
+
+    enum class IterationResult
+    {
+        BREAK,
+        CONTINUE,
+        REMOVE_AND_CONTINUE,
+    };
+    using IterateFunc = std::function<IterationResult(LockedKey &, FileSegmentMetadataPtr)>;
+
+    IFileCachePriority(size_t max_size_, size_t max_elements_) : max_size(max_size_), max_elements(max_elements_) {}
+
     virtual ~IFileCachePriority() = default;
 
-    /// Add a cache record that did not exist before, and throw a
-    /// logical exception if the cache block already exists.
-    virtual WriteIterator add(const Key & key, size_t offset, size_t size, std::lock_guard<std::mutex> & cache_lock) = 0;
+    size_t getElementsLimit() const { return max_elements; }
 
-    /// This method is used for assertions in debug mode. So we do not care about complexity here.
-    /// Query whether a cache record exists. If it exists, return true. If not, return false.
-    virtual bool contains(const Key & key, size_t offset, std::lock_guard<std::mutex> & cache_lock) = 0;
+    size_t getSizeLimit() const { return max_size; }
 
-    virtual void removeAll(std::lock_guard<std::mutex> & cache_lock) = 0;
+    virtual size_t getSize(const CacheGuard::Lock &) const = 0;
 
-    /// Returns an iterator pointing to the lowest priority cached record.
-    /// We can traverse all cached records through the iterator's next().
-    virtual ReadIterator getLowestPriorityReadIterator(std::lock_guard<std::mutex> & cache_lock) = 0;
+    virtual size_t getElementsCount(const CacheGuard::Lock &) const = 0;
 
-    /// The same as getLowestPriorityReadIterator(), but it is writeable.
-    virtual WriteIterator getLowestPriorityWriteIterator(std::lock_guard<std::mutex> & cache_lock) = 0;
+    virtual Iterator add(
+        KeyMetadataPtr key_metadata, size_t offset, size_t size, const CacheGuard::Lock &) = 0;
 
-    virtual size_t getElementsNum(std::lock_guard<std::mutex> & cache_lock) const = 0;
+    virtual void pop(const CacheGuard::Lock &) = 0;
 
-    size_t getCacheSize(std::lock_guard<std::mutex> &) const { return cache_size; }
+    virtual void removeAll(const CacheGuard::Lock &) = 0;
 
-protected:
-    size_t max_cache_size = 0;
-    size_t cache_size = 0;
+    virtual void iterate(IterateFunc && func, const CacheGuard::Lock &) = 0;
+
+private:
+    const size_t max_size = 0;
+    const size_t max_elements = 0;
 };
+
 };
diff --git a/src/Interpreters/Cache/LRUFileCachePriority.cpp b/src/Interpreters/Cache/LRUFileCachePriority.cpp
index 5623b8443f7..f1798cd626c 100644
--- a/src/Interpreters/Cache/LRUFileCachePriority.cpp
+++ b/src/Interpreters/Cache/LRUFileCachePriority.cpp
@@ -1,5 +1,7 @@
 #include <Interpreters/Cache/LRUFileCachePriority.h>
+#include <Interpreters/Cache/FileCache.h>
 #include <Common/CurrentMetrics.h>
+#include <Common/randomSeed.h>
 #include <Common/logger_useful.h>
 
 namespace CurrentMetrics
@@ -16,8 +18,13 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
-IFileCachePriority::WriteIterator LRUFileCachePriority::add(const Key & key, size_t offset, size_t size, std::lock_guard<std::mutex> &)
+IFileCachePriority::Iterator LRUFileCachePriority::add(
+    KeyMetadataPtr key_metadata,
+    size_t offset,
+    size_t size,
+    const CacheGuard::Lock &)
 {
+    const auto & key = key_metadata->key;
 #ifndef NDEBUG
     for (const auto & entry : queue)
     {
@@ -25,40 +32,56 @@ IFileCachePriority::WriteIterator LRUFileCachePriority::add(const Key & key, siz
             throw Exception(
                 ErrorCodes::LOGICAL_ERROR,
                 "Attempt to add duplicate queue entry to queue. (Key: {}, offset: {}, size: {})",
-                entry.key.toString(), entry.offset, entry.size);
+                entry.key, entry.offset, entry.size);
     }
 #endif
 
-    auto iter = queue.insert(queue.end(), FileCacheRecord(key, offset, size));
-    cache_size += size;
+    const auto & size_limit = getSizeLimit();
+    if (size_limit && current_size + size > size_limit)
+    {
+        throw Exception(
+            ErrorCodes::LOGICAL_ERROR,
+            "Not enough space to add {}:{} with size {}: current size: {}/{}",
+            key, offset, size, current_size, getSizeLimit());
+    }
+
+    current_size += size;
+
+    auto iter = queue.insert(queue.end(), Entry(key, offset, size, key_metadata));
 
     CurrentMetrics::add(CurrentMetrics::FilesystemCacheSize, size);
     CurrentMetrics::add(CurrentMetrics::FilesystemCacheElements);
 
-    LOG_TEST(log, "Added entry into LRU queue, key: {}, offset: {}", key.toString(), offset);
+    LOG_TEST(log, "Added entry into LRU queue, key: {}, offset: {}", key, offset);
 
     return std::make_shared<LRUFileCacheIterator>(this, iter);
 }
 
-bool LRUFileCachePriority::contains(const Key & key, size_t offset, std::lock_guard<std::mutex> &)
+void LRUFileCachePriority::removeAll(const CacheGuard::Lock &)
 {
-    for (const auto & record : queue)
-    {
-        if (key == record.key && offset == record.offset)
-            return true;
-    }
-    return false;
-}
-
-void LRUFileCachePriority::removeAll(std::lock_guard<std::mutex> &)
-{
-    CurrentMetrics::sub(CurrentMetrics::FilesystemCacheSize, cache_size);
+    CurrentMetrics::sub(CurrentMetrics::FilesystemCacheSize, current_size);
     CurrentMetrics::sub(CurrentMetrics::FilesystemCacheElements, queue.size());
 
     LOG_TEST(log, "Removed all entries from LRU queue");
 
     queue.clear();
-    cache_size = 0;
+    current_size = 0;
+}
+
+void LRUFileCachePriority::pop(const CacheGuard::Lock &)
+{
+    remove(queue.begin());
+}
+
+LRUFileCachePriority::LRUQueueIterator LRUFileCachePriority::remove(LRUQueueIterator it)
+{
+    current_size -= it->size;
+
+    CurrentMetrics::sub(CurrentMetrics::FilesystemCacheSize, it->size);
+    CurrentMetrics::sub(CurrentMetrics::FilesystemCacheElements);
+
+    LOG_TEST(log, "Removed entry from LRU queue, key: {}, offset: {}", it->key, it->offset);
+    return queue.erase(it);
 }
 
 LRUFileCachePriority::LRUFileCacheIterator::LRUFileCacheIterator(
@@ -67,36 +90,67 @@ LRUFileCachePriority::LRUFileCacheIterator::LRUFileCacheIterator(
 {
 }
 
-IFileCachePriority::ReadIterator LRUFileCachePriority::getLowestPriorityReadIterator(std::lock_guard<std::mutex> &)
+void LRUFileCachePriority::iterate(IterateFunc && func, const CacheGuard::Lock &)
 {
-    return std::make_unique<const LRUFileCacheIterator>(this, queue.begin());
+    for (auto it = queue.begin(); it != queue.end();)
+    {
+        auto locked_key = it->key_metadata->tryLock();
+        if (!locked_key || it->size == 0)
+        {
+            it = remove(it);
+            continue;
+        }
+
+        auto metadata = locked_key->tryGetByOffset(it->offset);
+        if (!metadata)
+        {
+            it = remove(it);
+            continue;
+        }
+
+        if (metadata->size() != it->size)
+        {
+            throw Exception(
+                ErrorCodes::LOGICAL_ERROR,
+                "Mismatch of file segment size in file segment metadata and priority queue: {} != {} ({})",
+                it->size, metadata->size(), metadata->file_segment->getInfoForLog());
+        }
+
+        auto result = func(*locked_key, metadata);
+        switch (result)
+        {
+            case IterationResult::BREAK:
+            {
+                return;
+            }
+            case IterationResult::CONTINUE:
+            {
+                ++it;
+                break;
+            }
+            case IterationResult::REMOVE_AND_CONTINUE:
+            {
+                it = remove(it);
+                break;
+            }
+        }
+    }
 }
 
-IFileCachePriority::WriteIterator LRUFileCachePriority::getLowestPriorityWriteIterator(std::lock_guard<std::mutex> &)
+LRUFileCachePriority::Iterator LRUFileCachePriority::LRUFileCacheIterator::remove(const CacheGuard::Lock &)
 {
-    return std::make_shared<LRUFileCacheIterator>(this, queue.begin());
+    return std::make_shared<LRUFileCacheIterator>(cache_priority, cache_priority->remove(queue_iter));
 }
 
-size_t LRUFileCachePriority::getElementsNum(std::lock_guard<std::mutex> &) const
+void LRUFileCachePriority::LRUFileCacheIterator::annul()
 {
-    return queue.size();
+    cache_priority->current_size -= queue_iter->size;
+    queue_iter->size = 0;
 }
 
-void LRUFileCachePriority::LRUFileCacheIterator::removeAndGetNext(std::lock_guard<std::mutex> &)
+void LRUFileCachePriority::LRUFileCacheIterator::updateSize(int64_t size)
 {
-    cache_priority->cache_size -= queue_iter->size;
-
-    CurrentMetrics::sub(CurrentMetrics::FilesystemCacheSize, queue_iter->size);
-    CurrentMetrics::sub(CurrentMetrics::FilesystemCacheElements);
-
-    LOG_TEST(cache_priority->log, "Removed entry from LRU queue, key: {}, offset: {}", queue_iter->key.toString(), queue_iter->offset);
-
-    queue_iter = cache_priority->queue.erase(queue_iter);
-}
-
-void LRUFileCachePriority::LRUFileCacheIterator::updateSize(ssize_t size, std::lock_guard<std::mutex> &)
-{
-    cache_priority->cache_size += size;
+    cache_priority->current_size += size;
 
     if (size > 0)
         CurrentMetrics::add(CurrentMetrics::FilesystemCacheSize, size);
@@ -105,14 +159,14 @@ void LRUFileCachePriority::LRUFileCacheIterator::updateSize(ssize_t size, std::l
 
     queue_iter->size += size;
 
-    chassert(queue_iter->size > 0);
-    chassert(cache_priority->cache_size >= 0);
+    chassert(cache_priority->current_size >= 0);
+    chassert(queue_iter->size >= 0);
 }
 
-void LRUFileCachePriority::LRUFileCacheIterator::use(std::lock_guard<std::mutex> &)
+size_t LRUFileCachePriority::LRUFileCacheIterator::use(const CacheGuard::Lock &)
 {
-    queue_iter->hits++;
     cache_priority->queue.splice(cache_priority->queue.end(), cache_priority->queue, queue_iter);
+    return ++queue_iter->hits;
 }
 
 };
diff --git a/src/Interpreters/Cache/LRUFileCachePriority.h b/src/Interpreters/Cache/LRUFileCachePriority.h
index 949e83c2a28..0cb81109fcd 100644
--- a/src/Interpreters/Cache/LRUFileCachePriority.h
+++ b/src/Interpreters/Cache/LRUFileCachePriority.h
@@ -2,6 +2,8 @@
 
 #include <list>
 #include <Interpreters/Cache/IFileCachePriority.h>
+#include <Interpreters/Cache/FileCacheKey.h>
+#include <Common/logger_useful.h>
 
 namespace DB
 {
@@ -12,51 +14,51 @@ class LRUFileCachePriority : public IFileCachePriority
 {
 private:
     class LRUFileCacheIterator;
-    using LRUQueue = std::list<FileCacheRecord>;
+    using LRUQueue = std::list<Entry>;
     using LRUQueueIterator = typename LRUQueue::iterator;
 
 public:
-    LRUFileCachePriority() = default;
+    LRUFileCachePriority(size_t max_size_, size_t max_elements_) : IFileCachePriority(max_size_, max_elements_) {}
 
-    WriteIterator add(const Key & key, size_t offset, size_t size, std::lock_guard<std::mutex> &) override;
+    size_t getSize(const CacheGuard::Lock &) const override { return current_size; }
 
-    bool contains(const Key & key, size_t offset, std::lock_guard<std::mutex> &) override;
+    size_t getElementsCount(const CacheGuard::Lock &) const override { return queue.size(); }
 
-    void removeAll(std::lock_guard<std::mutex> &) override;
+    Iterator add(KeyMetadataPtr key_metadata, size_t offset, size_t size, const CacheGuard::Lock &) override;
 
-    ReadIterator getLowestPriorityReadIterator(std::lock_guard<std::mutex> &) override;
+    void pop(const CacheGuard::Lock &) override;
 
-    WriteIterator getLowestPriorityWriteIterator(std::lock_guard<std::mutex> &) override;
+    void removeAll(const CacheGuard::Lock &) override;
 
-    size_t getElementsNum(std::lock_guard<std::mutex> &) const override;
+    void iterate(IterateFunc && func, const CacheGuard::Lock &) override;
 
 private:
     LRUQueue queue;
     Poco::Logger * log = &Poco::Logger::get("LRUFileCachePriority");
+
+    std::atomic<size_t> current_size = 0;
+
+    LRUQueueIterator remove(LRUQueueIterator it);
 };
 
 class LRUFileCachePriority::LRUFileCacheIterator : public IFileCachePriority::IIterator
 {
 public:
-    LRUFileCacheIterator(LRUFileCachePriority * cache_priority_, LRUFileCachePriority::LRUQueueIterator queue_iter_);
+    LRUFileCacheIterator(
+        LRUFileCachePriority * cache_priority_,
+        LRUFileCachePriority::LRUQueueIterator queue_iter_);
 
-    void next() const override { queue_iter++; }
+    const Entry & getEntry() const override { return *queue_iter; }
 
-    bool valid() const override { return queue_iter != cache_priority->queue.end(); }
+    Entry & getEntry() override { return *queue_iter; }
 
-    const Key & key() const override { return queue_iter->key; }
+    size_t use(const CacheGuard::Lock &) override;
 
-    size_t offset() const override { return queue_iter->offset; }
+    Iterator remove(const CacheGuard::Lock &) override;
 
-    size_t size() const override { return queue_iter->size; }
+    void annul() override;
 
-    size_t hits() const override { return queue_iter->hits; }
-
-    void removeAndGetNext(std::lock_guard<std::mutex> &) override;
-
-    void updateSize(ssize_t size, std::lock_guard<std::mutex> &) override;
-
-    void use(std::lock_guard<std::mutex> &) override;
+    void updateSize(int64_t size) override;
 
 private:
     LRUFileCachePriority * cache_priority;
diff --git a/src/Interpreters/Cache/Metadata.cpp b/src/Interpreters/Cache/Metadata.cpp
new file mode 100644
index 00000000000..ac16d0ef9da
--- /dev/null
+++ b/src/Interpreters/Cache/Metadata.cpp
@@ -0,0 +1,468 @@
+#include <Interpreters/Cache/Metadata.h>
+#include <Interpreters/Cache/FileCache.h>
+#include <Interpreters/Cache/FileSegment.h>
+#include <Common/logger_useful.h>
+#include <filesystem>
+
+namespace fs = std::filesystem;
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+FileSegmentMetadata::FileSegmentMetadata(FileSegmentPtr && file_segment_)
+    : file_segment(std::move(file_segment_))
+{
+    switch (file_segment->state())
+    {
+        case FileSegment::State::DOWNLOADED:
+        {
+            chassert(file_segment->getQueueIterator());
+            break;
+        }
+        case FileSegment::State::EMPTY:
+        case FileSegment::State::DOWNLOADING:
+        {
+            break;
+        }
+        default:
+            throw Exception(
+                ErrorCodes::LOGICAL_ERROR,
+                "Can create file segment with either EMPTY, DOWNLOADED, DOWNLOADING state, got: {}",
+                FileSegment::stateToString(file_segment->state()));
+    }
+}
+
+size_t FileSegmentMetadata::size() const
+{
+    return file_segment->getReservedSize();
+}
+
+KeyMetadata::KeyMetadata(
+    const Key & key_,
+    const std::string & key_path_,
+    CleanupQueue & cleanup_queue_,
+    bool created_base_directory_)
+    : key(key_)
+    , key_path(key_path_)
+    , cleanup_queue(cleanup_queue_)
+    , created_base_directory(created_base_directory_)
+{
+    if (created_base_directory)
+        chassert(fs::exists(key_path));
+}
+
+LockedKeyPtr KeyMetadata::lock()
+{
+    auto locked = tryLock();
+    if (locked)
+        return locked;
+
+    throw Exception(
+        ErrorCodes::LOGICAL_ERROR,
+        "Cannot lock key {} (state: {})", key, magic_enum::enum_name(key_state));
+}
+
+LockedKeyPtr KeyMetadata::tryLock()
+{
+    auto locked = std::make_unique<LockedKey>(shared_from_this());
+    if (key_state == KeyMetadata::KeyState::ACTIVE)
+        return locked;
+
+    return nullptr;
+}
+
+bool KeyMetadata::createBaseDirectory()
+{
+    if (!created_base_directory.exchange(true))
+    {
+        try
+        {
+            fs::create_directories(key_path);
+        }
+        catch (...)
+        {
+            /// Avoid errors like
+            /// std::__1::__fs::filesystem::filesystem_error: filesystem error: in create_directories: No space left on device
+            /// and mark file segment with SKIP_CACHE state
+            tryLogCurrentException(__PRETTY_FUNCTION__);
+            created_base_directory = false;
+            return false;
+        }
+    }
+    return true;
+}
+
+std::string KeyMetadata::getFileSegmentPath(const FileSegment & file_segment)
+{
+    return fs::path(key_path)
+        / CacheMetadata::getFileNameForFileSegment(file_segment.offset(), file_segment.getKind());
+}
+
+
+class CleanupQueue
+{
+    friend struct CacheMetadata;
+public:
+    void add(const FileCacheKey & key);
+    void remove(const FileCacheKey & key);
+    size_t getSize() const;
+
+private:
+    bool tryPop(FileCacheKey & key);
+
+    std::unordered_set<FileCacheKey> keys;
+    mutable std::mutex mutex;
+};
+
+
+CacheMetadata::CacheMetadata(const std::string & path_)
+    : path(path_)
+    , cleanup_queue(std::make_unique<CleanupQueue>())
+    , log(&Poco::Logger::get("CacheMetadata"))
+{
+}
+
+String CacheMetadata::getFileNameForFileSegment(size_t offset, FileSegmentKind segment_kind)
+{
+    String file_suffix;
+    switch (segment_kind)
+    {
+        case FileSegmentKind::Persistent:
+            file_suffix = "_persistent";
+            break;
+        case FileSegmentKind::Temporary:
+            file_suffix = "_temporary";
+            break;
+        case FileSegmentKind::Regular:
+            file_suffix = "";
+            break;
+    }
+    return std::to_string(offset) + file_suffix;
+}
+
+String CacheMetadata::getPathInLocalCache(const Key & key, size_t offset, FileSegmentKind segment_kind) const
+{
+    String file_suffix;
+
+    const auto key_str = key.toString();
+    return fs::path(path) / key_str.substr(0, 3) / key_str / getFileNameForFileSegment(offset, segment_kind);
+}
+
+String CacheMetadata::getPathInLocalCache(const Key & key) const
+{
+    const auto key_str = key.toString();
+    return fs::path(path) / key_str.substr(0, 3) / key_str;
+}
+
+LockedKeyPtr CacheMetadata::lockKeyMetadata(
+    const FileCacheKey & key,
+    KeyNotFoundPolicy key_not_found_policy,
+    bool is_initial_load)
+{
+    KeyMetadataPtr key_metadata;
+    {
+        auto lock = guard.lock();
+
+        auto it = find(key);
+        if (it == end())
+        {
+            if (key_not_found_policy == KeyNotFoundPolicy::THROW)
+                throw Exception(ErrorCodes::LOGICAL_ERROR, "No such key `{}` in cache", key);
+            else if (key_not_found_policy == KeyNotFoundPolicy::RETURN_NULL)
+                return nullptr;
+
+            it = emplace(
+                key, std::make_shared<KeyMetadata>(
+                    key, getPathInLocalCache(key), *cleanup_queue, is_initial_load)).first;
+        }
+
+        key_metadata = it->second;
+    }
+
+    {
+        auto locked_metadata = std::make_unique<LockedKey>(key_metadata);
+        const auto key_state = locked_metadata->getKeyState();
+
+        if (key_state == KeyMetadata::KeyState::ACTIVE)
+            return locked_metadata;
+
+        if (key_not_found_policy == KeyNotFoundPolicy::THROW)
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "No such key `{}` in cache", key);
+
+        if (key_not_found_policy == KeyNotFoundPolicy::RETURN_NULL)
+            return nullptr;
+
+        if (key_state == KeyMetadata::KeyState::REMOVING)
+        {
+            locked_metadata->removeFromCleanupQueue();
+            return locked_metadata;
+        }
+
+        chassert(key_state == KeyMetadata::KeyState::REMOVED);
+        chassert(key_not_found_policy == KeyNotFoundPolicy::CREATE_EMPTY);
+    }
+
+    /// Not we are at a case:
+    /// key_state == KeyMetadata::KeyState::REMOVED
+    /// and KeyNotFoundPolicy == CREATE_EMPTY
+    /// Retry.
+    return lockKeyMetadata(key, key_not_found_policy);
+}
+
+void CacheMetadata::iterate(IterateCacheMetadataFunc && func)
+{
+    auto lock = guard.lock();
+    for (const auto & [key, key_metadata] : *this)
+    {
+        auto locked_key = std::make_unique<LockedKey>(key_metadata);
+        const auto key_state = locked_key->getKeyState();
+
+        if (key_state == KeyMetadata::KeyState::ACTIVE)
+        {
+            func(*locked_key);
+            continue;
+        }
+
+        if (key_state == KeyMetadata::KeyState::REMOVING)
+            continue;
+
+        throw Exception(
+            ErrorCodes::LOGICAL_ERROR, "Cannot lock key {}: key does not exist", key_metadata->key);
+    }
+}
+
+void CacheMetadata::doCleanup()
+{
+    auto lock = guard.lock();
+
+    /// Let's mention this case.
+    /// This metadata cleanup is delayed so what is we marked key as deleted and
+    /// put it to deletion queue, but then the same key was added to cache before
+    /// we actually performed this delayed removal?
+    /// In this case it will work fine because on each attempt to add any key to cache
+    /// we perform this delayed removal.
+
+    FileCacheKey cleanup_key;
+    while (cleanup_queue->tryPop(cleanup_key))
+    {
+        auto it = find(cleanup_key);
+        if (it == end())
+            continue;
+
+        auto locked_metadata = std::make_unique<LockedKey>(it->second);
+        const auto key_state = locked_metadata->getKeyState();
+
+        if (key_state == KeyMetadata::KeyState::ACTIVE)
+        {
+            /// Key was added back to cache after we submitted it to removal queue.
+            continue;
+        }
+
+        locked_metadata->markAsRemoved();
+        erase(it);
+
+        try
+        {
+            const fs::path key_directory = getPathInLocalCache(cleanup_key);
+            if (fs::exists(key_directory))
+                fs::remove_all(key_directory);
+
+            const fs::path key_prefix_directory = key_directory.parent_path();
+            if (fs::exists(key_prefix_directory) && fs::is_empty(key_prefix_directory))
+                fs::remove_all(key_prefix_directory);
+        }
+        catch (...)
+        {
+            chassert(false);
+            tryLogCurrentException(__PRETTY_FUNCTION__);
+        }
+    }
+}
+
+LockedKey::LockedKey(std::shared_ptr<KeyMetadata> key_metadata_)
+    : key_metadata(key_metadata_)
+    , lock(key_metadata->guard.lock())
+    , log(&Poco::Logger::get("LockedKey"))
+{
+}
+
+LockedKey::~LockedKey()
+{
+    if (!key_metadata->empty())
+        return;
+
+    key_metadata->key_state = KeyMetadata::KeyState::REMOVING;
+    key_metadata->cleanup_queue.add(getKey());
+}
+
+void LockedKey::removeFromCleanupQueue()
+{
+    if (key_metadata->key_state != KeyMetadata::KeyState::REMOVING)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot remove non-removing");
+
+    /// Just mark key_state as "not to be removed", the cleanup thread will check it and skip the key.
+    key_metadata->key_state = KeyMetadata::KeyState::ACTIVE;
+}
+
+void LockedKey::markAsRemoved()
+{
+    key_metadata->key_state = KeyMetadata::KeyState::REMOVED;
+}
+
+bool LockedKey::isLastOwnerOfFileSegment(size_t offset) const
+{
+    const auto file_segment_metadata = getByOffset(offset);
+    return file_segment_metadata->file_segment.use_count() == 2;
+}
+
+void LockedKey::removeAllReleasable()
+{
+    for (auto it = key_metadata->begin(); it != key_metadata->end();)
+    {
+        if (!it->second->releasable())
+        {
+            ++it;
+            continue;
+        }
+
+        auto file_segment = it->second->file_segment;
+        it = removeFileSegment(file_segment->offset(), file_segment->lock());
+    }
+}
+
+KeyMetadata::iterator LockedKey::removeFileSegment(size_t offset, const FileSegmentGuard::Lock & segment_lock)
+{
+    LOG_DEBUG(log, "Remove from cache. Key: {}, offset: {}", getKey(), offset);
+
+    auto it = key_metadata->find(offset);
+    if (it == key_metadata->end())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "There is no offset {}", offset);
+
+    auto file_segment = it->second->file_segment;
+    if (file_segment->queue_iterator)
+        file_segment->queue_iterator->annul();
+
+    const auto path = key_metadata->getFileSegmentPath(*file_segment);
+    if (fs::exists(path))
+        fs::remove(path);
+
+    file_segment->detach(segment_lock, *this);
+    return key_metadata->erase(it);
+}
+
+void LockedKey::shrinkFileSegmentToDownloadedSize(
+    size_t offset,
+    const FileSegmentGuard::Lock & segment_lock)
+{
+    /**
+     * In case file was partially downloaded and it's download cannot be continued
+     * because of no space left in cache, we need to be able to cut file segment's size to downloaded_size.
+     */
+
+    auto metadata = getByOffset(offset);
+    const auto & file_segment = metadata->file_segment;
+    chassert(file_segment->assertCorrectnessUnlocked(segment_lock));
+
+    const size_t downloaded_size = file_segment->getDownloadedSize(false);
+    if (downloaded_size == file_segment->range().size())
+    {
+        throw Exception(
+            ErrorCodes::LOGICAL_ERROR,
+            "Nothing to reduce, file segment fully downloaded: {}",
+            file_segment->getInfoForLogUnlocked(segment_lock));
+    }
+
+    int64_t diff = file_segment->reserved_size - downloaded_size;
+
+    metadata->file_segment = std::make_shared<FileSegment>(
+        getKey(), offset, downloaded_size, FileSegment::State::DOWNLOADED,
+        CreateFileSegmentSettings(file_segment->getKind()),
+        file_segment->cache, key_metadata, file_segment->queue_iterator);
+
+    if (diff)
+        metadata->getQueueIterator()->updateSize(-diff);
+
+    chassert(file_segment->assertCorrectnessUnlocked(segment_lock));
+}
+
+std::shared_ptr<const FileSegmentMetadata> LockedKey::getByOffset(size_t offset) const
+{
+    auto it = key_metadata->find(offset);
+    if (it == key_metadata->end())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "There is not offset {}", offset);
+    return it->second;
+}
+
+std::shared_ptr<FileSegmentMetadata> LockedKey::getByOffset(size_t offset)
+{
+    auto it = key_metadata->find(offset);
+    if (it == key_metadata->end())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "There is not offset {}", offset);
+    return it->second;
+}
+
+std::shared_ptr<const FileSegmentMetadata> LockedKey::tryGetByOffset(size_t offset) const
+{
+    auto it = key_metadata->find(offset);
+    if (it == key_metadata->end())
+        return nullptr;
+    return it->second;
+}
+
+std::shared_ptr<FileSegmentMetadata> LockedKey::tryGetByOffset(size_t offset)
+{
+    auto it = key_metadata->find(offset);
+    if (it == key_metadata->end())
+        return nullptr;
+    return it->second;
+}
+
+std::string LockedKey::toString() const
+{
+    std::string result;
+    for (auto it = key_metadata->begin(); it != key_metadata->end(); ++it)
+    {
+        if (it != key_metadata->begin())
+            result += ", ";
+        result += std::to_string(it->first);
+    }
+    return result;
+}
+
+void CleanupQueue::add(const FileCacheKey & key)
+{
+    std::lock_guard lock(mutex);
+    keys.insert(key);
+}
+
+void CleanupQueue::remove(const FileCacheKey & key)
+{
+    std::lock_guard lock(mutex);
+    bool erased = keys.erase(key);
+    if (!erased)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "No such key {} in removal queue", key);
+}
+
+bool CleanupQueue::tryPop(FileCacheKey & key)
+{
+    std::lock_guard lock(mutex);
+    if (keys.empty())
+        return false;
+    auto it = keys.begin();
+    key = *it;
+    keys.erase(it);
+    return true;
+}
+
+size_t CleanupQueue::getSize() const
+{
+    std::lock_guard lock(mutex);
+    return keys.size();
+}
+
+}
diff --git a/src/Interpreters/Cache/Metadata.h b/src/Interpreters/Cache/Metadata.h
new file mode 100644
index 00000000000..586c7e5c2a8
--- /dev/null
+++ b/src/Interpreters/Cache/Metadata.h
@@ -0,0 +1,176 @@
+#pragma once
+#include <boost/noncopyable.hpp>
+#include <Interpreters/Cache/Guards.h>
+#include <Interpreters/Cache/IFileCachePriority.h>
+#include <Interpreters/Cache/FileCacheKey.h>
+#include <Interpreters/Cache/FileSegment.h>
+#include <Interpreters/Cache/FileCache_fwd_internal.h>
+
+namespace DB
+{
+class CleanupQueue;
+using CleanupQueuePtr = std::shared_ptr<CleanupQueue>;
+
+
+struct FileSegmentMetadata : private boost::noncopyable
+{
+    using Priority = IFileCachePriority;
+
+    explicit FileSegmentMetadata(FileSegmentPtr && file_segment_);
+
+    bool releasable() const { return file_segment.unique(); }
+
+    size_t size() const;
+
+    bool valid() const { return !removal_candidate.load(); }
+
+    Priority::Iterator getQueueIterator() { return file_segment->getQueueIterator(); }
+
+    FileSegmentPtr file_segment;
+    std::atomic<bool> removal_candidate{false};
+};
+
+using FileSegmentMetadataPtr = std::shared_ptr<FileSegmentMetadata>;
+
+
+struct KeyMetadata : public std::map<size_t, FileSegmentMetadataPtr>,
+                     private boost::noncopyable,
+                     public std::enable_shared_from_this<KeyMetadata>
+{
+    friend struct LockedKey;
+    using Key = FileCacheKey;
+
+    KeyMetadata(
+        const Key & key_,
+        const std::string & key_path_,
+        CleanupQueue & cleanup_queue_,
+        bool created_base_directory_ = false);
+
+    enum class KeyState
+    {
+        ACTIVE,
+        REMOVING,
+        REMOVED,
+    };
+
+    const Key key;
+    const std::string key_path;
+
+    LockedKeyPtr lock();
+
+    /// Return nullptr if key has non-ACTIVE state.
+    LockedKeyPtr tryLock();
+
+    bool createBaseDirectory();
+
+    std::string getFileSegmentPath(const FileSegment & file_segment);
+
+private:
+    KeyState key_state = KeyState::ACTIVE;
+    KeyGuard guard;
+    CleanupQueue & cleanup_queue;
+    std::atomic<bool> created_base_directory = false;
+};
+
+using KeyMetadataPtr = std::shared_ptr<KeyMetadata>;
+
+
+struct CacheMetadata : public std::unordered_map<FileCacheKey, KeyMetadataPtr>, private boost::noncopyable
+{
+public:
+    using Key = FileCacheKey;
+    using IterateCacheMetadataFunc = std::function<void(const LockedKey &)>;
+
+    explicit CacheMetadata(const std::string & path_);
+
+    const String & getBaseDirectory() const { return path; }
+
+    String getPathInLocalCache(
+        const Key & key,
+        size_t offset,
+        FileSegmentKind segment_kind) const;
+
+    String getPathInLocalCache(const Key & key) const;
+    static String getFileNameForFileSegment(size_t offset, FileSegmentKind segment_kind);
+
+    void iterate(IterateCacheMetadataFunc && func);
+
+    enum class KeyNotFoundPolicy
+    {
+        THROW,
+        CREATE_EMPTY,
+        RETURN_NULL,
+    };
+
+    LockedKeyPtr lockKeyMetadata(
+        const Key & key,
+        KeyNotFoundPolicy key_not_found_policy,
+        bool is_initial_load = false);
+
+    void doCleanup();
+
+private:
+    const std::string path; /// Cache base path
+    CacheMetadataGuard guard;
+    const CleanupQueuePtr cleanup_queue;
+    Poco::Logger * log;
+};
+
+
+/**
+ * `LockedKey` is an object which makes sure that as long as it exists the following is true:
+ * 1. the key cannot be removed from cache
+ *    (Why: this LockedKey locks key metadata mutex in ctor, unlocks it in dtor, and so
+ *    when key is going to be deleted, key mutex is also locked.
+ *    Why it cannot be the other way round? E.g. that ctor of LockedKey locks the key
+ *    right after it was deleted? This case it taken into consideration in createLockedKey())
+ * 2. the key cannot be modified, e.g. new offsets cannot be added to key; already existing
+ *    offsets cannot be deleted from the key
+ * And also provides some methods which allow the owner of this LockedKey object to do such
+ * modification of the key (adding/deleting offsets) and deleting the key from cache.
+ */
+struct LockedKey : private boost::noncopyable
+{
+    using Key = FileCacheKey;
+
+    explicit LockedKey(std::shared_ptr<KeyMetadata> key_metadata_);
+
+    ~LockedKey();
+
+    const Key & getKey() const { return key_metadata->key; }
+
+    auto begin() const { return key_metadata->begin(); }
+    auto end() const { return key_metadata->end(); }
+
+    std::shared_ptr<const FileSegmentMetadata> getByOffset(size_t offset) const;
+    std::shared_ptr<FileSegmentMetadata> getByOffset(size_t offset);
+
+    std::shared_ptr<const FileSegmentMetadata> tryGetByOffset(size_t offset) const;
+    std::shared_ptr<FileSegmentMetadata> tryGetByOffset(size_t offset);
+
+    KeyMetadata::KeyState getKeyState() const { return key_metadata->key_state; }
+
+    std::shared_ptr<const KeyMetadata> getKeyMetadata() const { return key_metadata; }
+    std::shared_ptr<KeyMetadata> getKeyMetadata() { return key_metadata; }
+
+    void removeAllReleasable();
+
+    KeyMetadata::iterator removeFileSegment(size_t offset, const FileSegmentGuard::Lock &);
+
+    void shrinkFileSegmentToDownloadedSize(size_t offset, const FileSegmentGuard::Lock &);
+
+    bool isLastOwnerOfFileSegment(size_t offset) const;
+
+    void removeFromCleanupQueue();
+
+    void markAsRemoved();
+
+    std::string toString() const;
+
+private:
+    const std::shared_ptr<KeyMetadata> key_metadata;
+    KeyGuard::Lock lock; /// `lock` must be destructed before `key_metadata`.
+    Poco::Logger * log;
+};
+
+}
diff --git a/src/Interpreters/Cache/QueryLimit.cpp b/src/Interpreters/Cache/QueryLimit.cpp
new file mode 100644
index 00000000000..fc7556f21f5
--- /dev/null
+++ b/src/Interpreters/Cache/QueryLimit.cpp
@@ -0,0 +1,112 @@
+#include <Interpreters/Cache/QueryLimit.h>
+#include <Interpreters/Cache/Metadata.h>
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+static bool isQueryInitialized()
+{
+    return CurrentThread::isInitialized()
+        && CurrentThread::get().getQueryContext()
+        && !CurrentThread::getQueryId().empty();
+}
+
+FileCacheQueryLimit::QueryContextPtr FileCacheQueryLimit::tryGetQueryContext(const CacheGuard::Lock &)
+{
+    if (!isQueryInitialized())
+        return nullptr;
+
+    auto query_iter = query_map.find(std::string(CurrentThread::getQueryId()));
+    return (query_iter == query_map.end()) ? nullptr : query_iter->second;
+}
+
+void FileCacheQueryLimit::removeQueryContext(const std::string & query_id, const CacheGuard::Lock &)
+{
+    auto query_iter = query_map.find(query_id);
+    if (query_iter == query_map.end())
+    {
+        throw Exception(
+            ErrorCodes::LOGICAL_ERROR,
+            "Attempt to release query context that does not exist (query_id: {})",
+            query_id);
+    }
+    query_map.erase(query_iter);
+}
+
+FileCacheQueryLimit::QueryContextPtr FileCacheQueryLimit::getOrSetQueryContext(
+    const std::string & query_id,
+    const ReadSettings & settings,
+    const CacheGuard::Lock &)
+{
+    if (query_id.empty())
+        return nullptr;
+
+    auto [it, inserted] = query_map.emplace(query_id, nullptr);
+    if (inserted)
+    {
+        it->second = std::make_shared<QueryContext>(
+            settings.filesystem_cache_max_download_size,
+            !settings.skip_download_if_exceeds_query_cache);
+    }
+
+    return it->second;
+}
+
+FileCacheQueryLimit::QueryContext::QueryContext(
+    size_t query_cache_size,
+    bool recache_on_query_limit_exceeded_)
+    : priority(LRUFileCachePriority(query_cache_size, 0))
+    , recache_on_query_limit_exceeded(recache_on_query_limit_exceeded_)
+{
+}
+
+void FileCacheQueryLimit::QueryContext::add(
+    const FileSegment & file_segment,
+    const CacheGuard::Lock & lock)
+{
+    const auto key = file_segment.key();
+    const auto offset = file_segment.offset();
+
+    auto it = getPriority().add(
+        file_segment.getKeyMetadata(), offset, file_segment.range().size(), lock);
+
+    auto [_, inserted] = records.emplace(FileCacheKeyAndOffset{key, offset}, it);
+    if (!inserted)
+    {
+        throw Exception(
+            ErrorCodes::LOGICAL_ERROR,
+            "Cannot add offset {} to query context under key {}, it already exists",
+            offset, key);
+    }
+}
+
+void FileCacheQueryLimit::QueryContext::remove(
+    const Key & key,
+    size_t offset,
+    const CacheGuard::Lock & lock)
+{
+    auto record = records.find({key, offset});
+    if (record == records.end())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "There is no {}:{} in query context", key, offset);
+
+    record->second->remove(lock);
+    records.erase({key, offset});
+}
+
+IFileCachePriority::Iterator FileCacheQueryLimit::QueryContext::tryGet(
+    const Key & key,
+    size_t offset,
+    const CacheGuard::Lock &)
+{
+    auto it = records.find({key, offset});
+    if (it == records.end())
+        return nullptr;
+    return it->second;
+
+}
+
+}
diff --git a/src/Interpreters/Cache/QueryLimit.h b/src/Interpreters/Cache/QueryLimit.h
new file mode 100644
index 00000000000..5c08584bacf
--- /dev/null
+++ b/src/Interpreters/Cache/QueryLimit.h
@@ -0,0 +1,67 @@
+#pragma once
+#include <Interpreters/Cache/Guards.h>
+#include <Interpreters/Cache/LRUFileCachePriority.h>
+
+namespace DB
+{
+struct ReadSettings;
+class FileSegment;
+
+class FileCacheQueryLimit
+{
+public:
+    class QueryContext;
+    using QueryContextPtr = std::shared_ptr<QueryContext>;
+
+    QueryContextPtr tryGetQueryContext(const CacheGuard::Lock & lock);
+
+    QueryContextPtr getOrSetQueryContext(
+        const std::string & query_id,
+        const ReadSettings & settings,
+        const CacheGuard::Lock &);
+
+    void removeQueryContext(const std::string & query_id, const CacheGuard::Lock &);
+
+    class QueryContext
+    {
+    public:
+        using Key = FileCacheKey;
+        using Priority = IFileCachePriority;
+        using PriorityIterator = IFileCachePriority::Iterator;
+
+        QueryContext(size_t query_cache_size, bool recache_on_query_limit_exceeded_);
+
+        Priority & getPriority() { return priority; }
+        const Priority & getPriority() const { return priority; }
+
+        bool recacheOnFileCacheQueryLimitExceeded() const { return recache_on_query_limit_exceeded; }
+
+        IFileCachePriority::Iterator tryGet(
+            const Key & key,
+            size_t offset,
+            const CacheGuard::Lock &);
+
+        void add(
+            const FileSegment & file_segment,
+            const CacheGuard::Lock &);
+
+        void remove(
+            const Key & key,
+            size_t offset,
+            const CacheGuard::Lock &);
+
+    private:
+        using Records = std::unordered_map<FileCacheKeyAndOffset, IFileCachePriority::Iterator, FileCacheKeyAndOffsetHash>;
+        Records records;
+        LRUFileCachePriority priority;
+        const bool recache_on_query_limit_exceeded;
+    };
+
+private:
+    using QueryContextMap = std::unordered_map<String, QueryContextPtr>;
+    QueryContextMap query_map;
+};
+
+using FileCacheQueryLimitPtr = std::unique_ptr<FileCacheQueryLimit>;
+
+}
diff --git a/src/Interpreters/Cache/WriteBufferToFileSegment.cpp b/src/Interpreters/Cache/WriteBufferToFileSegment.cpp
index a1f0992afdf..1eac87a804d 100644
--- a/src/Interpreters/Cache/WriteBufferToFileSegment.cpp
+++ b/src/Interpreters/Cache/WriteBufferToFileSegment.cpp
@@ -17,17 +17,17 @@ namespace ErrorCodes
 }
 
 WriteBufferToFileSegment::WriteBufferToFileSegment(FileSegment * file_segment_)
-    : WriteBufferFromFileDecorator(file_segment_->detachWriter())
+    : WriteBufferFromFileDecorator(std::make_unique<WriteBufferFromFile>(file_segment_->getPathInLocalCache()))
     , file_segment(file_segment_)
 {
 }
 
-WriteBufferToFileSegment::WriteBufferToFileSegment(FileSegmentsHolder && segment_holder_)
+WriteBufferToFileSegment::WriteBufferToFileSegment(FileSegmentsHolderPtr segment_holder_)
     : WriteBufferFromFileDecorator(
-        segment_holder_.file_segments.size() == 1
-        ? segment_holder_.file_segments.front()->detachWriter()
+        segment_holder_->size() == 1
+        ? std::make_unique<WriteBufferFromFile>(segment_holder_->front().getPathInLocalCache())
         : throw Exception(ErrorCodes::LOGICAL_ERROR, "WriteBufferToFileSegment can be created only from single segment"))
-    , file_segment(segment_holder_.file_segments.front().get())
+    , file_segment(&segment_holder_->front())
     , segment_holder(std::move(segment_holder_))
 {
 }
diff --git a/src/Interpreters/Cache/WriteBufferToFileSegment.h b/src/Interpreters/Cache/WriteBufferToFileSegment.h
index 1305bcf8387..4d1e82996a3 100644
--- a/src/Interpreters/Cache/WriteBufferToFileSegment.h
+++ b/src/Interpreters/Cache/WriteBufferToFileSegment.h
@@ -13,7 +13,7 @@ class WriteBufferToFileSegment : public WriteBufferFromFileDecorator, public IRe
 {
 public:
     explicit WriteBufferToFileSegment(FileSegment * file_segment_);
-    explicit WriteBufferToFileSegment(FileSegmentsHolder && segment_holder);
+    explicit WriteBufferToFileSegment(FileSegmentsHolderPtr segment_holder);
 
     void nextImpl() override;
 
@@ -28,7 +28,7 @@ private:
     FileSegment * file_segment;
 
     /// Empty if file_segment is not owned by this WriteBufferToFileSegment
-    FileSegmentsHolder segment_holder;
+    FileSegmentsHolderPtr segment_holder;
 };
 
 
diff --git a/src/Interpreters/Context.cpp b/src/Interpreters/Context.cpp
index 66725ba5aa3..afeddbbe170 100644
--- a/src/Interpreters/Context.cpp
+++ b/src/Interpreters/Context.cpp
@@ -19,7 +19,6 @@
 #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>
@@ -43,6 +42,9 @@
 #include <Interpreters/ExternalLoaderXMLConfigRepository.h>
 #include <Interpreters/TemporaryDataOnDisk.h>
 #include <Interpreters/Cache/QueryCache.h>
+#include <Interpreters/Cache/FileCacheFactory.h>
+#include <Interpreters/Cache/FileCache.h>
+#include <Core/ServerSettings.h>
 #include <Interpreters/PreparedSets.h>
 #include <Core/Settings.h>
 #include <Core/SettingsQuirks.h>
@@ -107,15 +109,12 @@
 #include <Interpreters/Lemmatizers.h>
 #include <Interpreters/ClusterDiscovery.h>
 #include <Interpreters/TransactionLog.h>
-#include <Interpreters/Cache/FileCacheFactory.h>
 #include <filesystem>
 #include <re2/re2.h>
 #include <Storages/StorageView.h>
 #include <Parsers/ASTFunction.h>
 #include <base/find_symbols.h>
 
-#include <Interpreters/Cache/FileCache.h>
-
 #if USE_ROCKSDB
 #include <rocksdb/table.h>
 #endif
@@ -536,6 +535,12 @@ struct ContextSharedPart : boost::noncopyable
         /// take it as well, which will cause deadlock.
         delete_ddl_worker.reset();
 
+        /// Background operations in cache use background schedule pool.
+        /// Deactivate them before destructing it.
+        const auto & caches = FileCacheFactory::instance().getAll();
+        for (const auto & [_, cache] : caches)
+            cache->cache->deactivateBackgroundOperations();
+
         {
             auto lock = std::lock_guard(mutex);
 
diff --git a/src/Interpreters/InterpreterDescribeCacheQuery.cpp b/src/Interpreters/InterpreterDescribeCacheQuery.cpp
index b8f6a9b308d..ca875ee57b2 100644
--- a/src/Interpreters/InterpreterDescribeCacheQuery.cpp
+++ b/src/Interpreters/InterpreterDescribeCacheQuery.cpp
@@ -20,7 +20,7 @@ static Block getSampleBlock()
         ColumnWithTypeAndName{std::make_shared<DataTypeUInt64>(), "max_elements"},
         ColumnWithTypeAndName{std::make_shared<DataTypeUInt64>(), "max_file_segment_size"},
         ColumnWithTypeAndName{std::make_shared<DataTypeNumber<UInt8>>(), "cache_on_write_operations"},
-        ColumnWithTypeAndName{std::make_shared<DataTypeNumber<UInt8>>(), "enable_cache_hits_threshold"},
+        ColumnWithTypeAndName{std::make_shared<DataTypeNumber<UInt8>>(), "cache_hits_threshold"},
         ColumnWithTypeAndName{std::make_shared<DataTypeUInt64>(), "current_size"},
         ColumnWithTypeAndName{std::make_shared<DataTypeUInt64>(), "current_elements"},
         ColumnWithTypeAndName{std::make_shared<DataTypeString>(), "path"},
@@ -45,7 +45,7 @@ BlockIO InterpreterDescribeCacheQuery::execute()
     res_columns[1]->insert(settings.max_elements);
     res_columns[2]->insert(settings.max_file_segment_size);
     res_columns[3]->insert(settings.cache_on_write_operations);
-    res_columns[4]->insert(settings.enable_cache_hits_threshold);
+    res_columns[4]->insert(settings.cache_hits_threshold);
     res_columns[5]->insert(cache->getUsedCacheSize());
     res_columns[6]->insert(cache->getFileSegmentsNum());
     res_columns[7]->insert(cache->getBasePath());
diff --git a/src/Interpreters/InterpreterSystemQuery.cpp b/src/Interpreters/InterpreterSystemQuery.cpp
index 36cb57c3678..f0233980a14 100644
--- a/src/Interpreters/InterpreterSystemQuery.cpp
+++ b/src/Interpreters/InterpreterSystemQuery.cpp
@@ -364,12 +364,12 @@ BlockIO InterpreterSystemQuery::execute()
             {
                 auto caches = FileCacheFactory::instance().getAll();
                 for (const auto & [_, cache_data] : caches)
-                    cache_data->cache->removeIfReleasable();
+                    cache_data->cache->removeAllReleasable();
             }
             else
             {
                 auto cache = FileCacheFactory::instance().getByName(query.filesystem_cache_name).cache;
-                cache->removeIfReleasable();
+                cache->removeAllReleasable();
             }
             break;
         }
diff --git a/src/Interpreters/MergeTreeTransaction.cpp b/src/Interpreters/MergeTreeTransaction.cpp
index bfdda354c9b..1358e3ed3c2 100644
--- a/src/Interpreters/MergeTreeTransaction.cpp
+++ b/src/Interpreters/MergeTreeTransaction.cpp
@@ -184,7 +184,7 @@ scope_guard MergeTreeTransaction::beforeCommit()
 
     /// We should wait for mutations to finish before committing transaction, because some mutation may fail and cause rollback.
     for (const auto & table_and_mutation : mutations_to_wait)
-        table_and_mutation.first->waitForMutation(table_and_mutation.second);
+        table_and_mutation.first->waitForMutation(table_and_mutation.second, /* wait_for_another_mutation */ false);
 
     assert([&]()
     {
diff --git a/src/Interpreters/Session.h b/src/Interpreters/Session.h
index 443867806d6..d7c06a60464 100644
--- a/src/Interpreters/Session.h
+++ b/src/Interpreters/Session.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Common/SettingsChanges.h>
-#include <Access/Common/AuthenticationData.h>
+#include <Access/AuthenticationData.h>
 #include <Interpreters/ClientInfo.h>
 #include <Interpreters/Context_fwd.h>
 
diff --git a/src/Interpreters/SessionLog.h b/src/Interpreters/SessionLog.h
index 990c7ffea01..1282ac09c4d 100644
--- a/src/Interpreters/SessionLog.h
+++ b/src/Interpreters/SessionLog.h
@@ -2,7 +2,7 @@
 
 #include <Interpreters/SystemLog.h>
 #include <Interpreters/ClientInfo.h>
-#include <Access/Common/AuthenticationData.h>
+#include <Access/Common/AuthenticationType.h>
 #include <Core/NamesAndTypes.h>
 #include <Core/NamesAndAliases.h>
 #include <Columns/IColumn.h>
diff --git a/src/Interpreters/TemporaryDataOnDisk.cpp b/src/Interpreters/TemporaryDataOnDisk.cpp
index 11877eccc5c..69fef21dbab 100644
--- a/src/Interpreters/TemporaryDataOnDisk.cpp
+++ b/src/Interpreters/TemporaryDataOnDisk.cpp
@@ -92,12 +92,15 @@ TemporaryFileStream & TemporaryDataOnDisk::createStream(const Block & header, si
     throw Exception(ErrorCodes::LOGICAL_ERROR, "TemporaryDataOnDiskScope has no cache and no volume");
 }
 
-FileSegmentsHolder TemporaryDataOnDisk::createCacheFile(size_t max_file_size)
+FileSegmentsHolderPtr TemporaryDataOnDisk::createCacheFile(size_t max_file_size)
 {
     if (!file_cache)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "TemporaryDataOnDiskScope has no cache");
 
-    return file_cache->set(FileSegment::Key::random(), 0, std::max(10_MiB, max_file_size), CreateFileSegmentSettings(FileSegmentKind::Temporary, /* unbounded */ true));
+    const auto key = FileSegment::Key::random();
+    auto holder = file_cache->set(key, 0, std::max(10_MiB, max_file_size), CreateFileSegmentSettings(FileSegmentKind::Temporary, /* unbounded */ true));
+    fs::create_directories(file_cache->getPathInLocalCache(key));
+    return holder;
 }
 
 TemporaryFileOnDiskHolder TemporaryDataOnDisk::createRegularFile(size_t max_file_size)
@@ -237,15 +240,14 @@ TemporaryFileStream::TemporaryFileStream(TemporaryFileOnDiskHolder file_, const
     LOG_TEST(&Poco::Logger::get("TemporaryFileStream"), "Writing to temporary file {}", file->getPath());
 }
 
-TemporaryFileStream::TemporaryFileStream(FileSegmentsHolder && segments_, const Block & header_, TemporaryDataOnDisk * parent_)
+TemporaryFileStream::TemporaryFileStream(FileSegmentsHolderPtr segments_, const Block & header_, TemporaryDataOnDisk * parent_)
     : parent(parent_)
     , header(header_)
     , segment_holder(std::move(segments_))
 {
-    if (segment_holder.file_segments.size() != 1)
+    if (segment_holder->size() != 1)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "TemporaryFileStream can be created only from single segment");
-    auto & segment = segment_holder.file_segments.front();
-    auto out_buf = std::make_unique<WriteBufferToFileSegment>(segment.get());
+    auto out_buf = std::make_unique<WriteBufferToFileSegment>(&segment_holder->front());
 
     LOG_TEST(&Poco::Logger::get("TemporaryFileStream"), "Writing to temporary file {}", out_buf->getFileName());
     out_writer = std::make_unique<OutputWriter>(std::move(out_buf), header);
@@ -336,7 +338,7 @@ void TemporaryFileStream::updateAllocAndCheck()
 
 bool TemporaryFileStream::isEof() const
 {
-    return file == nullptr && segment_holder.empty();
+    return file == nullptr && !segment_holder;
 }
 
 void TemporaryFileStream::release()
@@ -356,7 +358,7 @@ void TemporaryFileStream::release()
         parent->deltaAllocAndCheck(-stat.compressed_size, -stat.uncompressed_size);
     }
 
-    if (!segment_holder.empty())
+    if (segment_holder)
         segment_holder.reset();
 }
 
@@ -364,8 +366,8 @@ String TemporaryFileStream::getPath() const
 {
     if (file)
         return file->getPath();
-    if (!segment_holder.file_segments.empty())
-        return segment_holder.file_segments.front()->getPathInLocalCache();
+    if (segment_holder && !segment_holder->empty())
+        return segment_holder->front().getPathInLocalCache();
 
     throw Exception(ErrorCodes::LOGICAL_ERROR, "TemporaryFileStream has no file");
 }
diff --git a/src/Interpreters/TemporaryDataOnDisk.h b/src/Interpreters/TemporaryDataOnDisk.h
index d06f0564559..14eefbf984d 100644
--- a/src/Interpreters/TemporaryDataOnDisk.h
+++ b/src/Interpreters/TemporaryDataOnDisk.h
@@ -103,7 +103,7 @@ public:
     const StatAtomic & getStat() const { return stat; }
 
 private:
-    FileSegmentsHolder createCacheFile(size_t max_file_size);
+    FileSegmentsHolderPtr createCacheFile(size_t max_file_size);
     TemporaryFileOnDiskHolder createRegularFile(size_t max_file_size);
 
     mutable std::mutex mutex;
@@ -130,7 +130,7 @@ public:
     };
 
     TemporaryFileStream(TemporaryFileOnDiskHolder file_, const Block & header_, TemporaryDataOnDisk * parent_);
-    TemporaryFileStream(FileSegmentsHolder && segments_, const Block & header_, TemporaryDataOnDisk * parent_);
+    TemporaryFileStream(FileSegmentsHolderPtr segments_, const Block & header_, TemporaryDataOnDisk * parent_);
 
     size_t write(const Block & block);
     void flush();
@@ -161,7 +161,7 @@ private:
 
     /// Data can be stored in file directly or in the cache
     TemporaryFileOnDiskHolder file;
-    FileSegmentsHolder segment_holder;
+    FileSegmentsHolderPtr segment_holder;
 
     Stat stat;
 
diff --git a/src/Interpreters/convertFieldToType.cpp b/src/Interpreters/convertFieldToType.cpp
index 1e69a73e9f2..08ac2fce556 100644
--- a/src/Interpreters/convertFieldToType.cpp
+++ b/src/Interpreters/convertFieldToType.cpp
@@ -237,6 +237,20 @@ Field convertFieldToTypeImpl(const Field & src, const IDataType & type, const ID
             return src;
         }
 
+        /// For toDate('xxx') in 1::Int64, we CAST `src` to UInt64, which may
+        /// produce wrong result in some special cases.
+        if (which_type.isDate() && src.getType() == Field::Types::Int64)
+        {
+            return convertNumericType<UInt64>(src, type);
+        }
+
+        /// For toDate32('xxx') in 1, we CAST `src` to Int64. Also, it may
+        /// produce wrong result in some special cases.
+        if (which_type.isDate32() && src.getType() == Field::Types::UInt64)
+        {
+            return convertNumericType<Int64>(src, type);
+        }
+
         if (which_type.isDateTime64()
             && (src.getType() == Field::Types::UInt64 || src.getType() == Field::Types::Int64 || src.getType() == Field::Types::Decimal64))
         {
diff --git a/src/Interpreters/tests/gtest_lru_file_cache.cpp b/src/Interpreters/tests/gtest_lru_file_cache.cpp
index 0754c394f66..e26d412b35e 100644
--- a/src/Interpreters/tests/gtest_lru_file_cache.cpp
+++ b/src/Interpreters/tests/gtest_lru_file_cache.cpp
@@ -16,6 +16,9 @@
 #include <filesystem>
 #include <thread>
 #include <DataTypes/DataTypesNumber.h>
+#include <Poco/Util/XMLConfiguration.h>
+#include <Poco/DOM/DOMParser.h>
+#include <base/sleep.h>
 
 #include <Poco/ConsoleChannel.h>
 #include <Disks/IO/CachedOnDiskWriteBufferFromFile.h>
@@ -26,21 +29,6 @@ using namespace DB;
 
 static constexpr auto TEST_LOG_LEVEL = "debug";
 
-void assertRange(
-    [[maybe_unused]] size_t assert_n, DB::FileSegmentPtr file_segment,
-    const DB::FileSegment::Range & expected_range, DB::FileSegment::State expected_state)
-{
-    auto range = file_segment->range();
-
-    std::cerr << fmt::format("\nAssert #{} : {} == {} (state: {} == {})\n", assert_n,
-                             range.toString(), expected_range.toString(),
-                             toString(file_segment->state()), toString(expected_state));
-
-    ASSERT_EQ(range.left, expected_range.left);
-    ASSERT_EQ(range.right, expected_range.right);
-    ASSERT_EQ(file_segment->state(), expected_state);
-}
-
 void printRanges(const auto & segments)
 {
     std::cerr << "\nHaving file segments: ";
@@ -48,21 +36,16 @@ void printRanges(const auto & segments)
         std::cerr << '\n' << segment->range().toString() << " (state: " + DB::FileSegment::stateToString(segment->state()) + ")" << "\n";
 }
 
-std::vector<DB::FileSegmentPtr> fromHolder(const DB::FileSegmentsHolder & holder)
-{
-    return std::vector<DB::FileSegmentPtr>(holder.file_segments.begin(), holder.file_segments.end());
-}
-
 String getFileSegmentPath(const String & base_path, const DB::FileCache::Key & key, size_t offset)
 {
     auto key_str = key.toString();
     return fs::path(base_path) / key_str.substr(0, 3) / key_str / DB::toString(offset);
 }
 
-void download(const std::string & cache_base_path, DB::FileSegmentPtr file_segment)
+void download(const std::string & cache_base_path, DB::FileSegment & file_segment)
 {
-    const auto & key = file_segment->key();
-    size_t size = file_segment->range().size();
+    const auto & key = file_segment.key();
+    size_t size = file_segment.range().size();
 
     auto key_str = key.toString();
     auto subdir = fs::path(cache_base_path) / key_str.substr(0, 3) / key_str;
@@ -70,29 +53,94 @@ void download(const std::string & cache_base_path, DB::FileSegmentPtr file_segme
         fs::create_directories(subdir);
 
     std::string data(size, '0');
-    file_segment->write(data.data(), size, file_segment->getCurrentWriteOffset());
+    file_segment.write(data.data(), size, file_segment.getCurrentWriteOffset(false));
 }
 
-void prepareAndDownload(const std::string & cache_base_path, DB::FileSegmentPtr file_segment)
-{
-    ASSERT_TRUE(file_segment->reserve(file_segment->range().size()));
-    download(cache_base_path, file_segment);
-}
+using Range = FileSegment::Range;
+using Ranges = std::vector<Range>;
+using State = FileSegment::State;
+using States = std::vector<State>;
+using Holder = FileSegmentsHolder;
+using HolderPtr = FileSegmentsHolderPtr;
 
-void complete(const std::string & cache_base_path, const DB::FileSegmentsHolder & holder)
+fs::path caches_dir = fs::current_path() / "lru_cache_test";
+std::string cache_base_path = caches_dir / "cache1" / "";
+
+
+void assertEqual(const HolderPtr & holder, const Ranges & expected_ranges, const States & expected_states = {})
 {
-    for (const auto & file_segment : holder.file_segments)
+    std::cerr << "Holder: " << holder->toString() << "\n";
+    ASSERT_EQ(holder->size(), expected_ranges.size());
+
+    if (!expected_states.empty())
+        ASSERT_EQ(holder->size(), expected_states.size());
+
+    auto get_expected_state = [&](size_t i)
     {
-        ASSERT_TRUE(file_segment->getOrSetDownloader() == DB::FileSegment::getCallerId());
-        prepareAndDownload(cache_base_path, file_segment);
-        file_segment->completeWithoutState();
+        if (expected_states.empty())
+            return State::DOWNLOADED;
+        else
+            return expected_states[i];
+    };
+
+    size_t i = 0;
+    for (const auto & file_segment : *holder)
+    {
+        ASSERT_EQ(file_segment->range(), expected_ranges[i]);
+        ASSERT_EQ(file_segment->state(), get_expected_state(i));
+        ++i;
     }
 }
 
+FileSegment & get(const HolderPtr & holder, int i)
+{
+    auto it = std::next(holder->begin(), i);
+    if (it == holder->end())
+        std::terminate();
+    return **it;
+}
+
+void download(FileSegment & file_segment)
+{
+    std::cerr << "Downloading range " << file_segment.range().toString() << "\n";
+
+    ASSERT_EQ(file_segment.getOrSetDownloader(), FileSegment::getCallerId());
+    ASSERT_EQ(file_segment.state(), State::DOWNLOADING);
+    ASSERT_EQ(file_segment.getDownloadedSize(false), 0);
+
+    ASSERT_TRUE(file_segment.reserve(file_segment.range().size()));
+    download(cache_base_path, file_segment);
+    ASSERT_EQ(file_segment.state(), State::DOWNLOADING);
+
+    file_segment.complete();
+    ASSERT_EQ(file_segment.state(), State::DOWNLOADED);
+}
+
+void assertDownloadFails(FileSegment & file_segment)
+{
+    ASSERT_EQ(file_segment.getOrSetDownloader(), FileSegment::getCallerId());
+    ASSERT_EQ(file_segment.getDownloadedSize(false), 0);
+    ASSERT_FALSE(file_segment.reserve(file_segment.range().size()));
+    file_segment.complete();
+}
+
+void download(const HolderPtr & holder)
+{
+    for (auto & it : *holder)
+    {
+        download(*it);
+    }
+}
+
+void increasePriority(const HolderPtr & holder)
+{
+    for (auto & it : *holder)
+        it->use();
+}
+
 class FileCacheTest : public ::testing::Test
 {
 public:
-
     static void setupLogs(const std::string & level)
     {
         Poco::AutoPtr<Poco::ConsoleChannel> channel(new Poco::ConsoleChannel(std::cerr));
@@ -118,8 +166,6 @@ public:
             fs::remove_all(cache_base_path);
     }
 
-    fs::path caches_dir = fs::current_path() / "lru_cache_test";
-    std::string cache_base_path = caches_dir / "cache1" / "";
 };
 
 TEST_F(FileCacheTest, get)
@@ -128,6 +174,14 @@ TEST_F(FileCacheTest, get)
 
     /// To work with cache need query_id and query context.
     std::string query_id = "query_id";
+
+    Poco::XML::DOMParser dom_parser;
+    std::string xml(R"CONFIG(<clickhouse>
+</clickhouse>)CONFIG");
+    Poco::AutoPtr<Poco::XML::Document> document = dom_parser.parseString(xml);
+    Poco::AutoPtr<Poco::Util::XMLConfiguration> config = new Poco::Util::XMLConfiguration(document);
+    getMutableContext().context->setConfig(config);
+
     auto query_context = DB::Context::createCopy(getContext().context);
     query_context->makeQueryContext();
     query_context->setCurrentQueryId(query_id);
@@ -140,255 +194,249 @@ TEST_F(FileCacheTest, get)
     settings.max_elements = 5;
 
     {
+        std::cerr << "Step 1\n";
         auto cache = DB::FileCache(settings);
         cache.initialize();
-        auto key = cache.hash("key1");
+        auto key = cache.createKeyForPath("key1");
 
         {
             auto holder = cache.getOrSet(key, 0, 10, {});  /// Add range [0, 9]
-            auto segments = fromHolder(holder);
-            /// Range was not present in cache. It should be added in cache as one while file segment.
-            ASSERT_EQ(segments.size(), 1);
-
-            assertRange(1, segments[0], DB::FileSegment::Range(0, 9), DB::FileSegment::State::EMPTY);
-
-            /// Exception because space not reserved.
-            /// EXPECT_THROW(download(segments[0]), DB::Exception);
-            /// Exception because space can be reserved only by downloader
-            /// EXPECT_THROW(segments[0]->reserve(segments[0]->range().size()), DB::Exception);
-
-            ASSERT_TRUE(segments[0]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            ASSERT_TRUE(segments[0]->reserve(segments[0]->range().size()));
-            assertRange(2, segments[0], DB::FileSegment::Range(0, 9), DB::FileSegment::State::DOWNLOADING);
-
-            download(cache_base_path, segments[0]);
-            segments[0]->completeWithoutState();
-            assertRange(3, segments[0], DB::FileSegment::Range(0, 9), DB::FileSegment::State::DOWNLOADED);
+            assertEqual(holder, { Range(0, 9) }, { State::EMPTY });
+            download(holder->front());
+            assertEqual(holder, { Range(0, 9) }, { State::DOWNLOADED });
+            increasePriority(holder);
         }
 
         /// Current cache:    [__________]
         ///                   ^          ^
         ///                   0          9
+        assertEqual(cache.getSnapshot(key), { Range(0, 9) });
+        assertEqual(cache.dumpQueue(), { Range(0, 9) });
         ASSERT_EQ(cache.getFileSegmentsNum(), 1);
         ASSERT_EQ(cache.getUsedCacheSize(), 10);
 
+        std::cerr << "Step 2\n";
+
         {
             /// Want range [5, 14], but [0, 9] already in cache, so only [10, 14] will be put in cache.
             auto holder = cache.getOrSet(key, 5, 10, {});
-            auto segments = fromHolder(holder);
-            ASSERT_EQ(segments.size(), 2);
-
-            assertRange(4, segments[0], DB::FileSegment::Range(0, 9), DB::FileSegment::State::DOWNLOADED);
-            assertRange(5, segments[1], DB::FileSegment::Range(10, 14), DB::FileSegment::State::EMPTY);
-
-            ASSERT_TRUE(segments[1]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            prepareAndDownload(cache_base_path, segments[1]);
-            segments[1]->completeWithoutState();
-            assertRange(6, segments[1], DB::FileSegment::Range(10, 14), DB::FileSegment::State::DOWNLOADED);
+            assertEqual(holder, { Range(0, 9), Range(10, 14) }, { State::DOWNLOADED, State::EMPTY });
+            download(get(holder, 1));
+            assertEqual(holder, { Range(0, 9), Range(10, 14) }, { State::DOWNLOADED, State::DOWNLOADED });
+            increasePriority(holder);
         }
 
         /// Current cache:    [__________][_____]
         ///                   ^          ^^     ^
         ///                   0          910    14
+        assertEqual(cache.getSnapshot(key), { Range(0, 9), Range(10, 14) });
+        assertEqual(cache.dumpQueue(), { Range(0, 9), Range(10, 14) });
         ASSERT_EQ(cache.getFileSegmentsNum(), 2);
         ASSERT_EQ(cache.getUsedCacheSize(), 15);
 
+        std::cerr << "Step 3\n";
+
+        /// Get [9, 9]
         {
-            auto holder = cache.getOrSet(key, 9, 1, {});  /// Get [9, 9]
-            auto segments = fromHolder(holder);
-            ASSERT_EQ(segments.size(), 1);
-            assertRange(7, segments[0], DB::FileSegment::Range(0, 9), DB::FileSegment::State::DOWNLOADED);
+            auto holder = cache.getOrSet(key, 9, 1, {});
+            assertEqual(holder, { Range(0, 9) }, { State::DOWNLOADED });
+            increasePriority(holder);
+        }
+
+        assertEqual(cache.dumpQueue(), { Range(10, 14), Range(0, 9) });
+        /// Get [9, 10]
+        assertEqual(cache.getOrSet(key, 9, 2, {}),
+                    { Range(0, 9),       Range(10, 14) },
+                    { State::DOWNLOADED, State::DOWNLOADED });
+
+        /// Get [10, 10]
+        {
+            auto holder = cache.getOrSet(key, 10, 1, {});
+            assertEqual(holder, { Range(10, 14) }, { State::DOWNLOADED });
+            increasePriority(holder);
+        }
+
+        assertEqual(cache.getSnapshot(key), { Range(0, 9), Range(10, 14) });
+        assertEqual(cache.dumpQueue(), { Range(0, 9), Range(10, 14) });
+        ASSERT_EQ(cache.getFileSegmentsNum(), 2);
+        ASSERT_EQ(cache.getUsedCacheSize(), 15);
+
+        std::cerr << "Step 4\n";
+
+        {
+            auto holder = cache.getOrSet(key, 17, 4, {});
+            download(holder); /// Get [17, 20]
+            increasePriority(holder);
         }
 
         {
-            auto holder = cache.getOrSet(key, 9, 2, {});  /// Get [9, 10]
-            auto segments = fromHolder(holder);
-            ASSERT_EQ(segments.size(), 2);
-            assertRange(8, segments[0], DB::FileSegment::Range(0, 9), DB::FileSegment::State::DOWNLOADED);
-            assertRange(9, segments[1], DB::FileSegment::Range(10, 14), DB::FileSegment::State::DOWNLOADED);
+            auto holder = cache.getOrSet(key, 24, 3, {});
+            download(holder); /// Get [24, 26]
+            increasePriority(holder);
         }
 
         {
-            auto holder = cache.getOrSet(key, 10, 1, {});  /// Get [10, 10]
-            auto segments = fromHolder(holder);
-            ASSERT_EQ(segments.size(), 1);
-            assertRange(10, segments[0], DB::FileSegment::Range(10, 14), DB::FileSegment::State::DOWNLOADED);
+            auto holder = cache.getOrSet(key, 27, 1, {});
+            download(holder); /// Get [27, 27]
+            increasePriority(holder);
         }
 
-        complete(cache_base_path, cache.getOrSet(key, 17, 4, {})); /// Get [17, 20]
-        complete(cache_base_path, cache.getOrSet(key, 24, 3, {})); /// Get [24, 26]
-        /// completeWithState(cache.getOrSet(key, 27, 1, false)); /// Get [27, 27]
-
         /// Current cache:    [__________][_____]   [____]    [___][]
         ///                   ^          ^^     ^   ^    ^    ^   ^^^
         ///                   0          910    14  17   20   24  2627
         ///
-        ASSERT_EQ(cache.getFileSegmentsNum(), 4);
-        ASSERT_EQ(cache.getUsedCacheSize(), 22);
+        assertEqual(cache.getSnapshot(key), { Range(0, 9), Range(10, 14), Range(17, 20), Range(24, 26), Range(27, 27) });
+        assertEqual(cache.dumpQueue(), { Range(0, 9), Range(10, 14), Range(17, 20), Range(24, 26), Range(27, 27) });
+        ASSERT_EQ(cache.getFileSegmentsNum(), 5);
+        ASSERT_EQ(cache.getUsedCacheSize(), 23);
 
+        std::cerr << "Step 5\n";
         {
             auto holder = cache.getOrSet(key, 0, 26, {}); /// Get [0, 25]
-            auto segments = fromHolder(holder);
-            ASSERT_EQ(segments.size(), 6);
-
-            assertRange(11, segments[0], DB::FileSegment::Range(0, 9), DB::FileSegment::State::DOWNLOADED);
-            assertRange(12, segments[1], DB::FileSegment::Range(10, 14), DB::FileSegment::State::DOWNLOADED);
-
-            /// Missing [15, 16] should be added in cache.
-            assertRange(13, segments[2], DB::FileSegment::Range(15, 16), DB::FileSegment::State::EMPTY);
-
-            ASSERT_TRUE(segments[2]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            prepareAndDownload(cache_base_path, segments[2]);
-
-            segments[2]->completeWithoutState();
-
-            assertRange(14, segments[3], DB::FileSegment::Range(17, 20), DB::FileSegment::State::DOWNLOADED);
-
-            /// New [21, 23], but will not be added in cache because of elements limit (5)
-            assertRange(15, segments[4], DB::FileSegment::Range(21, 23), DB::FileSegment::State::EMPTY);
-            ASSERT_TRUE(segments[4]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            ASSERT_FALSE(segments[4]->reserve(1));
-
-            assertRange(16, segments[5], DB::FileSegment::Range(24, 26), DB::FileSegment::State::DOWNLOADED);
-
-            /// Current cache:    [__________][_____][   ][____]    [___]
-            ///                   ^                            ^    ^
-            ///                   0                            20   24
-            ///
+            assertEqual(holder,
+                        { Range(0, 9),       Range(10, 14),     Range(15, 16),  Range(17, 20),     Range(21, 23), Range(24, 26) },
+                        { State::DOWNLOADED, State::DOWNLOADED, State::EMPTY,   State::DOWNLOADED, State::EMPTY,  State::DOWNLOADED });
+            download(get(holder, 2)); /// [27, 27] was evicted.
+            assertEqual(holder,
+                        { Range(0, 9),       Range(10, 14),     Range(15, 16),     Range(17, 20),     Range(21, 23), Range(24, 26) },
+                        { State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED, State::EMPTY,  State::DOWNLOADED });
+            assertDownloadFails(get(holder, 4));
+            assertEqual(holder,
+                        { Range(0, 9),       Range(10, 14),     Range(15, 16),     Range(17, 20),     Range(21, 23),     Range(24, 26) },
+                        { State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED, State::DETACHED, State::DOWNLOADED });
 
             /// Range [27, 27] must be evicted in previous getOrSet [0, 25].
             /// Let's not invalidate pointers to returned segments from range [0, 25] and
             /// as max elements size is reached, next attempt to put something in cache should fail.
             /// This will also check that [27, 27] was indeed evicted.
+            auto holder2 = cache.getOrSet(key, 27, 1, {});
+            assertEqual(holder2, { Range(27, 27) }, { State::EMPTY });
+            assertDownloadFails(holder2->front());
+            assertEqual(holder2, { Range(27, 27) }, { State::DETACHED });
 
-            auto holder1 = cache.getOrSet(key, 27, 1, {});
-            auto segments_1 = fromHolder(holder1); /// Get [27, 27]
-            ASSERT_EQ(segments_1.size(), 1);
-            assertRange(17, segments_1[0], DB::FileSegment::Range(27, 27), DB::FileSegment::State::EMPTY);
+            auto holder3 = cache.getOrSet(key, 28, 3, {});
+            assertEqual(holder3, { Range(28, 30) }, { State::EMPTY });
+            assertDownloadFails(holder3->front());
+            assertEqual(holder3, { Range(28, 30) }, { State::DETACHED });
+
+            increasePriority(holder);
+            increasePriority(holder2);
+            increasePriority(holder3);
         }
 
+        /// Current cache:    [__________][_____][   ][____]    [___]
+        ///                   ^                            ^    ^
+        ///                   0                            20   24
+        ///
+        assertEqual(cache.getSnapshot(key), { Range(0, 9), Range(10, 14), Range(15, 16), Range(17, 20), Range(24, 26) });
+        assertEqual(cache.dumpQueue(), { Range(0, 9), Range(10, 14), Range(15, 16), Range(17, 20), Range(24, 26) });
+        ASSERT_EQ(cache.getFileSegmentsNum(), 5);
+        ASSERT_EQ(cache.getUsedCacheSize(), 24);
+
+        std::cerr << "Step 6\n";
+
         {
             auto holder = cache.getOrSet(key, 12, 10, {}); /// Get [12, 21]
-            auto segments = fromHolder(holder);
-            ASSERT_EQ(segments.size(), 4);
-
-            assertRange(18, segments[0], DB::FileSegment::Range(10, 14), DB::FileSegment::State::DOWNLOADED);
-            assertRange(19, segments[1], DB::FileSegment::Range(15, 16), DB::FileSegment::State::DOWNLOADED);
-            assertRange(20, segments[2], DB::FileSegment::Range(17, 20), DB::FileSegment::State::DOWNLOADED);
-
-            assertRange(21, segments[3], DB::FileSegment::Range(21, 21), DB::FileSegment::State::EMPTY);
-
-            ASSERT_TRUE(segments[3]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            prepareAndDownload(cache_base_path, segments[3]);
-
-            segments[3]->completeWithoutState();
-            ASSERT_TRUE(segments[3]->state() == DB::FileSegment::State::DOWNLOADED);
+            assertEqual(holder,
+                        { Range(10, 14),     Range(15, 16),     Range(17, 20),     Range(21, 21) },
+                        { State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED, State::EMPTY });
+            download(get(holder, 3));
+            assertEqual(holder,
+                        { Range(10, 14),     Range(15, 16),     Range(17, 20),     Range(21, 21) },
+                        { State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED });
+            increasePriority(holder);
         }
 
         /// Current cache:    [_____][__][____][_]   [___]
         ///                   ^          ^       ^   ^   ^
         ///                   10         17      21  24  26
-
+        assertEqual(cache.getSnapshot(key), { Range(10, 14), Range(15, 16), Range(17, 20), Range(21, 21), Range(24, 26) });
+        assertEqual(cache.dumpQueue(), { Range(24, 26), Range(10, 14), Range(15, 16), Range(17, 20), Range(21, 21) });
         ASSERT_EQ(cache.getFileSegmentsNum(), 5);
+        ASSERT_EQ(cache.getUsedCacheSize(), 15);
 
+        std::cerr << "Step 7\n";
         {
-            auto holder = cache.getOrSet(key, 23, 5, {}); /// Get [23, 28]
-            auto segments = fromHolder(holder);
-            ASSERT_EQ(segments.size(), 3);
-
-            assertRange(22, segments[0], DB::FileSegment::Range(23, 23), DB::FileSegment::State::EMPTY);
-            assertRange(23, segments[1], DB::FileSegment::Range(24, 26), DB::FileSegment::State::DOWNLOADED);
-            assertRange(24, segments[2], DB::FileSegment::Range(27, 27), DB::FileSegment::State::EMPTY);
-
-            ASSERT_TRUE(segments[0]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            ASSERT_TRUE(segments[2]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            prepareAndDownload(cache_base_path, segments[0]);
-            prepareAndDownload(cache_base_path, segments[2]);
-            segments[0]->completeWithoutState();
-            segments[2]->completeWithoutState();
+            auto holder = cache.getOrSet(key, 23, 5, {}); /// Get [23, 27]
+            assertEqual(holder,
+                        { Range(23, 23), Range(24, 26),     Range(27, 27) },
+                        { State::EMPTY,  State::DOWNLOADED, State::EMPTY });
+            download(get(holder, 0));
+            download(get(holder, 2));
+            increasePriority(holder);
         }
 
         /// Current cache:    [____][_]  [][___][__]
         ///                   ^       ^  ^^^   ^^  ^
-        ///                   17      21 2324  26  28
-
-        {
-            auto holder5 = cache.getOrSet(key, 2, 3, {}); /// Get [2, 4]
-            auto s5 = fromHolder(holder5);
-            ASSERT_EQ(s5.size(), 1);
-            assertRange(25, s5[0], DB::FileSegment::Range(2, 4), DB::FileSegment::State::EMPTY);
-
-            auto holder1 = cache.getOrSet(key, 30, 2, {}); /// Get [30, 31]
-            auto s1 = fromHolder(holder1);
-            ASSERT_EQ(s1.size(), 1);
-            assertRange(26, s1[0], DB::FileSegment::Range(30, 31), DB::FileSegment::State::EMPTY);
-
-            ASSERT_TRUE(s5[0]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            ASSERT_TRUE(s1[0]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            prepareAndDownload(cache_base_path, s5[0]);
-            prepareAndDownload(cache_base_path, s1[0]);
-            s5[0]->completeWithoutState();
-            s1[0]->completeWithoutState();
-
-            /// Current cache:    [___]       [_][___][_]   [__]
-            ///                   ^   ^       ^  ^   ^  ^   ^  ^
-            ///                   2   4       23 24  26 27  30 31
-
-            auto holder2 = cache.getOrSet(key, 23, 1, {}); /// Get [23, 23]
-            auto s2 = fromHolder(holder2);
-            ASSERT_EQ(s2.size(), 1);
-
-            auto holder3 = cache.getOrSet(key, 24, 3, {}); /// Get [24, 26]
-            auto s3 = fromHolder(holder3);
-            ASSERT_EQ(s3.size(), 1);
-
-            auto holder4 = cache.getOrSet(key, 27, 1, {}); /// Get [27, 27]
-            auto s4 = fromHolder(holder4);
-            ASSERT_EQ(s4.size(), 1);
-
-            /// All cache is now unreleasable because pointers are still hold
-            auto holder6 = cache.getOrSet(key, 0, 40, {});
-            auto f = fromHolder(holder6);
-            ASSERT_EQ(f.size(), 9);
-
-            assertRange(27, f[0], DB::FileSegment::Range(0, 1), DB::FileSegment::State::EMPTY);
-            assertRange(28, f[2], DB::FileSegment::Range(5, 22), DB::FileSegment::State::EMPTY);
-            assertRange(29, f[6], DB::FileSegment::Range(28, 29), DB::FileSegment::State::EMPTY);
-            assertRange(30, f[8], DB::FileSegment::Range(32, 39), DB::FileSegment::State::EMPTY);
-
-            ASSERT_TRUE(f[0]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            ASSERT_TRUE(f[2]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            ASSERT_TRUE(f[6]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            ASSERT_TRUE(f[8]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-
-            ASSERT_FALSE(f[0]->reserve(1));
-            ASSERT_FALSE(f[2]->reserve(1));
-            ASSERT_FALSE(f[6]->reserve(1));
-            ASSERT_FALSE(f[8]->reserve(1));
-        }
+        ///                   17      21 2324  26  27
+        assertEqual(cache.getSnapshot(key), { Range(17, 20), Range(21, 21), Range(23, 23), Range(24, 26), Range(27, 27) });
+        assertEqual(cache.dumpQueue(), { Range(17, 20), Range(21, 21), Range(23, 23), Range(24, 26), Range(27, 27) });
+        ASSERT_EQ(cache.getFileSegmentsNum(), 5);
+        ASSERT_EQ(cache.getUsedCacheSize(), 10);
 
+        std::cerr << "Step 8\n";
         {
             auto holder = cache.getOrSet(key, 2, 3, {}); /// Get [2, 4]
-            auto segments = fromHolder(holder);
-            ASSERT_EQ(segments.size(), 1);
-            assertRange(31, segments[0], DB::FileSegment::Range(2, 4), DB::FileSegment::State::DOWNLOADED);
+            assertEqual(holder, { Range(2, 4) }, { State::EMPTY });
+
+            auto holder2 = cache.getOrSet(key, 30, 2, {}); /// Get [30, 31]
+            assertEqual(holder2, { Range(30, 31) }, { State::EMPTY });
+
+            download(get(holder, 0));
+            download(get(holder2, 0));
+
+            auto holder3 = cache.getOrSet(key, 23, 1, {}); /// Get [23, 23]
+            assertEqual(holder3, { Range(23, 23) }, { State::DOWNLOADED });
+
+            auto holder4 = cache.getOrSet(key, 24, 3, {}); /// Get [24, 26]
+            assertEqual(holder4, { Range(24, 26) }, { State::DOWNLOADED });
+
+            auto holder5 = cache.getOrSet(key, 27, 1, {}); /// Get [27, 27]
+            assertEqual(holder5, { Range(27, 27) }, { State::DOWNLOADED });
+
+            auto holder6 = cache.getOrSet(key, 0, 40, {});
+            assertEqual(holder6,
+                        { Range(0, 1), Range(2, 4),        Range(5, 22), Range(23, 23),     Range(24, 26),     Range(27, 27),    Range(28, 29), Range(30, 31),     Range(32, 39) },
+                        { State::EMPTY, State::DOWNLOADED, State::EMPTY, State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED, State::EMPTY, State::DOWNLOADED, State::EMPTY });
+
+            assertDownloadFails(get(holder6, 0));
+            assertDownloadFails(get(holder6, 2));
+            assertDownloadFails(get(holder6, 6));
+            assertDownloadFails(get(holder6, 8));
+
+            increasePriority(holder);
+            increasePriority(holder2);
+            increasePriority(holder3);
+            increasePriority(holder4);
+            increasePriority(holder5);
+            increasePriority(holder6);
         }
 
         /// Current cache:    [___]       [_][___][_]   [__]
         ///                   ^   ^       ^  ^   ^  ^   ^  ^
         ///                   2   4       23 24  26 27  30 31
+        assertEqual(cache.getSnapshot(key), { Range(2, 4), Range(23, 23), Range(24, 26), Range(27, 27), Range(30, 31) });
+        assertEqual(cache.dumpQueue(), { Range(2, 4), Range(23, 23), Range(24, 26), Range(27, 27), Range(30, 31) });
+
+        std::cerr << "Step 9\n";
+
+        /// Get [2, 4]
+        {
+            auto holder = cache.getOrSet(key, 2, 3, {});
+            assertEqual(holder, { Range(2, 4) }, { State::DOWNLOADED });
+            increasePriority(holder);
+        }
+
 
         {
             auto holder = cache.getOrSet(key, 25, 5, {}); /// Get [25, 29]
-            auto segments = fromHolder(holder);
-            ASSERT_EQ(segments.size(), 3);
+            assertEqual(holder,
+                        { Range(24, 26),     Range(27, 27),     Range(28, 29) },
+                        { State::DOWNLOADED, State::DOWNLOADED, State::EMPTY });
 
-            assertRange(32, segments[0], DB::FileSegment::Range(24, 26), DB::FileSegment::State::DOWNLOADED);
-            assertRange(33, segments[1], DB::FileSegment::Range(27, 27), DB::FileSegment::State::DOWNLOADED);
-
-            assertRange(34, segments[2], DB::FileSegment::Range(28, 29), DB::FileSegment::State::EMPTY);
-            ASSERT_TRUE(segments[2]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            ASSERT_TRUE(segments[2]->state() == DB::FileSegment::State::DOWNLOADING);
+            auto & file_segment = get(holder, 2);
+            ASSERT_TRUE(file_segment.getOrSetDownloader() == FileSegment::getCallerId());
+            ASSERT_TRUE(file_segment.state() == State::DOWNLOADING);
 
             bool lets_start_download = false;
             std::mutex mutex;
@@ -403,16 +451,13 @@ TEST_F(FileCacheTest, get)
                 chassert(&DB::CurrentThread::get() == &thread_status_1);
                 DB::CurrentThread::QueryScope query_scope_holder_1(query_context_1);
 
-                auto holder_2 = cache.getOrSet(key, 25, 5, {}); /// Get [25, 29] once again.
-                auto segments_2 = fromHolder(holder_2);
-                ASSERT_EQ(segments.size(), 3);
+                auto holder2 = cache.getOrSet(key, 25, 5, {}); /// Get [25, 29] once again.
+                assertEqual(holder2,
+                            { Range(24, 26),     Range(27, 27),     Range(28, 29) },
+                            { State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADING });
 
-                assertRange(35, segments_2[0], DB::FileSegment::Range(24, 26), DB::FileSegment::State::DOWNLOADED);
-                assertRange(36, segments_2[1], DB::FileSegment::Range(27, 27), DB::FileSegment::State::DOWNLOADED);
-                assertRange(37, segments_2[2], DB::FileSegment::Range(28, 29), DB::FileSegment::State::DOWNLOADING);
-
-                ASSERT_TRUE(segments[2]->getOrSetDownloader() != DB::FileSegment::getCallerId());
-                ASSERT_TRUE(segments[2]->state() == DB::FileSegment::State::DOWNLOADING);
+                auto & file_segment2 = get(holder2, 2);
+                ASSERT_TRUE(file_segment2.getOrSetDownloader() != FileSegment::getCallerId());
 
                 {
                     std::lock_guard lock(mutex);
@@ -420,8 +465,8 @@ TEST_F(FileCacheTest, get)
                 }
                 cv.notify_one();
 
-                segments_2[2]->wait();
-                ASSERT_TRUE(segments_2[2]->state() == DB::FileSegment::State::DOWNLOADED);
+                file_segment2.wait(file_segment2.range().left);
+                ASSERT_TRUE(file_segment2.state() == State::DOWNLOADED);
             });
 
             {
@@ -429,35 +474,34 @@ TEST_F(FileCacheTest, get)
                 cv.wait(lock, [&]{ return lets_start_download; });
             }
 
-            prepareAndDownload(cache_base_path, segments[2]);
-            segments[2]->completeWithoutState();
-            ASSERT_TRUE(segments[2]->state() == DB::FileSegment::State::DOWNLOADED);
+            download(file_segment);
+            ASSERT_TRUE(file_segment.state() == State::DOWNLOADED);
 
             other_1.join();
+
+            increasePriority(holder);
         }
 
         /// Current cache:    [___]       [___][_][__][__]
         ///                   ^   ^       ^   ^  ^^  ^^  ^
         ///                   2   4       24  26 27  2930 31
+        assertEqual(cache.getSnapshot(key), { Range(2, 4), Range(24, 26), Range(27, 27), Range(28, 29), Range(30, 31) });
+        assertEqual(cache.dumpQueue(), { Range(30, 31), Range(2, 4), Range(24, 26), Range(27, 27), Range(28, 29) });
 
+        std::cerr << "Step 10\n";
         {
             /// Now let's check the similar case but getting ERROR state after segment->wait(), when
             /// state is changed not manually via segment->completeWithState(state) but from destructor of holder
             /// and notify_all() is also called from destructor of holder.
 
-            std::optional<DB::FileSegmentsHolder> holder;
-            holder.emplace(cache.getOrSet(key, 3, 23, {})); /// Get [3, 25]
+            auto holder = cache.getOrSet(key, 3, 23, {}); /// Get [3, 25]
+            assertEqual(holder,
+                        { Range(2, 4),       Range(5, 23), Range(24, 26) },
+                        { State::DOWNLOADED, State::EMPTY, State::DOWNLOADED });
 
-            auto segments = fromHolder(*holder);
-            ASSERT_EQ(segments.size(), 3);
-
-            assertRange(38, segments[0], DB::FileSegment::Range(2, 4), DB::FileSegment::State::DOWNLOADED);
-
-            assertRange(39, segments[1], DB::FileSegment::Range(5, 23), DB::FileSegment::State::EMPTY);
-            ASSERT_TRUE(segments[1]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-            ASSERT_TRUE(segments[1]->state() == DB::FileSegment::State::DOWNLOADING);
-
-            assertRange(40, segments[2], DB::FileSegment::Range(24, 26), DB::FileSegment::State::DOWNLOADED);
+            auto & file_segment = get(holder, 1);
+            ASSERT_TRUE(file_segment.getOrSetDownloader() == FileSegment::getCallerId());
+            ASSERT_TRUE(file_segment.state() == State::DOWNLOADING);
 
             bool lets_start_download = false;
             std::mutex mutex;
@@ -472,16 +516,13 @@ TEST_F(FileCacheTest, get)
                 chassert(&DB::CurrentThread::get() == &thread_status_1);
                 DB::CurrentThread::QueryScope query_scope_holder_1(query_context_1);
 
-                auto holder_2 = cache.getOrSet(key, 3, 23, {}); /// Get [3, 25] once again
-                auto segments_2 = fromHolder(*holder);
-                ASSERT_EQ(segments_2.size(), 3);
+                auto holder2 = cache.getOrSet(key, 3, 23, {}); /// Get [3, 25] once again
+                assertEqual(holder,
+                            { Range(2, 4),       Range(5, 23),       Range(24, 26) },
+                            { State::DOWNLOADED, State::DOWNLOADING, State::DOWNLOADED });
 
-                assertRange(41, segments_2[0], DB::FileSegment::Range(2, 4), DB::FileSegment::State::DOWNLOADED);
-                assertRange(42, segments_2[1], DB::FileSegment::Range(5, 23), DB::FileSegment::State::DOWNLOADING);
-                assertRange(43, segments_2[2], DB::FileSegment::Range(24, 26), DB::FileSegment::State::DOWNLOADED);
-
-                ASSERT_TRUE(segments_2[1]->getDownloader() != DB::FileSegment::getCallerId());
-                ASSERT_TRUE(segments_2[1]->state() == DB::FileSegment::State::DOWNLOADING);
+                auto & file_segment2 = get(holder, 1);
+                ASSERT_TRUE(file_segment2.getDownloader() != FileSegment::getCallerId());
 
                 {
                     std::lock_guard lock(mutex);
@@ -489,13 +530,10 @@ TEST_F(FileCacheTest, get)
                 }
                 cv.notify_one();
 
-                segments_2[1]->wait();
-                printRanges(segments_2);
-                ASSERT_TRUE(segments_2[1]->state() == DB::FileSegment::State::PARTIALLY_DOWNLOADED);
-
-                ASSERT_TRUE(segments_2[1]->getOrSetDownloader() == DB::FileSegment::getCallerId());
-                prepareAndDownload(cache_base_path, segments_2[1]);
-                segments_2[1]->completeWithoutState();
+                file_segment2.wait(file_segment2.range().left);
+                ASSERT_TRUE(file_segment2.state() == DB::FileSegment::State::PARTIALLY_DOWNLOADED);
+                ASSERT_TRUE(file_segment2.getOrSetDownloader() == DB::FileSegment::getCallerId());
+                download(file_segment2);
             });
 
             {
@@ -505,8 +543,7 @@ TEST_F(FileCacheTest, get)
 
             holder.reset();
             other_1.join();
-            printRanges(segments);
-            ASSERT_TRUE(segments[1]->state() == DB::FileSegment::State::DOWNLOADED);
+            ASSERT_TRUE(file_segment.state() == DB::FileSegment::State::DOWNLOADED);
         }
     }
 
@@ -514,55 +551,103 @@ TEST_F(FileCacheTest, get)
     ///                   ^   ^^         ^   ^^  ^  ^
     ///                   2   45       24  2627 28 29
 
+    std::cerr << "Step 11\n";
     {
         /// Test LRUCache::restore().
 
         auto cache2 = DB::FileCache(settings);
         cache2.initialize();
-        auto key = cache2.hash("key1");
+        auto key = cache2.createKeyForPath("key1");
 
-        auto holder1 = cache2.getOrSet(key, 2, 28, {}); /// Get [2, 29]
-
-        auto segments1 = fromHolder(holder1);
-        ASSERT_EQ(segments1.size(), 5);
-
-        assertRange(44, segments1[0], DB::FileSegment::Range(2, 4), DB::FileSegment::State::DOWNLOADED);
-        assertRange(45, segments1[1], DB::FileSegment::Range(5, 23), DB::FileSegment::State::DOWNLOADED);
-        assertRange(45, segments1[2], DB::FileSegment::Range(24, 26), DB::FileSegment::State::DOWNLOADED);
-        assertRange(46, segments1[3], DB::FileSegment::Range(27, 27), DB::FileSegment::State::DOWNLOADED);
-        assertRange(47, segments1[4], DB::FileSegment::Range(28, 29), DB::FileSegment::State::DOWNLOADED);
+        /// Get [2, 29]
+        assertEqual(cache2.getOrSet(key, 2, 28, {}),
+                    { Range(2, 4),       Range(5, 23),      Range(24, 26),     Range(27, 27),     Range(28, 29) },
+                    { State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED, State::DOWNLOADED });
     }
 
+    std::cerr << "Step 12\n";
     {
         /// Test max file segment size
 
         auto settings2 = settings;
         settings2.max_file_segment_size = 10;
         settings2.base_path = caches_dir / "cache2";
+        fs::create_directories(settings2.base_path);
         auto cache2 = DB::FileCache(settings2);
         cache2.initialize();
-        auto key = cache2.hash("key1");
+        auto key = cache2.createKeyForPath("key1");
 
-        auto holder1 = cache2.getOrSet(key, 0, 25, {}); /// Get [0, 24]
-        auto segments1 = fromHolder(holder1);
-
-        ASSERT_EQ(segments1.size(), 3);
-        assertRange(48, segments1[0], DB::FileSegment::Range(0, 9), DB::FileSegment::State::EMPTY);
-        assertRange(49, segments1[1], DB::FileSegment::Range(10, 19), DB::FileSegment::State::EMPTY);
-        assertRange(50, segments1[2], DB::FileSegment::Range(20, 24), DB::FileSegment::State::EMPTY);
+        /// Get [0, 24]
+        assertEqual(cache2.getOrSet(key, 0, 25, {}),
+                    { Range(0, 9),  Range(10, 19), Range(20, 24) },
+                    { State::EMPTY, State::EMPTY,  State::EMPTY });
     }
 
+    std::cerr << "Step 13\n";
+    {
+        /// Test delated cleanup
+
+        auto cache = FileCache(settings);
+        cache.initialize();
+        cache.cleanup();
+        const auto key = cache.createKeyForPath("key10");
+        const auto key_path = cache.getPathInLocalCache(key);
+
+        cache.removeAllReleasable();
+        ASSERT_EQ(cache.getUsedCacheSize(), 0);
+        ASSERT_TRUE(!fs::exists(key_path));
+        ASSERT_TRUE(!fs::exists(fs::path(key_path).parent_path()));
+
+        download(cache.getOrSet(key, 0, 10, {}));
+        ASSERT_EQ(cache.getUsedCacheSize(), 10);
+        ASSERT_TRUE(fs::exists(cache.getPathInLocalCache(key, 0, FileSegmentKind::Regular)));
+
+        cache.removeAllReleasable();
+        ASSERT_EQ(cache.getUsedCacheSize(), 0);
+        ASSERT_TRUE(fs::exists(key_path));
+        ASSERT_TRUE(!fs::exists(cache.getPathInLocalCache(key, 0, FileSegmentKind::Regular)));
+
+        cache.cleanup();
+        ASSERT_TRUE(!fs::exists(key_path));
+        ASSERT_TRUE(!fs::exists(fs::path(key_path).parent_path()));
+    }
+
+    std::cerr << "Step 14\n";
+    {
+        /// Test background thread delated cleanup
+
+        auto settings2{settings};
+        settings2.delayed_cleanup_interval_ms = 0;
+        auto cache = DB::FileCache(settings2);
+        cache.initialize();
+        const auto key = cache.createKeyForPath("key10");
+        const auto key_path = cache.getPathInLocalCache(key);
+
+        cache.removeAllReleasable();
+        ASSERT_EQ(cache.getUsedCacheSize(), 0);
+        ASSERT_TRUE(!fs::exists(key_path));
+        ASSERT_TRUE(!fs::exists(fs::path(key_path).parent_path()));
+
+        download(cache.getOrSet(key, 0, 10, {}));
+        ASSERT_EQ(cache.getUsedCacheSize(), 10);
+        ASSERT_TRUE(fs::exists(key_path));
+
+        cache.removeAllReleasable();
+        ASSERT_EQ(cache.getUsedCacheSize(), 0);
+        sleepForSeconds(2);
+        ASSERT_TRUE(!fs::exists(key_path));
+    }
 }
 
 TEST_F(FileCacheTest, writeBuffer)
 {
-    DB::FileCacheSettings settings;
+    FileCacheSettings settings;
     settings.max_size = 100;
     settings.max_elements = 5;
     settings.max_file_segment_size = 5;
     settings.base_path = cache_base_path;
 
-    DB::FileCache cache(settings);
+    FileCache cache(settings);
     cache.initialize();
 
     auto write_to_cache = [&cache](const String & key, const Strings & data, bool flush)
@@ -571,10 +656,13 @@ TEST_F(FileCacheTest, writeBuffer)
         segment_settings.kind = FileSegmentKind::Temporary;
         segment_settings.unbounded = true;
 
-        auto holder = cache.set(cache.hash(key), 0, 3, segment_settings);
-        EXPECT_EQ(holder.file_segments.size(), 1);
-        auto & segment = holder.file_segments.front();
-        WriteBufferToFileSegment out(segment.get());
+        auto cache_key = cache.createKeyForPath(key);
+        auto holder = cache.set(cache_key, 0, 3, segment_settings);
+        /// The same is done in TemporaryDataOnDisk::createStreamToCacheFile.
+        std::filesystem::create_directories(cache.getPathInLocalCache(cache_key));
+        EXPECT_EQ(holder->size(), 1);
+        auto & segment = holder->front();
+        WriteBufferToFileSegment out(&segment);
         std::list<std::thread> threads;
         std::mutex mu;
         for (const auto & s : data)
@@ -600,18 +688,18 @@ TEST_F(FileCacheTest, writeBuffer)
     std::vector<fs::path> file_segment_paths;
     {
         auto holder = write_to_cache("key1", {"abc", "defg"}, false);
-        file_segment_paths.emplace_back(holder.file_segments.front()->getPathInLocalCache());
+        file_segment_paths.emplace_back(holder->front().getPathInLocalCache());
 
         ASSERT_EQ(fs::file_size(file_segment_paths.back()), 7);
-        ASSERT_TRUE(holder.file_segments.front()->range() == FileSegment::Range(0, 7));
+        ASSERT_TRUE(holder->front().range() == FileSegment::Range(0, 7));
         ASSERT_EQ(cache.getUsedCacheSize(), 7);
 
         {
             auto holder2 = write_to_cache("key2", {"1", "22", "333", "4444", "55555"}, true);
-            file_segment_paths.emplace_back(holder2.file_segments.front()->getPathInLocalCache());
+            file_segment_paths.emplace_back(holder2->front().getPathInLocalCache());
 
             ASSERT_EQ(fs::file_size(file_segment_paths.back()), 15);
-            ASSERT_TRUE(holder2.file_segments.front()->range() == FileSegment::Range(0, 15));
+            ASSERT_TRUE(holder2->front().range() == FileSegment::Range(0, 15));
             ASSERT_EQ(cache.getUsedCacheSize(), 22);
         }
         ASSERT_FALSE(fs::exists(file_segment_paths.back()));
@@ -668,17 +756,16 @@ TEST_F(FileCacheTest, temporaryData)
 
     auto tmp_data_scope = std::make_shared<TemporaryDataOnDiskScope>(nullptr, &file_cache, 0);
 
-    auto some_data_holder = file_cache.getOrSet(file_cache.hash("some_data"), 0, 5_KiB, CreateFileSegmentSettings{});
+    auto some_data_holder = file_cache.getOrSet(file_cache.createKeyForPath("some_data"), 0, 5_KiB, CreateFileSegmentSettings{});
 
     {
-        auto segments = fromHolder(some_data_holder);
-        ASSERT_EQ(segments.size(), 5);
-        for (auto & segment : segments)
+        ASSERT_EQ(some_data_holder->size(), 5);
+        for (auto & segment : *some_data_holder)
         {
             ASSERT_TRUE(segment->getOrSetDownloader() == DB::FileSegment::getCallerId());
             ASSERT_TRUE(segment->reserve(segment->range().size()));
-            download(cache_base_path, segment);
-            segment->completeWithoutState();
+            download(*segment);
+            segment->complete();
         }
     }
 
diff --git a/src/Parsers/ASTSubquery.h b/src/Parsers/ASTSubquery.h
index 7d0fabf3ed4..e4de766621a 100644
--- a/src/Parsers/ASTSubquery.h
+++ b/src/Parsers/ASTSubquery.h
@@ -21,15 +21,9 @@ public:
 
     ASTPtr clone() const override
     {
-        const auto res = std::make_shared<ASTSubquery>(*this);
-        ASTPtr ptr{res};
-
-        res->children.clear();
-
-        for (const auto & child : children)
-            res->children.emplace_back(child->clone());
-
-        return ptr;
+        auto clone = std::make_shared<ASTSubquery>(*this);
+        clone->cloneChildren();
+        return clone;
     }
 
     void updateTreeHashImpl(SipHash & hash_state) const override;
diff --git a/src/Parsers/Access/ASTAuthenticationData.cpp b/src/Parsers/Access/ASTAuthenticationData.cpp
new file mode 100644
index 00000000000..4e0cabfdec7
--- /dev/null
+++ b/src/Parsers/Access/ASTAuthenticationData.cpp
@@ -0,0 +1,190 @@
+#include <Parsers/Access/ASTAuthenticationData.h>
+
+#include <Access/AccessControl.h>
+#include <Common/Exception.h>
+#include <Parsers/ASTLiteral.h>
+#include <IO/Operators.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+std::optional<String> ASTAuthenticationData::getPassword() const
+{
+    if (contains_password)
+    {
+        if (const auto * password = children[0]->as<const ASTLiteral>())
+        {
+            return password->value.safeGet<String>();
+        }
+    }
+
+    return {};
+}
+std::optional<String> ASTAuthenticationData::getSalt() const
+{
+    if (type && *type == AuthenticationType::SHA256_PASSWORD && children.size() == 2)
+    {
+        if (const auto * salt = children[1]->as<const ASTLiteral>())
+        {
+            return salt->value.safeGet<String>();
+        }
+    }
+
+    return {};
+}
+
+void ASTAuthenticationData::formatImpl(const FormatSettings & settings, FormatState &, FormatStateStacked) const
+{
+    if (type && *type == AuthenticationType::NO_PASSWORD)
+    {
+        settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " NOT IDENTIFIED"
+                      << (settings.hilite ? IAST::hilite_none : "");
+        return;
+    }
+
+    String auth_type_name;
+    String prefix; /// "BY" or "SERVER" or "REALM"
+    bool password = false; /// either a password or hash
+    bool salt = false;
+    bool parameter = false;
+    bool parameters = false;
+
+    if (type)
+    {
+        auth_type_name = AuthenticationTypeInfo::get(*type).name;
+
+        switch (*type)
+        {
+            case AuthenticationType::PLAINTEXT_PASSWORD:
+            {
+                prefix = "BY";
+                password = true;
+                break;
+            }
+            case AuthenticationType::SHA256_PASSWORD:
+            {
+                if (contains_hash)
+                    auth_type_name = "sha256_hash";
+
+                prefix = "BY";
+                password = true;
+                if (children.size() == 2)
+                    salt = true;
+                break;
+            }
+            case AuthenticationType::DOUBLE_SHA1_PASSWORD:
+            {
+                if (contains_hash)
+                    auth_type_name = "double_sha1_hash";
+
+                prefix = "BY";
+                password = true;
+                break;
+            }
+            case AuthenticationType::LDAP:
+            {
+                prefix = "SERVER";
+                parameter = true;
+                break;
+            }
+            case AuthenticationType::KERBEROS:
+            {
+                if (!children.empty())
+                {
+                    prefix = "REALM";
+                    parameter = true;
+                }
+                break;
+            }
+            case AuthenticationType::SSL_CERTIFICATE:
+            {
+                prefix = "CN";
+                parameters = true;
+                break;
+            }
+            case AuthenticationType::NO_PASSWORD: [[fallthrough]];
+            case AuthenticationType::MAX:
+                throw Exception(ErrorCodes::LOGICAL_ERROR, "AST: Unexpected authentication type {}", toString(*type));
+        }
+    }
+    else
+    {
+        /// Default password type
+        prefix = "BY";
+        password = true;
+    }
+
+    if (password && !settings.show_secrets)
+    {
+        prefix = "";
+        password = false;
+        salt = false;
+        if (type)
+            auth_type_name = AuthenticationTypeInfo::get(*type).name;
+    }
+
+    settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " IDENTIFIED" << (settings.hilite ? IAST::hilite_none : "");
+
+    if (!auth_type_name.empty())
+    {
+        settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " WITH " << auth_type_name
+                        << (settings.hilite ? IAST::hilite_none : "");
+    }
+
+    if (!prefix.empty())
+    {
+        settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " " << prefix << (settings.hilite ? IAST::hilite_none : "");
+    }
+
+    if (password)
+    {
+        settings.ostr << " ";
+        children[0]->format(settings);
+    }
+
+    if (salt)
+    {
+        settings.ostr << " SALT ";
+        children[1]->format(settings);
+    }
+
+    if (parameter)
+    {
+        settings.ostr << " ";
+        children[0]->format(settings);
+    }
+    else if (parameters)
+    {
+        settings.ostr << " ";
+        bool need_comma = false;
+        for (const auto & child : children)
+        {
+            if (std::exchange(need_comma, true))
+                settings.ostr << ", ";
+            child->format(settings);
+        }
+    }
+}
+
+bool ASTAuthenticationData::hasSecretParts() const
+{
+    /// Default password type is used hence secret part
+    if (!type)
+        return true;
+
+    auto auth_type = *type;
+    if ((auth_type == AuthenticationType::PLAINTEXT_PASSWORD)
+        || (auth_type == AuthenticationType::SHA256_PASSWORD)
+        || (auth_type == AuthenticationType::DOUBLE_SHA1_PASSWORD))
+        return true;
+
+    return childrenHaveSecretParts();
+}
+
+}
diff --git a/src/Parsers/Access/ASTAuthenticationData.h b/src/Parsers/Access/ASTAuthenticationData.h
new file mode 100644
index 00000000000..de166bdf234
--- /dev/null
+++ b/src/Parsers/Access/ASTAuthenticationData.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <Parsers/IAST.h>
+#include <Access/Common/AuthenticationType.h>
+#include <optional>
+
+
+namespace DB
+{
+
+/** Represents authentication data in CREATE/ALTER USER query:
+  *  ... IDENTIFIED WITH sha256_password BY 'password'
+  *
+  * Can store password, hash and salt, LDAP server name, Kerberos Realm, or common names.
+  * They are stored in children vector as ASTLiteral or ASTQueryParameter.
+  * ASTAuthenticationData without a type represents authentication data with
+  *  the default password type that will be later inferred from the server parameters.
+  */
+
+class ASTAuthenticationData : public IAST
+{
+public:
+    String getID(char) const override { return "AuthenticationData"; }
+
+    ASTPtr clone() const override
+    {
+        auto clone = std::make_shared<ASTAuthenticationData>(*this);
+        clone->cloneChildren();
+        return clone;
+    }
+
+    bool hasSecretParts() const override;
+
+    std::optional<String> getPassword() const;
+    std::optional<String> getSalt() const;
+
+    /// If type is empty we use the default password type.
+    /// AuthenticationType::NO_PASSWORD is specified explicitly.
+    std::optional<AuthenticationType> type;
+
+    bool contains_password = false;
+    bool contains_hash = false;
+
+protected:
+    void formatImpl(const FormatSettings & settings, FormatState &, FormatStateStacked) const override;
+};
+
+}
diff --git a/src/Parsers/Access/ASTCreateUserQuery.cpp b/src/Parsers/Access/ASTCreateUserQuery.cpp
index b0d4aef38b8..0611545adf0 100644
--- a/src/Parsers/Access/ASTCreateUserQuery.cpp
+++ b/src/Parsers/Access/ASTCreateUserQuery.cpp
@@ -2,17 +2,13 @@
 #include <Parsers/Access/ASTRolesOrUsersSet.h>
 #include <Parsers/Access/ASTSettingsProfileElement.h>
 #include <Parsers/Access/ASTUserNameWithHost.h>
+#include <Parsers/Access/ASTAuthenticationData.h>
 #include <Common/quoteString.h>
 #include <IO/Operators.h>
 
 
 namespace DB
 {
-namespace ErrorCodes
-{
-    extern const int LOGICAL_ERROR;
-}
-
 
 namespace
 {
@@ -23,122 +19,9 @@ namespace
     }
 
 
-    void formatAuthenticationData(const AuthenticationData & auth_data, const IAST::FormatSettings & settings)
+    void formatAuthenticationData(const ASTAuthenticationData & auth_data, const IAST::FormatSettings & settings)
     {
-        auto auth_type = auth_data.getType();
-        if (auth_type == AuthenticationType::NO_PASSWORD)
-        {
-            settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " NOT IDENTIFIED"
-                          << (settings.hilite ? IAST::hilite_none : "");
-            return;
-        }
-
-        String auth_type_name = AuthenticationTypeInfo::get(auth_type).name;
-        String prefix; /// "BY" or "SERVER" or "REALM"
-        std::optional<String> password; /// either a password or hash
-        std::optional<String> salt;
-        std::optional<String> parameter;
-        const boost::container::flat_set<String> * parameters = nullptr;
-
-        switch (auth_type)
-        {
-            case AuthenticationType::PLAINTEXT_PASSWORD:
-            {
-                prefix = "BY";
-                password = auth_data.getPassword();
-                break;
-            }
-            case AuthenticationType::SHA256_PASSWORD:
-            {
-                auth_type_name = "sha256_hash";
-                prefix = "BY";
-                password = auth_data.getPasswordHashHex();
-                if (!auth_data.getSalt().empty())
-                    salt = auth_data.getSalt();
-                break;
-            }
-            case AuthenticationType::DOUBLE_SHA1_PASSWORD:
-            {
-                auth_type_name = "double_sha1_hash";
-                prefix = "BY";
-                password = auth_data.getPasswordHashHex();
-                break;
-            }
-            case AuthenticationType::LDAP:
-            {
-                prefix = "SERVER";
-                parameter = auth_data.getLDAPServerName();
-                break;
-            }
-            case AuthenticationType::KERBEROS:
-            {
-                const auto & realm = auth_data.getKerberosRealm();
-                if (!realm.empty())
-                {
-                    prefix = "REALM";
-                    parameter = realm;
-                }
-                break;
-            }
-
-            case AuthenticationType::SSL_CERTIFICATE:
-            {
-                prefix = "CN";
-                parameters = &auth_data.getSSLCertificateCommonNames();
-                break;
-            }
-
-            case AuthenticationType::NO_PASSWORD: [[fallthrough]];
-            case AuthenticationType::MAX:
-                throw Exception(ErrorCodes::LOGICAL_ERROR, "AST: Unexpected authentication type {}", toString(auth_type));
-        }
-
-        if (password && !settings.show_secrets)
-        {
-            prefix = "";
-            password.reset();
-            salt.reset();
-            auth_type_name = AuthenticationTypeInfo::get(auth_type).name;
-        }
-
-        settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " IDENTIFIED" << (settings.hilite ? IAST::hilite_none : "");
-
-        if (!auth_type_name.empty())
-        {
-            settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " WITH " << auth_type_name
-                          << (settings.hilite ? IAST::hilite_none : "");
-        }
-
-        if (!prefix.empty())
-        {
-            settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " " << prefix << (settings.hilite ? IAST::hilite_none : "");
-        }
-
-        if (password)
-        {
-            settings.ostr << " " << quoteString(*password);
-        }
-
-        if (salt)
-        {
-            settings.ostr << " SALT " << quoteString(*salt);
-        }
-
-        if (parameter)
-        {
-            settings.ostr << " " << quoteString(*parameter);
-        }
-        else if (parameters)
-        {
-            settings.ostr << " ";
-            bool need_comma = false;
-            for (const auto & param : *parameters)
-            {
-                if (std::exchange(need_comma, true))
-                    settings.ostr << ", ";
-                settings.ostr << quoteString(param);
-            }
-        }
+        auth_data.format(settings);
     }
 
 
@@ -276,6 +159,7 @@ String ASTCreateUserQuery::getID(char) const
 ASTPtr ASTCreateUserQuery::clone() const
 {
     auto res = std::make_shared<ASTCreateUserQuery>(*this);
+    res->children.clear();
 
     if (names)
         res->names = std::static_pointer_cast<ASTUserNamesWithHost>(names->clone());
@@ -292,6 +176,12 @@ ASTPtr ASTCreateUserQuery::clone() const
     if (settings)
         res->settings = std::static_pointer_cast<ASTSettingsProfileElements>(settings->clone());
 
+    if (auth_data)
+    {
+        res->auth_data = std::static_pointer_cast<ASTAuthenticationData>(auth_data->clone());
+        res->children.push_back(res->auth_data);
+    }
+
     return res;
 }
 
@@ -346,17 +236,4 @@ void ASTCreateUserQuery::formatImpl(const FormatSettings & format, FormatState &
         formatGrantees(*grantees, format);
 }
 
-bool ASTCreateUserQuery::hasSecretParts() const
-{
-    if (auth_data)
-    {
-        auto auth_type = auth_data->getType();
-        if ((auth_type == AuthenticationType::PLAINTEXT_PASSWORD)
-            || (auth_type == AuthenticationType::SHA256_PASSWORD)
-            || (auth_type == AuthenticationType::DOUBLE_SHA1_PASSWORD))
-            return true;
-    }
-    return childrenHaveSecretParts();
-}
-
 }
diff --git a/src/Parsers/Access/ASTCreateUserQuery.h b/src/Parsers/Access/ASTCreateUserQuery.h
index a3571dd6c61..62ddbfd0040 100644
--- a/src/Parsers/Access/ASTCreateUserQuery.h
+++ b/src/Parsers/Access/ASTCreateUserQuery.h
@@ -3,7 +3,7 @@
 #include <Parsers/IAST.h>
 #include <Parsers/ASTQueryWithOnCluster.h>
 #include <Parsers/ASTDatabaseOrNone.h>
-#include <Access/Common/AuthenticationData.h>
+#include <Access/Common/AuthenticationType.h>
 #include <Access/Common/AllowedClientHosts.h>
 
 
@@ -13,6 +13,8 @@ class ASTUserNamesWithHost;
 class ASTRolesOrUsersSet;
 class ASTDatabaseOrNone;
 class ASTSettingsProfileElements;
+class ASTAuthenticationData;
+
 
 /** CREATE USER [IF NOT EXISTS | OR REPLACE] name
   *     [NOT IDENTIFIED | IDENTIFIED {[WITH {no_password|plaintext_password|sha256_password|sha256_hash|double_sha1_password|double_sha1_hash}] BY {'password'|'hash'}}|{WITH ldap SERVER 'server_name'}|{WITH kerberos [REALM 'realm']}]
@@ -44,9 +46,7 @@ public:
     std::shared_ptr<ASTUserNamesWithHost> names;
     std::optional<String> new_name;
 
-    std::optional<AuthenticationData> auth_data;
-
-    mutable std::optional<String> temporary_password_for_checks;
+    std::shared_ptr<ASTAuthenticationData> auth_data;
 
     std::optional<AllowedClientHosts> hosts;
     std::optional<AllowedClientHosts> add_hosts;
@@ -61,7 +61,6 @@ public:
     String getID(char) const override;
     ASTPtr clone() const override;
     void formatImpl(const FormatSettings & format, FormatState &, FormatStateStacked) const override;
-    bool hasSecretParts() const override;
     ASTPtr getRewrittenASTWithoutOnCluster(const WithoutOnClusterASTRewriteParams &) const override { return removeOnCluster<ASTCreateUserQuery>(clone()); }
 
     QueryKind getQueryKind() const override { return QueryKind::Create; }
diff --git a/src/Parsers/Access/ParserCreateUserQuery.cpp b/src/Parsers/Access/ParserCreateUserQuery.cpp
index c1d0691d305..0237a457f2d 100644
--- a/src/Parsers/Access/ParserCreateUserQuery.cpp
+++ b/src/Parsers/Access/ParserCreateUserQuery.cpp
@@ -3,6 +3,7 @@
 #include <Parsers/Access/ASTRolesOrUsersSet.h>
 #include <Parsers/Access/ASTSettingsProfileElement.h>
 #include <Parsers/Access/ASTUserNameWithHost.h>
+#include <Parsers/Access/ASTAuthenticationData.h>
 #include <Parsers/Access/ParserRolesOrUsersSet.h>
 #include <Parsers/Access/ParserSettingsProfileElement.h>
 #include <Parsers/Access/ParserUserNameWithHost.h>
@@ -17,21 +18,11 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <base/insertAtEnd.h>
 #include "config.h"
-#include <base/hex.h>
-#if USE_SSL
-#     include <openssl/crypto.h>
-#     include <openssl/rand.h>
-#     include <openssl/err.h>
-#endif
+
 
 namespace DB
 {
 
-namespace ErrorCodes
-{
-    extern const int OPENSSL_ERROR;
-}
-
 namespace
 {
     bool parseRenameTo(IParserBase::Pos & pos, Expected & expected, std::optional<String> & new_name)
@@ -50,14 +41,29 @@ namespace
         });
     }
 
+    class ParserStringAndSubstitution : public IParserBase
+    {
+    private:
+        const char * getName() const override { return "ParserStringAndSubstitution"; }
+        bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override
+        {
+            return ParserStringLiteral{}.parse(pos, node, expected) || ParserSubstitution{}.parse(pos, node, expected);
+        }
 
-    bool parseAuthenticationData(IParserBase::Pos & pos, Expected & expected, AuthenticationData & auth_data, std::optional<String> & temporary_password_for_checks)
+    public:
+        explicit ParserStringAndSubstitution() = default;
+    };
+
+
+    bool parseAuthenticationData(IParserBase::Pos & pos, Expected & expected, std::shared_ptr<ASTAuthenticationData> & auth_data)
     {
         return IParserBase::wrapParseImpl(pos, [&]
         {
             if (ParserKeyword{"NOT IDENTIFIED"}.ignore(pos, expected))
             {
-                auth_data = AuthenticationData{AuthenticationType::NO_PASSWORD};
+                auth_data = std::make_shared<ASTAuthenticationData>();
+                auth_data->type = AuthenticationType::NO_PASSWORD;
+
                 return true;
             }
 
@@ -65,6 +71,7 @@ namespace
                 return false;
 
             std::optional<AuthenticationType> type;
+
             bool expect_password = false;
             bool expect_hash = false;
             bool expect_ldap_server_name = false;
@@ -109,47 +116,38 @@ namespace
                 }
             }
 
+            /// If authentication type is not specified, then the default password type is used
             if (!type)
-            {
-                type = AuthenticationType::SHA256_PASSWORD;
                 expect_password = true;
-            }
 
-            String value;
-            String parsed_salt;
-            boost::container::flat_set<String> common_names;
+            ASTPtr value;
+            ASTPtr parsed_salt;
+            ASTPtr common_names;
             if (expect_password || expect_hash)
             {
-                ASTPtr ast;
-                if (!ParserKeyword{"BY"}.ignore(pos, expected) || !ParserStringLiteral{}.parse(pos, ast, expected))
+                if (!ParserKeyword{"BY"}.ignore(pos, expected) || !ParserStringAndSubstitution{}.parse(pos, value, expected))
                     return false;
-                value = ast->as<const ASTLiteral &>().value.safeGet<String>();
 
                 if (expect_hash && type == AuthenticationType::SHA256_PASSWORD)
                 {
-                    if (ParserKeyword{"SALT"}.ignore(pos, expected) && ParserStringLiteral{}.parse(pos, ast, expected))
+                    if (ParserKeyword{"SALT"}.ignore(pos, expected))
                     {
-                        parsed_salt = ast->as<const ASTLiteral &>().value.safeGet<String>();
+                        if (!ParserStringAndSubstitution{}.parse(pos, parsed_salt, expected))
+                            return false;
                     }
                 }
             }
             else if (expect_ldap_server_name)
             {
-                ASTPtr ast;
-                if (!ParserKeyword{"SERVER"}.ignore(pos, expected) || !ParserStringLiteral{}.parse(pos, ast, expected))
+                if (!ParserKeyword{"SERVER"}.ignore(pos, expected) || !ParserStringAndSubstitution{}.parse(pos, value, expected))
                     return false;
-
-                value = ast->as<const ASTLiteral &>().value.safeGet<String>();
             }
             else if (expect_kerberos_realm)
             {
                 if (ParserKeyword{"REALM"}.ignore(pos, expected))
                 {
-                    ASTPtr ast;
-                    if (!ParserStringLiteral{}.parse(pos, ast, expected))
+                    if (!ParserStringAndSubstitution{}.parse(pos, value, expected))
                         return false;
-
-                    value = ast->as<const ASTLiteral &>().value.safeGet<String>();
                 }
             }
             else if (expect_common_names)
@@ -157,63 +155,24 @@ namespace
                 if (!ParserKeyword{"CN"}.ignore(pos, expected))
                     return false;
 
-                ASTPtr ast;
-                if (!ParserList{std::make_unique<ParserStringLiteral>(), std::make_unique<ParserToken>(TokenType::Comma), false}.parse(pos, ast, expected))
+                if (!ParserList{std::make_unique<ParserStringAndSubstitution>(), std::make_unique<ParserToken>(TokenType::Comma), false}.parse(pos, common_names, expected))
                     return false;
-
-                for (const auto & ast_child : ast->children)
-                    common_names.insert(ast_child->as<const ASTLiteral &>().value.safeGet<String>());
             }
 
-            /// Save password separately for future complexity rules check
-            if (expect_password)
-                temporary_password_for_checks = value;
+            auth_data = std::make_shared<ASTAuthenticationData>();
 
-            auth_data = AuthenticationData{*type};
-            if (auth_data.getType() == AuthenticationType::SHA256_PASSWORD)
-            {
-                if (!parsed_salt.empty())
-                {
-                    auth_data.setSalt(parsed_salt);
-                }
-                else if (expect_password)
-                {
-#if USE_SSL
-                    ///generate and add salt here
-                    ///random generator FIPS complaint
-                    uint8_t key[32];
-                    if (RAND_bytes(key, sizeof(key)) != 1)
-                    {
-                        char buf[512] = {0};
-                        ERR_error_string_n(ERR_get_error(), buf, sizeof(buf));
-                        throw Exception(ErrorCodes::OPENSSL_ERROR, "Cannot generate salt for password. OpenSSL {}", buf);
-                    }
+            auth_data->type = type;
+            auth_data->contains_password = expect_password;
+            auth_data->contains_hash = expect_hash;
 
-                    String salt;
-                    salt.resize(sizeof(key) * 2);
-                    char * buf_pos = salt.data();
-                    for (uint8_t k : key)
-                    {
-                        writeHexByteUppercase(k, buf_pos);
-                        buf_pos += 2;
-                    }
-                    value.append(salt);
-                    auth_data.setSalt(salt);
-#else
-                    ///if USE_SSL is not defined, Exception thrown later
-#endif
-                }
-            }
-            if (expect_password)
-                auth_data.setPassword(value);
-            else if (expect_hash)
-                auth_data.setPasswordHashHex(value);
-            else if (expect_ldap_server_name)
-                auth_data.setLDAPServerName(value);
-            else if (expect_kerberos_realm)
-                auth_data.setKerberosRealm(value);
-            else if (expect_common_names)
-                auth_data.setSSLCertificateCommonNames(std::move(common_names));
+            if (value)
+                auth_data->children.push_back(std::move(value));
+
+            if (parsed_salt)
+                auth_data->children.push_back(std::move(parsed_salt));
+
+            if (common_names)
+                auth_data->children = std::move(common_names->children);
 
             return true;
         });
@@ -441,11 +400,11 @@ bool ParserCreateUserQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expec
     auto names_ref = names->names;
 
     std::optional<String> new_name;
-    std::optional<AuthenticationData> auth_data;
-    std::optional<String> temporary_password_for_checks;
+    std::optional<String> temporary_password;
     std::optional<AllowedClientHosts> hosts;
     std::optional<AllowedClientHosts> add_hosts;
     std::optional<AllowedClientHosts> remove_hosts;
+    std::shared_ptr<ASTAuthenticationData> auth_data;
     std::shared_ptr<ASTRolesOrUsersSet> default_roles;
     std::shared_ptr<ASTSettingsProfileElements> settings;
     std::shared_ptr<ASTRolesOrUsersSet> grantees;
@@ -456,12 +415,10 @@ bool ParserCreateUserQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expec
     {
         if (!auth_data)
         {
-            AuthenticationData new_auth_data;
-            std::optional<String> new_temporary_password_for_checks;
-            if (parseAuthenticationData(pos, expected, new_auth_data, new_temporary_password_for_checks))
+            std::shared_ptr<ASTAuthenticationData> new_auth_data;
+            if (parseAuthenticationData(pos, expected, new_auth_data))
             {
                 auth_data = std::move(new_auth_data);
-                temporary_password_for_checks = std::move(new_temporary_password_for_checks);
                 continue;
             }
         }
@@ -546,7 +503,6 @@ bool ParserCreateUserQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expec
     query->names = std::move(names);
     query->new_name = std::move(new_name);
     query->auth_data = std::move(auth_data);
-    query->temporary_password_for_checks = std::move(temporary_password_for_checks);
     query->hosts = std::move(hosts);
     query->add_hosts = std::move(add_hosts);
     query->remove_hosts = std::move(remove_hosts);
@@ -555,6 +511,9 @@ bool ParserCreateUserQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expec
     query->grantees = std::move(grantees);
     query->default_database = std::move(default_database);
 
+    if (query->auth_data)
+        query->children.push_back(query->auth_data);
+
     return true;
 }
 }
diff --git a/src/Parsers/tests/gtest_Parser.cpp b/src/Parsers/tests/gtest_Parser.cpp
index b452bd27642..19872c4189a 100644
--- a/src/Parsers/tests/gtest_Parser.cpp
+++ b/src/Parsers/tests/gtest_Parser.cpp
@@ -5,6 +5,7 @@
 #include <Parsers/ASTIdentifier.h>
 #include <Parsers/Access/ASTCreateUserQuery.h>
 #include <Parsers/Access/ParserCreateUserQuery.h>
+#include <Parsers/Access/ASTAuthenticationData.h>
 #include <Parsers/ParserAlterQuery.h>
 #include <Parsers/ParserCreateQuery.h>
 #include <Parsers/ParserOptimizeQuery.h>
@@ -69,7 +70,7 @@ TEST_P(ParserTest, parseQuery)
             {
                 if (input_text.starts_with("ATTACH"))
                 {
-                    auto salt = (dynamic_cast<const ASTCreateUserQuery *>(ast.get())->auth_data)->getSalt();
+                    auto salt = (dynamic_cast<const ASTCreateUserQuery *>(ast.get())->auth_data)->getSalt().value_or("");
                     EXPECT_TRUE(std::regex_match(salt, std::regex(expected_ast)));
                 }
                 else
@@ -260,7 +261,7 @@ INSTANTIATE_TEST_SUITE_P(ParserCreateUserQuery, ParserTest,
         ::testing::ValuesIn(std::initializer_list<ParserTestCase>{
         {
             "CREATE USER user1 IDENTIFIED WITH sha256_password BY 'qwe123'",
-            "CREATE USER user1 IDENTIFIED WITH sha256_hash BY '[A-Za-z0-9]{64}' SALT '[A-Za-z0-9]{64}'"
+            "CREATE USER user1 IDENTIFIED WITH sha256_password BY 'qwe123'"
         },
         {
             "CREATE USER user1 IDENTIFIED WITH sha256_hash BY '7A37B85C8918EAC19A9089C0FA5A2AB4DCE3F90528DCDEEC108B23DDF3607B99' SALT 'salt'",
@@ -268,7 +269,7 @@ INSTANTIATE_TEST_SUITE_P(ParserCreateUserQuery, ParserTest,
         },
         {
             "ALTER USER user1 IDENTIFIED WITH sha256_password BY 'qwe123'",
-            "ALTER USER user1 IDENTIFIED WITH sha256_hash BY '[A-Za-z0-9]{64}' SALT '[A-Za-z0-9]{64}'"
+            "ALTER USER user1 IDENTIFIED WITH sha256_password BY 'qwe123'"
         },
         {
             "ALTER USER user1 IDENTIFIED WITH sha256_hash BY '7A37B85C8918EAC19A9089C0FA5A2AB4DCE3F90528DCDEEC108B23DDF3607B99' SALT 'salt'",
diff --git a/src/Processors/Executors/ExecutingGraph.cpp b/src/Processors/Executors/ExecutingGraph.cpp
index 574b1ccbcd2..27f6a454b24 100644
--- a/src/Processors/Executors/ExecutingGraph.cpp
+++ b/src/Processors/Executors/ExecutingGraph.cpp
@@ -219,7 +219,7 @@ bool ExecutingGraph::updateNode(uint64_t pid, Queue & queue, Queue & async_queue
     std::stack<uint64_t> updated_processors;
     updated_processors.push(pid);
 
-    UpgradableMutex::ReadGuard read_lock(nodes_mutex);
+    std::shared_lock read_lock(nodes_mutex);
 
     while (!updated_processors.empty() || !updated_edges.empty())
     {
@@ -382,11 +382,14 @@ bool ExecutingGraph::updateNode(uint64_t pid, Queue & queue, Queue & async_queue
 
             if (need_expand_pipeline)
             {
+                // We do not need to upgrade lock atomically, so we can safely release shared_lock and acquire unique_lock
+                read_lock.unlock();
                 {
-                    UpgradableMutex::WriteGuard lock(read_lock);
+                    std::unique_lock lock(nodes_mutex);
                     if (!expandPipeline(updated_processors, pid))
                         return false;
                 }
+                read_lock.lock();
 
                 /// Add itself back to be prepared again.
                 updated_processors.push(pid);
diff --git a/src/Processors/Executors/ExecutingGraph.h b/src/Processors/Executors/ExecutingGraph.h
index 69acc7fb31b..1a7659d3e08 100644
--- a/src/Processors/Executors/ExecutingGraph.h
+++ b/src/Processors/Executors/ExecutingGraph.h
@@ -2,7 +2,7 @@
 
 #include <Processors/Port.h>
 #include <Processors/IProcessor.h>
-#include <Processors/Executors/UpgradableLock.h>
+#include <Common/SharedMutex.h>
 #include <mutex>
 #include <queue>
 #include <stack>
@@ -156,7 +156,7 @@ private:
     std::vector<bool> source_processors;
     std::mutex processors_mutex;
 
-    UpgradableMutex nodes_mutex;
+    SharedMutex nodes_mutex;
 
     const bool profile_processors;
     bool cancelled = false;
diff --git a/src/Processors/Executors/UpgradableLock.h b/src/Processors/Executors/UpgradableLock.h
deleted file mode 100644
index b5a31885424..00000000000
--- a/src/Processors/Executors/UpgradableLock.h
+++ /dev/null
@@ -1,175 +0,0 @@
-#pragma once
-#include <atomic>
-#include <cassert>
-#include <list>
-#include <mutex>
-#include <condition_variable>
-
-namespace DB
-{
-
-/// RWLock which allows to upgrade read lock to write lock.
-/// Read locks should be fast if there is no write lock.
-///
-/// Newly created write lock waits for all active read locks.
-/// Newly created read lock waits for all write locks. Starvation is possible.
-///
-/// Mutex must live longer than locks.
-/// Read lock must live longer than corresponding  write lock.
-///
-/// For every write lock, a new internal state is created inside mutex.
-/// This state is not deallocated until the destruction of mutex itself.
-///
-/// Usage example:
-///
-/// UpgradableMutex mutex;
-/// {
-///     UpgradableMutex::ReadLock read_lock(mutex);
-///     ...
-///     {
-///         UpgradableMutex::WriteLock write_lock(read_lock);
-///         ...
-///     }
-///     ...
-/// }
-class UpgradableMutex
-{
-private:
-    /// Implementation idea
-    ///
-    /// ----------- (read scope)
-    /// ++num_readers
-    /// ** wait for active writer (in loop, starvation is possible here) **
-    ///
-    /// =========== (write scope)
-    /// ** create new State **
-    /// ** wait for active writer (in loop, starvation is possible here) **
-    /// ** wait for all active readers **
-    ///
-    /// ** notify all waiting readers for the current state.
-    /// =========== (end write scope)
-    ///
-    /// --num_readers
-    /// ** notify current active writer **
-    /// ----------- (end read scope)
-    struct State
-    {
-        size_t num_waiting = 0;
-        bool is_done = false;
-
-        std::mutex mutex;
-        std::condition_variable read_condvar;
-        std::condition_variable write_condvar;
-
-        void wait() noexcept
-        {
-            std::unique_lock lock(mutex);
-            ++num_waiting;
-            write_condvar.notify_one();
-            while (!is_done)
-                read_condvar.wait(lock);
-        }
-
-        void lock(std::atomic_size_t & num_readers_) noexcept
-        {
-            /// Note : num_locked is an atomic
-            /// which can change it's value without locked mutex.
-            /// We support an invariant that after changing num_locked value,
-            /// UpgradableMutex::write_state is checked, and in case of active
-            /// write lock, we always notify it's write condvar.
-            std::unique_lock lock(mutex);
-            ++num_waiting;
-            while (num_waiting < num_readers_.load())
-                write_condvar.wait(lock);
-        }
-
-        void unlock() noexcept
-        {
-            {
-                std::unique_lock lock(mutex);
-                is_done = true;
-            }
-            read_condvar.notify_all();
-        }
-    };
-
-    std::atomic_size_t num_readers = 0;
-
-    std::list<State> states;
-    std::mutex states_mutex;
-    std::atomic<State *> write_state{nullptr};
-
-    void lock() noexcept
-    {
-        ++num_readers;
-        while (auto * state = write_state.load())
-            state->wait();
-    }
-
-    void unlock() noexcept
-    {
-        --num_readers;
-        while (auto * state = write_state.load())
-            state->write_condvar.notify_one();
-    }
-
-    State * allocState()
-    {
-        std::lock_guard guard(states_mutex);
-        return &states.emplace_back();
-    }
-
-    void upgrade(State & state) noexcept
-    {
-        State * expected = nullptr;
-
-        /// Only change nullptr -> state is possible.
-        while (!write_state.compare_exchange_strong(expected, &state))
-        {
-            expected->wait();
-            expected = nullptr;
-        }
-
-        state.lock(num_readers);
-    }
-
-    void degrade(State & state) noexcept
-    {
-        State * my = write_state.exchange(nullptr);
-        if (&state != my)
-            std::terminate();
-        state.unlock();
-    }
-
-public:
-    class ReadGuard
-    {
-    public:
-        explicit ReadGuard(UpgradableMutex & lock_) : lock(lock_) { lock.lock(); }
-        ~ReadGuard() { lock.unlock(); }
-
-        UpgradableMutex & lock;
-    };
-
-    class WriteGuard
-    {
-    public:
-        explicit WriteGuard(ReadGuard & read_guard_) : read_guard(read_guard_)
-        {
-            state = read_guard.lock.allocState();
-            read_guard.lock.upgrade(*state);
-        }
-
-        ~WriteGuard()
-        {
-            if (state)
-                read_guard.lock.degrade(*state);
-        }
-
-    private:
-        ReadGuard & read_guard;
-        State * state = nullptr;
-    };
-};
-
-}
diff --git a/src/Processors/QueryPlan/ReadFromRemote.cpp b/src/Processors/QueryPlan/ReadFromRemote.cpp
index 4096599cc5c..ca603c53707 100644
--- a/src/Processors/QueryPlan/ReadFromRemote.cpp
+++ b/src/Processors/QueryPlan/ReadFromRemote.cpp
@@ -331,7 +331,7 @@ void ReadFromParallelRemoteReplicasStep::initializePipeline(QueryPipelineBuilder
         all_replicas_count = cluster->getShardsInfo().size();
     }
 
-    /// Find local shard
+    /// Find local shard. It might happen that there is no local shard, but that's fine
     for (const auto & shard: cluster->getShardsInfo())
     {
         if (shard.isLocal())
@@ -346,9 +346,6 @@ void ReadFromParallelRemoteReplicasStep::initializePipeline(QueryPipelineBuilder
         }
     }
 
-    if (pipes.empty())
-        throw Exception(ErrorCodes::LOGICAL_ERROR, "No local shard");
-
     auto current_shard = cluster->getShardsInfo().begin();
     while (pipes.size() != all_replicas_count)
     {
diff --git a/src/Storages/DataLakes/StorageIceberg.h b/src/Storages/DataLakes/StorageIceberg.h
index 6e93c732338..f1c9c485ef0 100644
--- a/src/Storages/DataLakes/StorageIceberg.h
+++ b/src/Storages/DataLakes/StorageIceberg.h
@@ -5,7 +5,7 @@
 #include <Storages/DataLakes/IcebergMetadataParser.h>
 #include "config.h"
 
-#if USE_AWS_S3
+#if USE_AWS_S3 && USE_AVRO
 #include <Storages/DataLakes/S3MetadataReader.h>
 #include <Storages/StorageS3.h>
 #endif
@@ -18,7 +18,7 @@ struct StorageIcebergName
     static constexpr auto name = "Iceberg";
 };
 
-#if USE_AWS_S3
+#if USE_AWS_S3 && USE_AVRO
 using StorageIcebergS3 = IStorageDataLake<StorageS3, StorageIcebergName, IcebergMetadataParser<StorageS3::Configuration, S3DataLakeMetadataReadHelper>>;
 #endif
 
diff --git a/src/Storages/DataLakes/registerDataLakes.cpp b/src/Storages/DataLakes/registerDataLakes.cpp
index 508cf9c8d80..1447a4777c5 100644
--- a/src/Storages/DataLakes/registerDataLakes.cpp
+++ b/src/Storages/DataLakes/registerDataLakes.cpp
@@ -31,11 +31,15 @@ void registerStorageDeltaLake(StorageFactory & factory)
 }
 #endif
 
+#if USE_AVRO /// StorageIceberg depending on Avro to parse metadata with Avro format.
+
 void registerStorageIceberg(StorageFactory & factory)
 {
     REGISTER_DATA_LAKE_STORAGE(StorageIcebergS3, StorageIcebergName::name)
 }
 
+#endif
+
 void registerStorageHudi(StorageFactory & factory)
 {
     REGISTER_DATA_LAKE_STORAGE(StorageHudiS3, StorageHudiName::name)
diff --git a/src/Storages/HDFS/StorageHDFSCluster.cpp b/src/Storages/HDFS/StorageHDFSCluster.cpp
index 45f1df92e38..856d3eb2b27 100644
--- a/src/Storages/HDFS/StorageHDFSCluster.cpp
+++ b/src/Storages/HDFS/StorageHDFSCluster.cpp
@@ -102,7 +102,8 @@ Pipe StorageHDFSCluster::read(
         addColumnsStructureToQueryWithClusterEngine(
             query_to_send, StorageDictionary::generateNamesAndTypesDescription(storage_snapshot->metadata->getColumns().getAll()), 3, getName());
 
-    const auto & current_settings = context->getSettingsRef();
+    auto new_context = IStorageCluster::updateSettingsForTableFunctionCluster(context, context->getSettingsRef());
+    const auto & current_settings = new_context->getSettingsRef();
     auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(current_settings);
     for (const auto & shard_info : cluster->getShardsInfo())
     {
@@ -113,7 +114,7 @@ Pipe StorageHDFSCluster::read(
                 std::vector<IConnectionPool::Entry>{try_result},
                 queryToString(query_to_send),
                 header,
-                context,
+                new_context,
                 /*throttler=*/nullptr,
                 scalars,
                 Tables(),
diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp
index 87dcee9d9a6..98990b9e37b 100644
--- a/src/Storages/IStorage.cpp
+++ b/src/Storages/IStorage.cpp
@@ -136,8 +136,8 @@ void IStorage::read(
 
     /// parallelize processing if not yet
     const size_t output_ports = pipe.numOutputPorts();
-    const auto storage_name = getName();
-    if (parallelizeOutputAfterReading() && output_ports > 0 && output_ports < num_streams)
+    const bool parallelize_output = context->getSettingsRef().parallelize_output_from_storages;
+    if (parallelize_output && parallelizeOutputAfterReading() && output_ports > 0 && output_ports < num_streams)
         pipe.resize(num_streams);
 
     readFromPipe(query_plan, std::move(pipe), column_names, storage_snapshot, query_info, context, getName());
diff --git a/src/Storages/IStorage.h b/src/Storages/IStorage.h
index 3cebb7d6820..a2e827d9830 100644
--- a/src/Storages/IStorage.h
+++ b/src/Storages/IStorage.h
@@ -512,7 +512,7 @@ public:
         throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Mutations are not supported by storage {}", getName());
     }
 
-    virtual void waitForMutation(const String & /*mutation_id*/)
+    virtual void waitForMutation(const String & /*mutation_id*/, bool /*wait_for_another_mutation*/)
     {
         throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Mutations are not supported by storage {}", getName());
     }
diff --git a/src/Storages/IStorageCluster.h b/src/Storages/IStorageCluster.h
index 35d297428ba..03185e7aee6 100644
--- a/src/Storages/IStorageCluster.h
+++ b/src/Storages/IStorageCluster.h
@@ -23,6 +23,18 @@ public:
     virtual RemoteQueryExecutor::Extension getTaskIteratorExtension(ASTPtr query, ContextPtr context) const = 0;
 
     bool isRemote() const override { return true; }
+
+    static ContextPtr updateSettingsForTableFunctionCluster(ContextPtr context, const Settings & settings)
+    {
+        Settings new_settings = settings;
+
+        /// Cluster table functions should always skip unavailable shards.
+        new_settings.skip_unavailable_shards = true;
+
+        auto new_context = Context::createCopy(context);
+        new_context->setSettings(new_settings);
+        return new_context;
+    }
 };
 
 
diff --git a/src/Storages/MergeTree/KeyCondition.cpp b/src/Storages/MergeTree/KeyCondition.cpp
index 5d961425469..ed686a0b38b 100644
--- a/src/Storages/MergeTree/KeyCondition.cpp
+++ b/src/Storages/MergeTree/KeyCondition.cpp
@@ -1999,9 +1999,9 @@ static BoolMask forAnyHyperrectangle(
         if (left_bounded && right_bounded)
             hyperrectangle[prefix_size] = Range(left_keys[prefix_size], true, right_keys[prefix_size], true);
         else if (left_bounded)
-            hyperrectangle[prefix_size] = Range::createLeftBounded(left_keys[prefix_size], true);
+            hyperrectangle[prefix_size] = Range::createLeftBounded(left_keys[prefix_size], true, data_types[prefix_size]->isNullable());
         else if (right_bounded)
-            hyperrectangle[prefix_size] = Range::createRightBounded(right_keys[prefix_size], true);
+            hyperrectangle[prefix_size] = Range::createRightBounded(right_keys[prefix_size], true, data_types[prefix_size]->isNullable());
 
         return callback(hyperrectangle);
     }
diff --git a/src/Storages/MergeTree/MergeTreeBackgroundExecutor.cpp b/src/Storages/MergeTree/MergeTreeBackgroundExecutor.cpp
index 6f1e41d2791..6512aad9260 100644
--- a/src/Storages/MergeTree/MergeTreeBackgroundExecutor.cpp
+++ b/src/Storages/MergeTree/MergeTreeBackgroundExecutor.cpp
@@ -32,13 +32,15 @@ MergeTreeBackgroundExecutor<Queue>::MergeTreeBackgroundExecutor(
     size_t threads_count_,
     size_t max_tasks_count_,
     CurrentMetrics::Metric metric_,
-    CurrentMetrics::Metric max_tasks_metric_)
+    CurrentMetrics::Metric max_tasks_metric_,
+    std::string_view policy)
     : name(name_)
     , threads_count(threads_count_)
     , max_tasks_count(max_tasks_count_)
     , metric(metric_)
     , max_tasks_metric(max_tasks_metric_, 2 * max_tasks_count) // active + pending
-    , pool(std::make_unique<ThreadPool>(CurrentMetrics::MergeTreeBackgroundExecutorThreads, CurrentMetrics::MergeTreeBackgroundExecutorThreadsActive))
+    , pool(std::make_unique<ThreadPool>(
+          CurrentMetrics::MergeTreeBackgroundExecutorThreads, CurrentMetrics::MergeTreeBackgroundExecutorThreadsActive))
 {
     if (max_tasks_count == 0)
         throw Exception(ErrorCodes::INVALID_CONFIG_PARAMETER, "Task count for MergeTreeBackgroundExecutor must not be zero");
@@ -52,20 +54,9 @@ MergeTreeBackgroundExecutor<Queue>::MergeTreeBackgroundExecutor(
 
     for (size_t number = 0; number < threads_count; ++number)
         pool->scheduleOrThrowOnError([this] { threadFunction(); });
-}
 
-template <class Queue>
-MergeTreeBackgroundExecutor<Queue>::MergeTreeBackgroundExecutor(
-    String name_,
-    size_t threads_count_,
-    size_t max_tasks_count_,
-    CurrentMetrics::Metric metric_,
-    CurrentMetrics::Metric max_tasks_metric_,
-    std::string_view policy)
-    requires requires(Queue queue) { queue.updatePolicy(policy); } // Because we use explicit template instantiation
-    : MergeTreeBackgroundExecutor(name_, threads_count_, max_tasks_count_, metric_, max_tasks_metric_)
-{
-    pending.updatePolicy(policy);
+    if (!policy.empty())
+        pending.updatePolicy(policy);
 }
 
 template <class Queue>
@@ -326,5 +317,4 @@ void MergeTreeBackgroundExecutor<Queue>::threadFunction()
 template class MergeTreeBackgroundExecutor<RoundRobinRuntimeQueue>;
 template class MergeTreeBackgroundExecutor<PriorityRuntimeQueue>;
 template class MergeTreeBackgroundExecutor<DynamicRuntimeQueue>;
-
 }
diff --git a/src/Storages/MergeTree/MergeTreeBackgroundExecutor.h b/src/Storages/MergeTree/MergeTreeBackgroundExecutor.h
index 9bfea32c7f9..8142e383d0c 100644
--- a/src/Storages/MergeTree/MergeTreeBackgroundExecutor.h
+++ b/src/Storages/MergeTree/MergeTreeBackgroundExecutor.h
@@ -13,16 +13,22 @@
 #include <boost/noncopyable.hpp>
 #include <Poco/Event.h>
 
-#include <Common/CurrentMetrics.h>
-#include <Common/ThreadPool_fwd.h>
-#include <Common/Stopwatch.h>
-#include <base/defines.h>
 #include <Storages/MergeTree/IExecutableTask.h>
+#include <base/defines.h>
+#include <Common/CurrentMetrics.h>
+#include <Common/Exception.h>
+#include <Common/Stopwatch.h>
+#include <Common/ThreadPool_fwd.h>
 
 
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int NOT_IMPLEMENTED;
+}
+
 struct TaskRuntimeData;
 using TaskRuntimeDataPtr = std::shared_ptr<TaskRuntimeData>;
 
@@ -92,6 +98,11 @@ public:
     void setCapacity(size_t count) { queue.set_capacity(count); }
     bool empty() { return queue.empty(); }
 
+    [[noreturn]] void updatePolicy(std::string_view)
+    {
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method updatePolicy() is not implemented");
+    }
+
     static constexpr std::string_view name = "round_robin";
 
 private:
@@ -126,6 +137,11 @@ public:
     void setCapacity(size_t count) { buffer.reserve(count); }
     bool empty() { return buffer.empty(); }
 
+    [[noreturn]] void updatePolicy(std::string_view)
+    {
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method updatePolicy() is not implemented");
+    }
+
     static constexpr std::string_view name = "shortest_task_first";
 
 private:
@@ -239,20 +255,14 @@ template <class Queue>
 class MergeTreeBackgroundExecutor final : boost::noncopyable
 {
 public:
-    MergeTreeBackgroundExecutor(
-        String name_,
-        size_t threads_count_,
-        size_t max_tasks_count_,
-        CurrentMetrics::Metric metric_,
-        CurrentMetrics::Metric max_tasks_metric_);
     MergeTreeBackgroundExecutor(
         String name_,
         size_t threads_count_,
         size_t max_tasks_count_,
         CurrentMetrics::Metric metric_,
         CurrentMetrics::Metric max_tasks_metric_,
-        std::string_view policy)
-        requires requires(Queue queue) { queue.updatePolicy(policy); }; // Because we use explicit template instantiation
+        std::string_view policy = {});
+
     ~MergeTreeBackgroundExecutor();
 
     /// Handler for hot-reloading
@@ -271,7 +281,6 @@ public:
 
     /// Update scheduling policy for pending tasks. It does nothing if `new_policy` is the same or unknown.
     void updateSchedulingPolicy(std::string_view new_policy)
-        requires requires(Queue queue) { queue.updatePolicy(new_policy); } // Because we use explicit template instantiation
     {
         std::lock_guard lock(mutex);
         pending.updatePolicy(new_policy);
diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp
index afde1cd2fca..83f5c0d359c 100644
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@@ -18,6 +18,7 @@
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/typeid_cast.h>
 #include <Common/CurrentMetrics.h>
+#include <Common/ThreadFuzzer.h>
 #include <Compression/CompressedReadBuffer.h>
 #include <Core/QueryProcessingStage.h>
 #include <DataTypes/DataTypeEnum.h>
@@ -2044,6 +2045,7 @@ size_t MergeTreeData::clearOldTemporaryDirectories(size_t custom_directories_lif
             {
                 if (isOldPartDirectory(disk, it->path(), deadline))
                 {
+                    ThreadFuzzer::maybeInjectSleep();
                     if (temporary_parts.contains(basename))
                     {
                         /// Actually we don't rely on temporary_directories_lifetime when removing old temporaries directories,
@@ -2051,6 +2053,13 @@ size_t MergeTreeData::clearOldTemporaryDirectories(size_t custom_directories_lif
                         LOG_INFO(LogFrequencyLimiter(log, 10), "{} is in use (by merge/mutation/INSERT) (consider increasing temporary_directories_lifetime setting)", full_path);
                         continue;
                     }
+                    else if (!disk->exists(it->path()))
+                    {
+                        /// We should recheck that the dir exists, otherwise we can get "No such file or directory"
+                        /// due to a race condition with "Renaming temporary part" (temporary part holder could be already released, so the check above is not enough)
+                        LOG_WARNING(log, "Temporary directory {} suddenly disappeared while iterating, assuming it was concurrently renamed to persistent", it->path());
+                        continue;
+                    }
                     else
                     {
                         LOG_WARNING(log, "Removing temporary directory {}", full_path);
@@ -3948,6 +3957,9 @@ void MergeTreeData::forcefullyMovePartToDetachedAndRemoveFromMemory(const MergeT
     else
         LOG_INFO(log, "Renaming {} to {}_{} and forgetting it.", part_to_detach->getDataPartStorage().getPartDirectory(), prefix, part_to_detach->name);
 
+    if (restore_covered)
+        waitForOutdatedPartsToBeLoaded();
+
     auto lock = lockParts();
     bool removed_active_part = false;
     bool restored_active_part = false;
diff --git a/src/Storages/MergeTree/MergeTreePartition.cpp b/src/Storages/MergeTree/MergeTreePartition.cpp
index 2c5350909d5..1626018f1c1 100644
--- a/src/Storages/MergeTree/MergeTreePartition.cpp
+++ b/src/Storages/MergeTree/MergeTreePartition.cpp
@@ -84,7 +84,15 @@ namespace
         }
         void operator() (const UUID & x) const
         {
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+            auto tmp_x = x.toUnderType();
+            char * start = reinterpret_cast<char *>(&tmp_x);
+            char * end = start + sizeof(tmp_x);
+            std::reverse(start, end);
+            operator()(tmp_x);
+#else
             operator()(x.toUnderType());
+#endif
         }
         void operator() (const IPv4 & x) const
         {
diff --git a/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.cpp b/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.cpp
index 6ad0628eac4..77c280d4710 100644
--- a/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.cpp
+++ b/src/Storages/MergeTree/ParallelReplicasReadingCoordinator.cpp
@@ -131,7 +131,7 @@ public:
 
 DefaultCoordinator::~DefaultCoordinator()
 {
-    LOG_INFO(log, "Coordination done: {}", toString(stats));
+    LOG_DEBUG(log, "Coordination done: {}", toString(stats));
 }
 
 void DefaultCoordinator::updateReadingState(const InitialAllRangesAnnouncement & announcement)
@@ -214,7 +214,7 @@ void DefaultCoordinator::finalizeReadingState()
         description += fmt::format("Replicas: ({}) --- ", fmt::join(part.replicas, ","));
     }
 
-    LOG_INFO(log, "Reading state is fully initialized: {}", description);
+    LOG_DEBUG(log, "Reading state is fully initialized: {}", description);
 }
 
 
@@ -228,7 +228,7 @@ void DefaultCoordinator::handleInitialAllRangesAnnouncement(InitialAllRangesAnno
     stats[announcement.replica_num].number_of_requests +=1;
 
     ++sent_initial_requests;
-    LOG_INFO(log, "{} {}", sent_initial_requests, replicas_count);
+    LOG_DEBUG(log, "Sent initial requests: {} Replicas count: {}", sent_initial_requests, replicas_count);
     if (sent_initial_requests == replicas_count)
         finalizeReadingState();
 }
@@ -334,7 +334,7 @@ public:
     {}
     ~InOrderCoordinator() override
     {
-        LOG_INFO(log, "Coordination done: {}", toString(stats));
+        LOG_DEBUG(log, "Coordination done: {}", toString(stats));
     }
 
     ParallelReadResponse handleRequest([[ maybe_unused ]]  ParallelReadRequest request) override;
@@ -349,7 +349,7 @@ public:
 template <CoordinationMode mode>
 void InOrderCoordinator<mode>::handleInitialAllRangesAnnouncement(InitialAllRangesAnnouncement announcement)
 {
-    LOG_TRACE(log, "Received an announecement {}", announcement.describe());
+    LOG_TRACE(log, "Received an announcement {}", announcement.describe());
 
     /// To get rid of duplicates
     for (const auto & part: announcement.description)
diff --git a/src/Storages/MergeTree/RangesInDataPart.cpp b/src/Storages/MergeTree/RangesInDataPart.cpp
index ab76611a507..6203f9f7483 100644
--- a/src/Storages/MergeTree/RangesInDataPart.cpp
+++ b/src/Storages/MergeTree/RangesInDataPart.cpp
@@ -1,12 +1,23 @@
 #include <Storages/MergeTree/RangesInDataPart.h>
 
-#include <Storages/MergeTree/IMergeTreeDataPart.h>
-
-#include "IO/VarInt.h"
+#include <fmt/format.h>
 
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
+#include <Storages/MergeTree/IMergeTreeDataPart.h>
+#include "IO/VarInt.h"
 
+template <>
+struct fmt::formatter<DB::RangesInDataPartDescription>
+{
+    static constexpr auto parse(format_parse_context & ctx) { return ctx.begin(); }
+
+    template <typename FormatContext>
+    auto format(const DB::RangesInDataPartDescription & range, FormatContext & ctx)
+    {
+        return format_to(ctx.out(), "{}", range.describe());
+    }
+};
 
 namespace DB
 {
@@ -26,8 +37,7 @@ void RangesInDataPartDescription::serialize(WriteBuffer & out) const
 String RangesInDataPartDescription::describe() const
 {
     String result;
-    result += fmt::format("Part: {}, ", info.getPartNameV1());
-    result += fmt::format("Ranges: [{}], ", fmt::join(ranges, ","));
+    result += fmt::format("part {} with ranges [{}]", info.getPartNameV1(), fmt::join(ranges, ","));
     return result;
 }
 
@@ -46,10 +56,7 @@ void RangesInDataPartsDescription::serialize(WriteBuffer & out) const
 
 String RangesInDataPartsDescription::describe() const
 {
-    String result;
-    for (const auto & desc : *this)
-        result += desc.describe() + ",";
-    return result;
+    return fmt::format("{} parts: [{}]", this->size(), fmt::join(*this, ", "));
 }
 
 void RangesInDataPartsDescription::deserialize(ReadBuffer & in)
diff --git a/src/Storages/MergeTree/ReplicatedTableStatus.h b/src/Storages/MergeTree/ReplicatedTableStatus.h
index 46e971f562a..ce9ad3640f4 100644
--- a/src/Storages/MergeTree/ReplicatedTableStatus.h
+++ b/src/Storages/MergeTree/ReplicatedTableStatus.h
@@ -16,6 +16,7 @@ struct ReplicatedTableStatus
 
     ReplicatedMergeTreeQueue::Status queue;
     UInt32 parts_to_check;
+    String zookeeper_name;
     String zookeeper_path;
     String replica_name;
     String replica_path;
diff --git a/src/Storages/MergeTree/RequestResponse.cpp b/src/Storages/MergeTree/RequestResponse.cpp
index 945477c5a34..05930d5a4c4 100644
--- a/src/Storages/MergeTree/RequestResponse.cpp
+++ b/src/Storages/MergeTree/RequestResponse.cpp
@@ -88,10 +88,7 @@ void ParallelReadResponse::serialize(WriteBuffer & out) const
 
 String ParallelReadResponse::describe() const
 {
-    String result;
-    result += fmt::format("finish: {} \n", finish);
-    result += description.describe();
-    return result;
+    return fmt::format("{}. Finish: {}", description.describe(), finish);
 }
 
 void ParallelReadResponse::deserialize(ReadBuffer & in)
diff --git a/src/Storages/StorageMergeTree.cpp b/src/Storages/StorageMergeTree.cpp
index 61b096b6689..981e856fc83 100644
--- a/src/Storages/StorageMergeTree.cpp
+++ b/src/Storages/StorageMergeTree.cpp
@@ -339,7 +339,7 @@ void StorageMergeTree::alter(
             if (prev_mutation != 0)
             {
                 LOG_DEBUG(log, "Cannot change metadata with barrier alter query, will wait for mutation {}", prev_mutation);
-                waitForMutation(prev_mutation);
+                waitForMutation(prev_mutation, /* from_another_mutation */ true);
                 LOG_DEBUG(log, "Mutation {} finished", prev_mutation);
             }
         }
@@ -535,19 +535,19 @@ void StorageMergeTree::updateMutationEntriesErrors(FutureMergedMutatedPartPtr re
     mutation_wait_event.notify_all();
 }
 
-void StorageMergeTree::waitForMutation(Int64 version)
+void StorageMergeTree::waitForMutation(Int64 version, bool wait_for_another_mutation)
 {
     String mutation_id = MergeTreeMutationEntry::versionToFileName(version);
-    waitForMutation(version, mutation_id);
+    waitForMutation(version, mutation_id, wait_for_another_mutation);
 }
 
-void StorageMergeTree::waitForMutation(const String & mutation_id)
+void StorageMergeTree::waitForMutation(const String & mutation_id, bool wait_for_another_mutation)
 {
     Int64 version = MergeTreeMutationEntry::parseFileName(mutation_id);
-    waitForMutation(version, mutation_id);
+    waitForMutation(version, mutation_id, wait_for_another_mutation);
 }
 
-void StorageMergeTree::waitForMutation(Int64 version, const String & mutation_id)
+void StorageMergeTree::waitForMutation(Int64 version, const String & mutation_id, bool wait_for_another_mutation)
 {
     LOG_INFO(log, "Waiting mutation: {}", mutation_id);
     {
@@ -567,7 +567,7 @@ void StorageMergeTree::waitForMutation(Int64 version, const String & mutation_id
     std::set<String> mutation_ids;
     mutation_ids.insert(mutation_id);
 
-    auto mutation_status = getIncompleteMutationsStatus(version, &mutation_ids);
+    auto mutation_status = getIncompleteMutationsStatus(version, &mutation_ids, wait_for_another_mutation);
     checkMutationStatus(mutation_status, mutation_ids);
 
     LOG_INFO(log, "Mutation {} done", mutation_id);
@@ -617,7 +617,8 @@ bool comparator(const PartVersionWithName & f, const PartVersionWithName & s)
 
 }
 
-std::optional<MergeTreeMutationStatus> StorageMergeTree::getIncompleteMutationsStatus(Int64 mutation_version, std::set<String> * mutation_ids) const
+std::optional<MergeTreeMutationStatus> StorageMergeTree::getIncompleteMutationsStatus(
+    Int64 mutation_version, std::set<String> * mutation_ids, bool from_another_mutation) const
 {
     std::lock_guard lock(currently_processing_in_background_mutex);
 
@@ -631,7 +632,9 @@ std::optional<MergeTreeMutationStatus> StorageMergeTree::getIncompleteMutationsS
     const auto & mutation_entry = current_mutation_it->second;
 
     auto txn = tryGetTransactionForMutation(mutation_entry, log);
-    assert(txn || mutation_entry.tid.isPrehistoric());
+    /// There's no way a transaction may finish before a mutation that was started by the transaction.
+    /// But sometimes we need to check status of an unrelated mutation, in this case we don't care about transactions.
+    assert(txn || mutation_entry.tid.isPrehistoric() || from_another_mutation);
     auto data_parts = getVisibleDataPartsVector(txn);
     for (const auto & data_part : data_parts)
     {
@@ -656,7 +659,7 @@ std::optional<MergeTreeMutationStatus> StorageMergeTree::getIncompleteMutationsS
                             mutation_ids->insert(it->second.file_name);
                 }
             }
-            else if (txn)
+            else if (txn && !from_another_mutation)
             {
                 /// Part is locked by concurrent transaction, most likely it will never be mutated
                 TIDHash part_locked = data_part->version.removal_tid_lock.load();
diff --git a/src/Storages/StorageMergeTree.h b/src/Storages/StorageMergeTree.h
index 6f8acf9965a..3a39ae12856 100644
--- a/src/Storages/StorageMergeTree.h
+++ b/src/Storages/StorageMergeTree.h
@@ -190,9 +190,9 @@ private:
     /// and into in-memory structures. Wake up merge-mutation task.
     Int64 startMutation(const MutationCommands & commands, ContextPtr query_context);
     /// Wait until mutation with version will finish mutation for all parts
-    void waitForMutation(Int64 version);
-    void waitForMutation(const String & mutation_id) override;
-    void waitForMutation(Int64 version, const String & mutation_id);
+    void waitForMutation(Int64 version, bool wait_for_another_mutation = false);
+    void waitForMutation(const String & mutation_id, bool wait_for_another_mutation) override;
+    void waitForMutation(Int64 version, const String & mutation_id, bool wait_for_another_mutation = false);
     void setMutationCSN(const String & mutation_id, CSN csn) override;
 
 
@@ -253,7 +253,8 @@ private:
     /// because we can execute several mutations at once. Order is important for
     /// better readability of exception message. If mutation was killed doesn't
     /// return any ids.
-    std::optional<MergeTreeMutationStatus> getIncompleteMutationsStatus(Int64 mutation_version, std::set<String> * mutation_ids = nullptr) const;
+    std::optional<MergeTreeMutationStatus> getIncompleteMutationsStatus(Int64 mutation_version, std::set<String> * mutation_ids = nullptr,
+                                                                        bool from_another_mutation = false) const;
 
     void fillNewPartName(MutableDataPartPtr & part, DataPartsLock & lock);
 
diff --git a/src/Storages/StoragePostgreSQL.cpp b/src/Storages/StoragePostgreSQL.cpp
index 8e1a799fa07..e013199c584 100644
--- a/src/Storages/StoragePostgreSQL.cpp
+++ b/src/Storages/StoragePostgreSQL.cpp
@@ -345,6 +345,7 @@ private:
         PreparedInsert(pqxx::connection & connection_, const String & table, const String & schema,
                        const ColumnsWithTypeAndName & columns, const String & on_conflict_)
             : Inserter(connection_)
+            , statement_name("insert_" + getHexUIntLowercase(thread_local_rng()))
         {
             WriteBufferFromOwnString buf;
             buf << getInsertQuery(schema, table, columns, IdentifierQuotingStyle::DoubleQuotes);
@@ -357,12 +358,14 @@ private:
             }
             buf << ") ";
             buf << on_conflict_;
-            connection.prepare("insert", buf.str());
+            connection.prepare(statement_name, buf.str());
+            prepared = true;
         }
 
         void complete() override
         {
-            connection.unprepare("insert");
+            connection.unprepare(statement_name);
+            prepared = false;
             tx.commit();
         }
 
@@ -371,8 +374,24 @@ private:
             pqxx::params params;
             params.reserve(row.size());
             params.append_multi(row);
-            tx.exec_prepared("insert", params);
+            tx.exec_prepared(statement_name, params);
         }
+
+        ~PreparedInsert() override
+        {
+            try
+            {
+                if (prepared)
+                    connection.unprepare(statement_name);
+            }
+            catch (...)
+            {
+                tryLogCurrentException(__PRETTY_FUNCTION__);
+            }
+        }
+
+        const String statement_name;
+        bool prepared = false;
     };
 
     StorageMetadataPtr metadata_snapshot;
@@ -397,7 +416,7 @@ StoragePostgreSQL::Configuration StoragePostgreSQL::processNamedCollectionResult
         required_arguments.insert("table");
 
     validateNamedCollection<ValidateKeysMultiset<ExternalDatabaseEqualKeysSet>>(
-        named_collection, required_arguments, {"schema", "on_conflict", "addresses_expr", "host", "hostname", "port"});
+        named_collection, required_arguments, {"schema", "on_conflict", "addresses_expr", "host", "hostname", "port", "use_tables_cache"});
 
     configuration.addresses_expr = named_collection.getOrDefault<String>("addresses_expr", "");
     if (configuration.addresses_expr.empty())
diff --git a/src/Storages/StorageReplicatedMergeTree.cpp b/src/Storages/StorageReplicatedMergeTree.cpp
index 9b4972ade59..1e8c2c583a4 100644
--- a/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/src/Storages/StorageReplicatedMergeTree.cpp
@@ -5969,6 +5969,7 @@ void StorageReplicatedMergeTree::getStatus(ReplicatedTableStatus & res, bool wit
     /// NOTE: consider convert to UInt64
     res.parts_to_check = static_cast<UInt32>(part_check_thread.size());
 
+    res.zookeeper_name = zookeeper_name;
     res.zookeeper_path = zookeeper_path;
     res.replica_name = replica_name;
     res.replica_path = replica_path;
@@ -7616,7 +7617,7 @@ bool StorageReplicatedMergeTree::waitForProcessingQueue(UInt64 max_wait_millisec
     background_operations_assignee.trigger();
 
     std::unordered_set<String> wait_for_ids;
-    bool was_interrupted = false;
+    std::atomic_bool was_interrupted = false;
 
     Poco::Event target_entry_event;
     auto callback = [this, &target_entry_event, &wait_for_ids, &was_interrupted, sync_mode]
diff --git a/src/Storages/StorageS3Cluster.cpp b/src/Storages/StorageS3Cluster.cpp
index 220cc1dc1f6..fb99d95ef52 100644
--- a/src/Storages/StorageS3Cluster.cpp
+++ b/src/Storages/StorageS3Cluster.cpp
@@ -140,7 +140,8 @@ Pipe StorageS3Cluster::read(
         /* only_replace_in_join_= */true);
     visitor.visit(query_to_send);
 
-    const auto & current_settings = context->getSettingsRef();
+    auto new_context = IStorageCluster::updateSettingsForTableFunctionCluster(context, context->getSettingsRef());
+    const auto & current_settings = new_context->getSettingsRef();
     auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(current_settings);
     for (const auto & shard_info : cluster->getShardsInfo())
     {
@@ -151,7 +152,7 @@ Pipe StorageS3Cluster::read(
                     std::vector<IConnectionPool::Entry>{try_result},
                     queryToString(query_to_send),
                     sample_block,
-                    context,
+                    new_context,
                     /*throttler=*/nullptr,
                     scalars,
                     Tables(),
diff --git a/src/Storages/StorageS3Settings.cpp b/src/Storages/StorageS3Settings.cpp
index 17a11ba9848..4db44b7b4f7 100644
--- a/src/Storages/StorageS3Settings.cpp
+++ b/src/Storages/StorageS3Settings.cpp
@@ -32,6 +32,7 @@ S3Settings::RequestSettings::PartUploadSettings::PartUploadSettings(
     : PartUploadSettings(settings)
 {
     String key = config_prefix + "." + setting_name_prefix;
+    strict_upload_part_size = config.getUInt64(key + "strict_upload_part_size", strict_upload_part_size);
     min_upload_part_size = config.getUInt64(key + "min_upload_part_size", min_upload_part_size);
     max_upload_part_size = config.getUInt64(key + "max_upload_part_size", max_upload_part_size);
     upload_part_size_multiply_factor = config.getUInt64(key + "upload_part_size_multiply_factor", upload_part_size_multiply_factor);
@@ -49,10 +50,11 @@ S3Settings::RequestSettings::PartUploadSettings::PartUploadSettings(
 
 S3Settings::RequestSettings::PartUploadSettings::PartUploadSettings(const NamedCollection & collection)
 {
+    strict_upload_part_size = collection.getOrDefault<UInt64>("strict_upload_part_size", strict_upload_part_size);
     min_upload_part_size = collection.getOrDefault<UInt64>("min_upload_part_size", min_upload_part_size);
+    max_single_part_upload_size = collection.getOrDefault<UInt64>("max_single_part_upload_size", max_single_part_upload_size);
     upload_part_size_multiply_factor = collection.getOrDefault<UInt64>("upload_part_size_multiply_factor", upload_part_size_multiply_factor);
     upload_part_size_multiply_parts_count_threshold = collection.getOrDefault<UInt64>("upload_part_size_multiply_parts_count_threshold", upload_part_size_multiply_parts_count_threshold);
-    max_single_part_upload_size = collection.getOrDefault<UInt64>("max_single_part_upload_size", max_single_part_upload_size);
 
     /// This configuration is only applicable to s3. Other types of object storage are not applicable or have different meanings.
     storage_class_name = collection.getOrDefault<String>("s3_storage_class", storage_class_name);
@@ -63,6 +65,9 @@ S3Settings::RequestSettings::PartUploadSettings::PartUploadSettings(const NamedC
 
 void S3Settings::RequestSettings::PartUploadSettings::updateFromSettingsImpl(const Settings & settings, bool if_changed)
 {
+    if (!if_changed || settings.s3_strict_upload_part_size.changed)
+        strict_upload_part_size = settings.s3_strict_upload_part_size;
+
     if (!if_changed || settings.s3_min_upload_part_size.changed)
         min_upload_part_size = settings.s3_min_upload_part_size;
 
@@ -82,6 +87,12 @@ void S3Settings::RequestSettings::PartUploadSettings::updateFromSettingsImpl(con
 void S3Settings::RequestSettings::PartUploadSettings::validate()
 {
     static constexpr size_t min_upload_part_size_limit = 5 * 1024 * 1024;
+    if (strict_upload_part_size && strict_upload_part_size < min_upload_part_size_limit)
+        throw Exception(
+            ErrorCodes::INVALID_SETTING_VALUE,
+            "Setting strict_upload_part_size has invalid value {} which is less than the s3 API limit {}",
+            ReadableSize(strict_upload_part_size), ReadableSize(min_upload_part_size_limit));
+
     if (min_upload_part_size < min_upload_part_size_limit)
         throw Exception(
             ErrorCodes::INVALID_SETTING_VALUE,
diff --git a/src/Storages/StorageS3Settings.h b/src/Storages/StorageS3Settings.h
index 49cb481626d..cd5be1626b5 100644
--- a/src/Storages/StorageS3Settings.h
+++ b/src/Storages/StorageS3Settings.h
@@ -28,6 +28,7 @@ struct S3Settings
     {
         struct PartUploadSettings
         {
+            size_t strict_upload_part_size = 0;
             size_t min_upload_part_size = 16 * 1024 * 1024;
             size_t max_upload_part_size = 5ULL * 1024 * 1024 * 1024;
             size_t upload_part_size_multiply_factor = 2;
diff --git a/src/Storages/System/StorageSystemContributors.generated.cpp b/src/Storages/System/StorageSystemContributors.generated.cpp
index a6704144fde..0f307650c9c 100644
--- a/src/Storages/System/StorageSystemContributors.generated.cpp
+++ b/src/Storages/System/StorageSystemContributors.generated.cpp
@@ -33,6 +33,7 @@ const char * auto_contributors[] {
     "Aleksandra (Ася)",
     "Aleksandrov Vladimir",
     "Aleksei Filatov",
+    "Aleksei Golub",
     "Aleksei Levushkin",
     "Aleksei Semiglazov",
     "Aleksei Tikhomirov",
@@ -159,6 +160,7 @@ const char * auto_contributors[] {
     "Anton Zhabolenko",
     "Antonio Andelic",
     "Antonio Bonuccelli",
+    "Aram Peres",
     "Ariel Robaldo",
     "Arsen Hakobyan",
     "Arslan G",
@@ -167,6 +169,7 @@ const char * auto_contributors[] {
     "Artem Gavrilov",
     "Artem Hnilov",
     "Artem Konovalov",
+    "Artem Pershin",
     "Artem Streltsov",
     "Artem Zuikov",
     "Artemeey",
@@ -317,6 +320,7 @@ const char * auto_contributors[] {
     "Enrique Herreros",
     "Eric",
     "Eric Daniel",
+    "Eric Thomas",
     "Erixonich",
     "Ernest Poletaev",
     "Eugene Galkin",
@@ -353,6 +357,7 @@ const char * auto_contributors[] {
     "Frank Zhao",
     "François Violette",
     "Fred Wulff",
+    "FriendLey",
     "Fruit of Eden",
     "Fu Zhe",
     "Fullstop000",
@@ -455,6 +460,7 @@ const char * auto_contributors[] {
     "Jason Keirstead",
     "Javi Santana",
     "Javi santana bot",
+    "JaySon",
     "JaySon-Huang",
     "Jean Baptiste Favre",
     "Jeffrey Dang",
@@ -482,6 +488,7 @@ const char * auto_contributors[] {
     "Junfu Wu",
     "Jus",
     "Justin Hilliard",
+    "Justin de Guzman",
     "Kang Liu",
     "Karl Pietrzak",
     "Keiji Yoshida",
@@ -661,6 +668,7 @@ const char * auto_contributors[] {
     "Neeke Gao",
     "Neng Liu",
     "NengLiu",
+    "Nick-71",
     "Nickita",
     "Nickita Taranov",
     "Nickolay Yastrebov",
@@ -834,6 +842,7 @@ const char * auto_contributors[] {
     "Seyed Mehrshad Hosseini",
     "Sherry Wang",
     "Shoh Jahon",
+    "Sichen Zhao",
     "SiderZhang",
     "Sidorov Pavel",
     "Silviu Caragea",
@@ -910,6 +919,7 @@ const char * auto_contributors[] {
     "Vadim Skipin",
     "Vadim Volodin",
     "VadimPE",
+    "Vadym Chekan",
     "Vage Ogannisian",
     "Val",
     "Valera Ryaboshapko",
@@ -1030,6 +1040,7 @@ const char * auto_contributors[] {
     "akonyaev",
     "akuzm",
     "alekseik1",
+    "alekseygolub",
     "alesapin",
     "alex filatov",
     "alex-zaitsev",
@@ -1080,6 +1091,7 @@ const char * auto_contributors[] {
     "bobrovskij artemij",
     "booknouse",
     "bseng",
+    "caipengxiang",
     "candiduslynx",
     "canenoneko",
     "caspian",
@@ -1104,6 +1116,8 @@ const char * auto_contributors[] {
     "clarkcaoliu",
     "clickhouse-adrianfraguela",
     "clickhouse-robot-curie",
+    "clundro",
+    "cluster",
     "cms",
     "cmsxbc",
     "cn-ds",
@@ -1263,6 +1277,7 @@ const char * auto_contributors[] {
     "ks1322",
     "kshvakov",
     "kssenii",
+    "kst-morozov",
     "l",
     "l1tsolaiki",
     "lalex",
@@ -1302,6 +1317,7 @@ const char * auto_contributors[] {
     "lixuchun",
     "liyang",
     "liyang830",
+    "lizhuoyu5",
     "lokax",
     "lomberts",
     "loneylee",
@@ -1359,6 +1375,7 @@ const char * auto_contributors[] {
     "mwish",
     "myrrc",
     "nagorny",
+    "natasha",
     "nathanbegbie",
     "nauta",
     "nautaa",
@@ -1388,6 +1405,7 @@ const char * auto_contributors[] {
     "pawelsz-rb",
     "pdai",
     "pdv-ru",
+    "pengxiangcai",
     "peshkurov",
     "peter279k",
     "philip.han",
@@ -1516,6 +1534,7 @@ const char * auto_contributors[] {
     "wzl",
     "xPoSx",
     "xiedeyantu",
+    "xieyichen",
     "xinhuitian",
     "xlwh",
     "yakkomajuri",
@@ -1587,6 +1606,7 @@ const char * auto_contributors[] {
     "万康",
     "何李夫",
     "凌涛",
+    "刘浩林",
     "刘陶峰",
     "吴健",
     "小蝌蚪",
diff --git a/src/Storages/System/StorageSystemFilesystemCache.cpp b/src/Storages/System/StorageSystemFilesystemCache.cpp
index 4fa821bf689..8e9ad2ac501 100644
--- a/src/Storages/System/StorageSystemFilesystemCache.cpp
+++ b/src/Storages/System/StorageSystemFilesystemCache.cpp
@@ -18,6 +18,7 @@ NamesAndTypesList StorageSystemFilesystemCache::getNamesAndTypes()
         {"cache_name", std::make_shared<DataTypeString>()},
         {"cache_base_path", std::make_shared<DataTypeString>()},
         {"cache_path", std::make_shared<DataTypeString>()},
+        {"key", std::make_shared<DataTypeString>()},
         {"file_segment_range_begin", std::make_shared<DataTypeUInt64>()},
         {"file_segment_range_end", std::make_shared<DataTypeUInt64>()},
         {"size", std::make_shared<DataTypeUInt64>()},
@@ -45,27 +46,27 @@ void StorageSystemFilesystemCache::fillData(MutableColumns & res_columns, Contex
         const auto & cache = cache_data->cache;
         auto file_segments = cache->getSnapshot();
 
-        for (const auto & file_segment : file_segments)
+        for (const auto & file_segment : *file_segments)
         {
             res_columns[0]->insert(cache_name);
             res_columns[1]->insert(cache->getBasePath());
 
             /// Do not use `file_segment->getPathInLocalCache` here because it will lead to nullptr dereference
             /// (because file_segments in getSnapshot doesn't have `cache` field set)
-            res_columns[2]->insert(
-                cache->getPathInLocalCache(file_segment->key(), file_segment->offset(), file_segment->getKind()));
+            res_columns[2]->insert(cache->getPathInLocalCache(file_segment->key(), file_segment->offset(), file_segment->getKind()));
+            res_columns[3]->insert(file_segment->key().toString());
 
             const auto & range = file_segment->range();
-            res_columns[3]->insert(range.left);
-            res_columns[4]->insert(range.right);
-            res_columns[5]->insert(range.size());
-            res_columns[6]->insert(FileSegment::stateToString(file_segment->state()));
-            res_columns[7]->insert(file_segment->getHitsCount());
-            res_columns[8]->insert(file_segment->getRefCount());
-            res_columns[9]->insert(file_segment->getDownloadedSize());
-            res_columns[10]->insert(file_segment->isPersistent());
-            res_columns[11]->insert(toString(file_segment->getKind()));
-            res_columns[12]->insert(file_segment->isUnbound());
+            res_columns[4]->insert(range.left);
+            res_columns[5]->insert(range.right);
+            res_columns[6]->insert(range.size());
+            res_columns[7]->insert(FileSegment::stateToString(file_segment->state()));
+            res_columns[8]->insert(file_segment->getHitsCount());
+            res_columns[9]->insert(file_segment->getRefCount());
+            res_columns[10]->insert(file_segment->getDownloadedSize(false));
+            res_columns[11]->insert(file_segment->isPersistent());
+            res_columns[12]->insert(toString(file_segment->getKind()));
+            res_columns[13]->insert(file_segment->isUnbound());
         }
     }
 }
diff --git a/src/Storages/System/StorageSystemFunctions.cpp b/src/Storages/System/StorageSystemFunctions.cpp
index a0a406a974c..f3a297a11d1 100644
--- a/src/Storages/System/StorageSystemFunctions.cpp
+++ b/src/Storages/System/StorageSystemFunctions.cpp
@@ -1,4 +1,5 @@
 #include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <DataTypes/DataTypeMap.h>
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeEnum.h>
@@ -55,15 +56,38 @@ namespace
         if constexpr (std::is_same_v<Factory, FunctionFactory>)
         {
             if (factory.isAlias(name))
+            {
                 res_columns[6]->insertDefault();
+                res_columns[7]->insertDefault();
+                res_columns[8]->insertDefault();
+                res_columns[9]->insertDefault();
+                res_columns[10]->insertDefault();
+                res_columns[11]->insertDefault();
+            }
             else
-                res_columns[6]->insert(factory.getDocumentation(name).description);
+            {
+                auto documentation = factory.getDocumentation(name);
+                res_columns[6]->insert(documentation.description);
+                res_columns[7]->insertDefault();
+                res_columns[8]->insertDefault();
+                res_columns[9]->insertDefault();
+                res_columns[10]->insert(documentation.examplesAsString());
+                res_columns[11]->insert(documentation.categoriesAsString());
+            }
         }
         else
+        {
             res_columns[6]->insertDefault();
+            res_columns[7]->insertDefault();
+            res_columns[8]->insertDefault();
+            res_columns[9]->insertDefault();
+            res_columns[10]->insertDefault();
+            res_columns[11]->insertDefault();
+        }
     }
 }
 
+
 std::vector<std::pair<String, Int8>> getOriginEnumsAndValues()
 {
     return std::vector<std::pair<String, Int8>>{
@@ -83,6 +107,11 @@ NamesAndTypesList StorageSystemFunctions::getNamesAndTypes()
         {"create_query", std::make_shared<DataTypeString>()},
         {"origin", std::make_shared<DataTypeEnum8>(getOriginEnumsAndValues())},
         {"description", std::make_shared<DataTypeString>()},
+        {"syntax", std::make_shared<DataTypeString>()},
+        {"arguments", std::make_shared<DataTypeString>()},
+        {"returned_value", std::make_shared<DataTypeString>()},
+        {"examples", std::make_shared<DataTypeString>()},
+        {"categories", std::make_shared<DataTypeString>()}
     };
 }
 
diff --git a/src/Storages/System/StorageSystemRemoteDataPaths.cpp b/src/Storages/System/StorageSystemRemoteDataPaths.cpp
index 9a70633155d..23981c2a275 100644
--- a/src/Storages/System/StorageSystemRemoteDataPaths.cpp
+++ b/src/Storages/System/StorageSystemRemoteDataPaths.cpp
@@ -82,7 +82,7 @@ Pipe StorageSystemRemoteDataPaths::read(
 
                     if (cache)
                     {
-                        auto cache_paths = cache->tryGetCachePaths(cache->hash(object.getPathKeyForCache()));
+                        auto cache_paths = cache->tryGetCachePaths(cache->createKeyForPath(object.getPathKeyForCache()));
                         col_cache_paths->insert(Array(cache_paths.begin(), cache_paths.end()));
                     }
                     else
diff --git a/src/Storages/System/StorageSystemReplicas.cpp b/src/Storages/System/StorageSystemReplicas.cpp
index f1e807a3313..92e04748149 100644
--- a/src/Storages/System/StorageSystemReplicas.cpp
+++ b/src/Storages/System/StorageSystemReplicas.cpp
@@ -39,6 +39,7 @@ StorageSystemReplicas::StorageSystemReplicas(const StorageID & table_id_)
         { "is_session_expired",                   std::make_shared<DataTypeUInt8>()    },
         { "future_parts",                         std::make_shared<DataTypeUInt32>()   },
         { "parts_to_check",                       std::make_shared<DataTypeUInt32>()   },
+        { "zookeeper_name",                       std::make_shared<DataTypeString>()   },
         { "zookeeper_path",                       std::make_shared<DataTypeString>()   },
         { "replica_name",                         std::make_shared<DataTypeString>()   },
         { "replica_path",                         std::make_shared<DataTypeString>()   },
@@ -194,6 +195,7 @@ Pipe StorageSystemReplicas::read(
         res_columns[col_num++]->insert(status.is_session_expired);
         res_columns[col_num++]->insert(status.queue.future_parts);
         res_columns[col_num++]->insert(status.parts_to_check);
+        res_columns[col_num++]->insert(status.zookeeper_name);
         res_columns[col_num++]->insert(status.zookeeper_path);
         res_columns[col_num++]->insert(status.replica_name);
         res_columns[col_num++]->insert(status.replica_path);
diff --git a/tests/broken_tests.txt b/tests/broken_tests.txt
index f052faa6515..b0a8e0fe535 100644
--- a/tests/broken_tests.txt
+++ b/tests/broken_tests.txt
@@ -123,12 +123,7 @@
 02713_array_low_cardinality_string
 02707_skip_index_with_in
 02707_complex_query_fails_analyzer
-02699_polygons_sym_difference_rollup
 02680_mysql_ast_logical_err
-02677_analyzer_bitmap_has_any
-02661_quantile_approx
-02540_duplicate_primary_key2
-02516_join_with_totals_and_subquery_bug
 02324_map_combinator_bug
 02241_join_rocksdb_bs
 02003_WithMergeableStateAfterAggregationAndLimit_LIMIT_BY_LIMIT_OFFSET
diff --git a/tests/ci/ast_fuzzer_check.py b/tests/ci/ast_fuzzer_check.py
index 3c2fa05016f..514aaf7e2ac 100644
--- a/tests/ci/ast_fuzzer_check.py
+++ b/tests/ci/ast_fuzzer_check.py
@@ -9,19 +9,21 @@ from github import Github
 
 from build_download_helper import get_build_name_for_check, read_build_urls
 from clickhouse_helper import ClickHouseHelper, prepare_tests_results_for_clickhouse
-from commit_status_helper import format_description, post_commit_status
+from commit_status_helper import (
+    RerunHelper,
+    format_description,
+    get_commit,
+    post_commit_status,
+)
 from docker_pull_helper import get_image_with_version
 from env_helper import (
-    GITHUB_REPOSITORY,
     GITHUB_RUN_URL,
     REPORTS_PATH,
-    REPO_COPY,
     TEMP_PATH,
 )
 from get_robot_token import get_best_robot_token
 from pr_info import PRInfo
 from report import TestResult
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from stopwatch import Stopwatch
 
@@ -41,19 +43,12 @@ def get_run_command(pr_number, sha, download_url, workspace_path, image):
     )
 
 
-def get_commit(gh, commit_sha):
-    repo = gh.get_repo(GITHUB_REPOSITORY)
-    commit = repo.get_commit(commit_sha)
-    return commit
-
-
-if __name__ == "__main__":
+def main():
     logging.basicConfig(level=logging.INFO)
 
     stopwatch = Stopwatch()
 
     temp_path = TEMP_PATH
-    repo_path = REPO_COPY
     reports_path = REPORTS_PATH
 
     check_name = sys.argv[1]
@@ -64,8 +59,9 @@ if __name__ == "__main__":
     pr_info = PRInfo()
 
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
 
-    rerun_helper = RerunHelper(gh, pr_info, check_name)
+    rerun_helper = RerunHelper(commit, check_name)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -172,4 +168,8 @@ if __name__ == "__main__":
 
     logging.info("Result: '%s', '%s', '%s'", status, description, report_url)
     print(f"::notice ::Report url: {report_url}")
-    post_commit_status(gh, pr_info.sha, check_name, description, status, report_url)
+    post_commit_status(commit, status, report_url, description, check_name, pr_info)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/ci/bugfix_validate_check.py b/tests/ci/bugfix_validate_check.py
index 14ea58500bc..e5ce655bdde 100644
--- a/tests/ci/bugfix_validate_check.py
+++ b/tests/ci/bugfix_validate_check.py
@@ -8,7 +8,7 @@ import os
 
 from github import Github
 
-from commit_status_helper import post_commit_status
+from commit_status_helper import get_commit, post_commit_status
 from get_robot_token import get_best_robot_token
 from pr_info import PRInfo
 from report import TestResults, TestResult
@@ -81,13 +81,14 @@ def main(args):
     )
 
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
     post_commit_status(
-        gh,
-        pr_info.sha,
-        check_name_with_group,
-        "" if is_ok else "Changed tests don't reproduce the bug",
+        commit,
         "success" if is_ok else "error",
         report_url,
+        "" if is_ok else "Changed tests don't reproduce the bug",
+        check_name_with_group,
+        pr_info,
     )
 
 
diff --git a/tests/ci/build_check.py b/tests/ci/build_check.py
index a829069985d..4bc61c79fc0 100644
--- a/tests/ci/build_check.py
+++ b/tests/ci/build_check.py
@@ -9,7 +9,12 @@ import time
 from typing import List, Tuple
 
 from ci_config import CI_CONFIG, BuildConfig
-from commit_status_helper import get_commit_filtered_statuses, get_commit
+from commit_status_helper import (
+    NotSet,
+    get_commit_filtered_statuses,
+    get_commit,
+    post_commit_status,
+)
 from docker_pull_helper import get_image_with_version
 from env_helper import (
     GITHUB_JOB,
@@ -232,10 +237,10 @@ def upload_master_static_binaries(
     print(f"::notice ::Binary static URL: {url}")
 
 
-def mark_failed_reports_pending(build_name: str, sha: str) -> None:
+def mark_failed_reports_pending(build_name: str, pr_info: PRInfo) -> None:
     try:
         gh = GitHub(get_best_robot_token())
-        commit = get_commit(gh, sha)
+        commit = get_commit(gh, pr_info.sha)
         statuses = get_commit_filtered_statuses(commit)
         report_status = [
             name
@@ -248,8 +253,13 @@ def mark_failed_reports_pending(build_name: str, sha: str) -> None:
                     "Commit already have failed status for '%s', setting it to 'pending'",
                     report_status,
                 )
-                commit.create_status(
-                    "pending", status.url, "Set to pending on rerun", report_status
+                post_commit_status(
+                    commit,
+                    "pending",
+                    status.target_url or NotSet,
+                    "Set to pending on rerun",
+                    report_status,
+                    pr_info,
                 )
     except:  # we do not care about any exception here
         logging.info("Failed to get or mark the reports status as pending, continue")
@@ -285,7 +295,7 @@ def main():
     check_for_success_run(s3_helper, s3_path_prefix, build_name, build_config)
 
     # If it's a latter running, we need to mark possible failed status
-    mark_failed_reports_pending(build_name, pr_info.sha)
+    mark_failed_reports_pending(build_name, pr_info)
 
     docker_image = get_image_with_version(IMAGES_PATH, IMAGE_NAME)
     image_version = docker_image.version
diff --git a/tests/ci/build_download_helper.py b/tests/ci/build_download_helper.py
index c6136015316..76f81343b54 100644
--- a/tests/ci/build_download_helper.py
+++ b/tests/ci/build_download_helper.py
@@ -6,11 +6,12 @@ import os
 import sys
 import time
 from pathlib import Path
-from typing import Any, Callable, List, Optional
+from typing import Any, Callable, List
 
 import requests  # type: ignore
 
 from ci_config import CI_CONFIG
+from get_robot_token import ROBOT_TOKEN, get_best_robot_token
 
 DOWNLOAD_RETRIES_COUNT = 5
 
@@ -24,22 +25,62 @@ def get_with_retries(
     logging.info(
         "Getting URL with %i tries and sleep %i in between: %s", retries, sleep, url
     )
-    exc = None  # type: Optional[Exception]
+    exc = Exception("A placeholder to satisfy typing and avoid nesting")
     for i in range(retries):
         try:
             response = requests.get(url, **kwargs)
             response.raise_for_status()
-            break
+            return response
         except Exception as e:
             if i + 1 < retries:
                 logging.info("Exception '%s' while getting, retry %i", e, i + 1)
                 time.sleep(sleep)
 
             exc = e
-    else:
-        raise Exception(exc)
 
-    return response
+    raise exc
+
+
+def get_gh_api(
+    url: str,
+    retries: int = DOWNLOAD_RETRIES_COUNT,
+    sleep: int = 3,
+    **kwargs: Any,
+) -> requests.Response:
+    """It's a wrapper around get_with_retries that requests GH api w/o auth by
+    default, and falls back to the get_best_robot_token in case of receiving
+    "403 rate limit exceeded" error
+    It sets auth automatically when ROBOT_TOKEN is already set by get_best_robot_token
+    """
+
+    def set_auth_header():
+        if "headers" in kwargs:
+            if "Authorization" not in kwargs["headers"]:
+                kwargs["headers"]["Authorization"] = f"Bearer {get_best_robot_token()}"
+        else:
+            kwargs["headers"] = {"Authorization": f"Bearer {get_best_robot_token()}"}
+
+    if ROBOT_TOKEN is not None:
+        set_auth_header()
+
+    for _ in range(retries):
+        try:
+            response = get_with_retries(url, 1, sleep, **kwargs)
+            response.raise_for_status()
+            return response
+        except requests.HTTPError as exc:
+            if (
+                exc.response.status_code == 403
+                and b"rate limit exceeded"
+                in exc.response._content  # pylint:disable=protected-access
+            ):
+                logging.warning(
+                    "Received rate limit exception, setting the auth header and retry"
+                )
+                set_auth_header()
+                break
+
+    return get_with_retries(url, retries, sleep, **kwargs)
 
 
 def get_build_name_for_check(check_name: str) -> str:
diff --git a/tests/ci/build_report_check.py b/tests/ci/build_report_check.py
index 32cbaf08f07..13257eabb71 100644
--- a/tests/ci/build_report_check.py
+++ b/tests/ci/build_report_check.py
@@ -22,11 +22,12 @@ from s3_helper import S3Helper
 from get_robot_token import get_best_robot_token
 from pr_info import NeedsDataType, PRInfo
 from commit_status_helper import (
+    RerunHelper,
     get_commit,
+    post_commit_status,
     update_mergeable_check,
 )
 from ci_config import CI_CONFIG
-from rerun_helper import RerunHelper
 
 
 NEEDS_DATA_PATH = os.getenv("NEEDS_DATA_PATH", "")
@@ -136,10 +137,11 @@ def main():
 
     gh = Github(get_best_robot_token(), per_page=100)
     pr_info = PRInfo()
+    commit = get_commit(gh, pr_info.sha)
 
     atexit.register(update_mergeable_check, gh, pr_info, build_check_name)
 
-    rerun_helper = RerunHelper(gh, pr_info, build_check_name)
+    rerun_helper = RerunHelper(commit, build_check_name)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -274,12 +276,8 @@ def main():
 
     description = f"{ok_groups}/{total_groups} artifact groups are OK {addition}"
 
-    commit = get_commit(gh, pr_info.sha)
-    commit.create_status(
-        context=build_check_name,
-        description=description,
-        state=summary_status,
-        target_url=url,
+    post_commit_status(
+        commit, summary_status, url, description, build_check_name, pr_info
     )
 
     if summary_status == "error":
diff --git a/tests/ci/ci_config.py b/tests/ci/ci_config.py
index bda04853d81..9dca9f2d8bd 100644
--- a/tests/ci/ci_config.py
+++ b/tests/ci/ci_config.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 
-from typing import Dict, TypeVar
+from dataclasses import dataclass
+from typing import Callable, Dict, TypeVar
 
 ConfValue = TypeVar("ConfValue", str, bool)
 BuildConfig = Dict[str, ConfValue]
@@ -399,3 +400,161 @@ REQUIRED_CHECKS = [
     "Unit tests (tsan)",
     "Unit tests (ubsan)",
 ]
+
+
+@dataclass
+class CheckDescription:
+    name: str
+    description: str  # the check descriptions, will be put into the status table
+    match_func: Callable[[str], bool]  # the function to check vs the commit status
+
+    def __hash__(self) -> int:
+        return hash(self.name + self.description)
+
+
+CHECK_DESCRIPTIONS = [
+    CheckDescription(
+        "AST fuzzer",
+        "Runs randomly generated queries to catch program errors. "
+        "The build type is optionally given in parenthesis. "
+        "If it fails, ask a maintainer for help.",
+        lambda x: x.startswith("AST fuzzer"),
+    ),
+    CheckDescription(
+        "Bugfix validate check",
+        "Checks that either a new test (functional or integration) or there "
+        "some changed tests that fail with the binary built on master branch",
+        lambda x: x == "Bugfix validate check",
+    ),
+    CheckDescription(
+        "CI running",
+        "A meta-check that indicates the running CI. Normally, it's in <b>success</b> or "
+        "<b>pending</b> state. The failed status indicates some problems with the PR",
+        lambda x: x == "CI running",
+    ),
+    CheckDescription(
+        "ClickHouse build check",
+        "Builds ClickHouse in various configurations for use in further steps. "
+        "You have to fix the builds that fail. Build logs often has enough "
+        "information to fix the error, but you might have to reproduce the failure "
+        "locally. The <b>cmake</b> options can be found in the build log, grepping for "
+        '<b>cmake</b>. Use these options and follow the <a href="'
+        'https://clickhouse.com/docs/en/development/build">general build process</a>.',
+        lambda x: x.startswith("ClickHouse") and x.endswith("build check"),
+    ),
+    CheckDescription(
+        "Compatibility check",
+        "Checks that <b>clickhouse</b> binary runs on distributions with old libc "
+        "versions. If it fails, ask a maintainer for help.",
+        lambda x: x.startswith("Compatibility check"),
+    ),
+    CheckDescription(
+        "Docker image for servers",
+        "The check to build and optionally push the mentioned image to docker hub",
+        lambda x: x.startswith("Docker image")
+        and (x.endswith("building check") or x.endswith("build and push")),
+    ),
+    CheckDescription(
+        "Docs Check", "Builds and tests the documentation", lambda x: x == "Docs Check"
+    ),
+    CheckDescription(
+        "Fast test",
+        "Normally this is the first check that is ran for a PR. It builds ClickHouse "
+        'and runs most of <a href="https://clickhouse.com/docs/en/development/tests'
+        '#functional-tests">stateless functional tests</a>, '
+        "omitting some. If it fails, further checks are not started until it is fixed. "
+        "Look at the report to see which tests fail, then reproduce the failure "
+        'locally as described <a href="https://clickhouse.com/docs/en/development/'
+        'tests#functional-test-locally">here</a>.',
+        lambda x: x == "Fast test",
+    ),
+    CheckDescription(
+        "Flaky tests",
+        "Runs a flaky tests from master multiple times to identify if they are stable.",
+        lambda x: "tests flaky check" in x,
+    ),
+    CheckDescription(
+        "Install packages",
+        "Checks that the built packages are installable in a clear environment",
+        lambda x: x.startswith("Install packages ("),
+    ),
+    CheckDescription(
+        "Integration tests",
+        "The integration tests report. In parenthesis the package type is given, "
+        "and in square brackets are the optional part/total tests",
+        lambda x: x.startswith("Integration tests ("),
+    ),
+    CheckDescription(
+        "Mergeable Check",
+        "Checks if all other necessary checks are successful",
+        lambda x: x == "Mergeable Check",
+    ),
+    CheckDescription(
+        "Performance Comparison",
+        "Measure changes in query performance. The performance test report is "
+        'described in detail <a href="https://github.com/ClickHouse/ClickHouse/tree'
+        '/master/docker/test/performance-comparison#how-to-read-the-report">here</a>. '
+        "In square brackets are the optional part/total tests",
+        lambda x: x.startswith("Performance Comparison"),
+    ),
+    CheckDescription(
+        "Push to Dockerhub",
+        "The check for building and pushing the CI related docker images to docker hub",
+        lambda x: x.startswith("Push") and "to Dockerhub" in x,
+    ),
+    CheckDescription(
+        "Sqllogic",
+        "Run clickhouse on the "
+        '<a href="https://www.sqlite.org/sqllogictest">sqllogic</a> '
+        "test set against sqlite and checks that all statements are passed.",
+        lambda x: x.startswith("Sqllogic test"),
+    ),
+    CheckDescription(
+        "SQLancer",
+        "Fuzzing tests that detect logical bugs with "
+        '<a href="https://github.com/sqlancer/sqlancer">SQLancer</a> tool.',
+        lambda x: x.startswith("SQLancer"),
+    ),
+    CheckDescription(
+        "Stateful tests",
+        "Runs stateful functional tests for ClickHouse binaries built in various "
+        "configurations -- release, debug, with sanitizers, etc.",
+        lambda x: x.startswith("Stateful tests ("),
+    ),
+    CheckDescription(
+        "Stateless tests",
+        "Runs stateless functional tests for ClickHouse binaries built in various "
+        "configurations -- release, debug, with sanitizers, etc.",
+        lambda x: x.startswith("Stateless tests ("),
+    ),
+    CheckDescription(
+        "Stress test",
+        "Runs stateless functional tests concurrently from several clients to detect "
+        "concurrency-related errors.",
+        lambda x: x.startswith("Stress test ("),
+    ),
+    CheckDescription(
+        "Style Check",
+        "Runs a set of checks to keep the code style clean. If some of tests failed, "
+        "see the related log from the report.",
+        lambda x: x == "Style Check",
+    ),
+    CheckDescription(
+        "Unit tests",
+        "Runs the unit tests for different release types",
+        lambda x: x.startswith("Unit tests ("),
+    ),
+    CheckDescription(
+        "Upgrade check",
+        "Runs stress tests on server version from last release and then tries to "
+        "upgrade it to the version from the PR. It checks if the new server can "
+        "successfully startup without any errors, crashes or sanitizer asserts.",
+        lambda x: x.startswith("Upgrade check ("),
+    ),
+    CheckDescription(
+        "Falback for unknown",
+        "There's no description for the check yet, please add it to "
+        "tests/ci/ci_config.py:CHECK_DESCRIPTIONS",
+        lambda x: True,
+    ),
+]
diff --git a/tests/ci/codebrowser_check.py b/tests/ci/codebrowser_check.py
index 9fa202a357c..0eb4921e3fe 100644
--- a/tests/ci/codebrowser_check.py
+++ b/tests/ci/codebrowser_check.py
@@ -7,7 +7,7 @@ import logging
 
 from github import Github
 
-from commit_status_helper import post_commit_status
+from commit_status_helper import get_commit, post_commit_status
 from docker_pull_helper import get_image_with_version
 from env_helper import (
     IMAGES_PATH,
@@ -43,6 +43,7 @@ if __name__ == "__main__":
 
     gh = Github(get_best_robot_token(), per_page=100)
     pr_info = PRInfo()
+    commit = get_commit(gh, pr_info.sha)
 
     if not os.path.exists(TEMP_PATH):
         os.makedirs(TEMP_PATH)
@@ -87,4 +88,4 @@ if __name__ == "__main__":
 
     print(f"::notice ::Report url: {report_url}")
 
-    post_commit_status(gh, pr_info.sha, NAME, "Report built", "success", report_url)
+    post_commit_status(commit, "success", report_url, "Report built", NAME, pr_info)
diff --git a/tests/ci/commit_status_helper.py b/tests/ci/commit_status_helper.py
index 6260abac1eb..666eb27919e 100644
--- a/tests/ci/commit_status_helper.py
+++ b/tests/ci/commit_status_helper.py
@@ -3,20 +3,51 @@
 import csv
 import os
 import time
-from typing import List, Literal
+from typing import Dict, List, Literal, Optional, Union
 import logging
 
 from github import Github
+from github.GithubObject import _NotSetType, NotSet as NotSet  # type: ignore
 from github.Commit import Commit
 from github.CommitStatus import CommitStatus
+from github.IssueComment import IssueComment
+from github.Repository import Repository
 
-from ci_config import CI_CONFIG, REQUIRED_CHECKS
+from ci_config import CI_CONFIG, REQUIRED_CHECKS, CHECK_DESCRIPTIONS, CheckDescription
 from env_helper import GITHUB_REPOSITORY, GITHUB_RUN_URL
 from pr_info import PRInfo, SKIP_MERGEABLE_CHECK_LABEL
+from report import TestResult, TestResults
+from s3_helper import S3Helper
+from upload_result_helper import upload_results
 
 RETRY = 5
 CommitStatuses = List[CommitStatus]
 MERGEABLE_NAME = "Mergeable Check"
+GH_REPO = None  # type: Optional[Repository]
+CI_STATUS_NAME = "CI running"
+
+
+class RerunHelper:
+    def __init__(self, commit: Commit, check_name: str):
+        self.check_name = check_name
+        self.commit = commit
+        self.statuses = get_commit_filtered_statuses(commit)
+
+    def is_already_finished_by_status(self) -> bool:
+        # currently we agree even for failed statuses
+        for status in self.statuses:
+            if self.check_name in status.context and status.state in (
+                "success",
+                "failure",
+            ):
+                return True
+        return False
+
+    def get_finished_status(self) -> Optional[CommitStatus]:
+        for status in self.statuses:
+            if self.check_name in status.context:
+                return status
+        return None
 
 
 def override_status(status: str, check_name: str, invert: bool = False) -> str:
@@ -34,7 +65,7 @@ def override_status(status: str, check_name: str, invert: bool = False) -> str:
 def get_commit(gh: Github, commit_sha: str, retry_count: int = RETRY) -> Commit:
     for i in range(retry_count):
         try:
-            repo = gh.get_repo(GITHUB_REPOSITORY)
+            repo = get_repo(gh)
             commit = repo.get_commit(commit_sha)
             break
         except Exception as ex:
@@ -46,22 +77,165 @@ def get_commit(gh: Github, commit_sha: str, retry_count: int = RETRY) -> Commit:
 
 
 def post_commit_status(
-    gh: Github, sha: str, check_name: str, description: str, state: str, report_url: str
+    commit: Commit,
+    state: str,
+    report_url: Union[_NotSetType, str] = NotSet,
+    description: Union[_NotSetType, str] = NotSet,
+    check_name: Union[_NotSetType, str] = NotSet,
+    pr_info: Optional[PRInfo] = None,
 ) -> None:
+    """The parameters are given in the same order as for commit.create_status,
+    if an optional parameter `pr_info` is given, the `set_status_comment` functions
+    is invoked to add or update the comment with statuses overview"""
     for i in range(RETRY):
         try:
-            commit = get_commit(gh, sha, 1)
             commit.create_status(
-                context=check_name,
-                description=description,
                 state=state,
                 target_url=report_url,
+                description=description,
+                context=check_name,
             )
             break
         except Exception as ex:
             if i == RETRY - 1:
                 raise ex
             time.sleep(i)
+    if pr_info:
+        set_status_comment(commit, pr_info)
+
+
+def set_status_comment(commit: Commit, pr_info: PRInfo) -> None:
+    """It adds or updates the comment status to all Pull Requests but for release
+    one, so the method does nothing for simple pushes and pull requests with
+    `release`/`release-lts` labels"""
+    # to reduce number of parameters, the Github is constructed on the fly
+    gh = Github()
+    gh.__requester = commit._requester  # type:ignore #pylint:disable=protected-access
+    repo = get_repo(gh)
+    statuses = sorted(get_commit_filtered_statuses(commit), key=lambda x: x.context)
+    if not statuses:
+        return
+
+    # We update the report in generate_status_comment function, so do it each
+    # run, even in the release PRs and normal pushes
+    comment_body = generate_status_comment(pr_info, statuses)
+    # We post the comment only to normal and backport PRs
+    if pr_info.number == 0 or pr_info.labels.intersection({"release", "release-lts"}):
+        return
+
+    comment_service_header = comment_body.split("\n", 1)[0]
+    comment = None  # type: Optional[IssueComment]
+    pr = repo.get_pull(pr_info.number)
+    for ic in pr.get_issue_comments():
+        if ic.body.startswith(comment_service_header):
+            comment = ic
+            break
+
+    if comment is None:
+        pr.create_issue_comment(comment_body)
+        return
+
+    if comment.body == comment_body:
+        logging.info("The status comment is already updated, no needs to change it")
+        return
+    comment.edit(comment_body)
+
+
+def generate_status_comment(pr_info: PRInfo, statuses: CommitStatuses) -> str:
+    """The method generates the comment body, as well it updates the CI report"""
+
+    def beauty_state(state: str) -> str:
+        if state == "success":
+            return f"🟢 {state}"
+        if state == "pending":
+            return f"🟡 {state}"
+        if state in ["error", "failure"]:
+            return f"🔴 {state}"
+        return state
+
+    report_url = create_ci_report(pr_info, statuses)
+    worst_state = get_worst_state(statuses)
+    if not worst_state:
+        # Theoretically possible, although
+        # the function should not be used on empty statuses
+        worst_state = "The commit doesn't have the statuses yet"
+    else:
+        worst_state = f"The overall status of the commit is {beauty_state(worst_state)}"
+
+    comment_body = (
+        f"<!-- automatic status comment for PR #{pr_info.number} "
+        f"from {pr_info.head_name}:{pr_info.head_ref} -->\n"
+        f"This is an automated comment for commit {pr_info.sha} with "
+        f"description of existing statuses. It's updated for the latest CI running\n"
+        f"The full report is available [here]({report_url})\n"
+        f"{worst_state}\n\n<table>"
+        "<thead><tr><th>Check name</th><th>Description</th><th>Status</th></tr></thead>\n"
+        "<tbody>"
+    )
+    # group checks by the name to get the worst one per each
+    grouped_statuses = {}  # type: Dict[CheckDescription, CommitStatuses]
+    for status in statuses:
+        cd = None
+        for c in CHECK_DESCRIPTIONS:
+            if c.match_func(status.context):
+                cd = c
+                break
+
+        if cd is None or cd == CHECK_DESCRIPTIONS[-1]:
+            # This is the case for either non-found description or a fallback
+            cd = CheckDescription(
+                status.context,
+                CHECK_DESCRIPTIONS[-1].description,
+                CHECK_DESCRIPTIONS[-1].match_func,
+            )
+
+        if cd in grouped_statuses:
+            grouped_statuses[cd].append(status)
+        else:
+            grouped_statuses[cd] = [status]
+
+    table_rows = []  # type: List[str]
+    for desc, gs in grouped_statuses.items():
+        table_rows.append(
+            f"<tr><td>{desc.name}</td><td>{desc.description}</td>"
+            f"<td>{beauty_state(get_worst_state(gs))}</td></tr>\n"
+        )
+
+    table_rows.sort()
+
+    comment_footer = "</table>"
+    return "".join([comment_body, *table_rows, comment_footer])
+
+
+def get_worst_state(statuses: CommitStatuses) -> str:
+    worst_status = None
+    states = {"error": 0, "failure": 1, "pending": 2, "success": 3}
+    for status in statuses:
+        if worst_status is None:
+            worst_status = status
+            continue
+        if states[status.state] < states[worst_status.state]:
+            worst_status = status
+        if worst_status.state == "error":
+            break
+
+    if worst_status is None:
+        return ""
+    return worst_status.state
+
+
+def create_ci_report(pr_info: PRInfo, statuses: CommitStatuses) -> str:
+    """The function converst the statuses to TestResults and uploads the report
+    to S3 tests bucket. Then it returns the URL"""
+    test_results = []  # type: TestResults
+    for status in statuses:
+        log_urls = None
+        if status.target_url is not None:
+            log_urls = [status.target_url]
+        test_results.append(TestResult(status.context, status.state, log_urls=log_urls))
+    return upload_results(
+        S3Helper(), pr_info.number, pr_info.sha, test_results, [], CI_STATUS_NAME
+    )
 
 
 def post_commit_status_to_file(
@@ -90,8 +264,16 @@ def get_commit_filtered_statuses(commit: Commit) -> CommitStatuses:
     return list(filtered.values())
 
 
+def get_repo(gh: Github) -> Repository:
+    global GH_REPO
+    if GH_REPO is not None:
+        return GH_REPO
+    GH_REPO = gh.get_repo(GITHUB_REPOSITORY)
+    return GH_REPO
+
+
 def remove_labels(gh: Github, pr_info: PRInfo, labels_names: List[str]) -> None:
-    repo = gh.get_repo(GITHUB_REPOSITORY)
+    repo = get_repo(gh)
     pull_request = repo.get_pull(pr_info.number)
     for label in labels_names:
         pull_request.remove_from_labels(label)
@@ -99,7 +281,7 @@ def remove_labels(gh: Github, pr_info: PRInfo, labels_names: List[str]) -> None:
 
 
 def post_labels(gh: Github, pr_info: PRInfo, labels_names: List[str]) -> None:
-    repo = gh.get_repo(GITHUB_REPOSITORY)
+    repo = get_repo(gh)
     pull_request = repo.get_pull(pr_info.number)
     for label in labels_names:
         pull_request.add_to_labels(label)
diff --git a/tests/ci/compatibility_check.py b/tests/ci/compatibility_check.py
index 432e9ec7c01..04203617dca 100644
--- a/tests/ci/compatibility_check.py
+++ b/tests/ci/compatibility_check.py
@@ -16,13 +16,12 @@ from clickhouse_helper import (
     mark_flaky_tests,
     prepare_tests_results_for_clickhouse,
 )
-from commit_status_helper import post_commit_status
+from commit_status_helper import RerunHelper, get_commit, post_commit_status
 from docker_pull_helper import get_images_with_versions
 from env_helper import TEMP_PATH, REPORTS_PATH
 from get_robot_token import get_best_robot_token
 from pr_info import PRInfo
 from report import TestResults, TestResult
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from stopwatch import Stopwatch
 from upload_result_helper import upload_results
@@ -150,8 +149,9 @@ def main():
     pr_info = PRInfo()
 
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
 
-    rerun_helper = RerunHelper(gh, pr_info, args.check_name)
+    rerun_helper = RerunHelper(commit, args.check_name)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -242,7 +242,7 @@ def main():
         args.check_name,
     )
     print(f"::notice ::Report url: {report_url}")
-    post_commit_status(gh, pr_info.sha, args.check_name, description, state, report_url)
+    post_commit_status(commit, state, report_url, description, args.check_name, pr_info)
 
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
diff --git a/tests/ci/docker_images_check.py b/tests/ci/docker_images_check.py
index f2b1105b3b0..16a58a90dcf 100644
--- a/tests/ci/docker_images_check.py
+++ b/tests/ci/docker_images_check.py
@@ -14,7 +14,7 @@ from typing import Any, Dict, List, Optional, Set, Tuple, Union
 from github import Github
 
 from clickhouse_helper import ClickHouseHelper, prepare_tests_results_for_clickhouse
-from commit_status_helper import format_description, post_commit_status
+from commit_status_helper import format_description, get_commit, post_commit_status
 from env_helper import GITHUB_WORKSPACE, RUNNER_TEMP, GITHUB_RUN_URL
 from get_robot_token import get_best_robot_token, get_parameter_from_ssm
 from pr_info import PRInfo
@@ -474,7 +474,8 @@ def main():
         return
 
     gh = Github(get_best_robot_token(), per_page=100)
-    post_commit_status(gh, pr_info.sha, NAME, description, status, url)
+    commit = get_commit(gh, pr_info.sha)
+    post_commit_status(commit, status, url, description, NAME, pr_info)
 
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
diff --git a/tests/ci/docker_manifests_merge.py b/tests/ci/docker_manifests_merge.py
index 0484ea8f641..d89708b9277 100644
--- a/tests/ci/docker_manifests_merge.py
+++ b/tests/ci/docker_manifests_merge.py
@@ -10,7 +10,7 @@ from typing import List, Dict, Tuple
 from github import Github
 
 from clickhouse_helper import ClickHouseHelper, prepare_tests_results_for_clickhouse
-from commit_status_helper import format_description, post_commit_status
+from commit_status_helper import format_description, get_commit, post_commit_status
 from env_helper import RUNNER_TEMP
 from get_robot_token import get_best_robot_token, get_parameter_from_ssm
 from pr_info import PRInfo
@@ -221,7 +221,8 @@ def main():
     description = format_description(description)
 
     gh = Github(get_best_robot_token(), per_page=100)
-    post_commit_status(gh, pr_info.sha, NAME, description, status, url)
+    commit = get_commit(gh, pr_info.sha)
+    post_commit_status(commit, status, url, description, NAME, pr_info)
 
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
diff --git a/tests/ci/docker_server.py b/tests/ci/docker_server.py
index c6854c5aa78..a434d3cc841 100644
--- a/tests/ci/docker_server.py
+++ b/tests/ci/docker_server.py
@@ -15,7 +15,7 @@ from github import Github
 
 from build_check import get_release_or_pr
 from clickhouse_helper import ClickHouseHelper, prepare_tests_results_for_clickhouse
-from commit_status_helper import format_description, post_commit_status
+from commit_status_helper import format_description, get_commit, post_commit_status
 from docker_images_check import DockerImage
 from env_helper import CI, GITHUB_RUN_URL, RUNNER_TEMP, S3_BUILDS_BUCKET, S3_DOWNLOAD
 from get_robot_token import get_best_robot_token, get_parameter_from_ssm
@@ -372,7 +372,8 @@ def main():
     description = format_description(description)
 
     gh = Github(get_best_robot_token(), per_page=100)
-    post_commit_status(gh, pr_info.sha, NAME, description, status, url)
+    commit = get_commit(gh, pr_info.sha)
+    post_commit_status(commit, status, url, description, NAME, pr_info)
 
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
diff --git a/tests/ci/docs_check.py b/tests/ci/docs_check.py
index ed2743ca965..e3930a20bd9 100644
--- a/tests/ci/docs_check.py
+++ b/tests/ci/docs_check.py
@@ -9,13 +9,18 @@ import sys
 from github import Github
 
 from clickhouse_helper import ClickHouseHelper, prepare_tests_results_for_clickhouse
-from commit_status_helper import post_commit_status, get_commit, update_mergeable_check
+from commit_status_helper import (
+    NotSet,
+    RerunHelper,
+    get_commit,
+    post_commit_status,
+    update_mergeable_check,
+)
 from docker_pull_helper import get_image_with_version
 from env_helper import TEMP_PATH, REPO_COPY
 from get_robot_token import get_best_robot_token
 from pr_info import PRInfo
 from report import TestResults, TestResult
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from stopwatch import Stopwatch
 from tee_popen import TeePopen
@@ -52,8 +57,9 @@ def main():
     pr_info = PRInfo(need_changed_files=True)
 
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
 
-    rerun_helper = RerunHelper(gh, pr_info, NAME)
+    rerun_helper = RerunHelper(commit, NAME)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -61,9 +67,8 @@ def main():
 
     if not pr_info.has_changes_in_documentation() and not args.force:
         logging.info("No changes in documentation")
-        commit = get_commit(gh, pr_info.sha)
-        commit.create_status(
-            context=NAME, description="No changes in docs", state="success"
+        post_commit_status(
+            commit, "success", NotSet, "No changes in docs", NAME, pr_info
         )
         sys.exit(0)
 
@@ -132,7 +137,7 @@ def main():
         s3_helper, pr_info.number, pr_info.sha, test_results, additional_files, NAME
     )
     print("::notice ::Report url: {report_url}")
-    post_commit_status(gh, pr_info.sha, NAME, description, status, report_url)
+    post_commit_status(commit, status, report_url, description, NAME, pr_info)
 
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
diff --git a/tests/ci/env_helper.py b/tests/ci/env_helper.py
index a5a4913be0b..5c2139ae0bc 100644
--- a/tests/ci/env_helper.py
+++ b/tests/ci/env_helper.py
@@ -1,7 +1,7 @@
 import os
 from os import path as p
 
-from build_download_helper import get_with_retries
+from build_download_helper import get_gh_api
 
 module_dir = p.abspath(p.dirname(__file__))
 git_root = p.abspath(p.join(module_dir, "..", ".."))
@@ -46,7 +46,7 @@ def GITHUB_JOB_ID() -> str:
     jobs = []
     page = 1
     while not _GITHUB_JOB_ID:
-        response = get_with_retries(
+        response = get_gh_api(
             f"https://api.github.com/repos/{GITHUB_REPOSITORY}/"
             f"actions/runs/{GITHUB_RUN_ID}/jobs?per_page=100&page={page}"
         )
diff --git a/tests/ci/fast_test_check.py b/tests/ci/fast_test_check.py
index f13b4099657..89066ade2cb 100644
--- a/tests/ci/fast_test_check.py
+++ b/tests/ci/fast_test_check.py
@@ -17,6 +17,8 @@ from clickhouse_helper import (
     prepare_tests_results_for_clickhouse,
 )
 from commit_status_helper import (
+    RerunHelper,
+    get_commit,
     post_commit_status,
     update_mergeable_check,
 )
@@ -25,7 +27,6 @@ from env_helper import S3_BUILDS_BUCKET, TEMP_PATH
 from get_robot_token import get_best_robot_token
 from pr_info import FORCE_TESTS_LABEL, PRInfo
 from report import TestResults, read_test_results
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from stopwatch import Stopwatch
 from tee_popen import TeePopen
@@ -106,10 +107,11 @@ def main():
     pr_info = PRInfo()
 
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
 
     atexit.register(update_mergeable_check, gh, pr_info, NAME)
 
-    rerun_helper = RerunHelper(gh, pr_info, NAME)
+    rerun_helper = RerunHelper(commit, NAME)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         status = rerun_helper.get_finished_status()
@@ -197,7 +199,7 @@ def main():
         NAME,
     )
     print(f"::notice ::Report url: {report_url}")
-    post_commit_status(gh, pr_info.sha, NAME, description, state, report_url)
+    post_commit_status(commit, state, report_url, description, NAME, pr_info)
 
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
diff --git a/tests/ci/finish_check.py b/tests/ci/finish_check.py
index ea2f5eb3136..aa8a0cf9553 100644
--- a/tests/ci/finish_check.py
+++ b/tests/ci/finish_check.py
@@ -2,32 +2,42 @@
 import logging
 from github import Github
 
-from env_helper import GITHUB_RUN_URL
-from pr_info import PRInfo
+from commit_status_helper import (
+    CI_STATUS_NAME,
+    NotSet,
+    get_commit,
+    get_commit_filtered_statuses,
+    post_commit_status,
+)
 from get_robot_token import get_best_robot_token
-from commit_status_helper import get_commit, get_commit_filtered_statuses
-
-NAME = "Run Check"
+from pr_info import PRInfo
 
 
-if __name__ == "__main__":
+def main():
     logging.basicConfig(level=logging.INFO)
 
     pr_info = PRInfo(need_orgs=True)
     gh = Github(get_best_robot_token(), per_page=100)
     commit = get_commit(gh, pr_info.sha)
 
-    url = GITHUB_RUN_URL
-    statuses = get_commit_filtered_statuses(commit)
-    pending_status = any(  # find NAME status in pending state
-        True
-        for status in statuses
-        if status.context == NAME and status.state == "pending"
-    )
-    if pending_status:
-        commit.create_status(
-            context=NAME,
-            description="All checks finished",
-            state="success",
-            target_url=url,
+    statuses = [
+        status
+        for status in get_commit_filtered_statuses(commit)
+        if status.context == CI_STATUS_NAME
+    ]
+    if not statuses:
+        return
+    status = statuses[0]
+    if status.state == "pending":
+        post_commit_status(
+            commit,
+            "success",
+            status.target_url or NotSet,
+            "All checks finished",
+            CI_STATUS_NAME,
+            pr_info,
         )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/ci/functional_test_check.py b/tests/ci/functional_test_check.py
index 813386bc0db..037bb13f1f8 100644
--- a/tests/ci/functional_test_check.py
+++ b/tests/ci/functional_test_check.py
@@ -20,9 +20,11 @@ from clickhouse_helper import (
     prepare_tests_results_for_clickhouse,
 )
 from commit_status_helper import (
-    post_commit_status,
+    NotSet,
+    RerunHelper,
     get_commit,
     override_status,
+    post_commit_status,
     post_commit_status_to_file,
     update_mergeable_check,
 )
@@ -32,7 +34,6 @@ from env_helper import TEMP_PATH, REPO_COPY, REPORTS_PATH
 from get_robot_token import get_best_robot_token
 from pr_info import FORCE_TESTS_LABEL, PRInfo
 from report import TestResults, read_test_results
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from stopwatch import Stopwatch
 from tee_popen import TeePopen
@@ -247,6 +248,7 @@ def main():
         need_changed_files=run_changed_tests, pr_event_from_api=validate_bugfix_check
     )
 
+    commit = get_commit(gh, pr_info.sha)
     atexit.register(update_mergeable_check, gh, pr_info, check_name)
 
     if not os.path.exists(temp_path):
@@ -274,7 +276,7 @@ def main():
         run_by_hash_total = 0
         check_name_with_group = check_name
 
-    rerun_helper = RerunHelper(gh, pr_info, check_name_with_group)
+    rerun_helper = RerunHelper(commit, check_name_with_group)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -283,13 +285,15 @@ def main():
     if run_changed_tests:
         tests_to_run = get_tests_to_run(pr_info)
         if not tests_to_run:
-            commit = get_commit(gh, pr_info.sha)
             state = override_status("success", check_name, validate_bugfix_check)
             if args.post_commit_status == "commit_status":
-                commit.create_status(
-                    context=check_name_with_group,
-                    description=NO_CHANGES_MSG,
-                    state=state,
+                post_commit_status(
+                    commit,
+                    state,
+                    NotSet,
+                    NO_CHANGES_MSG,
+                    check_name_with_group,
+                    pr_info,
                 )
             elif args.post_commit_status == "file":
                 post_commit_status_to_file(
@@ -376,16 +380,16 @@ def main():
     if args.post_commit_status == "commit_status":
         if "parallelreplicas" in check_name.lower():
             post_commit_status(
-                gh,
-                pr_info.sha,
-                check_name_with_group,
-                description,
+                commit,
                 "success",
                 report_url,
+                description,
+                check_name_with_group,
+                pr_info,
             )
         else:
             post_commit_status(
-                gh, pr_info.sha, check_name_with_group, description, state, report_url
+                commit, state, report_url, description, check_name_with_group, pr_info
             )
     elif args.post_commit_status == "file":
         if "parallelreplicas" in check_name.lower():
diff --git a/tests/ci/get_robot_token.py b/tests/ci/get_robot_token.py
index 6ecaf468ed1..b41eba49cc3 100644
--- a/tests/ci/get_robot_token.py
+++ b/tests/ci/get_robot_token.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 import logging
 from dataclasses import dataclass
+from typing import Optional
 
 import boto3  # type: ignore
 from github import Github
@@ -20,7 +21,13 @@ def get_parameter_from_ssm(name, decrypt=True, client=None):
     return client.get_parameter(Name=name, WithDecryption=decrypt)["Parameter"]["Value"]
 
 
+ROBOT_TOKEN = None  # type: Optional[Token]
+
+
 def get_best_robot_token(token_prefix_env_name="github_robot_token_"):
+    global ROBOT_TOKEN
+    if ROBOT_TOKEN is not None:
+        return ROBOT_TOKEN.value
     client = boto3.client("ssm", region_name="us-east-1")
     parameters = client.describe_parameters(
         ParameterFilters=[
@@ -28,7 +35,6 @@ def get_best_robot_token(token_prefix_env_name="github_robot_token_"):
         ]
     )["Parameters"]
     assert parameters
-    token = None
 
     for token_name in [p["Name"] for p in parameters]:
         value = get_parameter_from_ssm(token_name, True, client)
@@ -38,15 +44,17 @@ def get_best_robot_token(token_prefix_env_name="github_robot_token_"):
         user = gh.get_user()
         rest, _ = gh.rate_limiting
         logging.info("Get token with %s remaining requests", rest)
-        if token is None:
-            token = Token(user, value, rest)
+        if ROBOT_TOKEN is None:
+            ROBOT_TOKEN = Token(user, value, rest)
             continue
-        if token.rest < rest:
-            token.user, token.value, token.rest = user, value, rest
+        if ROBOT_TOKEN.rest < rest:
+            ROBOT_TOKEN.user, ROBOT_TOKEN.value, ROBOT_TOKEN.rest = user, value, rest
 
-    assert token
+    assert ROBOT_TOKEN
     logging.info(
-        "User %s with %s remaining requests is used", token.user.login, token.rest
+        "User %s with %s remaining requests is used",
+        ROBOT_TOKEN.user.login,
+        ROBOT_TOKEN.rest,
     )
 
-    return token.value
+    return ROBOT_TOKEN.value
diff --git a/tests/ci/install_check.py b/tests/ci/install_check.py
index 54245670b26..d619ce96cee 100644
--- a/tests/ci/install_check.py
+++ b/tests/ci/install_check.py
@@ -19,7 +19,9 @@ from clickhouse_helper import (
     prepare_tests_results_for_clickhouse,
 )
 from commit_status_helper import (
+    RerunHelper,
     format_description,
+    get_commit,
     post_commit_status,
     update_mergeable_check,
 )
@@ -29,7 +31,6 @@ from env_helper import CI, TEMP_PATH as TEMP, REPORTS_PATH
 from get_robot_token import get_best_robot_token
 from pr_info import PRInfo
 from report import TestResults, TestResult
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from stopwatch import Stopwatch
 from tee_popen import TeePopen
@@ -268,9 +269,10 @@ def main():
 
     if CI:
         gh = Github(get_best_robot_token(), per_page=100)
+        commit = get_commit(gh, pr_info.sha)
         atexit.register(update_mergeable_check, gh, pr_info, args.check_name)
 
-        rerun_helper = RerunHelper(gh, pr_info, args.check_name)
+        rerun_helper = RerunHelper(commit, args.check_name)
         if rerun_helper.is_already_finished_by_status():
             logging.info(
                 "Check is already finished according to github status, exiting"
@@ -347,7 +349,7 @@ def main():
 
     description = format_description(description)
 
-    post_commit_status(gh, pr_info.sha, args.check_name, description, state, report_url)
+    post_commit_status(commit, state, report_url, description, args.check_name, pr_info)
 
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
diff --git a/tests/ci/integration_test_check.py b/tests/ci/integration_test_check.py
index f864751e830..8ef6244a1c5 100644
--- a/tests/ci/integration_test_check.py
+++ b/tests/ci/integration_test_check.py
@@ -19,8 +19,10 @@ from clickhouse_helper import (
     prepare_tests_results_for_clickhouse,
 )
 from commit_status_helper import (
-    post_commit_status,
+    RerunHelper,
+    get_commit,
     override_status,
+    post_commit_status,
     post_commit_status_to_file,
 )
 from docker_pull_helper import get_images_with_versions
@@ -29,7 +31,6 @@ from env_helper import TEMP_PATH, REPO_COPY, REPORTS_PATH
 from get_robot_token import get_best_robot_token
 from pr_info import PRInfo
 from report import TestResults, read_test_results
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from stopwatch import Stopwatch
 from tee_popen import TeePopen
@@ -198,8 +199,9 @@ def main():
         sys.exit(0)
 
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
 
-    rerun_helper = RerunHelper(gh, pr_info, check_name_with_group)
+    rerun_helper = RerunHelper(commit, check_name_with_group)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -284,15 +286,10 @@ def main():
     print(f"::notice:: {check_name} Report url: {report_url}")
     if args.post_commit_status == "commit_status":
         post_commit_status(
-            gh, pr_info.sha, check_name_with_group, description, state, report_url
+            commit, state, report_url, description, check_name_with_group, pr_info
         )
     elif args.post_commit_status == "file":
-        post_commit_status_to_file(
-            post_commit_path,
-            description,
-            state,
-            report_url,
-        )
+        post_commit_status_to_file(post_commit_path, description, state, report_url)
     else:
         raise Exception(
             f'Unknown post_commit_status option "{args.post_commit_status}"'
diff --git a/tests/ci/jepsen_check.py b/tests/ci/jepsen_check.py
index ffa9e45373f..9d35d2d6e35 100644
--- a/tests/ci/jepsen_check.py
+++ b/tests/ci/jepsen_check.py
@@ -13,13 +13,12 @@ from github import Github
 
 from build_download_helper import get_build_name_for_check
 from clickhouse_helper import ClickHouseHelper, prepare_tests_results_for_clickhouse
-from commit_status_helper import post_commit_status
+from commit_status_helper import RerunHelper, get_commit, post_commit_status
 from compress_files import compress_fast
 from env_helper import REPO_COPY, TEMP_PATH, S3_BUILDS_BUCKET, S3_DOWNLOAD
 from get_robot_token import get_best_robot_token, get_parameter_from_ssm
 from pr_info import PRInfo
 from report import TestResults, TestResult
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from ssh import SSHKey
 from stopwatch import Stopwatch
@@ -181,10 +180,11 @@ if __name__ == "__main__":
         sys.exit(0)
 
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
 
     check_name = KEEPER_CHECK_NAME if args.program == "keeper" else SERVER_CHECK_NAME
 
-    rerun_helper = RerunHelper(gh, pr_info, check_name)
+    rerun_helper = RerunHelper(commit, check_name)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -293,7 +293,7 @@ if __name__ == "__main__":
     )
 
     print(f"::notice ::Report url: {report_url}")
-    post_commit_status(gh, pr_info.sha, check_name, description, status, report_url)
+    post_commit_status(commit, status, report_url, description, check_name, pr_info)
 
     ch_helper = ClickHouseHelper()
     prepared_events = prepare_tests_results_for_clickhouse(
diff --git a/tests/ci/mark_release_ready.py b/tests/ci/mark_release_ready.py
index b103dd053bb..4501d40e4d3 100755
--- a/tests/ci/mark_release_ready.py
+++ b/tests/ci/mark_release_ready.py
@@ -4,7 +4,7 @@ import argparse
 import logging
 import os
 
-from commit_status_helper import get_commit
+from commit_status_helper import NotSet, get_commit, post_commit_status
 from env_helper import GITHUB_JOB_URL
 from get_robot_token import get_best_robot_token
 from github_helper import GitHub
@@ -34,6 +34,7 @@ def main():
     args = parser.parse_args()
     url = ""
     description = "the release can be created from the commit, manually set"
+    pr_info = None
     if not args.commit:
         pr_info = PRInfo()
         if pr_info.event == pr_info.default_event:
@@ -45,14 +46,10 @@ def main():
 
     gh = GitHub(args.token, create_cache_dir=False)
     # Get the rate limits for a quick fail
-    gh.get_rate_limit()
     commit = get_commit(gh, args.commit)
-
-    commit.create_status(
-        context=RELEASE_READY_STATUS,
-        description=description,
-        state="success",
-        target_url=url,
+    gh.get_rate_limit()
+    post_commit_status(
+        commit, "success", url or NotSet, description, RELEASE_READY_STATUS, pr_info
     )
 
 
diff --git a/tests/ci/performance_comparison_check.py b/tests/ci/performance_comparison_check.py
index d0c84d56496..bf5704f31bd 100644
--- a/tests/ci/performance_comparison_check.py
+++ b/tests/ci/performance_comparison_check.py
@@ -12,13 +12,12 @@ from typing import Dict
 
 from github import Github
 
-from commit_status_helper import get_commit, post_commit_status
+from commit_status_helper import RerunHelper, get_commit, post_commit_status
 from ci_config import CI_CONFIG
 from docker_pull_helper import get_image_with_version
 from env_helper import GITHUB_EVENT_PATH, GITHUB_RUN_URL, S3_BUILDS_BUCKET, S3_DOWNLOAD
 from get_robot_token import get_best_robot_token, get_parameter_from_ssm
 from pr_info import PRInfo
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from tee_popen import TeePopen
 
@@ -118,7 +117,7 @@ if __name__ == "__main__":
         message = "Skipped, not labeled with 'pr-performance'"
         report_url = GITHUB_RUN_URL
         post_commit_status(
-            gh, pr_info.sha, check_name_with_group, message, status, report_url
+            commit, status, report_url, message, check_name_with_group, pr_info
         )
         sys.exit(0)
 
@@ -131,7 +130,7 @@ if __name__ == "__main__":
             "Fill fliter our performance tests by grep -v %s", test_grep_exclude_filter
         )
 
-    rerun_helper = RerunHelper(gh, pr_info, check_name_with_group)
+    rerun_helper = RerunHelper(commit, check_name_with_group)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -142,6 +141,7 @@ if __name__ == "__main__":
         .replace("(", "_")
         .replace(")", "_")
         .replace(",", "_")
+        .replace("/", "_")
     )
 
     docker_image = get_image_with_version(reports_path, IMAGE_NAME)
@@ -266,7 +266,7 @@ if __name__ == "__main__":
         report_url = uploaded["report.html"]
 
     post_commit_status(
-        gh, pr_info.sha, check_name_with_group, message, status, report_url
+        commit, status, report_url, message, check_name_with_group, pr_info
     )
 
     if status == "error":
diff --git a/tests/ci/pr_info.py b/tests/ci/pr_info.py
index ddeb070b2b9..86d4985c6b2 100644
--- a/tests/ci/pr_info.py
+++ b/tests/ci/pr_info.py
@@ -6,7 +6,7 @@ from typing import Dict, List, Set, Union
 
 from unidiff import PatchSet  # type: ignore
 
-from build_download_helper import get_with_retries
+from build_download_helper import get_gh_api
 from env_helper import (
     GITHUB_REPOSITORY,
     GITHUB_SERVER_URL,
@@ -45,7 +45,7 @@ def get_pr_for_commit(sha, ref):
         f"https://api.github.com/repos/{GITHUB_REPOSITORY}/commits/{sha}/pulls"
     )
     try:
-        response = get_with_retries(try_get_pr_url, sleep=RETRY_SLEEP)
+        response = get_gh_api(try_get_pr_url, sleep=RETRY_SLEEP)
         data = response.json()
         our_prs = []  # type: List[Dict]
         if len(data) > 1:
@@ -105,7 +105,7 @@ class PRInfo:
         # workflow completed event, used for PRs only
         if "action" in github_event and github_event["action"] == "completed":
             self.sha = github_event["workflow_run"]["head_sha"]
-            prs_for_sha = get_with_retries(
+            prs_for_sha = get_gh_api(
                 f"https://api.github.com/repos/{GITHUB_REPOSITORY}/commits/{self.sha}"
                 "/pulls",
                 sleep=RETRY_SLEEP,
@@ -117,7 +117,7 @@ class PRInfo:
             self.number = github_event["pull_request"]["number"]
             if pr_event_from_api:
                 try:
-                    response = get_with_retries(
+                    response = get_gh_api(
                         f"https://api.github.com/repos/{GITHUB_REPOSITORY}"
                         f"/pulls/{self.number}",
                         sleep=RETRY_SLEEP,
@@ -159,7 +159,7 @@ class PRInfo:
             self.user_login = github_event["pull_request"]["user"]["login"]
             self.user_orgs = set([])
             if need_orgs:
-                user_orgs_response = get_with_retries(
+                user_orgs_response = get_gh_api(
                     github_event["pull_request"]["user"]["organizations_url"],
                     sleep=RETRY_SLEEP,
                 )
@@ -255,7 +255,7 @@ class PRInfo:
             raise TypeError("The event does not have diff URLs")
 
         for diff_url in self.diff_urls:
-            response = get_with_retries(
+            response = get_gh_api(
                 diff_url,
                 sleep=RETRY_SLEEP,
             )
diff --git a/tests/ci/report.py b/tests/ci/report.py
index 15d8ff9010e..cdef8409e7e 100644
--- a/tests/ci/report.py
+++ b/tests/ci/report.py
@@ -262,17 +262,20 @@ class ReportColorTheme:
 ColorTheme = Tuple[str, str, str]
 
 
-def _format_header(header, branch_name, branch_url=None):
-    result = " ".join([w.capitalize() for w in header.split(" ")])
+def _format_header(
+    header: str, branch_name: str, branch_url: Optional[str] = None
+) -> str:
+    # Following line does not lower CI->Ci and SQLancer->Sqlancer. It only
+    # capitalizes the first letter and doesn't touch the rest of the word
+    result = " ".join([w[0].upper() + w[1:] for w in header.split(" ") if w])
     result = result.replace("Clickhouse", "ClickHouse")
     result = result.replace("clickhouse", "ClickHouse")
     if "ClickHouse" not in result:
-        result = "ClickHouse " + result
-    result += " for "
+        result = f"ClickHouse {result}"
     if branch_url:
-        result += f'<a href="{branch_url}">{branch_name}</a>'
+        result = f'{result} for <a href="{branch_url}">{branch_name}</a>'
     else:
-        result += branch_name
+        result = f"{result} for {branch_name}"
     return result
 
 
@@ -367,6 +370,7 @@ def create_test_html_report(
                 colspan += 1
 
             if test_result.log_urls is not None:
+                has_log_urls = True
                 test_logs_html = "<br>".join(
                     [_get_html_url(url) for url in test_result.log_urls]
                 )
diff --git a/tests/ci/rerun_helper.py b/tests/ci/rerun_helper.py
deleted file mode 100644
index fa73256d759..00000000000
--- a/tests/ci/rerun_helper.py
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-from typing import Optional
-
-from commit_status_helper import get_commit, get_commit_filtered_statuses
-from github import Github
-from github.CommitStatus import CommitStatus
-from pr_info import PRInfo
-
-
-# TODO: move it to commit_status_helper
-class RerunHelper:
-    def __init__(self, gh: Github, pr_info: PRInfo, check_name: str):
-        self.gh = gh
-        self.pr_info = pr_info
-        self.check_name = check_name
-        commit = get_commit(gh, self.pr_info.sha)
-        if commit is None:
-            raise ValueError(f"unable to receive commit for {pr_info.sha}")
-        self.pygh_commit = commit
-        self.statuses = get_commit_filtered_statuses(commit)
-
-    def is_already_finished_by_status(self) -> bool:
-        # currently we agree even for failed statuses
-        for status in self.statuses:
-            if self.check_name in status.context and status.state in (
-                "success",
-                "failure",
-            ):
-                return True
-        return False
-
-    def get_finished_status(self) -> Optional[CommitStatus]:
-        for status in self.statuses:
-            if self.check_name in status.context:
-                return status
-        return None
diff --git a/tests/ci/run_check.py b/tests/ci/run_check.py
index 44e1e4132c8..351e740bd3c 100644
--- a/tests/ci/run_check.py
+++ b/tests/ci/run_check.py
@@ -7,20 +7,22 @@ from typing import Tuple
 from github import Github
 
 from commit_status_helper import (
+    CI_STATUS_NAME,
+    NotSet,
+    create_ci_report,
     format_description,
     get_commit,
+    post_commit_status,
     post_labels,
     remove_labels,
     set_mergeable_check,
 )
 from docs_check import NAME as DOCS_NAME
-from env_helper import GITHUB_RUN_URL, GITHUB_REPOSITORY, GITHUB_SERVER_URL
+from env_helper import GITHUB_REPOSITORY, GITHUB_SERVER_URL
 from get_robot_token import get_best_robot_token
 from pr_info import FORCE_TESTS_LABEL, PRInfo
 from workflow_approve_rerun_lambda.app import TRUSTED_CONTRIBUTORS
 
-NAME = "Run Check"
-
 TRUSTED_ORG_IDS = {
     54801242,  # clickhouse
 }
@@ -89,7 +91,7 @@ def pr_is_by_trusted_user(pr_user_login, pr_user_orgs):
 # Returns whether we should look into individual checks for this PR. If not, it
 # can be skipped entirely.
 # Returns can_run, description, labels_state
-def should_run_checks_for_pr(pr_info: PRInfo) -> Tuple[bool, str, str]:
+def should_run_ci_for_pr(pr_info: PRInfo) -> Tuple[bool, str, str]:
     # Consider the labels and whether the user is trusted.
     print("Got labels", pr_info.labels)
     if FORCE_TESTS_LABEL in pr_info.labels:
@@ -203,7 +205,7 @@ def check_pr_description(pr_info: PRInfo) -> Tuple[str, str]:
     return description_error, category
 
 
-if __name__ == "__main__":
+def main():
     logging.basicConfig(level=logging.INFO)
 
     pr_info = PRInfo(need_orgs=True, pr_event_from_api=True, need_changed_files=True)
@@ -213,7 +215,7 @@ if __name__ == "__main__":
         print("::notice ::Cannot run, no PR exists for the commit")
         sys.exit(1)
 
-    can_run, description, labels_state = should_run_checks_for_pr(pr_info)
+    can_run, description, labels_state = should_run_ci_for_pr(pr_info)
     if can_run and OK_SKIP_LABELS.intersection(pr_info.labels):
         print("::notice :: Early finish the check, running in a special PR")
         sys.exit(0)
@@ -253,10 +255,12 @@ if __name__ == "__main__":
 
     if FEATURE_LABEL in pr_info.labels:
         print(f"The '{FEATURE_LABEL}' in the labels, expect the 'Docs Check' status")
-        commit.create_status(
-            context=DOCS_NAME,
-            description=f"expect adding docs for {FEATURE_LABEL}",
-            state="pending",
+        post_commit_status(  # do not pass pr_info here intentionally
+            commit,
+            "pending",
+            NotSet,
+            f"expect adding docs for {FEATURE_LABEL}",
+            DOCS_NAME,
         )
     else:
         set_mergeable_check(commit, "skipped")
@@ -267,7 +271,7 @@ if __name__ == "__main__":
             f"{description_error}"
         )
         logging.info(
-            "PR body doesn't match the template: (start)\n%s\n(end)\n" "Reason: %s",
+            "PR body doesn't match the template: (start)\n%s\n(end)\nReason: %s",
             pr_info.body,
             description_error,
         )
@@ -275,23 +279,29 @@ if __name__ == "__main__":
             f"{GITHUB_SERVER_URL}/{GITHUB_REPOSITORY}/"
             "blob/master/.github/PULL_REQUEST_TEMPLATE.md?plain=1"
         )
-        commit.create_status(
-            context=NAME,
-            description=format_description(description_error),
-            state="failure",
-            target_url=url,
+        post_commit_status(
+            commit,
+            "failure",
+            url,
+            format_description(description_error),
+            CI_STATUS_NAME,
+            pr_info,
         )
         sys.exit(1)
 
-    url = GITHUB_RUN_URL
+    ci_report_url = create_ci_report(pr_info, [])
     if not can_run:
         print("::notice ::Cannot run")
-        commit.create_status(
-            context=NAME, description=description, state=labels_state, target_url=url
+        post_commit_status(
+            commit, labels_state, ci_report_url, description, CI_STATUS_NAME, pr_info
         )
         sys.exit(1)
     else:
         print("::notice ::Can run")
-        commit.create_status(
-            context=NAME, description=description, state="pending", target_url=url
+        post_commit_status(
+            commit, "pending", ci_report_url, description, CI_STATUS_NAME, pr_info
         )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/ci/s3_helper.py b/tests/ci/s3_helper.py
index fbe9f33b49b..2af02d572c8 100644
--- a/tests/ci/s3_helper.py
+++ b/tests/ci/s3_helper.py
@@ -40,11 +40,11 @@ def _flatten_list(lst):
 
 
 class S3Helper:
-    def __init__(self, host=S3_URL, download_host=S3_DOWNLOAD):
+    def __init__(self):
         self.session = boto3.session.Session(region_name="us-east-1")
-        self.client = self.session.client("s3", endpoint_url=host)
-        self.host = host
-        self.download_host = download_host
+        self.client = self.session.client("s3", endpoint_url=S3_URL)
+        self.host = S3_URL
+        self.download_host = S3_DOWNLOAD
 
     def _upload_file_to_s3(self, bucket_name: str, file_path: str, s3_path: str) -> str:
         logging.debug(
diff --git a/tests/ci/sqlancer_check.py b/tests/ci/sqlancer_check.py
index 1a6c4d14616..144dea54133 100644
--- a/tests/ci/sqlancer_check.py
+++ b/tests/ci/sqlancer_check.py
@@ -10,10 +10,14 @@ from github import Github
 
 from build_download_helper import get_build_name_for_check, read_build_urls
 from clickhouse_helper import ClickHouseHelper, prepare_tests_results_for_clickhouse
-from commit_status_helper import format_description, post_commit_status
+from commit_status_helper import (
+    RerunHelper,
+    format_description,
+    get_commit,
+    post_commit_status,
+)
 from docker_pull_helper import get_image_with_version
 from env_helper import (
-    GITHUB_REPOSITORY,
     GITHUB_RUN_URL,
     REPORTS_PATH,
     TEMP_PATH,
@@ -21,7 +25,6 @@ from env_helper import (
 from get_robot_token import get_best_robot_token
 from pr_info import PRInfo
 from report import TestResults, TestResult
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from stopwatch import Stopwatch
 from upload_result_helper import upload_results
@@ -46,12 +49,6 @@ def get_run_command(download_url, workspace_path, image):
     )
 
 
-def get_commit(gh, commit_sha):
-    repo = gh.get_repo(GITHUB_REPOSITORY)
-    commit = repo.get_commit(commit_sha)
-    return commit
-
-
 def main():
     logging.basicConfig(level=logging.INFO)
 
@@ -68,8 +65,9 @@ def main():
     pr_info = PRInfo()
 
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
 
-    rerun_helper = RerunHelper(gh, pr_info, check_name)
+    rerun_helper = RerunHelper(commit, check_name)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -187,12 +185,10 @@ def main():
         check_name,
     )
 
-    post_commit_status(gh, pr_info.sha, check_name, description, status, report_url)
-
+    post_commit_status(commit, status, report_url, description, check_name, pr_info)
     print(f"::notice:: {check_name} Report url: {report_url}")
 
     ch_helper = ClickHouseHelper()
-
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
         test_results,
@@ -202,12 +198,8 @@ def main():
         report_url,
         check_name,
     )
-
     ch_helper.insert_events_into(db="default", table="checks", events=prepared_events)
 
-    print(f"::notice Result: '{status}', '{description}', '{report_url}'")
-    post_commit_status(gh, pr_info.sha, check_name, description, status, report_url)
-
 
 if __name__ == "__main__":
     main()
diff --git a/tests/ci/sqllogic_test.py b/tests/ci/sqllogic_test.py
index 9b41ff4680f..942c9c60ee8 100755
--- a/tests/ci/sqllogic_test.py
+++ b/tests/ci/sqllogic_test.py
@@ -17,11 +17,15 @@ from pr_info import FORCE_TESTS_LABEL, PRInfo
 from build_download_helper import download_all_deb_packages
 from upload_result_helper import upload_results
 from docker_pull_helper import get_image_with_version
-from commit_status_helper import override_status, post_commit_status
+from commit_status_helper import (
+    RerunHelper,
+    get_commit,
+    override_status,
+    post_commit_status,
+)
 from report import TestResults, read_test_results
 
 from stopwatch import Stopwatch
-from rerun_helper import RerunHelper
 from tee_popen import TeePopen
 
 
@@ -103,8 +107,9 @@ if __name__ == "__main__":
 
     pr_info = PRInfo()
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
 
-    rerun_helper = RerunHelper(gh, pr_info, check_name)
+    rerun_helper = RerunHelper(commit, check_name)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -203,7 +208,7 @@ if __name__ == "__main__":
 
     # Until it pass all tests, do not block CI, report "success"
     assert description is not None
-    post_commit_status(gh, pr_info.sha, check_name, description, "success", report_url)
+    post_commit_status(commit, "success", report_url, description, check_name, pr_info)
 
     if status != "success":
         if FORCE_TESTS_LABEL in pr_info.labels:
diff --git a/tests/ci/stress_check.py b/tests/ci/stress_check.py
index 7596a81ebc9..ac280916a2f 100644
--- a/tests/ci/stress_check.py
+++ b/tests/ci/stress_check.py
@@ -16,13 +16,12 @@ from clickhouse_helper import (
     mark_flaky_tests,
     prepare_tests_results_for_clickhouse,
 )
-from commit_status_helper import post_commit_status
+from commit_status_helper import RerunHelper, get_commit, post_commit_status
 from docker_pull_helper import get_image_with_version
 from env_helper import TEMP_PATH, REPO_COPY, REPORTS_PATH
 from get_robot_token import get_best_robot_token
 from pr_info import PRInfo
 from report import TestResults, read_test_results
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from stopwatch import Stopwatch
 from tee_popen import TeePopen
@@ -125,8 +124,9 @@ def run_stress_test(docker_image_name):
     pr_info = PRInfo()
 
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
 
-    rerun_helper = RerunHelper(gh, pr_info, check_name)
+    rerun_helper = RerunHelper(commit, check_name)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -180,7 +180,7 @@ def run_stress_test(docker_image_name):
     )
     print(f"::notice ::Report url: {report_url}")
 
-    post_commit_status(gh, pr_info.sha, check_name, description, state, report_url)
+    post_commit_status(commit, state, report_url, description, check_name, pr_info)
 
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
diff --git a/tests/ci/style_check.py b/tests/ci/style_check.py
index 89878990c2c..33a5cd21f39 100644
--- a/tests/ci/style_check.py
+++ b/tests/ci/style_check.py
@@ -15,7 +15,12 @@ from clickhouse_helper import (
     mark_flaky_tests,
     prepare_tests_results_for_clickhouse,
 )
-from commit_status_helper import post_commit_status, update_mergeable_check
+from commit_status_helper import (
+    RerunHelper,
+    get_commit,
+    post_commit_status,
+    update_mergeable_check,
+)
 from docker_pull_helper import get_image_with_version
 from env_helper import GITHUB_WORKSPACE, RUNNER_TEMP
 from get_robot_token import get_best_robot_token
@@ -23,7 +28,6 @@ from github_helper import GitHub
 from git_helper import git_runner
 from pr_info import PRInfo
 from report import TestResults, read_test_results
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from ssh import SSHKey
 from stopwatch import Stopwatch
@@ -149,10 +153,11 @@ def main():
         checkout_head(pr_info)
 
     gh = GitHub(get_best_robot_token(), create_cache_dir=False)
+    commit = get_commit(gh, pr_info.sha)
 
     atexit.register(update_mergeable_check, gh, pr_info, NAME)
 
-    rerun_helper = RerunHelper(gh, pr_info, NAME)
+    rerun_helper = RerunHelper(commit, NAME)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         # Finish with the same code as previous
@@ -190,7 +195,7 @@ def main():
         s3_helper, pr_info.number, pr_info.sha, test_results, additional_files, NAME
     )
     print(f"::notice ::Report url: {report_url}")
-    post_commit_status(gh, pr_info.sha, NAME, description, state, report_url)
+    post_commit_status(commit, state, report_url, description, NAME, pr_info)
 
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
diff --git a/tests/ci/unit_tests_check.py b/tests/ci/unit_tests_check.py
index edc096908f4..5279ccde492 100644
--- a/tests/ci/unit_tests_check.py
+++ b/tests/ci/unit_tests_check.py
@@ -15,13 +15,17 @@ from clickhouse_helper import (
     mark_flaky_tests,
     prepare_tests_results_for_clickhouse,
 )
-from commit_status_helper import post_commit_status, update_mergeable_check
+from commit_status_helper import (
+    RerunHelper,
+    get_commit,
+    post_commit_status,
+    update_mergeable_check,
+)
 from docker_pull_helper import get_image_with_version
 from env_helper import TEMP_PATH, REPORTS_PATH
 from get_robot_token import get_best_robot_token
 from pr_info import PRInfo
 from report import TestResults, TestResult
-from rerun_helper import RerunHelper
 from s3_helper import S3Helper
 from stopwatch import Stopwatch
 from tee_popen import TeePopen
@@ -116,10 +120,11 @@ def main():
     pr_info = PRInfo()
 
     gh = Github(get_best_robot_token(), per_page=100)
+    commit = get_commit(gh, pr_info.sha)
 
     atexit.register(update_mergeable_check, gh, pr_info, check_name)
 
-    rerun_helper = RerunHelper(gh, pr_info, check_name)
+    rerun_helper = RerunHelper(commit, check_name)
     if rerun_helper.is_already_finished_by_status():
         logging.info("Check is already finished according to github status, exiting")
         sys.exit(0)
@@ -165,7 +170,7 @@ def main():
         check_name,
     )
     print(f"::notice ::Report url: {report_url}")
-    post_commit_status(gh, pr_info.sha, check_name, description, state, report_url)
+    post_commit_status(commit, state, report_url, description, check_name, pr_info)
 
     prepared_events = prepare_tests_results_for_clickhouse(
         pr_info,
diff --git a/tests/ci/upload_result_helper.py b/tests/ci/upload_result_helper.py
index b988e240b0e..150af7aff4a 100644
--- a/tests/ci/upload_result_helper.py
+++ b/tests/ci/upload_result_helper.py
@@ -59,9 +59,10 @@ def upload_results(
     additional_files: List[str],
     check_name: str,
 ) -> str:
-    s3_path_prefix = f"{pr_number}/{commit_sha}/" + check_name.lower().replace(
-        " ", "_"
-    ).replace("(", "_").replace(")", "_").replace(",", "_")
+    normalized_check_name = check_name.lower()
+    for r in ((" ", "_"), ("(", "_"), (")", "_"), (",", "_"), ("/", "_")):
+        normalized_check_name = normalized_check_name.replace(*r)
+    s3_path_prefix = f"{pr_number}/{commit_sha}/{normalized_check_name}"
     additional_urls = process_logs(
         s3_client, additional_files, s3_path_prefix, test_results
     )
diff --git a/tests/ci/workflow_jobs_lambda/app.py b/tests/ci/workflow_jobs_lambda/app.py
index 6ac75bcb8e5..49d475d11dc 100644
--- a/tests/ci/workflow_jobs_lambda/app.py
+++ b/tests/ci/workflow_jobs_lambda/app.py
@@ -284,7 +284,9 @@ def handler(event: dict, _: Any) -> dict:
         wf_job["runner_group_name"] or "",  # nullable
         repo["full_name"],
     )
-    logging.info("Got the next event: %s", workflow_job)
+    logging.info(
+        "Got the next event (private_repo=%s): %s", repo["private"], workflow_job
+    )
     if repo["private"]:
         workflow_job.anonimyze()
 
diff --git a/tests/clickhouse-test b/tests/clickhouse-test
index 7c492a9b467..9470f87ff75 100755
--- a/tests/clickhouse-test
+++ b/tests/clickhouse-test
@@ -11,6 +11,7 @@ import shutil
 import sys
 import os
 import os.path
+import platform
 import signal
 import re
 import copy
@@ -542,7 +543,10 @@ class SettingsRandomizer:
             0.2, 0.5, 1, 10 * 1024 * 1024 * 1024
         ),
         "local_filesystem_read_method": lambda: random.choice(
+            # Allow to use uring only when running on Linux
             ["read", "pread", "mmap", "pread_threadpool", "io_uring"]
+            if platform.system().lower() == "linux"
+            else ["read", "pread", "mmap", "pread_threadpool"]
         ),
         "remote_filesystem_read_method": lambda: random.choice(["read", "threadpool"]),
         "local_filesystem_read_prefetch": lambda: random.randint(0, 1),
diff --git a/tests/config/config.d/merge_tree_old_dirs_cleanup.xml b/tests/config/config.d/merge_tree_old_dirs_cleanup.xml
index 41932cb6d61..2b8ea63b63d 100644
--- a/tests/config/config.d/merge_tree_old_dirs_cleanup.xml
+++ b/tests/config/config.d/merge_tree_old_dirs_cleanup.xml
@@ -3,6 +3,6 @@
         <!-- Default is 86400 (1 day), but we have protection from removal of tmp dirs that are currently in use -->
         <temporary_directories_lifetime>1</temporary_directories_lifetime>
         <!-- Default is 60 seconds, but let's make tests more aggressive -->
-        <merge_tree_clear_old_temporary_directories_interval_seconds>10</merge_tree_clear_old_temporary_directories_interval_seconds>
+        <merge_tree_clear_old_temporary_directories_interval_seconds>5</merge_tree_clear_old_temporary_directories_interval_seconds>
     </merge_tree>
 </clickhouse>
diff --git a/tests/config/config.d/storage_conf.xml b/tests/config/config.d/storage_conf.xml
index bc9269e6ec1..cb5a75f9698 100644
--- a/tests/config/config.d/storage_conf.xml
+++ b/tests/config/config.d/storage_conf.xml
@@ -55,52 +55,58 @@
                 <type>cache</type>
                 <disk>s3_disk</disk>
                 <path>s3_cache/</path>
-                <max_size>2147483648</max_size>
+                <max_size>128Mi</max_size>
                 <cache_on_write_operations>1</cache_on_write_operations>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </s3_cache>
             <s3_cache_2>
                 <type>cache</type>
                 <disk>s3_disk_2</disk>
                 <path>s3_cache_2/</path>
-                <max_size>2Gi</max_size>
+                <max_size>128Mi</max_size>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
                 <max_file_segment_size>100Mi</max_file_segment_size>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </s3_cache_2>
             <s3_cache_3>
                 <type>cache</type>
                 <disk>s3_disk_3</disk>
                 <path>s3_disk_3_cache/</path>
-                <max_size>22548578304</max_size>
+                <max_size>128Mi</max_size>
                 <data_cache_max_size>22548578304</data_cache_max_size>
                 <cache_on_write_operations>1</cache_on_write_operations>
                 <enable_cache_hits_threshold>1</enable_cache_hits_threshold>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </s3_cache_3>
             <s3_cache_4>
                 <type>cache</type>
                 <disk>s3_disk_4</disk>
                 <path>s3_cache_4/</path>
-                <max_size>22548578304</max_size>
+                <max_size>128Mi</max_size>
                 <cache_on_write_operations>1</cache_on_write_operations>
                 <enable_filesystem_query_cache_limit>1</enable_filesystem_query_cache_limit>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </s3_cache_4>
             <s3_cache_5>
                 <type>cache</type>
                 <disk>s3_disk_5</disk>
                 <path>s3_cache_5/</path>
-                <max_size>22548578304</max_size>
+                <max_size>128Mi</max_size>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </s3_cache_5>
             <s3_cache_6>
                 <type>cache</type>
                 <disk>s3_disk_6</disk>
                 <path>s3_cache_6/</path>
-                <max_size>22548578304</max_size>
+                <max_size>128Mi</max_size>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
                 <enable_bypass_cache_with_threashold>1</enable_bypass_cache_with_threashold>
                 <bypass_cache_threashold>100</bypass_cache_threashold>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </s3_cache_6>
             <s3_cache_small>
                 <type>cache</type>
@@ -108,15 +114,17 @@
                 <path>s3_cache_small/</path>
                 <max_size>1000</max_size>
                 <do_not_evict_index_and_mark_files>1</do_not_evict_index_and_mark_files>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </s3_cache_small>
             <s3_cache_small_segment_size>
                 <type>cache</type>
                 <disk>s3_disk_6</disk>
                 <path>s3_cache_small_segment_size/</path>
-                <max_size>22548578304</max_size>
+                <max_size>128Mi</max_size>
                 <max_file_segment_size>10Ki</max_file_segment_size>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
                 <cache_on_write_operations>1</cache_on_write_operations>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </s3_cache_small_segment_size>
             <!-- local disks -->
             <local_disk>
@@ -139,6 +147,7 @@
                 <max_size>22548578304</max_size>
                 <cache_on_write_operations>1</cache_on_write_operations>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </local_cache>
             <local_cache_2>
                 <type>cache</type>
@@ -146,6 +155,7 @@
                 <path>local_cache_2/</path>
                 <max_size>22548578304</max_size>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </local_cache_2>
             <local_cache_3>
                 <type>cache</type>
@@ -155,6 +165,7 @@
                 <cache_on_write_operations>1</cache_on_write_operations>
                 <enable_cache_hits_threshold>1</enable_cache_hits_threshold>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </local_cache_3>
             <!-- multi layer cache -->
             <s3_cache_multi>
@@ -163,6 +174,7 @@
                 <path>s3_cache_multi/</path>
                 <max_size>22548578304</max_size>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </s3_cache_multi>
             <s3_cache_multi_2>
                 <type>cache</type>
@@ -170,6 +182,7 @@
                 <path>s3_cache_multi_2/</path>
                 <max_size>22548578304</max_size>
                 <do_not_evict_index_and_mark_files>0</do_not_evict_index_and_mark_files>
+                <delayed_cleanup_interval_ms>100</delayed_cleanup_interval_ms>
             </s3_cache_multi_2>
         </disks>
         <policies>
diff --git a/tests/integration/helpers/external_sources.py b/tests/integration/helpers/external_sources.py
index fd086fc4526..afb91083d57 100644
--- a/tests/integration/helpers/external_sources.py
+++ b/tests/integration/helpers/external_sources.py
@@ -161,6 +161,29 @@ class SourceMySQL(ExternalSource):
 
 
 class SourceMongo(ExternalSource):
+    def __init__(
+        self,
+        name,
+        internal_hostname,
+        internal_port,
+        docker_hostname,
+        docker_port,
+        user,
+        password,
+        secure=False,
+    ):
+        ExternalSource.__init__(
+            self,
+            name,
+            internal_hostname,
+            internal_port,
+            docker_hostname,
+            docker_port,
+            user,
+            password,
+        )
+        self.secure = secure
+
     def get_source_str(self, table_name):
         return """
             <mongodb>
@@ -170,6 +193,7 @@ class SourceMongo(ExternalSource):
                 <password>{password}</password>
                 <db>test</db>
                 <collection>{tbl}</collection>
+                {options}
             </mongodb>
         """.format(
             host=self.docker_hostname,
@@ -177,6 +201,7 @@ class SourceMongo(ExternalSource):
             user=self.user,
             password=self.password,
             tbl=table_name,
+            options="<options>ssl=true</options>" if self.secure else "",
         )
 
     def prepare(self, structure, table_name, cluster):
@@ -186,6 +211,8 @@ class SourceMongo(ExternalSource):
             user=self.user,
             password=self.password,
         )
+        if self.secure:
+            connection_str += "/?tls=true&tlsAllowInvalidCertificates=true"
         self.connection = pymongo.MongoClient(connection_str)
         self.converters = {}
         for field in structure.get_all_fields():
@@ -228,7 +255,7 @@ class SourceMongoURI(SourceMongo):
     def get_source_str(self, table_name):
         return """
             <mongodb>
-                <uri>mongodb://{user}:{password}@{host}:{port}/test</uri>
+                <uri>mongodb://{user}:{password}@{host}:{port}/test{options}</uri>
                 <collection>{tbl}</collection>
             </mongodb>
         """.format(
@@ -237,6 +264,7 @@ class SourceMongoURI(SourceMongo):
             user=self.user,
             password=self.password,
             tbl=table_name,
+            options="?ssl=true" if self.secure else "",
         )
 
 
diff --git a/tests/integration/test_dictionaries_all_layouts_separate_sources/configs/ssl_verification.xml b/tests/integration/test_dictionaries_all_layouts_separate_sources/configs/ssl_verification.xml
new file mode 100644
index 00000000000..3efe98e7045
--- /dev/null
+++ b/tests/integration/test_dictionaries_all_layouts_separate_sources/configs/ssl_verification.xml
@@ -0,0 +1,8 @@
+<clickhouse>
+    <openSSL>
+        <client>
+            <!-- For self-signed certificate -->
+            <verificationMode>none</verificationMode>
+        </client>
+    </openSSL>
+</clickhouse>
diff --git a/tests/integration/test_dictionaries_all_layouts_separate_sources/test_mongo.py b/tests/integration/test_dictionaries_all_layouts_separate_sources/test_mongo.py
index 55639877ba0..973dbfc0429 100644
--- a/tests/integration/test_dictionaries_all_layouts_separate_sources/test_mongo.py
+++ b/tests/integration/test_dictionaries_all_layouts_separate_sources/test_mongo.py
@@ -17,14 +17,71 @@ ranged_tester = None
 test_name = "mongo"
 
 
-def setup_module(module):
-    global cluster
-    global node
-    global simple_tester
-    global complex_tester
-    global ranged_tester
+@pytest.fixture(scope="module")
+def secure_connection(request):
+    return request.param
 
-    cluster = ClickHouseCluster(__file__)
+
+@pytest.fixture(scope="module")
+def cluster(secure_connection):
+    return ClickHouseCluster(__file__)
+
+
+@pytest.fixture(scope="module")
+def source(secure_connection, cluster):
+    return SourceMongo(
+        "MongoDB",
+        "localhost",
+        cluster.mongo_port,
+        cluster.mongo_host,
+        "27017",
+        "root",
+        "clickhouse",
+        secure=secure_connection,
+    )
+
+
+@pytest.fixture(scope="module")
+def simple_tester(source):
+    tester = SimpleLayoutTester(test_name)
+    tester.cleanup()
+    tester.create_dictionaries(source)
+    return tester
+
+
+@pytest.fixture(scope="module")
+def complex_tester(source):
+    tester = ComplexLayoutTester(test_name)
+    tester.create_dictionaries(source)
+    return tester
+
+
+@pytest.fixture(scope="module")
+def ranged_tester(source):
+    tester = RangedLayoutTester(test_name)
+    tester.create_dictionaries(source)
+    return tester
+
+
+@pytest.fixture(scope="module")
+def main_config(secure_connection):
+    main_config = []
+    if secure_connection:
+        main_config.append(os.path.join("configs", "disable_ssl_verification.xml"))
+    else:
+        main_config.append(os.path.join("configs", "ssl_verification.xml"))
+    return main_config
+
+
+@pytest.fixture(scope="module")
+def started_cluster(
+    secure_connection,
+    cluster,
+    main_config,
+    simple_tester,
+    ranged_tester,
+    complex_tester,
+):
     SOURCE = SourceMongo(
         "MongoDB",
         "localhost",
@@ -33,35 +90,18 @@ def setup_module(module):
         "27017",
         "root",
         "clickhouse",
+        secure=secure_connection,
     )
-
-    simple_tester = SimpleLayoutTester(test_name)
-    simple_tester.cleanup()
-    simple_tester.create_dictionaries(SOURCE)
-
-    complex_tester = ComplexLayoutTester(test_name)
-    complex_tester.create_dictionaries(SOURCE)
-
-    ranged_tester = RangedLayoutTester(test_name)
-    ranged_tester.create_dictionaries(SOURCE)
-    # Since that all .xml configs were created
-
-    main_configs = []
-    main_configs.append(os.path.join("configs", "disable_ssl_verification.xml"))
-
     dictionaries = simple_tester.list_dictionaries()
 
     node = cluster.add_instance(
-        "node", main_configs=main_configs, dictionaries=dictionaries, with_mongo=True
+        "node",
+        main_configs=main_config,
+        dictionaries=dictionaries,
+        with_mongo=True,
+        with_mongo_secure=secure_connection,
     )
 
-
-def teardown_module(module):
-    simple_tester.cleanup()
-
-
-@pytest.fixture(scope="module")
-def started_cluster():
     try:
         cluster.start()
 
@@ -75,16 +115,25 @@ def started_cluster():
         cluster.shutdown()
 
 
+@pytest.mark.parametrize("secure_connection", [False], indirect=["secure_connection"])
 @pytest.mark.parametrize("layout_name", sorted(LAYOUTS_SIMPLE))
-def test_simple(started_cluster, layout_name):
-    simple_tester.execute(layout_name, node)
+def test_simple(secure_connection, started_cluster, layout_name, simple_tester):
+    simple_tester.execute(layout_name, started_cluster.instances["node"])
 
 
+@pytest.mark.parametrize("secure_connection", [False], indirect=["secure_connection"])
 @pytest.mark.parametrize("layout_name", sorted(LAYOUTS_COMPLEX))
-def test_complex(started_cluster, layout_name):
-    complex_tester.execute(layout_name, node)
+def test_complex(secure_connection, started_cluster, layout_name, complex_tester):
+    complex_tester.execute(layout_name, started_cluster.instances["node"])
 
 
+@pytest.mark.parametrize("secure_connection", [False], indirect=["secure_connection"])
 @pytest.mark.parametrize("layout_name", sorted(LAYOUTS_RANGED))
-def test_ranged(started_cluster, layout_name):
-    ranged_tester.execute(layout_name, node)
+def test_ranged(secure_connection, started_cluster, layout_name, ranged_tester):
+    ranged_tester.execute(layout_name, started_cluster.instances["node"])
+
+
+@pytest.mark.parametrize("secure_connection", [True], indirect=["secure_connection"])
+@pytest.mark.parametrize("layout_name", sorted(LAYOUTS_SIMPLE))
+def test_simple_ssl(secure_connection, started_cluster, layout_name, simple_tester):
+    simple_tester.execute(layout_name, started_cluster.instances["node"])
diff --git a/tests/integration/test_dictionaries_all_layouts_separate_sources/test_mongo_uri.py b/tests/integration/test_dictionaries_all_layouts_separate_sources/test_mongo_uri.py
index 84c547b7a6b..22541432259 100644
--- a/tests/integration/test_dictionaries_all_layouts_separate_sources/test_mongo_uri.py
+++ b/tests/integration/test_dictionaries_all_layouts_separate_sources/test_mongo_uri.py
@@ -8,25 +8,22 @@ from helpers.cluster import ClickHouseCluster
 from helpers.dictionary import Field, Row, Dictionary, DictionaryStructure, Layout
 from helpers.external_sources import SourceMongoURI
 
-SOURCE = None
-cluster = None
-node = None
-simple_tester = None
-complex_tester = None
-ranged_tester = None
 test_name = "mongo_uri"
 
 
-def setup_module(module):
-    global cluster
-    global node
-    global simple_tester
-    global complex_tester
-    global ranged_tester
+@pytest.fixture(scope="module")
+def secure_connection(request):
+    return request.param
 
-    cluster = ClickHouseCluster(__file__)
 
-    SOURCE = SourceMongoURI(
+@pytest.fixture(scope="module")
+def cluster(secure_connection):
+    return ClickHouseCluster(__file__)
+
+
+@pytest.fixture(scope="module")
+def source(secure_connection, cluster):
+    return SourceMongoURI(
         "MongoDB",
         "localhost",
         cluster.mongo_port,
@@ -34,52 +31,55 @@ def setup_module(module):
         "27017",
         "root",
         "clickhouse",
+        secure=secure_connection,
     )
 
-    simple_tester = SimpleLayoutTester(test_name)
-    simple_tester.cleanup()
-    simple_tester.create_dictionaries(SOURCE)
 
-    complex_tester = ComplexLayoutTester(test_name)
-    complex_tester.create_dictionaries(SOURCE)
+@pytest.fixture(scope="module")
+def simple_tester(source):
+    tester = SimpleLayoutTester(test_name)
+    tester.cleanup()
+    tester.create_dictionaries(source)
+    return tester
 
-    ranged_tester = RangedLayoutTester(test_name)
-    ranged_tester.create_dictionaries(SOURCE)
-    # Since that all .xml configs were created
 
-    main_configs = []
-    main_configs.append(os.path.join("configs", "disable_ssl_verification.xml"))
+@pytest.fixture(scope="module")
+def main_config(secure_connection):
+    main_config = []
+    if secure_connection:
+        main_config.append(os.path.join("configs", "disable_ssl_verification.xml"))
+    else:
+        main_config.append(os.path.join("configs", "ssl_verification.xml"))
+    return main_config
 
+
+@pytest.fixture(scope="module")
+def started_cluster(secure_connection, cluster, main_config, simple_tester):
     dictionaries = simple_tester.list_dictionaries()
 
     node = cluster.add_instance(
         "uri_node",
-        main_configs=main_configs,
+        main_configs=main_config,
         dictionaries=dictionaries,
         with_mongo=True,
+        with_mongo_secure=secure_connection,
     )
-
-
-def teardown_module(module):
-    simple_tester.cleanup()
-
-
-@pytest.fixture(scope="module")
-def started_cluster():
     try:
         cluster.start()
-
         simple_tester.prepare(cluster)
-        complex_tester.prepare(cluster)
-        ranged_tester.prepare(cluster)
-
         yield cluster
-
     finally:
         cluster.shutdown()
 
 
 # See comment in SourceMongoURI
+@pytest.mark.parametrize("secure_connection", [False], indirect=["secure_connection"])
 @pytest.mark.parametrize("layout_name", ["flat"])
-def test_simple(started_cluster, layout_name):
-    simple_tester.execute(layout_name, node)
+def test_simple(secure_connection, started_cluster, simple_tester, layout_name):
+    simple_tester.execute(layout_name, started_cluster.instances["uri_node"])
+
+
+@pytest.mark.parametrize("secure_connection", [True], indirect=["secure_connection"])
+@pytest.mark.parametrize("layout_name", ["flat"])
+def test_simple_ssl(secure_connection, started_cluster, simple_tester, layout_name):
+    simple_tester.execute(layout_name, started_cluster.instances["uri_node"])
diff --git a/tests/integration/test_encrypted_disk_replication/test.py b/tests/integration/test_encrypted_disk_replication/test.py
index f68c534ed43..04b53bed58f 100644
--- a/tests/integration/test_encrypted_disk_replication/test.py
+++ b/tests/integration/test_encrypted_disk_replication/test.py
@@ -52,9 +52,7 @@ def create_table(
 ):
     engine = "ReplicatedMergeTree('/clickhouse/tables/encrypted_test/', '{replica}')"
 
-    settings = f"storage_policy='{storage_policy}'"
-    if zero_copy_replication:
-        settings += ", allow_remote_fs_zero_copy_replication=true"
+    settings = f"storage_policy='{storage_policy}', allow_remote_fs_zero_copy_replication={int(zero_copy_replication)}"
 
     node1.query(
         f"""
diff --git a/tests/integration/test_hedged_requests/test.py b/tests/integration/test_hedged_requests/test.py
index 88371f6908d..2ca37fbb7ee 100644
--- a/tests/integration/test_hedged_requests/test.py
+++ b/tests/integration/test_hedged_requests/test.py
@@ -128,12 +128,12 @@ def check_changing_replica_events(expected_count):
     assert int(result) >= expected_count
 
 
-def check_if_query_sending_was_suspended(minimum_count):
+def check_if_query_sending_was_suspended():
     result = NODES["node"].query(
         "SELECT value FROM system.events WHERE event='SuspendSendingQueryToShard'"
     )
 
-    assert int(result) >= minimum_count
+    assert int(result) >= 1
 
 
 def check_if_query_sending_was_not_suspended():
@@ -381,7 +381,7 @@ def test_async_connect(started_cluster):
         "SELECT hostName(), id FROM distributed_connect ORDER BY id LIMIT 1 SETTINGS prefer_localhost_replica = 0, connect_timeout_with_failover_ms=5000, async_query_sending_for_remote=1, max_threads=1"
     )
     check_changing_replica_events(2)
-    check_if_query_sending_was_suspended(2)
+    check_if_query_sending_was_suspended()
 
     NODES["node"].query("DROP TABLE distributed_connect")
 
@@ -406,7 +406,7 @@ def test_async_query_sending(started_cluster):
     NODES["node"].query("DROP TABLE IF EXISTS tmp")
     NODES["node"].query(
         "CREATE TEMPORARY TABLE tmp (number UInt64, s String) "
-        "as select number, randomString(number % 1000) from numbers(1000000)"
+        "as select number, randomString(number % 1000) from numbers(10000000)"
     )
 
     NODES["node"].query(
@@ -419,6 +419,6 @@ def test_async_query_sending(started_cluster):
         "SELECT hostName(), id FROM distributed_query_sending ORDER BY id LIMIT 1 SETTINGS"
         " prefer_localhost_replica = 0, async_query_sending_for_remote=1, max_threads = 1"
     )
-    check_if_query_sending_was_suspended(3)
+    check_if_query_sending_was_suspended()
 
     NODES["node"].query("DROP TABLE distributed_query_sending")
diff --git a/tests/integration/test_mask_sensitive_info/test.py b/tests/integration/test_mask_sensitive_info/test.py
index 92232f7e6a8..69144c0eb07 100644
--- a/tests/integration/test_mask_sensitive_info/test.py
+++ b/tests/integration/test_mask_sensitive_info/test.py
@@ -95,14 +95,14 @@ def test_create_alter_user():
 
     check_logs(
         must_contain=[
-            "CREATE USER u1 IDENTIFIED WITH sha256_password",
-            "ALTER USER u1 IDENTIFIED WITH sha256_password",
+            "CREATE USER u1 IDENTIFIED",
+            "ALTER USER u1 IDENTIFIED",
             "CREATE USER u2 IDENTIFIED WITH plaintext_password",
         ],
         must_not_contain=[
             password,
-            "IDENTIFIED WITH sha256_password BY",
-            "IDENTIFIED WITH sha256_hash BY",
+            "IDENTIFIED BY",
+            "IDENTIFIED BY",
             "IDENTIFIED WITH plaintext_password BY",
         ],
     )
diff --git a/tests/integration/test_merge_tree_s3_failover/configs/config.d/storage_conf.xml b/tests/integration/test_merge_tree_s3_failover/configs/config.d/storage_conf.xml
index 976933b2d21..74af657c783 100644
--- a/tests/integration/test_merge_tree_s3_failover/configs/config.d/storage_conf.xml
+++ b/tests/integration/test_merge_tree_s3_failover/configs/config.d/storage_conf.xml
@@ -11,6 +11,7 @@
                 <skip_access_check>true</skip_access_check>
                 <!-- Avoid extra retries to speed up tests -->
                 <retry_attempts>0</retry_attempts>
+                <connect_timeout_ms>20000</connect_timeout_ms>
             </s3>
             <s3_retryable>
                 <type>s3</type>
@@ -20,6 +21,7 @@
                 <secret_access_key>minio123</secret_access_key>
                 <!-- ClickHouse starts earlier than custom S3 endpoint. Skip access check to avoid fail on start-up -->
                 <skip_access_check>true</skip_access_check>
+                <connect_timeout_ms>20000</connect_timeout_ms>
             </s3_retryable>
             <s3_no_retries>
                 <type>s3</type>
@@ -32,6 +34,7 @@
                 <!-- Avoid extra retries to speed up tests -->
                 <s3_retry_attempts>1</s3_retry_attempts>
                 <s3_max_single_read_retries>1</s3_max_single_read_retries>
+                <connect_timeout_ms>20000</connect_timeout_ms>
             </s3_no_retries>
             <default/>
         </disks>
diff --git a/tests/integration/test_password_constraints/configs/default_password_type.xml b/tests/integration/test_password_constraints/configs/default_password_type.xml
new file mode 100644
index 00000000000..4b23ea31df0
--- /dev/null
+++ b/tests/integration/test_password_constraints/configs/default_password_type.xml
@@ -0,0 +1,3 @@
+<clickhouse>
+    <default_password_type>double_sha1_password</default_password_type>
+</clickhouse>
diff --git a/tests/integration/test_password_constraints/test.py b/tests/integration/test_password_constraints/test.py
index 9cdff51caa1..94e10ed5f9e 100644
--- a/tests/integration/test_password_constraints/test.py
+++ b/tests/integration/test_password_constraints/test.py
@@ -5,6 +5,9 @@ from helpers.cluster import ClickHouseCluster
 cluster = ClickHouseCluster(__file__)
 
 node = cluster.add_instance("node", main_configs=["configs/complexity_rules.xml"])
+node2 = cluster.add_instance(
+    "node2", main_configs=["configs/default_password_type.xml"]
+)
 
 
 @pytest.fixture(scope="module")
@@ -39,3 +42,10 @@ def test_complexity_rules(start_cluster):
 
     node.query("CREATE USER u_5 IDENTIFIED WITH plaintext_password BY 'aA!000000000'")
     node.query("DROP USER u_5")
+
+
+def test_default_password_type(start_cluster):
+    node2.query("CREATE USER u1 IDENTIFIED BY 'pwd'")
+
+    required_type = "double_sha1_password"
+    assert required_type in node2.query("SHOW CREATE USER u1")
diff --git a/tests/integration/test_postgresql_database_engine/test.py b/tests/integration/test_postgresql_database_engine/test.py
index de6c9ad2cf9..63e85afb1d4 100644
--- a/tests/integration/test_postgresql_database_engine/test.py
+++ b/tests/integration/test_postgresql_database_engine/test.py
@@ -327,6 +327,17 @@ def test_predefined_connection_configuration(started_cluster):
         node1.query(f"SELECT count() FROM postgres_database.test_table").rstrip()
         == "100"
     )
+    node1.query(
+        """
+        DROP DATABASE postgres_database;
+        CREATE DATABASE postgres_database ENGINE = PostgreSQL(postgres1, use_tables_cache=1);
+        """
+    )
+    assert (
+        node1.query(f"SELECT count() FROM postgres_database.test_table").rstrip()
+        == "100"
+    )
+    assert node1.contains_in_log("Cached table `test_table`")
 
     node1.query("DROP DATABASE postgres_database")
     cursor.execute(f"DROP TABLE test_table ")
diff --git a/tests/integration/test_s3_cluster/test.py b/tests/integration/test_s3_cluster/test.py
index 241b90cac3f..237a81da0f5 100644
--- a/tests/integration/test_s3_cluster/test.py
+++ b/tests/integration/test_s3_cluster/test.py
@@ -247,9 +247,10 @@ def test_skip_unavailable_shards(started_cluster):
     assert result == "10\n"
 
 
-def test_unskip_unavailable_shards(started_cluster):
+def test_unset_skip_unavailable_shards(started_cluster):
+    # Although skip_unavailable_shards is not set, cluster table functions should always skip unavailable shards.
     node = started_cluster.instances["s0_0_0"]
-    error = node.query_and_get_error(
+    result = node.query(
         """
     SELECT count(*) from s3Cluster(
         'cluster_non_existent_port',
@@ -258,7 +259,7 @@ def test_unskip_unavailable_shards(started_cluster):
     """
     )
 
-    assert "NETWORK_ERROR" in error
+    assert result == "10\n"
 
 
 def test_distributed_insert_select_with_replicated(started_cluster):
diff --git a/tests/integration/test_storage_hdfs/test.py b/tests/integration/test_storage_hdfs/test.py
index d4752d6cf2e..edf5344e887 100644
--- a/tests/integration/test_storage_hdfs/test.py
+++ b/tests/integration/test_storage_hdfs/test.py
@@ -788,6 +788,7 @@ def test_schema_inference_cache(started_cluster):
 
 
 def test_hdfsCluster_skip_unavailable_shards(started_cluster):
+    # Although skip_unavailable_shards is not set, cluster table functions should always skip unavailable shards.
     hdfs_api = started_cluster.hdfs_api
     node = started_cluster.instances["node1"]
     data = "1\tSerialize\t555.222\n2\tData\t777.333\n"
@@ -801,16 +802,18 @@ def test_hdfsCluster_skip_unavailable_shards(started_cluster):
     )
 
 
-def test_hdfsCluster_unskip_unavailable_shards(started_cluster):
+def test_hdfsCluster_unset_skip_unavailable_shards(started_cluster):
     hdfs_api = started_cluster.hdfs_api
     node = started_cluster.instances["node1"]
     data = "1\tSerialize\t555.222\n2\tData\t777.333\n"
     hdfs_api.write_data("/unskip_unavailable_shards", data)
-    error = node.query_and_get_error(
-        "select * from hdfsCluster('cluster_non_existent_port', 'hdfs://hdfs1:9000/unskip_unavailable_shards', 'TSV', 'id UInt64, text String, number Float64')"
-    )
 
-    assert "NETWORK_ERROR" in error
+    assert (
+        node1.query(
+            "select * from hdfsCluster('cluster_non_existent_port', 'hdfs://hdfs1:9000/skip_unavailable_shards', 'TSV', 'id UInt64, text String, number Float64')"
+        )
+        == data
+    )
 
 
 if __name__ == "__main__":
diff --git a/tests/queries/0_stateless/00155_long_merges.sh b/tests/queries/0_stateless/00155_long_merges.sh
index 83d89c57cfa..9ed0f2c6de1 100755
--- a/tests/queries/0_stateless/00155_long_merges.sh
+++ b/tests/queries/0_stateless/00155_long_merges.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Tags: long
+# Tags: long, no-debug
 
 CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 # shellcheck source=../shell_config.sh
diff --git a/tests/queries/0_stateless/00992_system_parts_race_condition_zookeeper_long.sh b/tests/queries/0_stateless/00992_system_parts_race_condition_zookeeper_long.sh
index d49f63e143d..5b1c50262bf 100755
--- a/tests/queries/0_stateless/00992_system_parts_race_condition_zookeeper_long.sh
+++ b/tests/queries/0_stateless/00992_system_parts_race_condition_zookeeper_long.sh
@@ -13,8 +13,8 @@ $CLICKHOUSE_CLIENT -n -q "
     DROP TABLE IF EXISTS alter_table0;
     DROP TABLE IF EXISTS alter_table1;
 
-    CREATE TABLE alter_table0 (a UInt8, b Int16, c Float32, d String, e Array(UInt8), f Nullable(UUID), g Tuple(UInt8, UInt16)) ENGINE = ReplicatedMergeTree('/clickhouse/tables/$CLICKHOUSE_TEST_ZOOKEEPER_PREFIX/alter_table', 'r1') ORDER BY a PARTITION BY b % 10 SETTINGS old_parts_lifetime = 1, cleanup_delay_period = 1, cleanup_delay_period_random_add = 0, replicated_max_mutations_in_one_entry = $(($RANDOM / 50));
-    CREATE TABLE alter_table1 (a UInt8, b Int16, c Float32, d String, e Array(UInt8), f Nullable(UUID), g Tuple(UInt8, UInt16)) ENGINE = ReplicatedMergeTree('/clickhouse/tables/$CLICKHOUSE_TEST_ZOOKEEPER_PREFIX/alter_table', 'r2') ORDER BY a PARTITION BY b % 10 SETTINGS old_parts_lifetime = 1, cleanup_delay_period = 1, cleanup_delay_period_random_add = 0, replicated_max_mutations_in_one_entry = $(($RANDOM / 50));
+    CREATE TABLE alter_table0 (a UInt8, b Int16, c Float32, d String, e Array(UInt8), f Nullable(UUID), g Tuple(UInt8, UInt16)) ENGINE = ReplicatedMergeTree('/clickhouse/tables/$CLICKHOUSE_TEST_ZOOKEEPER_PREFIX/alter_table', 'r1') ORDER BY a PARTITION BY b % 10 SETTINGS old_parts_lifetime = 1, cleanup_delay_period = 1, cleanup_delay_period_random_add = 0, replicated_max_mutations_in_one_entry = $(($RANDOM / 50 + 100));
+    CREATE TABLE alter_table1 (a UInt8, b Int16, c Float32, d String, e Array(UInt8), f Nullable(UUID), g Tuple(UInt8, UInt16)) ENGINE = ReplicatedMergeTree('/clickhouse/tables/$CLICKHOUSE_TEST_ZOOKEEPER_PREFIX/alter_table', 'r2') ORDER BY a PARTITION BY b % 10 SETTINGS old_parts_lifetime = 1, cleanup_delay_period = 1, cleanup_delay_period_random_add = 0, replicated_max_mutations_in_one_entry = $(($RANDOM / 50 + 200));
 "
 
 function thread1()
diff --git a/tests/queries/0_stateless/01142_join_lc_and_nullable_in_key.reference b/tests/queries/0_stateless/01142_join_lc_and_nullable_in_key.reference
index 01efbb7c64b..6d32c20909b 100644
--- a/tests/queries/0_stateless/01142_join_lc_and_nullable_in_key.reference
+++ b/tests/queries/0_stateless/01142_join_lc_and_nullable_in_key.reference
@@ -3,15 +3,27 @@
 1	l	\N	Nullable(String)
 2		\N	Nullable(String)
 -
+1	l	Nullable(String)	\N	Nullable(String)
+0	\N	Nullable(String)	\N	Nullable(String)
+0	\N	Nullable(String)	\N	Nullable(String)
+1	l	Nullable(String)	\N	Nullable(String)
+-
+1	l	LowCardinality(String)	\N	Nullable(String)
+0		LowCardinality(String)	\N	Nullable(String)
+0		LowCardinality(String)	\N	Nullable(String)
+1	l	LowCardinality(String)	\N	Nullable(String)
+-
+1	l	\N	Nullable(String)
+0	\N	\N	Nullable(String)
+0	\N	\N	Nullable(String)
+1	l	\N	Nullable(String)
+-
 1	l	\N	Nullable(String)
 0		\N	Nullable(String)
 0		\N	Nullable(String)
 1	l	\N	Nullable(String)
 -
-1	l	\N	Nullable(String)
-0		\N	Nullable(String)
-0		\N	Nullable(String)
-1	l	\N	Nullable(String)
+0	\N
 -
 0	
 -
diff --git a/tests/queries/0_stateless/01142_join_lc_and_nullable_in_key.sql b/tests/queries/0_stateless/01142_join_lc_and_nullable_in_key.sql
index 38b72837174..2464b7a57cf 100644
--- a/tests/queries/0_stateless/01142_join_lc_and_nullable_in_key.sql
+++ b/tests/queries/0_stateless/01142_join_lc_and_nullable_in_key.sql
@@ -15,19 +15,37 @@ SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l FULL JOIN nr AS r USING (x) ORD
 
 SELECT '-';
 
-SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x;
-SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x;
-SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x;
+-- lc should be supertype for l.lc and r.lc, so expect Nullable(String)
+SELECT x, lc, toTypeName(lc), r.lc, toTypeName(r.lc) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
+SELECT x, lc, toTypeName(lc), r.lc, toTypeName(r.lc) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
+SELECT x, lc, toTypeName(lc), r.lc, toTypeName(r.lc) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
 
 SELECT '-';
 
-SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x;
-SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x;
-SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x;
+-- old behavior is different
+SELECT x, lc, toTypeName(lc), r.lc, toTypeName(r.lc) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
+SELECT x, lc, toTypeName(lc), r.lc, toTypeName(r.lc) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
+SELECT x, lc, toTypeName(lc), r.lc, toTypeName(r.lc) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
 
 SELECT '-';
 
-SELECT x, lc FROM t AS l RIGHT JOIN nr AS r USING (lc);
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
+
+SELECT '-';
+
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
+
+SELECT '-';
+
+SELECT x, lc FROM t AS l RIGHT JOIN nr AS r USING (lc) SETTINGS allow_experimental_analyzer = 1;
+
+SELECT '-';
+
+SELECT x, lc FROM t AS l RIGHT JOIN nr AS r USING (lc) SETTINGS allow_experimental_analyzer = 0;
 
 SELECT '-';
 
diff --git a/tests/queries/0_stateless/01142_merge_join_lc_and_nullable_in_key.reference b/tests/queries/0_stateless/01142_merge_join_lc_and_nullable_in_key.reference
index c6bdcb773b2..bb29ec9becd 100644
--- a/tests/queries/0_stateless/01142_merge_join_lc_and_nullable_in_key.reference
+++ b/tests/queries/0_stateless/01142_merge_join_lc_and_nullable_in_key.reference
@@ -4,6 +4,16 @@
 2		\N	Nullable(String)
 -
 1	l	\N	Nullable(String)
+0	\N	\N	Nullable(String)
+0	\N	\N	Nullable(String)
+1	l	\N	Nullable(String)
+-
+1	l	\N	Nullable(String)
+0	\N	\N	Nullable(String)
+0	\N	\N	Nullable(String)
+1	l	\N	Nullable(String)
+-
+1	l	\N	Nullable(String)
 0		\N	Nullable(String)
 0		\N	Nullable(String)
 1	l	\N	Nullable(String)
diff --git a/tests/queries/0_stateless/01142_merge_join_lc_and_nullable_in_key.sql b/tests/queries/0_stateless/01142_merge_join_lc_and_nullable_in_key.sql
index dbc2d7c9f5d..718e8358c64 100644
--- a/tests/queries/0_stateless/01142_merge_join_lc_and_nullable_in_key.sql
+++ b/tests/queries/0_stateless/01142_merge_join_lc_and_nullable_in_key.sql
@@ -17,15 +17,27 @@ SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l FULL JOIN nr AS r USING (x) ORD
 
 SELECT '-';
 
-SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x;
-SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x;
-SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x;
+SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
+SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
+SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
 
 SELECT '-';
 
-SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x;
-SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x;
-SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x;
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 1;
+
+SELECT '-';
+
+SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
+SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
+SELECT x, lc, r.lc, toTypeName(r.lc) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
+
+SELECT '-';
+
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l LEFT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l RIGHT JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
+SELECT x, lc, materialize(r.lc) y, toTypeName(y) FROM t AS l FULL JOIN nr AS r USING (lc) ORDER BY x SETTINGS allow_experimental_analyzer = 0;
 
 SELECT '-';
 
diff --git a/tests/queries/0_stateless/01346_alter_enum_partition_key_replicated_zookeeper_long.reference b/tests/queries/0_stateless/01346_alter_enum_partition_key_replicated_zookeeper_long.reference
index 60c6076aef0..a905ea97ae5 100644
--- a/tests/queries/0_stateless/01346_alter_enum_partition_key_replicated_zookeeper_long.reference
+++ b/tests/queries/0_stateless/01346_alter_enum_partition_key_replicated_zookeeper_long.reference
@@ -1,24 +1,24 @@
 hello	test
 hello	test
-1_0_0_0	hello	1
-1_0_0_0	hello	1
+0	0	hello	1
+0	0	hello	1
 hello	test
 goodbye	test
 hello	test
 goodbye	test
-3_0_0_1	goodbye	3
-1_0_0_1	hello	1
-3_0_0_1	goodbye	3
-1_0_0_1	hello	1
+0	0	goodbye	3
+0	0	hello	1
+0	0	goodbye	3
+0	0	hello	1
 1	test
 3	test
 111	abc
 1	test
 3	test
 111	abc
-1_0_0_2	1	1
-111_0_0_1	111	111
-3_0_0_2	3	3
-1_0_0_2	1	1
-111_0_0_1	111	111
-3_0_0_2	3	3
+0	0	1	1
+0	0	111	111
+0	0	3	3
+0	0	1	1
+0	0	111	111
+0	0	3	3
diff --git a/tests/queries/0_stateless/01346_alter_enum_partition_key_replicated_zookeeper_long.sql b/tests/queries/0_stateless/01346_alter_enum_partition_key_replicated_zookeeper_long.sql
index f20156fd9e3..d40bcc15e55 100644
--- a/tests/queries/0_stateless/01346_alter_enum_partition_key_replicated_zookeeper_long.sql
+++ b/tests/queries/0_stateless/01346_alter_enum_partition_key_replicated_zookeeper_long.sql
@@ -13,16 +13,17 @@ INSERT INTO test VALUES ('hello', 'test');
 SELECT * FROM test;
 SYSTEM SYNC REPLICA test2;
 SELECT * FROM test2;
-SELECT name, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test' AND active ORDER BY partition;
-SELECT name, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test2' AND active ORDER BY partition;
+SELECT min_block_number, max_block_number, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test' AND active ORDER BY partition;
+SELECT min_block_number, max_block_number, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test2' AND active ORDER BY partition;
 
 ALTER TABLE test MODIFY COLUMN x Enum('hello' = 1, 'world' = 2, 'goodbye' = 3);
 INSERT INTO test VALUES ('goodbye', 'test');
 OPTIMIZE TABLE test FINAL;
 SELECT * FROM test ORDER BY x;
+SYSTEM SYNC REPLICA test2;
 SELECT * FROM test2 ORDER BY x;
-SELECT name, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test' AND active ORDER BY partition;
-SELECT name, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test2' AND active ORDER BY partition;
+SELECT min_block_number, max_block_number, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test' AND active ORDER BY partition;
+SELECT min_block_number, max_block_number, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test2' AND active ORDER BY partition;
 
 ALTER TABLE test MODIFY COLUMN x Enum('hello' = 1, 'world' = 2); -- { serverError 524 }
 ALTER TABLE test MODIFY COLUMN x Enum('hello' = 1, 'world' = 2, 'test' = 3);
@@ -33,9 +34,10 @@ ALTER TABLE test MODIFY COLUMN x Int8;
 INSERT INTO test VALUES (111, 'abc');
 OPTIMIZE TABLE test FINAL;
 SELECT * FROM test ORDER BY x;
+SYSTEM SYNC REPLICA test2;
 SELECT * FROM test2 ORDER BY x;
-SELECT name, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test' AND active ORDER BY partition;
-SELECT name, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test2' AND active ORDER BY partition;
+SELECT min_block_number, max_block_number, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test' AND active ORDER BY partition;
+SELECT min_block_number, max_block_number, partition, partition_id FROM system.parts WHERE database = currentDatabase() AND table = 'test2' AND active ORDER BY partition;
 
 ALTER TABLE test MODIFY COLUMN x Enum8('' = 1); -- { serverError 524 }
 ALTER TABLE test MODIFY COLUMN x Enum16('' = 1); -- { serverError 524 }
diff --git a/tests/queries/0_stateless/01442_merge_detach_attach_long.sh b/tests/queries/0_stateless/01442_merge_detach_attach_long.sh
index b3f9fbb42dd..c080dded1c8 100755
--- a/tests/queries/0_stateless/01442_merge_detach_attach_long.sh
+++ b/tests/queries/0_stateless/01442_merge_detach_attach_long.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Tags: long, no-parallel
+# Tags: long, no-parallel, no-debug
 
 set -e
 
diff --git a/tests/queries/0_stateless/01476_right_full_join_switch.reference b/tests/queries/0_stateless/01476_right_full_join_switch.reference
index 1f839b86013..54f9909762f 100644
--- a/tests/queries/0_stateless/01476_right_full_join_switch.reference
+++ b/tests/queries/0_stateless/01476_right_full_join_switch.reference
@@ -3,6 +3,16 @@
 1	l	\N	LowCardinality(String)	Nullable(String)
 2		\N	LowCardinality(String)	Nullable(String)
 -
+\N	\N		Nullable(String)	LowCardinality(String)
+1	\N	l	Nullable(String)	LowCardinality(String)
+1	\N	l	Nullable(String)	LowCardinality(String)
+\N	\N		Nullable(String)	LowCardinality(String)
+-
+1	l	\N	LowCardinality(String)	Nullable(String)
+2		\N	LowCardinality(String)	Nullable(String)
+1	l	\N	LowCardinality(String)	Nullable(String)
+2		\N	LowCardinality(String)	Nullable(String)
+-
 0	\N		Nullable(String)	LowCardinality(String)
 1	\N	l	Nullable(String)	LowCardinality(String)
 0	\N		Nullable(String)	LowCardinality(String)
diff --git a/tests/queries/0_stateless/01476_right_full_join_switch.sql b/tests/queries/0_stateless/01476_right_full_join_switch.sql
index 5d041843ee2..dfbdec47e1f 100644
--- a/tests/queries/0_stateless/01476_right_full_join_switch.sql
+++ b/tests/queries/0_stateless/01476_right_full_join_switch.sql
@@ -10,8 +10,27 @@ CREATE TABLE nr (`x` Nullable(UInt32), `s` Nullable(String)) ENGINE = Memory;
 INSERT INTO t VALUES (1, 'l');
 INSERT INTO nr VALUES (2, NULL);
 
+
 SET join_use_nulls = 0;
 
+SET allow_experimental_analyzer = 1;
+
+-- t.x is supertupe for `x` from left and right since `x` is inside `USING`.
+SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM t AS l LEFT JOIN nr AS r USING (x) ORDER BY t.x;
+SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM t AS l RIGHT JOIN nr AS r USING (x) ORDER BY t.x;
+SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM t AS l FULL JOIN nr AS r USING (x) ORDER BY t.x;
+
+SELECT '-';
+
+SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM nr AS l LEFT JOIN t AS r USING (x) ORDER BY t.x;
+SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM nr AS l RIGHT JOIN t AS r USING (x) ORDER BY t.x;
+SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM nr AS l FULL JOIN t AS r USING (x) ORDER BY t.x;
+
+SELECT '-';
+
+SET allow_experimental_analyzer = 0;
+
+-- t.x is supertupe for `x` from left and right since `x` is inside `USING`.
 SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM t AS l LEFT JOIN nr AS r USING (x) ORDER BY t.x;
 SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM t AS l RIGHT JOIN nr AS r USING (x) ORDER BY t.x;
 SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM t AS l FULL JOIN nr AS r USING (x) ORDER BY t.x;
diff --git a/tests/queries/0_stateless/01477_lc_in_merge_join_left_key.reference b/tests/queries/0_stateless/01477_lc_in_merge_join_left_key.reference
index ac4d0a3d21a..9b6890c01ee 100644
--- a/tests/queries/0_stateless/01477_lc_in_merge_join_left_key.reference
+++ b/tests/queries/0_stateless/01477_lc_in_merge_join_left_key.reference
@@ -17,7 +17,7 @@
 1	\N	l	Nullable(String)	LowCardinality(String)
 0	\N		Nullable(String)	LowCardinality(String)
 1	\N	l	Nullable(String)	LowCardinality(String)
--
+- join_use_nulls -
 1	l	\N	LowCardinality(String)	Nullable(String)
 2	\N	\N	LowCardinality(Nullable(String))	Nullable(String)
 1	l	\N	LowCardinality(Nullable(String))	Nullable(String)
@@ -33,3 +33,47 @@
 1	l	\N	LowCardinality(Nullable(String))	Nullable(String)
 \N	\N	\N	LowCardinality(Nullable(String))	Nullable(String)
 -
+\N	\N	\N	Nullable(String)	LowCardinality(Nullable(String))
+1	\N	l	Nullable(String)	LowCardinality(String)
+1	\N	l	Nullable(String)	LowCardinality(Nullable(String))
+\N	\N	\N	Nullable(String)	LowCardinality(Nullable(String))
+- analyzer -
+1	l	\N	LowCardinality(String)	Nullable(String)
+2		\N	LowCardinality(String)	Nullable(String)
+1	l	\N	LowCardinality(String)	Nullable(String)
+2		\N	LowCardinality(String)	Nullable(String)
+-
+\N	\N		Nullable(String)	LowCardinality(String)
+1	\N	l	Nullable(String)	LowCardinality(String)
+1	\N	l	Nullable(String)	LowCardinality(String)
+\N	\N		Nullable(String)	LowCardinality(String)
+-
+1	l	\N	Nullable(String)	Nullable(String)
+0	\N	\N	Nullable(String)	Nullable(String)
+0	\N	\N	Nullable(String)	Nullable(String)
+1	l	\N	Nullable(String)	Nullable(String)
+-
+0	\N	\N	Nullable(String)	Nullable(String)
+1	\N	l	Nullable(String)	Nullable(String)
+0	\N	\N	Nullable(String)	Nullable(String)
+1	\N	l	Nullable(String)	Nullable(String)
+- join_use_nulls -
+1	l	\N	LowCardinality(String)	Nullable(String)
+2	\N	\N	LowCardinality(Nullable(String))	Nullable(String)
+1	l	\N	LowCardinality(Nullable(String))	Nullable(String)
+2	\N	\N	LowCardinality(Nullable(String))	Nullable(String)
+-
+\N	\N	\N	Nullable(String)	LowCardinality(Nullable(String))
+1	\N	l	Nullable(String)	LowCardinality(String)
+1	\N	l	Nullable(String)	LowCardinality(Nullable(String))
+\N	\N	\N	Nullable(String)	LowCardinality(Nullable(String))
+-
+1	l	\N	Nullable(String)	Nullable(String)
+\N	\N	\N	Nullable(String)	Nullable(String)
+1	l	\N	Nullable(String)	Nullable(String)
+\N	\N	\N	Nullable(String)	Nullable(String)
+-
+\N	\N	\N	Nullable(String)	Nullable(String)
+1	\N	l	Nullable(String)	Nullable(String)
+1	\N	l	Nullable(String)	Nullable(String)
+\N	\N	\N	Nullable(String)	Nullable(String)
diff --git a/tests/queries/0_stateless/01477_lc_in_merge_join_left_key.sql b/tests/queries/0_stateless/01477_lc_in_merge_join_left_key.sql.j2
similarity index 83%
rename from tests/queries/0_stateless/01477_lc_in_merge_join_left_key.sql
rename to tests/queries/0_stateless/01477_lc_in_merge_join_left_key.sql.j2
index 2507613f051..6eafd41b411 100644
--- a/tests/queries/0_stateless/01477_lc_in_merge_join_left_key.sql
+++ b/tests/queries/0_stateless/01477_lc_in_merge_join_left_key.sql.j2
@@ -10,6 +10,14 @@ CREATE TABLE nr (`x` Nullable(UInt32), `s` Nullable(String)) ENGINE = Memory;
 INSERT INTO t VALUES (1, 'l');
 INSERT INTO nr VALUES (2, NULL);
 
+{% for allow_experimental_analyzer in [0, 1] -%}
+
+SET allow_experimental_analyzer = {{ allow_experimental_analyzer }};
+
+{% if allow_experimental_analyzer -%}
+SELECT '- analyzer -';
+{% endif -%}
+
 SET join_use_nulls = 0;
 
 SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM t AS l LEFT JOIN nr AS r USING (x) ORDER BY t.x;
@@ -36,7 +44,7 @@ SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM nr AS l FULL JOIN t
 
 SET join_use_nulls = 1;
 
-SELECT '-';
+SELECT '- join_use_nulls -';
 
 SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM t AS l LEFT JOIN nr AS r USING (x) ORDER BY t.x;
 SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM t AS l RIGHT JOIN nr AS r USING (x) ORDER BY t.x;
@@ -56,10 +64,11 @@ SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM t AS l FULL JOIN nr
 
 SELECT '-';
 
--- TODO
--- SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM nr AS l LEFT JOIN t AS r USING (s) ORDER BY t.x;
--- SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM nr AS l RIGHT JOIN t AS r USING (s) ORDER BY t.x;
--- SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM nr AS l FULL JOIN t AS r USING (s) ORDER BY t.x;
+SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM nr AS l LEFT JOIN t AS r USING (s) ORDER BY t.x;
+SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM nr AS l RIGHT JOIN t AS r USING (s) ORDER BY t.x;
+SELECT t.x, l.s, r.s, toTypeName(l.s), toTypeName(r.s) FROM nr AS l FULL JOIN t AS r USING (s) ORDER BY t.x;
+
+{% endfor %}
 
 DROP TABLE t;
 DROP TABLE nr;
diff --git a/tests/queries/0_stateless/01889_sql_json_functions.reference b/tests/queries/0_stateless/01889_sql_json_functions.reference
index 5ac1ff501e5..cb8e19ea2a0 100644
--- a/tests/queries/0_stateless/01889_sql_json_functions.reference
+++ b/tests/queries/0_stateless/01889_sql_json_functions.reference
@@ -37,6 +37,20 @@ select JSON_VALUE('{"hello":{"world":"!"}}', '$.hello') settings function_json_v
 {"world":"!"}
 SELECT JSON_VALUE('{"hello":["world","world2"]}', '$.hello') settings function_json_value_return_type_allow_complex=true;
 ["world","world2"]
+SELECT JSON_VALUE('{"1key":1}', '$.1key');
+1
+SELECT JSON_VALUE('{"hello":1}', '$[hello]');
+1
+SELECT JSON_VALUE('{"hello":1}', '$["hello"]');
+1
+SELECT JSON_VALUE('{"hello":1}', '$[\'hello\']');
+1
+SELECT JSON_VALUE('{"hello 1":1}', '$["hello 1"]');
+1
+SELECT JSON_VALUE('{"1key":1}', '$..1key'); -- { serverError 36 }
+SELECT JSON_VALUE('{"1key":1}', '$1key'); -- { serverError 36 }
+SELECT JSON_VALUE('{"1key":1}', '$key'); -- { serverError 36 }
+SELECT JSON_VALUE('{"1key":1}', '$.[key]'); -- { serverError 36 }
 SELECT '--JSON_QUERY--';
 --JSON_QUERY--
 SELECT JSON_QUERY('{"hello":1}', '$');
@@ -61,6 +75,20 @@ SELECT JSON_QUERY('', '$.hello');
 
 SELECT JSON_QUERY('{"array":[[0, 1, 2, 3, 4, 5], [0, -1, -2, -3, -4, -5]]}', '$.array[*][0 to 2, 4]');
 [0, 1, 4, 0, -1, -4]
+SELECT JSON_QUERY('{"1key":1}', '$.1key');
+[1]
+SELECT JSON_QUERY('{"hello":1}', '$[hello]');
+[1]
+SELECT JSON_QUERY('{"hello":1}', '$["hello"]');
+[1]
+SELECT JSON_QUERY('{"hello":1}', '$[\'hello\']');
+[1]
+SELECT JSON_QUERY('{"hello 1":1}', '$["hello 1"]');
+[1]
+SELECT JSON_QUERY('{"1key":1}', '$..1key'); -- { serverError 36 }
+SELECT JSON_QUERY('{"1key":1}', '$1key'); -- { serverError 36 }
+SELECT JSON_QUERY('{"1key":1}', '$key'); -- { serverError 36 }
+SELECT JSON_QUERY('{"1key":1}', '$.[key]'); -- { serverError 36 }
 SELECT '--JSON_EXISTS--';
 --JSON_EXISTS--
 SELECT JSON_EXISTS('{"hello":1}', '$');
diff --git a/tests/queries/0_stateless/01889_sql_json_functions.sql b/tests/queries/0_stateless/01889_sql_json_functions.sql
index f174d04933c..947b0171ec6 100644
--- a/tests/queries/0_stateless/01889_sql_json_functions.sql
+++ b/tests/queries/0_stateless/01889_sql_json_functions.sql
@@ -20,6 +20,15 @@ select JSON_VALUE('{"a":"\\u263a"}', '$.a');
 select JSON_VALUE('{"hello":"world"}', '$.b') settings function_json_value_return_type_allow_nullable=true;
 select JSON_VALUE('{"hello":{"world":"!"}}', '$.hello') settings function_json_value_return_type_allow_complex=true;
 SELECT JSON_VALUE('{"hello":["world","world2"]}', '$.hello') settings function_json_value_return_type_allow_complex=true;
+SELECT JSON_VALUE('{"1key":1}', '$.1key');
+SELECT JSON_VALUE('{"hello":1}', '$[hello]');
+SELECT JSON_VALUE('{"hello":1}', '$["hello"]');
+SELECT JSON_VALUE('{"hello":1}', '$[\'hello\']');
+SELECT JSON_VALUE('{"hello 1":1}', '$["hello 1"]');
+SELECT JSON_VALUE('{"1key":1}', '$..1key'); -- { serverError 36 }
+SELECT JSON_VALUE('{"1key":1}', '$1key'); -- { serverError 36 }
+SELECT JSON_VALUE('{"1key":1}', '$key'); -- { serverError 36 }
+SELECT JSON_VALUE('{"1key":1}', '$.[key]'); -- { serverError 36 }
 
 SELECT '--JSON_QUERY--';
 SELECT JSON_QUERY('{"hello":1}', '$');
@@ -33,6 +42,15 @@ SELECT JSON_QUERY('{"hello":{"world":"!"}}', '$.hello');
 SELECT JSON_QUERY( '{hello:{"world":"!"}}}', '$.hello'); -- invalid json => default value (empty string)
 SELECT JSON_QUERY('', '$.hello');
 SELECT JSON_QUERY('{"array":[[0, 1, 2, 3, 4, 5], [0, -1, -2, -3, -4, -5]]}', '$.array[*][0 to 2, 4]');
+SELECT JSON_QUERY('{"1key":1}', '$.1key');
+SELECT JSON_QUERY('{"hello":1}', '$[hello]');
+SELECT JSON_QUERY('{"hello":1}', '$["hello"]');
+SELECT JSON_QUERY('{"hello":1}', '$[\'hello\']');
+SELECT JSON_QUERY('{"hello 1":1}', '$["hello 1"]');
+SELECT JSON_QUERY('{"1key":1}', '$..1key'); -- { serverError 36 }
+SELECT JSON_QUERY('{"1key":1}', '$1key'); -- { serverError 36 }
+SELECT JSON_QUERY('{"1key":1}', '$key'); -- { serverError 36 }
+SELECT JSON_QUERY('{"1key":1}', '$.[key]'); -- { serverError 36 }
 
 SELECT '--JSON_EXISTS--';
 SELECT JSON_EXISTS('{"hello":1}', '$');
diff --git a/tests/queries/0_stateless/01891_partition_hash.reference b/tests/queries/0_stateless/01891_partition_hash.reference
index 56d11075e50..c5814777dfe 100644
--- a/tests/queries/0_stateless/01891_partition_hash.reference
+++ b/tests/queries/0_stateless/01891_partition_hash.reference
@@ -1 +1,2 @@
 6ba51fa36c625adab5d58007c96e32bf
+ebc1c2f37455caea601feeb840757dd3
diff --git a/tests/queries/0_stateless/01891_partition_hash.sql b/tests/queries/0_stateless/01891_partition_hash.sql
index f56ed6a4ff4..894594dd465 100644
--- a/tests/queries/0_stateless/01891_partition_hash.sql
+++ b/tests/queries/0_stateless/01891_partition_hash.sql
@@ -1,7 +1,32 @@
-drop table if exists tab;
-create table tab (i8 Int8, i16 Int16, i32 Int32, i64 Int64, i128 Int128, i256 Int256, u8 UInt8, u16 UInt16, u32 UInt32, u64 UInt64, u128 UInt128, u256 UInt256, id UUID, s String, fs FixedString(33), a Array(UInt8), t Tuple(UInt16, UInt32), d Date, dt DateTime('Asia/Istanbul'), dt64 DateTime64(3, 'Asia/Istanbul'), dec128 Decimal128(3), dec256 Decimal256(4), lc LowCardinality(String)) engine = MergeTree PARTITION BY (i8, i16, i32, i64, i128, i256, u8, u16, u32, u64, u128, u256, id, s, fs, a, t, d, dt, dt64, dec128, dec256, lc) order by tuple();
-insert into tab values (-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, '61f0c404-5cb3-11e7-907b-a6006ad3dba0', 'a', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', [1, 2, 3], (-1, -2), '2020-01-01', '2020-01-01 01:01:01', '2020-01-01 01:01:01', '123.456', '78.9101', 'a');
+DROP TABLE IF EXISTS tab;
+CREATE TABLE tab (
+    i8 Int8,
+    i16 Int16,
+    i32 Int32,
+    i64 Int64,
+    i128 Int128,
+    i256 Int256,
+    u8 UInt8,
+    u16 UInt16,
+    u32 UInt32,
+    u64 UInt64,
+    u128 UInt128,
+    u256 UInt256,
+    id UUID,
+    s String,
+    fs FixedString(33),
+    a Array(UInt8),
+    t Tuple(UInt16, UInt32),
+    d Date,
+    dt DateTime('Asia/Istanbul'),
+    dt64 DateTime64(3, 'Asia/Istanbul'),
+    dec128 Decimal128(3),
+    dec256 Decimal256(4),
+    lc LowCardinality(String))
+engine = MergeTree PARTITION BY (i8, i16, i32, i64, i128, i256, u8, u16, u32, u64, u128, u256, id, s, fs, a, t, d, dt, dt64, dec128, dec256, lc) ORDER BY tuple();
+INSERT INTO tab VALUES (-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, '61f0c404-5cb3-11e7-907b-a6006ad3dba0', 'a', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', [1, 2, 3], (-1, -2), '2020-01-01', '2020-01-01 01:01:01', '2020-01-01 01:01:01', '123.456', '78.9101', 'a');
+INSERT INTO tab VALUES (123, 12345, 1234567890, 1234567890000000000, 123456789000000000000000000000000000000, 123456789000000000000000000000000000000000000000000000000000000000000000000000, 123, 12345, 1234567890, 1234567890000000000, 123456789000000000000000000000000000000, 123456789000000000000000000000000000000000000000000000000000000000000000000000, '61f0c404-5cb3-11e7-907b-a6006ad3dba0', 'a', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', [1, 2, 3], (-1, -2), '2020-01-01', '2020-01-01 01:01:01', '2020-01-01 01:01:01', '123.456', '78.9101', 'a');
 -- Here we check that partition id did not change.
 -- Different result means Backward Incompatible Change. Old partitions will not be accepted by new server.
-select partition_id from system.parts where table = 'tab' and database = currentDatabase();
-drop table if exists tab;
+SELECT partition_id FROM system.parts WHERE table = 'tab' AND database = currentDatabase();
+DROP TABLE IF EXISTS tab;
diff --git a/tests/queries/0_stateless/02117_show_create_table_system.reference b/tests/queries/0_stateless/02117_show_create_table_system.reference
index f2524cac115..56330ea8bb9 100644
--- a/tests/queries/0_stateless/02117_show_create_table_system.reference
+++ b/tests/queries/0_stateless/02117_show_create_table_system.reference
@@ -281,7 +281,12 @@ CREATE TABLE system.functions
     `alias_to` String,
     `create_query` String,
     `origin` Enum8('System' = 0, 'SQLUserDefined' = 1, 'ExecutableUserDefined' = 2),
-    `description` String
+    `description` String,
+    `syntax` String,
+    `arguments` String,
+    `returned_value` String,
+    `examples` String,
+    `categories` String
 )
 ENGINE = SystemFunctions
 COMMENT 'SYSTEM TABLE is built on the fly.'
@@ -850,6 +855,7 @@ CREATE TABLE system.replicas
     `is_session_expired` UInt8,
     `future_parts` UInt32,
     `parts_to_check` UInt32,
+    `zookeeper_name` String,
     `zookeeper_path` String,
     `replica_name` String,
     `replica_path` String,
diff --git a/tests/queries/0_stateless/02125_transform_decimal_bug.reference b/tests/queries/0_stateless/02125_transform_decimal_bug.reference
index 7f59d0ee7bf..d1bf333ec8e 100644
--- a/tests/queries/0_stateless/02125_transform_decimal_bug.reference
+++ b/tests/queries/0_stateless/02125_transform_decimal_bug.reference
@@ -1,3 +1,4 @@
+1
 0
 1
 2
diff --git a/tests/queries/0_stateless/02125_transform_decimal_bug.sql b/tests/queries/0_stateless/02125_transform_decimal_bug.sql
index 4ef471ea875..002f60076e9 100644
--- a/tests/queries/0_stateless/02125_transform_decimal_bug.sql
+++ b/tests/queries/0_stateless/02125_transform_decimal_bug.sql
@@ -1,4 +1,4 @@
-SELECT transform(1, [1], [toDecimal32(1, 2)]); -- { serverError 44 }
+SELECT transform(1, [1], [toDecimal32(1, 2)]);
 SELECT transform(toDecimal32(number, 2), [toDecimal32(3, 2)], [toDecimal32(30, 2)]) FROM system.numbers LIMIT 10;
 SELECT transform(toDecimal32(number, 2), [toDecimal32(3, 2)], [toDecimal32(30, 2)], toDecimal32(1000, 2)) FROM system.numbers LIMIT 10;
 SELECT transform(number, [3, 5, 11], [toDecimal32(30, 2), toDecimal32(50, 2), toDecimal32(70,2)], toDecimal32(1000, 2)) FROM system.numbers LIMIT 10;
diff --git a/tests/queries/0_stateless/02163_operators.sql b/tests/queries/0_stateless/02163_operators.sql
index b2414bb197e..3f2d7d8bbb7 100644
--- a/tests/queries/0_stateless/02163_operators.sql
+++ b/tests/queries/0_stateless/02163_operators.sql
@@ -1,2 +1,2 @@
-WITH 2 AS `b.c`, [4, 5] AS a, 6 AS u, 3 AS v, 2 AS d, TRUE AS e, 1 AS f, 0 AS g, 2 AS h, 'Hello' AS i, 'World' AS j, TIMESTAMP '2022-02-02 02:02:02' AS w, [] AS k, (1, 2) AS l, 2 AS m, 3 AS n, [] AS o, [1] AS p, 1 AS q, q AS r, 1 AS s, 1 AS t
+WITH 2 AS `b.c`, [4, 5] AS a, 6 AS u, 3 AS v, 2 AS d, TRUE AS e, 1 AS f, 0 AS g, 2 AS h, 'Hello' AS i, 'World' AS j, 'hi' AS w, NULL AS k, (1, 2) AS l, 2 AS m, 3 AS n, [] AS o, [1] AS p, 1 AS q, q AS r, 1 AS s, 1 AS t
 SELECT INTERVAL CASE CASE WHEN NOT -a[`b.c`] * u DIV v + d IS NOT NULL AND e OR f BETWEEN g AND h THEN i ELSE j END WHEN w THEN k END || [l, (m, n)] MINUTE IS NULL OR NOT o::Array(INT) = p <> q < r > s != t AS upyachka;
diff --git a/tests/queries/0_stateless/02169_map_functions.reference b/tests/queries/0_stateless/02169_map_functions.reference
index bec2eaec595..10746a70f06 100644
--- a/tests/queries/0_stateless/02169_map_functions.reference
+++ b/tests/queries/0_stateless/02169_map_functions.reference
@@ -40,6 +40,8 @@
 {'key1':1111,'key2':2222,'key5':500,'key6':600}
 {'key1':1112,'key2':2224,'key5':500,'key6':600}
 {'key1':1113,'key2':2226,'key5':500,'key6':600}
+{'key5':500,'key6':600}
+{'key5':500,'key6':600}
 1
 1
 1
diff --git a/tests/queries/0_stateless/02169_map_functions.sql b/tests/queries/0_stateless/02169_map_functions.sql
index 27ceb252022..febaf2bd9d0 100644
--- a/tests/queries/0_stateless/02169_map_functions.sql
+++ b/tests/queries/0_stateless/02169_map_functions.sql
@@ -11,6 +11,8 @@ SELECT mapApply((k, v) -> tuple(v + 9223372036854775806), col) FROM table_map; -
 
 SELECT mapConcat(col, map('key5', 500), map('key6', 600)) FROM table_map ORDER BY id;
 SELECT mapConcat(col, materialize(map('key5', 500)), map('key6', 600)) FROM table_map ORDER BY id;
+SELECT concat(map('key5', 500), map('key6', 600));
+SELECT map('key5', 500) || map('key6', 600);
 
 SELECT mapExists((k, v) -> k LIKE '%3', col) FROM table_map ORDER BY id;
 SELECT mapExists((k, v) -> k LIKE '%2' AND v < 1000, col) FROM table_map ORDER BY id;
diff --git a/tests/queries/0_stateless/02240_system_filesystem_cache_table.reference b/tests/queries/0_stateless/02240_system_filesystem_cache_table.reference
index d3be4855b36..cf2bf5fb521 100644
--- a/tests/queries/0_stateless/02240_system_filesystem_cache_table.reference
+++ b/tests/queries/0_stateless/02240_system_filesystem_cache_table.reference
@@ -1,10 +1,60 @@
 Using storage policy: s3_cache
-0	79	80
-0	745	746
-0	745	746
-0	745	746
+0
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect no cache
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect no cache
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect no cache
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect no cache
 Using storage policy: local_cache
-0	79	80
-0	745	746
-0	745	746
-0	745	746
+0
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect no cache
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect no cache
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect no cache
+Expect cache
+DOWNLOADED	0	79	80
+DOWNLOADED	0	745	746
+2
+Expect no cache
diff --git a/tests/queries/0_stateless/02240_system_filesystem_cache_table.sh b/tests/queries/0_stateless/02240_system_filesystem_cache_table.sh
index a487f3ca739..c7dc9fbd961 100755
--- a/tests/queries/0_stateless/02240_system_filesystem_cache_table.sh
+++ b/tests/queries/0_stateless/02240_system_filesystem_cache_table.sh
@@ -9,34 +9,69 @@ CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 
 for STORAGE_POLICY in 's3_cache' 'local_cache'; do
     echo "Using storage policy: $STORAGE_POLICY"
+    ${CLICKHOUSE_CLIENT} --query "SYSTEM STOP MERGES"
     ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP FILESYSTEM CACHE"
+    ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP MARK CACHE"
+    ${CLICKHOUSE_CLIENT} --query "SELECT count() FROM system.filesystem_cache"
 
     ${CLICKHOUSE_CLIENT} --query "DROP TABLE IF EXISTS test_02240_storage_policy"
-    ${CLICKHOUSE_CLIENT} --query "CREATE TABLE test_02240_storage_policy (key UInt32, value String) Engine=MergeTree() ORDER BY key SETTINGS storage_policy='${STORAGE_POLICY}', min_bytes_for_wide_part = 10485760, compress_marks=false, compress_primary_key=false"
+    ${CLICKHOUSE_CLIENT} --query "CREATE TABLE test_02240_storage_policy (key UInt32, value String) Engine=MergeTree() ORDER BY key SETTINGS storage_policy='${STORAGE_POLICY}', min_bytes_for_wide_part = 1000000, compress_marks=false, compress_primary_key=false"
     ${CLICKHOUSE_CLIENT} --query "SYSTEM STOP MERGES test_02240_storage_policy"
     ${CLICKHOUSE_CLIENT} --enable_filesystem_cache_on_write_operations=0 --query "INSERT INTO test_02240_storage_policy SELECT number, toString(number) FROM numbers(100)"
+
+    echo 'Expect cache'
+    ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP MARK CACHE"
     ${CLICKHOUSE_CLIENT} --query "SELECT * FROM test_02240_storage_policy FORMAT Null"
-    ${CLICKHOUSE_CLIENT} --query "SELECT file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache ORDER BY file_segment_range_end, size"
+    ${CLICKHOUSE_CLIENT} --query "SELECT state, file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache ORDER BY file_segment_range_begin, file_segment_range_end, size"
+    ${CLICKHOUSE_CLIENT} --query "SELECT uniqExact(key) FROM system.filesystem_cache";
+
+    echo 'Expect cache'
+    ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP MARK CACHE"
+    ${CLICKHOUSE_CLIENT} --query "SELECT * FROM test_02240_storage_policy FORMAT Null"
+    ${CLICKHOUSE_CLIENT} --query "SELECT state, file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache ORDER BY file_segment_range_begin, file_segment_range_end, size"
+    ${CLICKHOUSE_CLIENT} --query "SELECT uniqExact(key) FROM system.filesystem_cache";
 
     ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP FILESYSTEM CACHE"
+    echo 'Expect no cache'
     ${CLICKHOUSE_CLIENT} --query "SELECT file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache"
+
+    echo 'Expect cache'
+    ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP MARK CACHE"
     ${CLICKHOUSE_CLIENT} --query "SELECT * FROM test_02240_storage_policy FORMAT Null"
-    ${CLICKHOUSE_CLIENT} --query "SELECT file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache"
+    ${CLICKHOUSE_CLIENT} --query "SELECT state, file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache ORDER BY file_segment_range_begin, file_segment_range_end, size"
+    ${CLICKHOUSE_CLIENT} --query "SELECT uniqExact(key) FROM system.filesystem_cache";
+
     ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP FILESYSTEM CACHE"
+    echo 'Expect no cache'
     ${CLICKHOUSE_CLIENT} --query "SELECT file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache"
 
     ${CLICKHOUSE_CLIENT} --query "DROP TABLE IF EXISTS test_02240_storage_policy_3"
-    ${CLICKHOUSE_CLIENT} --query "CREATE TABLE test_02240_storage_policy_3 (key UInt32, value String) Engine=MergeTree() ORDER BY key SETTINGS storage_policy='${STORAGE_POLICY}_3', min_bytes_for_wide_part = 10485760, compress_marks=false, compress_primary_key=false"
+    ${CLICKHOUSE_CLIENT} --query "CREATE TABLE test_02240_storage_policy_3 (key UInt32, value String) Engine=MergeTree() ORDER BY key SETTINGS storage_policy='${STORAGE_POLICY}_3', min_bytes_for_wide_part = 1000000, compress_marks=false, compress_primary_key=false"
     ${CLICKHOUSE_CLIENT} --enable_filesystem_cache_on_write_operations=0 --query "INSERT INTO test_02240_storage_policy_3 SELECT number, toString(number) FROM numbers(100)"
+
+    echo 'Expect cache'
+    ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP MARK CACHE"
     ${CLICKHOUSE_CLIENT} --query "SELECT * FROM test_02240_storage_policy_3 FORMAT Null"
-    ${CLICKHOUSE_CLIENT} --query "SELECT file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache ORDER BY file_segment_range_end, size"
+    ${CLICKHOUSE_CLIENT} --query "SELECT state, file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache ORDER BY file_segment_range_begin, file_segment_range_end, size"
+    ${CLICKHOUSE_CLIENT} --query "SELECT uniqExact(key) FROM system.filesystem_cache";
+
+    echo 'Expect cache'
+    ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP MARK CACHE"
     ${CLICKHOUSE_CLIENT} --query "SELECT * FROM test_02240_storage_policy_3 FORMAT Null"
-    ${CLICKHOUSE_CLIENT} --query "SELECT file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache ORDER BY file_segment_range_end, size"
+    ${CLICKHOUSE_CLIENT} --query "SELECT state, file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache ORDER BY file_segment_range_begin, file_segment_range_end, size"
+    ${CLICKHOUSE_CLIENT} --query "SELECT uniqExact(key) FROM system.filesystem_cache";
+
+    echo 'Expect no cache'
+    ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP FILESYSTEM CACHE"
+    ${CLICKHOUSE_CLIENT} --query "SELECT file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache"
+
+    echo 'Expect cache'
+    ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP MARK CACHE"
+    ${CLICKHOUSE_CLIENT} --query "SELECT * FROM test_02240_storage_policy_3 FORMAT Null"
+    ${CLICKHOUSE_CLIENT} --query "SELECT state, file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache ORDER BY file_segment_range_begin, file_segment_range_end, size"
+    ${CLICKHOUSE_CLIENT} --query "SELECT uniqExact(key) FROM system.filesystem_cache";
 
     ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP FILESYSTEM CACHE"
-    ${CLICKHOUSE_CLIENT} --query "SELECT file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache"
-    ${CLICKHOUSE_CLIENT} --query "SELECT * FROM test_02240_storage_policy_3 FORMAT Null"
-    ${CLICKHOUSE_CLIENT} --query "SELECT file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache"
-    ${CLICKHOUSE_CLIENT} --query "SYSTEM DROP FILESYSTEM CACHE"
+    echo 'Expect no cache'
     ${CLICKHOUSE_CLIENT} --query "SELECT file_segment_range_begin, file_segment_range_end, size FROM system.filesystem_cache"
 done
diff --git a/tests/queries/0_stateless/02344_describe_cache.reference b/tests/queries/0_stateless/02344_describe_cache.reference
index c98e9d263ca..7561b32bae1 100644
--- a/tests/queries/0_stateless/02344_describe_cache.reference
+++ b/tests/queries/0_stateless/02344_describe_cache.reference
@@ -1,2 +1,2 @@
-2147483648	1048576	104857600	1	0	0	0	/var/lib/clickhouse/caches/s3_cache/	0
-2147483648	1048576	104857600	0	0	0	0	/var/lib/clickhouse/caches/s3_cache_2/	0
+134217728	1048576	104857600	1	0	0	0	/var/lib/clickhouse/caches/s3_cache/	0
+134217728	1048576	104857600	0	0	0	0	/var/lib/clickhouse/caches/s3_cache_2/	0
diff --git a/tests/queries/0_stateless/02456_async_inserts_logs.reference b/tests/queries/0_stateless/02456_async_inserts_logs.reference
index efd8a88eca4..ba1b19fb184 100644
--- a/tests/queries/0_stateless/02456_async_inserts_logs.reference
+++ b/tests/queries/0_stateless/02456_async_inserts_logs.reference
@@ -1,7 +1,10 @@
 5
-	Values	21	1	Ok	1
-t_async_inserts_logs	JSONEachRow	39	1	Ok	1
-t_async_inserts_logs	Values	8	1	Ok	1
-t_async_inserts_logs	JSONEachRow	6	0	ParsingError	1
-t_async_inserts_logs	Values	6	0	ParsingError	1
-t_async_inserts_logs	Values	8	0	FlushError	1
+	Values	21	2	1	Ok	1
+t_async_inserts_logs	JSONEachRow	39	2	1	Ok	1
+t_async_inserts_logs	Values	8	1	1	Ok	1
+t_async_inserts_logs	JSONEachRow	6	0	0	ParsingError	1
+t_async_inserts_logs	Values	6	0	0	ParsingError	1
+t_async_inserts_logs	Values	8	1	0	FlushError	1
+AsyncInsertBytes	1
+AsyncInsertQuery	1
+AsyncInsertRows	1
diff --git a/tests/queries/0_stateless/02456_async_inserts_logs.sh b/tests/queries/0_stateless/02456_async_inserts_logs.sh
index 006455e2d42..43cd73d7231 100755
--- a/tests/queries/0_stateless/02456_async_inserts_logs.sh
+++ b/tests/queries/0_stateless/02456_async_inserts_logs.sh
@@ -30,10 +30,15 @@ ${CLICKHOUSE_CLIENT} -q "SELECT count() FROM t_async_inserts_logs"
 
 ${CLICKHOUSE_CLIENT} -q "SYSTEM FLUSH LOGS"
 ${CLICKHOUSE_CLIENT} -q "
-    SELECT table, format, bytes, empty(exception), status,
+    SELECT table, format, bytes, rows, empty(exception), status,
     status = 'ParsingError' ? flush_time_microseconds = 0 : flush_time_microseconds > event_time_microseconds AS time_ok
     FROM system.asynchronous_insert_log
     WHERE database = '$CLICKHOUSE_DATABASE' OR query ILIKE 'INSERT INTO FUNCTION%$CLICKHOUSE_DATABASE%'
     ORDER BY table, status, format"
 
 ${CLICKHOUSE_CLIENT} -q "DROP TABLE t_async_inserts_logs"
+
+${CLICKHOUSE_CLIENT} -q "
+SELECT event, value > 0 FROM system.events
+WHERE event IN ('AsyncInsertQuery', 'AsyncInsertBytes', 'AsyncInsertRows')
+ORDER BY event"
diff --git a/tests/queries/0_stateless/02479_nullable_primary_key_non_first_column.reference b/tests/queries/0_stateless/02479_nullable_primary_key_non_first_column.reference
new file mode 100644
index 00000000000..ed6ac232d9c
--- /dev/null
+++ b/tests/queries/0_stateless/02479_nullable_primary_key_non_first_column.reference
@@ -0,0 +1,2 @@
+a	\N
+1	1	\N
diff --git a/tests/queries/0_stateless/02479_nullable_primary_key_non_first_column.sql b/tests/queries/0_stateless/02479_nullable_primary_key_non_first_column.sql
new file mode 100644
index 00000000000..2d56e315bd1
--- /dev/null
+++ b/tests/queries/0_stateless/02479_nullable_primary_key_non_first_column.sql
@@ -0,0 +1,11 @@
+drop table if exists test_table;
+create table test_table (A Nullable(String), B Nullable(String)) engine MergeTree order by (A,B) settings index_granularity = 1, allow_nullable_key=1;
+insert into test_table values ('a', 'b'), ('a', null), (null, 'b');
+select * from test_table where B is null;
+drop table test_table;
+
+DROP TABLE IF EXISTS dm_metric_small2;
+CREATE TABLE dm_metric_small2 (`x` Nullable(Int64), `y` Nullable(Int64), `z` Nullable(Int64)) ENGINE = MergeTree() ORDER BY (x, y, z) SETTINGS index_granularity = 1, allow_nullable_key = 1;
+INSERT INTO dm_metric_small2 VALUES (1,1,NULL) (1,1,1) (1,2,0) (1,2,1) (1,2,NULL) (1,2,NULL);
+SELECT * FROM dm_metric_small2 WHERE (x = 1) AND (y = 1) AND z IS NULL;
+DROP TABLE dm_metric_small2;
\ No newline at end of file
diff --git a/tests/queries/0_stateless/02479_nullable_primary_key_second_column.reference b/tests/queries/0_stateless/02479_nullable_primary_key_second_column.reference
deleted file mode 100644
index f0227e1a41e..00000000000
--- a/tests/queries/0_stateless/02479_nullable_primary_key_second_column.reference
+++ /dev/null
@@ -1 +0,0 @@
-a	\N
diff --git a/tests/queries/0_stateless/02479_nullable_primary_key_second_column.sql b/tests/queries/0_stateless/02479_nullable_primary_key_second_column.sql
deleted file mode 100644
index ad0c09222c2..00000000000
--- a/tests/queries/0_stateless/02479_nullable_primary_key_second_column.sql
+++ /dev/null
@@ -1,9 +0,0 @@
-drop table if exists test_table;
-
-create table test_table (A Nullable(String), B Nullable(String)) engine MergeTree order by (A,B) settings index_granularity = 1, allow_nullable_key=1;
-
-insert into test_table values ('a', 'b'), ('a', null), (null, 'b');
-
-select * from test_table where B is null;
-
-drop table test_table;
diff --git a/tests/queries/0_stateless/02497_if_transform_strings_to_enum.reference b/tests/queries/0_stateless/02497_if_transform_strings_to_enum.reference
index f5284f38b86..a1a653361ee 100644
--- a/tests/queries/0_stateless/02497_if_transform_strings_to_enum.reference
+++ b/tests/queries/0_stateless/02497_if_transform_strings_to_enum.reference
@@ -405,16 +405,6 @@ QUERY id: 0
     TABLE id: 7, table_name: system.numbers
   LIMIT
     CONSTANT id: 17, constant_value: UInt64_10, constant_value_type: UInt64
-\N
-\N
-\N
-\N
-\N
-\N
-\N
-\N
-\N
-\N
 SELECT transform(number, [NULL], _CAST([\'google\', \'censor.net\', \'yahoo\'], \'Array(Enum8(\\\'censor.net\\\' = 1, \\\'google\\\' = 2, \\\'other\\\' = 3, \\\'yahoo\\\' = 4))\'), _CAST(\'other\', \'Enum8(\\\'censor.net\\\' = 1, \\\'google\\\' = 2, \\\'other\\\' = 3, \\\'yahoo\\\' = 4)\'))
 FROM
 (
@@ -424,56 +414,38 @@ FROM
 )
 QUERY id: 0
   PROJECTION COLUMNS
-    transform(number, [NULL], [\'google\', \'censor.net\', \'yahoo\'], \'other\') Nullable(Nothing)
+    transform(number, [NULL], [\'google\', \'censor.net\', \'yahoo\'], \'other\') String
   PROJECTION
     LIST id: 1, nodes: 1
-      FUNCTION id: 2, function_name: transform, function_type: ordinary, result_type: Nullable(Nothing)
+      FUNCTION id: 2, function_name: toString, function_type: ordinary, result_type: String
         ARGUMENTS
-          LIST id: 3, nodes: 4
-            COLUMN id: 4, column_name: number, result_type: Nullable(Nothing), source_id: 5
-            CONSTANT id: 6, constant_value: Array_[NULL], constant_value_type: Array(Nullable(Nothing))
-            CONSTANT id: 7, constant_value: Array_[\'google\', \'censor.net\', \'yahoo\'], constant_value_type: Array(String)
-            CONSTANT id: 8, constant_value: \'other\', constant_value_type: String
+          LIST id: 3, nodes: 1
+            FUNCTION id: 4, function_name: transform, function_type: ordinary, result_type: Enum8(\'censor.net\' = 1, \'google\' = 2, \'other\' = 3, \'yahoo\' = 4)
+              ARGUMENTS
+                LIST id: 5, nodes: 4
+                  COLUMN id: 6, column_name: number, result_type: Nullable(Nothing), source_id: 7
+                  CONSTANT id: 8, constant_value: Array_[NULL], constant_value_type: Array(Nullable(Nothing))
+                  FUNCTION id: 9, function_name: _CAST, function_type: ordinary, result_type: Array(Enum8(\'censor.net\' = 1, \'google\' = 2, \'other\' = 3, \'yahoo\' = 4))
+                    ARGUMENTS
+                      LIST id: 10, nodes: 2
+                        CONSTANT id: 11, constant_value: Array_[\'google\', \'censor.net\', \'yahoo\'], constant_value_type: Array(String)
+                        CONSTANT id: 12, constant_value: \'Array(Enum8(\\\'censor.net\\\' = 1, \\\'google\\\' = 2, \\\'other\\\' = 3, \\\'yahoo\\\' = 4))\', constant_value_type: String
+                  FUNCTION id: 13, function_name: _CAST, function_type: ordinary, result_type: Enum8(\'censor.net\' = 1, \'google\' = 2, \'other\' = 3, \'yahoo\' = 4)
+                    ARGUMENTS
+                      LIST id: 14, nodes: 2
+                        CONSTANT id: 15, constant_value: \'other\', constant_value_type: String
+                        CONSTANT id: 16, constant_value: \'Enum8(\\\'censor.net\\\' = 1, \\\'google\\\' = 2, \\\'other\\\' = 3, \\\'yahoo\\\' = 4)\', constant_value_type: String
   JOIN TREE
-    QUERY id: 5, is_subquery: 1
+    QUERY id: 7, is_subquery: 1
       PROJECTION COLUMNS
         number Nullable(Nothing)
       PROJECTION
-        LIST id: 9, nodes: 1
-          CONSTANT id: 10, constant_value: NULL, constant_value_type: Nullable(Nothing)
+        LIST id: 17, nodes: 1
+          CONSTANT id: 18, constant_value: NULL, constant_value_type: Nullable(Nothing)
       JOIN TREE
-        TABLE id: 11, table_name: system.numbers
+        TABLE id: 19, table_name: system.numbers
       LIMIT
-        CONSTANT id: 12, constant_value: UInt64_10, constant_value_type: UInt64
-\N
-\N
-\N
-\N
-\N
-\N
-\N
-\N
-\N
-\N
-SELECT transform(number, NULL, _CAST([\'google\', \'censor.net\', \'yahoo\'], \'Array(Enum8(\\\'censor.net\\\' = 1, \\\'google\\\' = 2, \\\'other\\\' = 3, \\\'yahoo\\\' = 4))\'), _CAST(\'other\', \'Enum8(\\\'censor.net\\\' = 1, \\\'google\\\' = 2, \\\'other\\\' = 3, \\\'yahoo\\\' = 4)\'))
-FROM system.numbers
-LIMIT 10
-QUERY id: 0
-  PROJECTION COLUMNS
-    transform(number, NULL, [\'google\', \'censor.net\', \'yahoo\'], \'other\') Nullable(Nothing)
-  PROJECTION
-    LIST id: 1, nodes: 1
-      FUNCTION id: 2, function_name: transform, function_type: ordinary, result_type: Nullable(Nothing)
-        ARGUMENTS
-          LIST id: 3, nodes: 4
-            COLUMN id: 4, column_name: number, result_type: UInt64, source_id: 5
-            CONSTANT id: 6, constant_value: NULL, constant_value_type: Nullable(Nothing)
-            CONSTANT id: 7, constant_value: Array_[\'google\', \'censor.net\', \'yahoo\'], constant_value_type: Array(String)
-            CONSTANT id: 8, constant_value: \'other\', constant_value_type: String
-  JOIN TREE
-    TABLE id: 5, table_name: system.numbers
-  LIMIT
-    CONSTANT id: 9, constant_value: UInt64_10, constant_value_type: UInt64
+        CONSTANT id: 20, constant_value: UInt64_10, constant_value_type: UInt64
 other
 other
 google
diff --git a/tests/queries/0_stateless/02497_if_transform_strings_to_enum.sql b/tests/queries/0_stateless/02497_if_transform_strings_to_enum.sql
index c23046c7b20..492d42cb6bc 100644
--- a/tests/queries/0_stateless/02497_if_transform_strings_to_enum.sql
+++ b/tests/queries/0_stateless/02497_if_transform_strings_to_enum.sql
@@ -33,13 +33,13 @@ SELECT transform(number, [2, 4, 6], ['google', 'censor.net', 'yahoo'], 'other')
 EXPLAIN SYNTAX SELECT transform(number, [2, 4, 6], ['google', 'censor.net', 'yahoo'], 'other') as value, value FROM system.numbers LIMIT 10;
 EXPLAIN QUERY TREE run_passes = 1 SELECT transform(number, [2, 4, 6], ['google', 'censor.net', 'yahoo'], 'other') as value, value FROM system.numbers LIMIT 10;
 
-SELECT transform(number, [NULL], ['google', 'censor.net', 'yahoo'], 'other') FROM (SELECT NULL as number FROM system.numbers LIMIT 10);
+SELECT transform(number, [NULL], ['google', 'censor.net', 'yahoo'], 'other') FROM (SELECT NULL as number FROM system.numbers LIMIT 10); -- { serverError 36 }
 EXPLAIN SYNTAX SELECT transform(number, [NULL], ['google', 'censor.net', 'yahoo'], 'other') FROM (SELECT NULL as number FROM system.numbers LIMIT 10);
 EXPLAIN QUERY TREE run_passes = 1 SELECT transform(number, [NULL], ['google', 'censor.net', 'yahoo'], 'other') FROM (SELECT NULL as number FROM system.numbers LIMIT 10);
 
-SELECT transform(number, NULL, ['google', 'censor.net', 'yahoo'], 'other') FROM system.numbers LIMIT 10;
-EXPLAIN SYNTAX SELECT transform(number, NULL, ['google', 'censor.net', 'yahoo'], 'other') FROM system.numbers LIMIT 10;
-EXPLAIN QUERY TREE run_passes = 1 SELECT transform(number, NULL, ['google', 'censor.net', 'yahoo'], 'other') FROM system.numbers LIMIT 10;
+SELECT transform(number, NULL, ['google', 'censor.net', 'yahoo'], 'other') FROM system.numbers LIMIT 10; -- { serverError 43 }
+EXPLAIN SYNTAX SELECT transform(number, NULL, ['google', 'censor.net', 'yahoo'], 'other') FROM system.numbers LIMIT 10; -- { serverError 43 }
+EXPLAIN QUERY TREE run_passes = 1 SELECT transform(number, NULL, ['google', 'censor.net', 'yahoo'], 'other') FROM system.numbers LIMIT 10; -- { serverError 43 }
 
 SET optimize_if_transform_strings_to_enum = 0;
 
diff --git a/tests/queries/0_stateless/02516_join_with_totals_and_subquery_bug.reference b/tests/queries/0_stateless/02516_join_with_totals_and_subquery_bug.reference
index fd0b223f8e5..19da8828c30 100644
--- a/tests/queries/0_stateless/02516_join_with_totals_and_subquery_bug.reference
+++ b/tests/queries/0_stateless/02516_join_with_totals_and_subquery_bug.reference
@@ -2,6 +2,10 @@
 1
 
 0
+1
+1
+
+1
 \N
 
 100000000000000000000
diff --git a/tests/queries/0_stateless/02516_join_with_totals_and_subquery_bug.sql b/tests/queries/0_stateless/02516_join_with_totals_and_subquery_bug.sql
index b6e60aa2e1f..6b58d737a3e 100644
--- a/tests/queries/0_stateless/02516_join_with_totals_and_subquery_bug.sql
+++ b/tests/queries/0_stateless/02516_join_with_totals_and_subquery_bug.sql
@@ -1,3 +1,5 @@
+SET allow_experimental_analyzer = 1;
+
 SELECT *
 FROM
 (
@@ -12,7 +14,26 @@ INNER JOIN
     SELECT 1
     GROUP BY 1
         WITH TOTALS
-) AS t2 USING (a);
+) AS t2 USING (a)
+SETTINGS allow_experimental_analyzer=0;
+
+SELECT *
+FROM
+(
+    SELECT 1 AS a
+) AS t1
+INNER JOIN
+(
+    SELECT 1 AS a
+    GROUP BY 1
+        WITH TOTALS
+    UNION ALL
+    SELECT 1
+    GROUP BY 1
+        WITH TOTALS
+) AS t2 USING (a)
+SETTINGS allow_experimental_analyzer=1;
+
 
 SELECT a
 FROM
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
index c7a02045316..5e50b9e6cbf 100644
--- 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
@@ -5,18 +5,33 @@
 3	Hello World	not_found	x	Hello World
 4	Hello World	[eo]	x	Hello World
 5	Hello World	.	x	Hello World
+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
+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
+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
@@ -24,18 +39,33 @@
 3	Hello World	not_found	x	Hello World
 4	Hello World	[eo]	x	Hello World
 5	Hello World	.	x	Hello World
+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
+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
+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
@@ -43,18 +73,33 @@
 3	Hello World	not_found	x	Hello World
 4	Hello World	[eo]	x	Hxllx Wxrld
 5	Hello World	.	x	xxxxxxxxxxx
+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
+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
+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
@@ -62,16 +107,31 @@
 3	Hello World	not_found	x	Hello World
 4	Hello World	[eo]	x	Hxllo World
 5	Hello World	.	x	xello World
+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
+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
+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
index 7406f0309bb..926bde3a74b 100644
--- 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
@@ -9,53 +9,63 @@ CREATE TABLE test_tab
 
 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 id, haystack, needle, 'x', replaceAll('Hello World', 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 id, haystack, 'l', replacement, replaceAll('Hello World', '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 id, haystack, needle, replacement, replaceAll('Hello World', 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 id, haystack, needle, 'x', replaceOne('Hello World', 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 id, haystack, 'l', replacement, replaceOne('Hello World', '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 id, haystack, needle, replacement, replaceOne('Hello World', 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 id, haystack, needle, 'x', replaceRegexpAll('Hello World', 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 id, haystack, 'l', replacement, replaceRegexpAll('Hello World', '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 id, haystack, needle, replacement, replaceRegexpAll('Hello World', 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 id, haystack, needle, 'x', replaceRegexpOne('Hello World', 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 id, haystack, 'l', replacement, replaceRegexpOne('Hello World', '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;
+SELECT id, haystack, needle, replacement, replaceRegexpOne('Hello World', needle, replacement) FROM test_tab ORDER BY id;
 
 DROP TABLE IF EXISTS test_tab;
 
diff --git a/tests/queries/0_stateless/02542_case_no_else.reference b/tests/queries/0_stateless/02542_case_no_else.reference
new file mode 100644
index 00000000000..8f3fdf29168
--- /dev/null
+++ b/tests/queries/0_stateless/02542_case_no_else.reference
@@ -0,0 +1,3 @@
+2
+1	Z
+1	Z
diff --git a/tests/queries/0_stateless/02542_case_no_else.sql b/tests/queries/0_stateless/02542_case_no_else.sql
new file mode 100644
index 00000000000..0c7975a750e
--- /dev/null
+++ b/tests/queries/0_stateless/02542_case_no_else.sql
@@ -0,0 +1,14 @@
+SELECT CASE 1 WHEN 1 THEN 2 END;
+
+SELECT id,
+    CASE id
+         WHEN 1 THEN 'Z'
+    END x
+FROM  (SELECT 1 as id);
+
+SELECT id,
+       CASE id
+            WHEN 1 THEN 'Z'
+            ELSE 'X'
+     END x
+FROM  (SELECT 1 as id);
diff --git a/tests/queries/0_stateless/02542_transform_new.reference b/tests/queries/0_stateless/02542_transform_new.reference
new file mode 100644
index 00000000000..b6eaa692c41
--- /dev/null
+++ b/tests/queries/0_stateless/02542_transform_new.reference
@@ -0,0 +1,32 @@
+1
+1
+1
+1
+9
+9
+\N
+7
+1
+9
+7
+b
+b
+b
+b
+a
+a
+\N
+c
+sep1
+80000
+80000
+sep2
+80000
+80000
+sep3
+1
+sep4
+8000
+sep5
+8000
+sep6
diff --git a/tests/queries/0_stateless/02542_transform_new.sql b/tests/queries/0_stateless/02542_transform_new.sql
new file mode 100644
index 00000000000..43da0a50731
--- /dev/null
+++ b/tests/queries/0_stateless/02542_transform_new.sql
@@ -0,0 +1,35 @@
+select transform(2, [1,2], [9,1], materialize(null));
+select transform(2, [1,2], [9,1], materialize(7));
+select transform(2, [1,2], [9,1], null);
+select transform(2, [1,2], [9,1], 7);
+select transform(1, [1,2], [9,1], null);
+select transform(1, [1,2], [9,1], 7);
+select transform(5, [1,2], [9,1], null);
+select transform(5, [1,2], [9,1], 7);
+select transform(2, [1,2], [9,1]);
+select transform(1, [1,2], [9,1]);
+select transform(7, [1,2], [9,1]);
+
+select transform(2, [1,2], ['a','b'], materialize(null));
+select transform(2, [1,2], ['a','b'], materialize('c'));
+select transform(2, [1,2], ['a','b'], null);
+select transform(2, [1,2], ['a','b'], 'c');
+select transform(1, [1,2], ['a','b'], null);
+select transform(1, [1,2], ['a','b'], 'c');
+select transform(5, [1,2], ['a','b'], null);
+select transform(5, [1,2], ['a','b'], 'c');
+
+select 'sep1';
+SELECT transform(number, [2], [toDecimal32(1, 1)], materialize(80000)) as x FROM numbers(2);
+select 'sep2';
+SELECT transform(number, [2], [toDecimal32(1, 1)], 80000) as x FROM numbers(2);
+select 'sep3';
+SELECT transform(toDecimal32(2, 1), [toDecimal32(2, 1)], [1]);
+select 'sep4';
+SELECT transform(8000, [1], [toDecimal32(2, 1)]);
+select 'sep5';
+SELECT transform(toDecimal32(8000,0), [1], [toDecimal32(2, 1)]);
+select 'sep6';
+SELECT transform(-9223372036854775807, [-1], [toDecimal32(1024, 3)]) FROM system.numbers LIMIT 7; -- { serverError BAD_ARGUMENTS }
+SELECT [NULL, NULL, NULL, NULL], transform(number, [2147483648], [toDecimal32(1, 2)]) AS x FROM numbers(257) WHERE materialize(10); -- { serverError BAD_ARGUMENTS }
+SELECT transform(-2147483649, [1], [toDecimal32(1, 2)]) GROUP BY [1] WITH TOTALS; -- { serverError BAD_ARGUMENTS }
diff --git a/tests/queries/0_stateless/02542_transform_old.reference b/tests/queries/0_stateless/02542_transform_old.reference
new file mode 100644
index 00000000000..d03b17d40a3
--- /dev/null
+++ b/tests/queries/0_stateless/02542_transform_old.reference
@@ -0,0 +1,72 @@
+google
+other
+yahoo
+yandex
+#1
+20
+21
+22
+29
+#2
+0
+1
+3
+5
+7
+8
+9
+20
+21
+29
+#3
+20
+21
+22
+29
+#4
+google
+other
+yahoo
+yandex
+#5
+0
+1
+3
+5
+7
+8
+9
+google
+yahoo
+yandex
+----
+google
+other
+yahoo
+yandex
+#1
+20
+21
+22
+29
+#3
+20
+21
+22
+29
+#4
+google
+other
+yahoo
+yandex
+----
+2000
+2100
+2200
+2900
+#1
+2000
+2100
+2200
+2900
+----
diff --git a/tests/queries/0_stateless/02542_transform_old.sql b/tests/queries/0_stateless/02542_transform_old.sql
new file mode 100644
index 00000000000..01a960ec367
--- /dev/null
+++ b/tests/queries/0_stateless/02542_transform_old.sql
@@ -0,0 +1,25 @@
+SELECT transform(number, [2, 4, 6], ['google', 'yandex', 'yahoo'], 'other') as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '#1';
+SELECT transform(number, [2, 4, 6], [29, 20, 21], 22) as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '#2';
+SELECT transform(number, [2, 4, 6], [29, 20, 21]) as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '#3';
+SELECT transform(toString(number), ['2', '4', '6'], [29, 20, 21], 22) as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '#4';
+SELECT transform(toString(number), ['2', '4', '6'], ['google', 'yandex', 'yahoo'], 'other') as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '#5';
+SELECT transform(toString(number), ['2', '4', '6'], ['google', 'yandex', 'yahoo']) as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '----';
+SELECT transform(number, [2, 4, 6], ['google', 'yandex', 'yahoo'], materialize('other')) as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '#1';
+SELECT transform(number, [2, 4, 6], [29, 20, 21], materialize(22)) as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '#3';
+SELECT transform(toString(number), ['2', '4', '6'], [29, 20, 21], materialize(22)) as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '#4';
+SELECT transform(toString(number), ['2', '4', '6'], ['google', 'yandex', 'yahoo'], materialize('other')) as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '----';
+SELECT transform(number, [2, 4, 6], [2900, 2000, 2100], 2200) as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '#1';
+SELECT transform(number, [2, 4, 6], [2900, 2000, 2100], materialize(2200)) as x FROM numbers(10) GROUP BY x ORDER BY x;
+SELECT '----';
+SELECT transform(number, [1], [null]) FROM system.numbers LIMIT 1; -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
diff --git a/tests/queries/0_stateless/02661_quantile_approx.reference b/tests/queries/0_stateless/02661_quantile_approx.reference
index f4e66adc8d9..8369363aa9b 100644
--- a/tests/queries/0_stateless/02661_quantile_approx.reference
+++ b/tests/queries/0_stateless/02661_quantile_approx.reference
@@ -19,8 +19,10 @@ select quantilesGK(1000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(numbe
 [99,199,249,313,776]
 select quantilesGK(10000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
 [100,200,250,314,777]
-select medianGK()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
-select quantileGK()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select medianGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 0; -- { serverError BAD_ARGUMENTS }
+select medianGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 1; -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+select quantileGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 0; -- { serverError BAD_ARGUMENTS }
+select quantileGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 1; -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
 select medianGK(100)(number) from numbers(10);
 4
 select quantileGK(100)(number) from numbers(10);
@@ -31,7 +33,8 @@ select quantileGK(100, 0.5, 0.75)(number) from numbers(10); -- { serverError NUM
 select quantileGK('abc', 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
 select quantileGK(1.23, 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
 select quantileGK(-100, 0.5)(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
-select quantilesGK()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantilesGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 0; -- { serverError BAD_ARGUMENTS }
+select quantilesGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 1; -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
 select quantilesGK(100)(number) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
 select quantilesGK(100, 0.5)(number) from numbers(10);
 [4]
diff --git a/tests/queries/0_stateless/02661_quantile_approx.sql b/tests/queries/0_stateless/02661_quantile_approx.sql
index 18c2e5de84b..52c2979ad44 100644
--- a/tests/queries/0_stateless/02661_quantile_approx.sql
+++ b/tests/queries/0_stateless/02661_quantile_approx.sql
@@ -1,3 +1,5 @@
+set allow_experimental_analyzer = 1;
+
 -- { echoOn }
 with arrayJoin([0, 1, 2, 10]) as x select quantilesGK(100, 0.5, 0.4, 0.1)(x);
 with arrayJoin([0, 6, 7, 9, 10]) as x select quantileGK(100, 0.5)(x);
@@ -14,8 +16,12 @@ select quantilesGK(1000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(numbe
 select quantilesGK(10000, 100/1000, 200/1000, 250/1000, 314/1000, 777/1000)(number + 1) from numbers(1000);
 
 
-select medianGK()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
-select quantileGK()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select medianGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 0; -- { serverError BAD_ARGUMENTS }
+select medianGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 1; -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+
+select quantileGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 0; -- { serverError BAD_ARGUMENTS }
+select quantileGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 1; -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+
 select medianGK(100)(number) from numbers(10);
 select quantileGK(100)(number) from numbers(10);
 select quantileGK(100, 0.5)(number) from numbers(10);
@@ -24,7 +30,9 @@ select quantileGK('abc', 0.5)(number) from numbers(10); -- { serverError ILLEGAL
 select quantileGK(1.23, 0.5)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
 select quantileGK(-100, 0.5)(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
 
-select quantilesGK()(number) from numbers(10); -- { serverError BAD_ARGUMENTS }
+select quantilesGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 0; -- { serverError BAD_ARGUMENTS }
+select quantilesGK()(number) from numbers(10) SETTINGS allow_experimental_analyzer = 1; -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+
 select quantilesGK(100)(number) from numbers(10); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
 select quantilesGK(100, 0.5)(number) from numbers(10);
 select quantilesGK('abc', 0.5, 0.75)(number) from numbers(10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
diff --git a/tests/queries/0_stateless/02677_analyzer_bitmap_has_any.sql b/tests/queries/0_stateless/02677_analyzer_bitmap_has_any.sql
index 4af06634c66..f0f9845d91d 100644
--- a/tests/queries/0_stateless/02677_analyzer_bitmap_has_any.sql
+++ b/tests/queries/0_stateless/02677_analyzer_bitmap_has_any.sql
@@ -18,7 +18,7 @@ FROM
         bitmapHasAny(bitmapBuild([toUInt64(1)]), (
             SELECT groupBitmapState(toUInt64(2))
         )) has2
-); -- { serverError 43 }
+) SETTINGS allow_experimental_analyzer = 0; -- { serverError 43 }
 
 SELECT '--------------';
 
diff --git a/tests/queries/0_stateless/02699_polygons_sym_difference_rollup.reference b/tests/queries/0_stateless/02699_polygons_sym_difference_rollup.reference
index 346025b277b..35c94347ac9 100644
--- a/tests/queries/0_stateless/02699_polygons_sym_difference_rollup.reference
+++ b/tests/queries/0_stateless/02699_polygons_sym_difference_rollup.reference
@@ -2,6 +2,8 @@
 []
 [[(2147483647,0),(10.0001,65535),(1,255),(1023,2147483646)]]	[[[(2147483647,0),(10.0001,65535),(1023,2147483646),(2147483647,0)]]]
 [[(2147483647,0),(10.0001,65535),(1,255),(1023,2147483646)]]	[]
+[[(2147483647,0),(10.0001,65535),(1,255),(1023,2147483646)]]	[[[(2147483647,0),(10.0001,65535),(1023,2147483646),(2147483647,0)]]]
+[[(2147483647,0),(10.0001,65535),(1,255),(1023,2147483646)]]	[[[(2147483647,0),(10.0001,65535),(1023,2147483646),(2147483647,0)]]]
 [[[(100.0001,1000.0001),(1000.0001,1.1920928955078125e-7),(20,-20),(20,20),(10,10),(-20,20),(100.0001,1000.0001)]]]
 [[[(100.0001,1000.0001),(1000.0001,1.1920928955078125e-7),(20,-20),(20,20),(10,10),(-20,20),(100.0001,1000.0001)]]]
 [(9223372036854775807,1.1754943508222875e-38)]	[[(1,1.0001)]]	\N	[]
diff --git a/tests/queries/0_stateless/02699_polygons_sym_difference_rollup.sql b/tests/queries/0_stateless/02699_polygons_sym_difference_rollup.sql
index 8b9b63f7996..85307bec6e5 100644
--- a/tests/queries/0_stateless/02699_polygons_sym_difference_rollup.sql
+++ b/tests/queries/0_stateless/02699_polygons_sym_difference_rollup.sql
@@ -1,5 +1,5 @@
-
 SELECT polygonsSymDifferenceCartesian([[[(1., 1.)]] AS x], [x]) GROUP BY x WITH ROLLUP;
-SELECT [[(2147483647, 0.), (10.0001, 65535), (1, 255), (1023, 2147483646)]], polygonsSymDifferenceCartesian([[[(2147483647, 0.), (10.0001, 65535), (1023, 2147483646)]]], [[[(1000.0001, 10.0001)]]]) GROUP BY [[(2147483647, 0.), (10.0001, 65535), (1023, 2147483646)]] WITH ROLLUP;
+SELECT [[(2147483647, 0.), (10.0001, 65535), (1, 255), (1023, 2147483646)]], polygonsSymDifferenceCartesian([[[(2147483647, 0.), (10.0001, 65535), (1023, 2147483646)]]], [[[(1000.0001, 10.0001)]]]) GROUP BY [[(2147483647, 0.), (10.0001, 65535), (1023, 2147483646)]] WITH ROLLUP SETTINGS allow_experimental_analyzer=0;
+SELECT [[(2147483647, 0.), (10.0001, 65535), (1, 255), (1023, 2147483646)]], polygonsSymDifferenceCartesian([[[(2147483647, 0.), (10.0001, 65535), (1023, 2147483646)]]], [[[(1000.0001, 10.0001)]]]) GROUP BY [[(2147483647, 0.), (10.0001, 65535), (1023, 2147483646)]] WITH ROLLUP SETTINGS allow_experimental_analyzer=1;
 SELECT polygonsSymDifferenceCartesian([[[(100.0001, 1000.0001), (-20., 20.), (10., 10.), (20., 20.), (20., -20.), (1000.0001, 1.1920928955078125e-7)]],[[(0.0001, 100000000000000000000.)]] AS x],[x]) GROUP BY x WITH ROLLUP;
 SELECT [(9223372036854775807, 1.1754943508222875e-38)], x, NULL, polygonsSymDifferenceCartesian([[[(1.1754943508222875e-38, 1.1920928955078125e-7), (0.5, 0.5)]], [[(1.1754943508222875e-38, 1.1920928955078125e-7), (1.1754943508222875e-38, 1.1920928955078125e-7)], [(0., 1.0001)]], [[(1., 1.0001)]] AS x], [[[(3.4028234663852886e38, 0.9999)]]]) GROUP BY GROUPING SETS ((x)) WITH TOTALS
diff --git a/tests/queries/0_stateless/02703_jit_external_aggregation.reference b/tests/queries/0_stateless/02703_jit_external_aggregation.reference
index cdeec60f4ef..9c558e357c4 100644
--- a/tests/queries/0_stateless/02703_jit_external_aggregation.reference
+++ b/tests/queries/0_stateless/02703_jit_external_aggregation.reference
@@ -1 +1 @@
-.....
+.
diff --git a/tests/queries/0_stateless/02703_jit_external_aggregation.sh b/tests/queries/0_stateless/02703_jit_external_aggregation.sh
index 2d1dda45de0..4bc17c106fb 100755
--- a/tests/queries/0_stateless/02703_jit_external_aggregation.sh
+++ b/tests/queries/0_stateless/02703_jit_external_aggregation.sh
@@ -5,11 +5,8 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 # shellcheck source=../shell_config.sh
 . "$CURDIR"/../shell_config.sh
 
-# This query should return empty result in every of five runs:
-
-for _ in {1..5}
-do
-    $CLICKHOUSE_CLIENT --compile_aggregate_expressions 0 --query "
+# This query should return empty result
+$CLICKHOUSE_CLIENT --compile_aggregate_expressions 1 --min_count_to_compile_aggregate_expression=0 --query "
 SELECT
     COUNT() AS c,
     group_key,
@@ -30,6 +27,5 @@ ORDER BY group_key ASC
 LIMIT 10
 SETTINGS max_bytes_before_external_group_by = 200000
 " && echo -n '.'
-done
 
 echo
diff --git a/tests/queries/0_stateless/02713_create_user_substitutions.reference b/tests/queries/0_stateless/02713_create_user_substitutions.reference
new file mode 100644
index 00000000000..02f7d1d8793
--- /dev/null
+++ b/tests/queries/0_stateless/02713_create_user_substitutions.reference
@@ -0,0 +1,7 @@
+1
+2
+3
+4
+CREATE USER user5_02713 IDENTIFIED WITH ldap SERVER \'qwerty5\'
+CREATE USER user6_02713 IDENTIFIED WITH kerberos REALM \'qwerty6\'
+CREATE USER user7_02713 IDENTIFIED WITH ssl_certificate CN \'qwerty7\', \'qwerty8\'
diff --git a/tests/queries/0_stateless/02713_create_user_substitutions.sh b/tests/queries/0_stateless/02713_create_user_substitutions.sh
new file mode 100755
index 00000000000..2d7fef56a21
--- /dev/null
+++ b/tests/queries/0_stateless/02713_create_user_substitutions.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Tags: no-fasttest, no-parallel
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+$CLICKHOUSE_CLIENT -q "DROP USER IF EXISTS user1_02713, user2_02713, user3_02713, user4_02713, user5_02713, user6_02713, user7_02713";
+
+$CLICKHOUSE_CLIENT --param_password=qwerty1 -q "CREATE USER user1_02713 IDENTIFIED BY {password:String}";
+$CLICKHOUSE_CLIENT --param_password=qwerty2 -q "CREATE USER user2_02713 IDENTIFIED WITH PLAINTEXT_PASSWORD BY {password:String}";
+$CLICKHOUSE_CLIENT --param_password=qwerty3 -q "CREATE USER user3_02713 IDENTIFIED WITH SHA256_PASSWORD BY {password:String}";
+$CLICKHOUSE_CLIENT --param_password=qwerty4 -q "CREATE USER user4_02713 IDENTIFIED WITH DOUBLE_SHA1_PASSWORD BY {password:String}";
+$CLICKHOUSE_CLIENT --param_server=qwerty5 -q "CREATE USER user5_02713 IDENTIFIED WITH LDAP SERVER {server:String}";
+$CLICKHOUSE_CLIENT --param_realm=qwerty6 -q "CREATE USER user6_02713 IDENTIFIED WITH KERBEROS REALM {realm:String}";
+$CLICKHOUSE_CLIENT --param_cert1=qwerty7 --param_cert2=qwerty8 -q "CREATE USER user7_02713 IDENTIFIED WITH SSL_CERTIFICATE CN {cert1:String}, {cert2:String}";
+
+$CLICKHOUSE_CLIENT --user=user1_02713 --password=qwerty1 -q "SELECT 1";
+$CLICKHOUSE_CLIENT --user=user2_02713 --password=qwerty2 -q "SELECT 2";
+$CLICKHOUSE_CLIENT --user=user3_02713 --password=qwerty3 -q "SELECT 3";
+$CLICKHOUSE_CLIENT --user=user4_02713 --password=qwerty4 -q "SELECT 4";
+
+$CLICKHOUSE_CLIENT -q "SHOW CREATE USER user5_02713";
+$CLICKHOUSE_CLIENT -q "SHOW CREATE USER user6_02713";
+$CLICKHOUSE_CLIENT -q "SHOW CREATE USER user7_02713";
+
+$CLICKHOUSE_CLIENT -q "DROP USER user1_02713, user2_02713, user3_02713, user4_02713, user5_02713, user6_02713, user7_02713";
diff --git a/tests/queries/0_stateless/02714_date_date32_in.reference b/tests/queries/0_stateless/02714_date_date32_in.reference
new file mode 100644
index 00000000000..d9ff83f1949
--- /dev/null
+++ b/tests/queries/0_stateless/02714_date_date32_in.reference
@@ -0,0 +1,4 @@
+1
+1
+0
+0
diff --git a/tests/queries/0_stateless/02714_date_date32_in.sql b/tests/queries/0_stateless/02714_date_date32_in.sql
new file mode 100644
index 00000000000..69a087eff6f
--- /dev/null
+++ b/tests/queries/0_stateless/02714_date_date32_in.sql
@@ -0,0 +1,4 @@
+select toDate32('2020-01-01') in (toDate('2020-01-01'));
+select toDate('2020-01-01') in (toDate32('2020-01-01'));
+select toDate('2020-01-01') in 1::Int64;
+select toDate32('2020-01-01') in 1::UInt64;
diff --git a/tests/queries/0_stateless/02720_s3_strict_upload_part_size.reference b/tests/queries/0_stateless/02720_s3_strict_upload_part_size.reference
new file mode 100644
index 00000000000..360b484bf28
--- /dev/null
+++ b/tests/queries/0_stateless/02720_s3_strict_upload_part_size.reference
@@ -0,0 +1,4 @@
+Size: 6000001
+Size: 6000001
+Size: 6000001
+Size: 2971517
diff --git a/tests/queries/0_stateless/02720_s3_strict_upload_part_size.sh b/tests/queries/0_stateless/02720_s3_strict_upload_part_size.sh
new file mode 100755
index 00000000000..69e2f734914
--- /dev/null
+++ b/tests/queries/0_stateless/02720_s3_strict_upload_part_size.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Tags: no-fasttest, long
+# Tag no-fasttest: requires S3
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CUR_DIR"/../shell_config.sh
+
+in="$CUR_DIR/$CLICKHOUSE_TEST_UNIQUE_NAME.in"
+out="$CUR_DIR/$CLICKHOUSE_TEST_UNIQUE_NAME.out"
+log="$CUR_DIR/$CLICKHOUSE_TEST_UNIQUE_NAME.log"
+
+set -e
+trap 'rm -f "${out:?}" "${in:?}" "${log:?}"' EXIT
+
+# Generate a file of 20MiB in size, with our part size it will have 4 parts
+# NOTE: 1 byte is for new line, so 1023 not 1024
+$CLICKHOUSE_LOCAL -q "SELECT randomPrintableASCII(1023) FROM numbers(20*1024) FORMAT LineAsString" > "$in"
+
+$CLICKHOUSE_CLIENT --send_logs_level=trace --server_logs_file="$log" -q "INSERT INTO FUNCTION s3(s3_conn, filename='$CLICKHOUSE_TEST_UNIQUE_NAME', format='LineAsString', structure='line String') FORMAT LineAsString" --s3_strict_upload_part_size=6000001 < "$in"
+grep -F '<Fatal>' "$log" || :
+grep -o 'WriteBufferFromS3: Writing part.*Size: .*' "$log" | grep -o 'Size: .*'
+$CLICKHOUSE_CLIENT -q "SELECT * FROM s3(s3_conn, filename='$CLICKHOUSE_TEST_UNIQUE_NAME', format='LineAsString', structure='line String') FORMAT LineAsString" > "$out"
+
+diff -q "$in" "$out"
diff --git a/tests/queries/0_stateless/02723_jit_aggregation_bug_48120.reference b/tests/queries/0_stateless/02723_jit_aggregation_bug_48120.reference
new file mode 100644
index 00000000000..6f9b4b4fc6a
--- /dev/null
+++ b/tests/queries/0_stateless/02723_jit_aggregation_bug_48120.reference
@@ -0,0 +1,7 @@
+-- { echoOn }
+SYSTEM DROP COMPILED EXPRESSION CACHE;
+SELECT minIf(num1, num1 < 5) FROM dummy GROUP BY num2;
+0
+SYSTEM DROP COMPILED EXPRESSION CACHE;
+SELECT minIf(num1, num1 >= 5) FROM dummy GROUP BY num2;
+5
diff --git a/tests/queries/0_stateless/02723_jit_aggregation_bug_48120.sql b/tests/queries/0_stateless/02723_jit_aggregation_bug_48120.sql
new file mode 100644
index 00000000000..04e0fc5e0ba
--- /dev/null
+++ b/tests/queries/0_stateless/02723_jit_aggregation_bug_48120.sql
@@ -0,0 +1,17 @@
+-- Tags: no-fasttest, no-ubsan, no-cpu-aarch64
+
+drop table if exists dummy;
+CREATE TABLE dummy ( num1 Int32, num2 Enum8('foo' = 0, 'bar' = 1, 'tar' = 2) )
+ENGINE = MergeTree ORDER BY num1 as select 5, 'bar';
+
+set compile_aggregate_expressions=1;
+set min_count_to_compile_aggregate_expression=0;
+
+-- { echoOn }
+SYSTEM DROP COMPILED EXPRESSION CACHE;
+SELECT minIf(num1, num1 < 5) FROM dummy GROUP BY num2;
+SYSTEM DROP COMPILED EXPRESSION CACHE;
+SELECT minIf(num1, num1 >= 5) FROM dummy GROUP BY num2;
+-- { echoOff }
+
+drop table dummy;
diff --git a/tests/queries/0_stateless/02723_parallelize_output_setting.reference b/tests/queries/0_stateless/02723_parallelize_output_setting.reference
new file mode 100644
index 00000000000..0f2a396f471
--- /dev/null
+++ b/tests/queries/0_stateless/02723_parallelize_output_setting.reference
@@ -0,0 +1,7 @@
+-- { echoOn }
+set parallelize_output_from_storages=1;
+select startsWith(trimLeft(explain),'Resize') as resize from (explain pipeline select * from file(data_02723.csv)) where resize;
+1
+-- no Resize in pipeline
+set parallelize_output_from_storages=0;
+select startsWith(trimLeft(explain),'Resize') as resize from (explain pipeline select * from file(data_02723.csv)) where resize;
diff --git a/tests/queries/0_stateless/02723_parallelize_output_setting.sql b/tests/queries/0_stateless/02723_parallelize_output_setting.sql
new file mode 100644
index 00000000000..7db28ca4dec
--- /dev/null
+++ b/tests/queries/0_stateless/02723_parallelize_output_setting.sql
@@ -0,0 +1,12 @@
+-- Tags: no-parallel
+
+insert into function file(data_02723.csv) select number from numbers(5) settings engine_file_truncate_on_insert=1;
+
+set max_threads=2;
+-- { echoOn }
+set parallelize_output_from_storages=1;
+select startsWith(trimLeft(explain),'Resize') as resize from (explain pipeline select * from file(data_02723.csv)) where resize;
+-- no Resize in pipeline
+set parallelize_output_from_storages=0;
+select startsWith(trimLeft(explain),'Resize') as resize from (explain pipeline select * from file(data_02723.csv)) where resize;
+
diff --git a/tests/queries/0_stateless/02723_zookeeper_name.reference b/tests/queries/0_stateless/02723_zookeeper_name.reference
new file mode 100644
index 00000000000..074712bd8fe
--- /dev/null
+++ b/tests/queries/0_stateless/02723_zookeeper_name.reference
@@ -0,0 +1,4 @@
+Create Tables
+Insert Data
+"t1","default",1
+"t2","default",1
diff --git a/tests/queries/0_stateless/02723_zookeeper_name.sql b/tests/queries/0_stateless/02723_zookeeper_name.sql
new file mode 100644
index 00000000000..7ddbf4edd47
--- /dev/null
+++ b/tests/queries/0_stateless/02723_zookeeper_name.sql
@@ -0,0 +1,23 @@
+-- Tags: zookeeper, replica
+
+SELECT 'Create Tables';
+CREATE TABLE t1(k UInt32, v UInt32) ENGINE ReplicatedMergeTree('/clickhouse/tables/{database}/test_02723/zookeeper_name/t1', '1') ORDER BY k;
+
+CREATE TABLE t2(k UInt32, v UInt32) ENGINE ReplicatedMergeTree('/clickhouse/tables/{database}/test_02723/zookeeper_name/t2', '1') ORDER BY k;
+
+SELECT 'Insert Data';
+
+INSERT INTO t1 SELECT * FROM generateRandom('k UInt32, v UInt32') LIMIT 1;
+INSERT INTO t2 SELECT * FROM generateRandom('k UInt32, v UInt32') LIMIT 1;
+
+SELECT
+    table,zookeeper_name,count()
+FROM system.replicas
+INNER JOIN system.parts USING (database, table)
+WHERE database = currentDatabase()
+GROUP BY
+    table,zookeeper_name
+FORMAT CSV;
+
+DROP TABLE t1;
+DROP TABLE t2;
diff --git a/tests/queries/0_stateless/02724_jit_logical_functions.reference b/tests/queries/0_stateless/02724_jit_logical_functions.reference
new file mode 100644
index 00000000000..673ffe02613
--- /dev/null
+++ b/tests/queries/0_stateless/02724_jit_logical_functions.reference
@@ -0,0 +1,18 @@
+Logical functions not null
+0	0	0	0	0
+0	1	0	1	1
+1	0	0	1	1
+1	1	1	1	0
+Logical functions nullable
+0	0	0	0	0
+0	1	0	1	1
+1	0	0	1	1
+1	1	1	1	0
+0	\N	0	\N	\N
+1	\N	\N	1	\N
+0	0	0
+1	1	0
+0	0	0
+1	1	0
+\N	\N	\N
+\N	\N	\N
diff --git a/tests/queries/0_stateless/02724_jit_logical_functions.sql b/tests/queries/0_stateless/02724_jit_logical_functions.sql
new file mode 100644
index 00000000000..fe6646337d0
--- /dev/null
+++ b/tests/queries/0_stateless/02724_jit_logical_functions.sql
@@ -0,0 +1,21 @@
+SET compile_expressions = 1;
+SET min_count_to_compile_expression = 0;
+
+DROP TABLE IF EXISTS test_table;
+CREATE TABLE test_table (a UInt8, b UInt8) ENGINE = TinyLog;
+INSERT INTO test_table VALUES (0, 0), (0, 1), (1, 0), (1, 1);
+
+SELECT 'Logical functions not null';
+SELECT a, b, and(a, b), or(a, b), xor(a, b) FROM test_table;
+
+DROP TABLE test_table;
+
+DROP TABLE IF EXISTS test_table_nullable;
+CREATE TABLE test_table_nullable (a UInt8, b Nullable(UInt8)) ENGINE = TinyLog;
+INSERT INTO test_table_nullable VALUES (0, 0), (0, 1), (1, 0), (1, 1), (0, NULL), (1, NULL);
+
+SELECT 'Logical functions nullable';
+SELECT a, b, and(a, b), or(a, b), xor(a, b) FROM test_table_nullable;
+SELECT and(b, b), or(b, b), xor(b, b) FROM test_table_nullable;
+
+DROP TABLE test_table_nullable;
diff --git a/utils/list-versions/version_date.tsv b/utils/list-versions/version_date.tsv
index f3aabeec87e..5be458488a8 100644
--- a/utils/list-versions/version_date.tsv
+++ b/utils/list-versions/version_date.tsv
@@ -1,3 +1,4 @@
+v23.4.1.1943-stable	2023-04-27
 v23.3.2.37-lts	2023-04-22
 v23.3.1.2823-lts	2023-03-31
 v23.2.6.34-stable	2023-04-23
diff --git a/utils/tests-visualizer/index.html b/utils/tests-visualizer/index.html
index 11b2d6504e4..b2db5dbed33 100644
--- a/utils/tests-visualizer/index.html
+++ b/utils/tests-visualizer/index.html
@@ -20,9 +20,7 @@
             width: 130px;
             display: block;
             margin: 30px auto;
-            -webkit-animation: spin 2s ease-in-out infinite;
-            -moz-animation: spin 2s ease-in-out infinite;
-            animation: spin 2s ease-in-out infinite;
+            animation: spin 10s ease-in-out infinite;
         }
 
         h1 {
@@ -45,16 +43,9 @@
             cursor: pointer;
         }
 
-        @-moz-keyframes spin {
-            100% { -moz-transform: rotate(360deg); }
-        }
-
-        @-webkit-keyframes spin {
-            100% { -webkit-transform: rotate(360deg); }
-        }
-
         @keyframes spin {
-            100% { transform:rotate(360deg); }
+            50% { transform:scale(150%); }
+            100% { transform:scale(100%); }
         }
     </style>
 </head>
@@ -67,33 +58,26 @@
 </div>
 <canvas id="canvas"></canvas>
 <script type="text/javascript">
-///////////////////////
-//  GLOBAL VARIABLES
-///////////////////////
-let start_date = '2020-06-13';
+let start_date = '2021-12-01';
 const canvasNode = document.getElementById('canvas');
 const infoNode = document.getElementById('info');
 const loadingNode = document.getElementById('loading');
 const failMessageNode = document.getElementById('fail-message');
 
-///////////////////////
-//      QUERIES
-///////////////////////
 let render_data_query = `
     WITH '${start_date}'::Date AS start_date
     SELECT groupArray([d, n, fail]) FROM
     (
         SELECT n, check_start_time::Date - start_date AS d, max(test_status LIKE 'F%' OR test_status LIKE 'E%') AS fail
-        FROM "default".checks
+        FROM checks
 
         INNER JOIN
         (
-            SELECT test_name, toUInt16(rowNumberInAllBlocks()) AS n FROM
+            SELECT test_name, toUInt16(row_number() OVER (ORDER BY test_name)) AS n FROM
             (
                 SELECT DISTINCT test_name
-                FROM "default".checks
+                FROM checks
                 WHERE match(test_name, '^\\d+_') AND check_name ILIKE '%stateless%' AND check_start_time > now() - INTERVAL 1 DAY
-                ORDER BY test_name
             )
         ) AS nums
 
@@ -109,25 +93,20 @@ let render_data_query = `
     FORMAT TSV`;
 
 let test_names_query = `
-    SELECT test_name, toUInt16(rowNumberInAllBlocks()) AS n FROM
+    SELECT test_name, toUInt16(row_number() OVER (ORDER BY test_name)) AS n FROM
     (
         SELECT DISTINCT test_name
-        FROM "default".checks
+        FROM checks
         WHERE match(test_name, '^\\d+_') AND check_name ILIKE '%stateless%' AND check_start_time > now() - INTERVAL 1 DAY
-        ORDER BY test_name
     ) FORMAT JSONCompact`;
 
-///////////////////////
-//       MAIN
-///////////////////////
-
 (async () => {
     try {
         const [render_data, test_names_data]  = await Promise.all([
             loadDataByQuery(render_data_query),
             loadDataByQuery(test_names_query),
         ]);
-        // we good
+
         renderResponse(render_data);
         saveTestNames(test_names_data);
     } catch (e) {
@@ -138,10 +117,6 @@ let test_names_query = `
     }
 })()
 
-///////////////////////
-//  SPECIAL FUNCTIONS
-///////////////////////
-
 async function loadDataByQuery(query) {
     const response = await fetch(
         "https://play.clickhouse.com?user=play&add_http_cors_header=1",