diff --git a/.gitmodules b/.gitmodules
index de7250166b8..f7dcf5f4ac1 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -133,7 +133,7 @@
 	url = https://github.com/unicode-org/icu.git
 [submodule "contrib/flatbuffers"]
 	path = contrib/flatbuffers
-	url = https://github.com/google/flatbuffers.git
+	url = https://github.com/ClickHouse-Extras/flatbuffers.git
 [submodule "contrib/libc-headers"]
 	path = contrib/libc-headers
 	url = https://github.com/ClickHouse-Extras/libc-headers.git
@@ -221,6 +221,9 @@
 [submodule "contrib/NuRaft"]
 	path = contrib/NuRaft
 	url = https://github.com/ClickHouse-Extras/NuRaft.git
+[submodule "contrib/nanodbc"]
+	path = contrib/nanodbc
+	url = https://github.com/ClickHouse-Extras/nanodbc.git
 [submodule "contrib/datasketches-cpp"]
 	path = contrib/datasketches-cpp
 	url = https://github.com/ClickHouse-Extras/datasketches-cpp.git
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 43531b60267..0f895c7c482 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,155 @@
+## ClickHouse release 21.4
+
+### ClickHouse release 21.4.1 2021-04-12
+
+#### Backward Incompatible Change
+
+* The `toStartOfIntervalFunction` will align hour intervals to the midnight (in previous versions they were aligned to the start of unix epoch). For example, `toStartOfInterval(x, INTERVAL 11 HOUR)` will split every day into three intervals: `00:00:00..10:59:59`, `11:00:00..21:59:59` and `22:00:00..23:59:59`. This behaviour is more suited for practical needs. This closes [#9510](https://github.com/ClickHouse/ClickHouse/issues/9510). [#22060](https://github.com/ClickHouse/ClickHouse/pull/22060) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* `Age` and `Precision` in graphite rollup configs should increase from retention to retention. Now it's checked and the wrong config raises an exception. [#21496](https://github.com/ClickHouse/ClickHouse/pull/21496) ([Mikhail f. Shiryaev](https://github.com/Felixoid)).
+* Fix `cutToFirstSignificantSubdomainCustom()`/`firstSignificantSubdomainCustom()` returning wrong result for 3+ level domains present in custom top-level domain list. For input domains matching these custom top-level domains, the third-level domain was considered to be the first significant one. This is now fixed. This change may introduce incompatibility if the function is used in e.g. the sharding key. [#21946](https://github.com/ClickHouse/ClickHouse/pull/21946) ([Azat Khuzhin](https://github.com/azat)).
+* Column `keys` in table `system.dictionaries` was replaced to columns `key.names` and `key.types`. Columns `key.names`, `key.types`, `attribute.names`, `attribute.types` from `system.dictionaries` table does not require dictionary to be loaded. [#21884](https://github.com/ClickHouse/ClickHouse/pull/21884) ([Maksim Kita](https://github.com/kitaisreal)).
+* Now replicas that are processing the `ALTER TABLE ATTACH PART[ITION]` command search in their `detached/` folders before fetching the data from other replicas. As an implementation detail, a new command `ATTACH_PART` is introduced in the replicated log. Parts are searched and compared by their checksums. [#18978](https://github.com/ClickHouse/ClickHouse/pull/18978) ([Mike Kot](https://github.com/myrrc)). **Note**:
+  * `ATTACH PART[ITION]` queries may not work during cluster upgrade.
+  * It's not possible to rollback to older ClickHouse version after executing `ALTER ... ATTACH` query in new version as the old servers would fail to pass the `ATTACH_PART` entry in the replicated log.
+
+#### New Feature
+
+* Extended range of `DateTime64` to support dates from year 1925 to 2283. Improved support of `DateTime` around zero date (`1970-01-01`). [#9404](https://github.com/ClickHouse/ClickHouse/pull/9404) ([alexey-milovidov](https://github.com/alexey-milovidov), [Vasily Nemkov](https://github.com/Enmk)). Not every time and date functions are working for extended range of dates.
+* Added support of Kerberos authentication for preconfigured users and HTTP requests (GSS-SPNEGO). [#14995](https://github.com/ClickHouse/ClickHouse/pull/14995) ([Denis Glazachev](https://github.com/traceon)).
+* Add `prefer_column_name_to_alias` setting to use original column names instead of aliases. it is needed to be more compatible with common databases' aliasing rules. This is for [#9715](https://github.com/ClickHouse/ClickHouse/issues/9715) and [#9887](https://github.com/ClickHouse/ClickHouse/issues/9887). [#22044](https://github.com/ClickHouse/ClickHouse/pull/22044) ([Amos Bird](https://github.com/amosbird)).
+* Added functions `dictGetChildren(dictionary, key)`, `dictGetDescendants(dictionary, key, level)`. Function `dictGetChildren` return all children as an array if indexes. It is a inverse transformation for `dictGetHierarchy`. Function `dictGetDescendants` return all descendants as if `dictGetChildren` was applied `level` times recursively. Zero `level` value is equivalent to infinity. Closes [#14656](https://github.com/ClickHouse/ClickHouse/issues/14656). [#22096](https://github.com/ClickHouse/ClickHouse/pull/22096) ([Maksim Kita](https://github.com/kitaisreal)).
+* Added `executable_pool` dictionary source. Close [#14528](https://github.com/ClickHouse/ClickHouse/issues/14528). [#21321](https://github.com/ClickHouse/ClickHouse/pull/21321) ([Maksim Kita](https://github.com/kitaisreal)).
+* Added table function `dictionary`. It works the same way as `Dictionary` engine. Closes [#21560](https://github.com/ClickHouse/ClickHouse/issues/21560). [#21910](https://github.com/ClickHouse/ClickHouse/pull/21910) ([Maksim Kita](https://github.com/kitaisreal)).
+* Support `Nullable` type for `PolygonDictionary` attribute. [#21890](https://github.com/ClickHouse/ClickHouse/pull/21890) ([Maksim Kita](https://github.com/kitaisreal)).
+* Functions `dictGet`, `dictHas` use current database name if it is not specified for dictionaries created with DDL. Closes [#21632](https://github.com/ClickHouse/ClickHouse/issues/21632). [#21859](https://github.com/ClickHouse/ClickHouse/pull/21859) ([Maksim Kita](https://github.com/kitaisreal)).
+* Added function `dictGetOrNull`. It works like `dictGet`, but return `Null` in case key was not found in dictionary. Closes [#22375](https://github.com/ClickHouse/ClickHouse/issues/22375). [#22413](https://github.com/ClickHouse/ClickHouse/pull/22413) ([Maksim Kita](https://github.com/kitaisreal)).
+* Added async update in `ComplexKeyCache`, `SSDCache`, `SSDComplexKeyCache` dictionaries. Added support for `Nullable` type in `Cache`, `ComplexKeyCache`, `SSDCache`, `SSDComplexKeyCache` dictionaries. Added support for multiple attributes fetch with `dictGet`, `dictGetOrDefault` functions. Fixes [#21517](https://github.com/ClickHouse/ClickHouse/issues/21517). [#20595](https://github.com/ClickHouse/ClickHouse/pull/20595) ([Maksim Kita](https://github.com/kitaisreal)).
+* Support `dictHas` function for `RangeHashedDictionary`. Fixes [#6680](https://github.com/ClickHouse/ClickHouse/issues/6680). [#19816](https://github.com/ClickHouse/ClickHouse/pull/19816) ([Maksim Kita](https://github.com/kitaisreal)).
+* Add function `timezoneOf` that returns the timezone name of `DateTime` or `DateTime64` data types. This does not close [#9959](https://github.com/ClickHouse/ClickHouse/issues/9959). Fix inconsistencies in function names: add aliases `timezone` and `timeZone` as well as `toTimezone` and `toTimeZone` and `timezoneOf` and `timeZoneOf`. [#22001](https://github.com/ClickHouse/ClickHouse/pull/22001) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Add new optional clause `GRANTEES` for `CREATE/ALTER USER` commands. It specifies users or roles which are allowed to receive grants from this user on condition this user has also all required access granted with grant option. By default `GRANTEES ANY` is used which means a user with grant option can grant to anyone. Syntax: `CREATE USER ... GRANTEES {user | role | ANY | NONE} [,...] [EXCEPT {user | role} [,...]]`. [#21641](https://github.com/ClickHouse/ClickHouse/pull/21641) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Add new column `slowdowns_count` to `system.clusters`. When using hedged requests, it shows how many times we switched to another replica because this replica was responding slowly. Also show actual value of `errors_count` in `system.clusters`. [#21480](https://github.com/ClickHouse/ClickHouse/pull/21480) ([Kruglov Pavel](https://github.com/Avogar)).
+* Add `_partition_id` virtual column for `MergeTree*` engines. Allow to prune partitions by `_partition_id`. Add `partitionID()` function to calculate partition id string. [#21401](https://github.com/ClickHouse/ClickHouse/pull/21401) ([Amos Bird](https://github.com/amosbird)).
+* Add function `isIPAddressInRange` to test if an IPv4 or IPv6 address is contained in a given CIDR network prefix. [#21329](https://github.com/ClickHouse/ClickHouse/pull/21329) ([PHO](https://github.com/depressed-pho)).
+* Added new SQL command `ALTER TABLE 'table_name' UNFREEZE [PARTITION 'part_expr'] WITH NAME 'backup_name'`. This command is needed to properly remove 'freezed' partitions from all disks. [#21142](https://github.com/ClickHouse/ClickHouse/pull/21142) ([Pavel Kovalenko](https://github.com/Jokser)).
+* Supports implicit key type conversion for JOIN. [#19885](https://github.com/ClickHouse/ClickHouse/pull/19885) ([Vladimir](https://github.com/vdimir)).
+
+#### Experimental Feature
+
+* Support `RANGE OFFSET` frame (for window functions) for floating point types. Implement `lagInFrame`/`leadInFrame` window functions, which are analogous to `lag`/`lead`, but respect the window frame. They are identical when the frame is `between unbounded preceding and unbounded following`. This closes [#5485](https://github.com/ClickHouse/ClickHouse/issues/5485). [#21895](https://github.com/ClickHouse/ClickHouse/pull/21895) ([Alexander Kuzmenkov](https://github.com/akuzm)).
+* Zero-copy replication for `ReplicatedMergeTree` over S3 storage. [#16240](https://github.com/ClickHouse/ClickHouse/pull/16240) ([ianton-ru](https://github.com/ianton-ru)).
+* Added possibility to migrate existing S3 disk to the schema with backup-restore capabilities. [#22070](https://github.com/ClickHouse/ClickHouse/pull/22070) ([Pavel Kovalenko](https://github.com/Jokser)).
+
+#### Performance Improvement
+
+* Supported parallel formatting in `clickhouse-local` and everywhere else. [#21630](https://github.com/ClickHouse/ClickHouse/pull/21630) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)).
+* Support parallel parsing for `CSVWithNames` and `TSVWithNames` formats. This closes [#21085](https://github.com/ClickHouse/ClickHouse/issues/21085). [#21149](https://github.com/ClickHouse/ClickHouse/pull/21149) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)).
+* Enable read with mmap IO for file ranges from 64 MiB (the settings `min_bytes_to_use_mmap_io`). It may lead to moderate performance improvement. [#22326](https://github.com/ClickHouse/ClickHouse/pull/22326) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Add cache for files read with `min_bytes_to_use_mmap_io` setting. It makes significant (2x and more) performance improvement when the value of the setting is small by avoiding frequent mmap/munmap calls and the consequent page faults. Note that mmap IO has major drawbacks that makes it less reliable in production (e.g. hung or SIGBUS on faulty disks; less controllable memory usage). Nevertheless it is good in benchmarks. [#22206](https://github.com/ClickHouse/ClickHouse/pull/22206) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Avoid unnecessary data copy when using codec `NONE`. Please note that codec `NONE` is mostly useless - it's recommended to always use compression (`LZ4` is by default). Despite the common belief, disabling compression may not improve performance (the opposite effect is possible). The `NONE` codec is useful in some cases: - when data is uncompressable; - for synthetic benchmarks. [#22145](https://github.com/ClickHouse/ClickHouse/pull/22145) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Faster `GROUP BY` with small `max_rows_to_group_by` and `group_by_overflow_mode='any'`. [#21856](https://github.com/ClickHouse/ClickHouse/pull/21856) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Optimize performance of queries like `SELECT ... FINAL ... WHERE`. Now in queries with `FINAL` it's allowed to move to `PREWHERE` columns, which are in sorting key. [#21830](https://github.com/ClickHouse/ClickHouse/pull/21830) ([foolchi](https://github.com/foolchi)).
+* Improved performance by replacing `memcpy` to another implementation. This closes [#18583](https://github.com/ClickHouse/ClickHouse/issues/18583). [#21520](https://github.com/ClickHouse/ClickHouse/pull/21520) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Improve performance of aggregation in order of sorting key (with enabled setting `optimize_aggregation_in_order`). [#19401](https://github.com/ClickHouse/ClickHouse/pull/19401) ([Anton Popov](https://github.com/CurtizJ)).
+
+#### Improvement
+
+* Add connection pool for PostgreSQL table/database engine and dictionary source. Should fix [#21444](https://github.com/ClickHouse/ClickHouse/issues/21444). [#21839](https://github.com/ClickHouse/ClickHouse/pull/21839) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Support non-default table schema for postgres storage/table-function. Closes [#21701](https://github.com/ClickHouse/ClickHouse/issues/21701). [#21711](https://github.com/ClickHouse/ClickHouse/pull/21711) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Support replicas priority for postgres dictionary source. [#21710](https://github.com/ClickHouse/ClickHouse/pull/21710) ([Kseniia Sumarokova](https://github.com/kssenii)).
+* Introduce a new merge tree setting `min_bytes_to_rebalance_partition_over_jbod` which allows assigning new parts to different disks of a JBOD volume in a balanced way. [#16481](https://github.com/ClickHouse/ClickHouse/pull/16481) ([Amos Bird](https://github.com/amosbird)).
+* Added `Grant`, `Revoke` and `System` values of `query_kind` column for corresponding queries in `system.query_log`. [#21102](https://github.com/ClickHouse/ClickHouse/pull/21102) ([Vasily Nemkov](https://github.com/Enmk)).
+* Allow customizing timeouts for HTTP connections used for replication independently from other HTTP timeouts. [#20088](https://github.com/ClickHouse/ClickHouse/pull/20088) ([nvartolomei](https://github.com/nvartolomei)).
+* Better exception message in client in case of exception while server is writing blocks. In previous versions client may get misleading message like `Data compressed with different methods`. [#22427](https://github.com/ClickHouse/ClickHouse/pull/22427) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Fix error `Directory tmp_fetch_XXX already exists` which could happen after failed fetch part. Delete temporary fetch directory if it already exists. Fixes [#14197](https://github.com/ClickHouse/ClickHouse/issues/14197). [#22411](https://github.com/ClickHouse/ClickHouse/pull/22411) ([nvartolomei](https://github.com/nvartolomei)).
+* Fix MSan report for function `range` with `UInt256` argument (support for large integers is experimental). This closes [#22157](https://github.com/ClickHouse/ClickHouse/issues/22157). [#22387](https://github.com/ClickHouse/ClickHouse/pull/22387) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Add `current_database` column to `system.processes` table. It contains the current database of the query. [#22365](https://github.com/ClickHouse/ClickHouse/pull/22365) ([Alexander Kuzmenkov](https://github.com/akuzm)).
+* Add case-insensitive history search/navigation and subword movement features to `clickhouse-client`. [#22105](https://github.com/ClickHouse/ClickHouse/pull/22105) ([Amos Bird](https://github.com/amosbird)).
+* If tuple of NULLs, e.g. `(NULL, NULL)` is on the left hand side of `IN` operator with tuples of non-NULLs on the right hand side, e.g. `SELECT (NULL, NULL) IN ((0, 0), (3, 1))` return 0 instead of throwing an exception about incompatible types. The expression may also appear due to optimization of something like `SELECT (NULL, NULL) = (8, 0) OR (NULL, NULL) = (3, 2) OR (NULL, NULL) = (0, 0) OR (NULL, NULL) = (3, 1)`. This closes [#22017](https://github.com/ClickHouse/ClickHouse/issues/22017). [#22063](https://github.com/ClickHouse/ClickHouse/pull/22063) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Update used version of simdjson to 0.9.1. This fixes [#21984](https://github.com/ClickHouse/ClickHouse/issues/21984). [#22057](https://github.com/ClickHouse/ClickHouse/pull/22057) ([Vitaly Baranov](https://github.com/vitlibar)).
+* Added case insensitive aliases for `CONNECTION_ID()` and `VERSION()` functions. This fixes [#22028](https://github.com/ClickHouse/ClickHouse/issues/22028). [#22042](https://github.com/ClickHouse/ClickHouse/pull/22042) ([Eugene Klimov](https://github.com/Slach)).
+* Add option `strict_increase` to `windowFunnel` function to calculate each event once (resolve [#21835](https://github.com/ClickHouse/ClickHouse/issues/21835)). [#22025](https://github.com/ClickHouse/ClickHouse/pull/22025) ([Vladimir](https://github.com/vdimir)).
+* If partition key of a `MergeTree` table does not include `Date` or `DateTime` columns but includes exactly one `DateTime64` column, expose its values in the `min_time` and `max_time` columns in `system.parts` and `system.parts_columns` tables. Add `min_time` and `max_time` columns to `system.parts_columns` table (these was inconsistency to the `system.parts` table). This closes [#18244](https://github.com/ClickHouse/ClickHouse/issues/18244). [#22011](https://github.com/ClickHouse/ClickHouse/pull/22011) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Supported `replication_alter_partitions_sync=1` setting in `clickhouse-copier` for moving partitions from helping table to destination. Decreased default timeouts. Fixes [#21911](https://github.com/ClickHouse/ClickHouse/issues/21911). [#21912](https://github.com/ClickHouse/ClickHouse/pull/21912) ([turbo jason](https://github.com/songenjie)).
+* Show path to data directory of `EmbeddedRocksDB` tables in system tables. [#21903](https://github.com/ClickHouse/ClickHouse/pull/21903) ([tavplubix](https://github.com/tavplubix)).
+* Add profile event `HedgedRequestsChangeReplica`, change read data timeout from sec to ms. [#21886](https://github.com/ClickHouse/ClickHouse/pull/21886) ([Kruglov Pavel](https://github.com/Avogar)).
+* DiskS3 (experimental feature under development). Fixed bug with the impossibility to move directory if the destination is not empty and cache disk is used. [#21837](https://github.com/ClickHouse/ClickHouse/pull/21837) ([Pavel Kovalenko](https://github.com/Jokser)).
+* Better formatting for `Array` and `Map` data types in Web UI. [#21798](https://github.com/ClickHouse/ClickHouse/pull/21798) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Update clusters only if their configurations were updated. [#21685](https://github.com/ClickHouse/ClickHouse/pull/21685) ([Kruglov Pavel](https://github.com/Avogar)).
+* Propagate query and session settings for distributed DDL queries. Set `distributed_ddl_entry_format_version` to 2 to enable this. Added `distributed_ddl_output_mode` setting. Supported modes: `none`, `throw` (default), `null_status_on_timeout` and `never_throw`. Miscellaneous fixes and improvements for `Replicated` database engine. [#21535](https://github.com/ClickHouse/ClickHouse/pull/21535) ([tavplubix](https://github.com/tavplubix)).
+* If `PODArray` was instantiated with element size that is neither a fraction or a multiple of 16, buffer overflow was possible. No bugs in current releases exist. [#21533](https://github.com/ClickHouse/ClickHouse/pull/21533) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Add `last_error_time`/`last_error_message`/`last_error_stacktrace`/`remote` columns for `system.errors`. [#21529](https://github.com/ClickHouse/ClickHouse/pull/21529) ([Azat Khuzhin](https://github.com/azat)).
+* Add aliases `simpleJSONExtract/simpleJSONHas` to `visitParam/visitParamExtract{UInt, Int, Bool, Float, Raw, String}`. Fixes #21383. [#21519](https://github.com/ClickHouse/ClickHouse/pull/21519) ([fastio](https://github.com/fastio)).
+* Add setting `optimize_skip_unused_shards_limit` to limit the number of sharding key values for `optimize_skip_unused_shards`. [#21512](https://github.com/ClickHouse/ClickHouse/pull/21512) ([Azat Khuzhin](https://github.com/azat)).
+* Improve `clickhouse-format` to not throw exception when there are extra spaces or comment after the last query, and throw exception early with readable message when format `ASTInsertQuery` with data . [#21311](https://github.com/ClickHouse/ClickHouse/pull/21311) ([flynn](https://github.com/ucasFL)).
+* Improve support of integer keys in data type `Map`. [#21157](https://github.com/ClickHouse/ClickHouse/pull/21157) ([Anton Popov](https://github.com/CurtizJ)).
+* MaterializeMySQL: attempt to reconnect to MySQL if the connection is lost. [#20961](https://github.com/ClickHouse/ClickHouse/pull/20961) ([Håvard Kvålen](https://github.com/havardk)).
+* Support more cases to rewrite `CROSS JOIN` to `INNER JOIN`. [#20392](https://github.com/ClickHouse/ClickHouse/pull/20392) ([Vladimir](https://github.com/vdimir)).
+* Do not create empty parts on INSERT when `optimize_on_insert` setting enabled. Fixes [#20304](https://github.com/ClickHouse/ClickHouse/issues/20304). [#20387](https://github.com/ClickHouse/ClickHouse/pull/20387) ([Kruglov Pavel](https://github.com/Avogar)).
+* `MaterializeMySQL`: add minmax skipping index for `_version` column. [#20382](https://github.com/ClickHouse/ClickHouse/pull/20382) ([Stig Bakken](https://github.com/stigsb)).
+* Add option `--backslash` for `clickhouse-format`, which can add a backslash at the end of each line of the formatted query. [#21494](https://github.com/ClickHouse/ClickHouse/pull/21494) ([flynn](https://github.com/ucasFL)).
+* Now clickhouse will not throw `LOGICAL_ERROR` exception when we try to mutate the already covered part. Fixes [#22013](https://github.com/ClickHouse/ClickHouse/issues/22013). [#22291](https://github.com/ClickHouse/ClickHouse/pull/22291) ([alesapin](https://github.com/alesapin)).
+
+#### Bug Fix
+
+* Remove socket from epoll before cancelling packet receiver in `HedgedConnections` to prevent possible race. Fixes [#22161](https://github.com/ClickHouse/ClickHouse/issues/22161). [#22443](https://github.com/ClickHouse/ClickHouse/pull/22443) ([Kruglov Pavel](https://github.com/Avogar)).
+* Add (missing) memory accounting in parallel parsing routines. In previous versions OOM was possible when the resultset contains very large blocks of data. This closes [#22008](https://github.com/ClickHouse/ClickHouse/issues/22008). [#22425](https://github.com/ClickHouse/ClickHouse/pull/22425) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Fix exception which may happen when `SELECT` has constant `WHERE` condition and source table has columns which names are digits. [#22270](https://github.com/ClickHouse/ClickHouse/pull/22270) ([LiuNeng](https://github.com/liuneng1994)).
+* Fix query cancellation with `use_hedged_requests=0` and `async_socket_for_remote=1`. [#22183](https://github.com/ClickHouse/ClickHouse/pull/22183) ([Azat Khuzhin](https://github.com/azat)).
+* Fix uncaught exception in `InterserverIOHTTPHandler`. [#22146](https://github.com/ClickHouse/ClickHouse/pull/22146) ([Azat Khuzhin](https://github.com/azat)).
+* Fix docker entrypoint in case `http_port` is not in the config. [#22132](https://github.com/ClickHouse/ClickHouse/pull/22132) ([Ewout](https://github.com/devwout)).
+* Fix error `Invalid number of rows in Chunk` in `JOIN` with `TOTALS` and `arrayJoin`. Closes [#19303](https://github.com/ClickHouse/ClickHouse/issues/19303). [#22129](https://github.com/ClickHouse/ClickHouse/pull/22129) ([Vladimir](https://github.com/vdimir)).
+* Fix the background thread pool name which used to poll message from Kafka. The Kafka engine with the broken thread pool will not consume the message from message queue. [#22122](https://github.com/ClickHouse/ClickHouse/pull/22122) ([fastio](https://github.com/fastio)).
+* Fix waiting for `OPTIMIZE` and `ALTER` queries for `ReplicatedMergeTree` table engines. Now the query will not hang when the table was detached or restarted. [#22118](https://github.com/ClickHouse/ClickHouse/pull/22118) ([alesapin](https://github.com/alesapin)).
+* Disable `async_socket_for_remote`/`use_hedged_requests` for buggy Linux kernels. [#22109](https://github.com/ClickHouse/ClickHouse/pull/22109) ([Azat Khuzhin](https://github.com/azat)).
+* Docker entrypoint: avoid chown of `.` in case when `LOG_PATH` is empty. Closes [#22100](https://github.com/ClickHouse/ClickHouse/issues/22100). [#22102](https://github.com/ClickHouse/ClickHouse/pull/22102) ([filimonov](https://github.com/filimonov)).
+* The function `decrypt` was lacking a check for the minimal size of data encrypted in `AEAD` mode. This closes [#21897](https://github.com/ClickHouse/ClickHouse/issues/21897). [#22064](https://github.com/ClickHouse/ClickHouse/pull/22064) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* In rare case, merge for `CollapsingMergeTree` may create granule with `index_granularity + 1` rows. Because of this, internal check, added in [#18928](https://github.com/ClickHouse/ClickHouse/issues/18928) (affects 21.2 and 21.3), may fail with error `Incomplete granules are not allowed while blocks are granules size`. This error did not allow parts to merge. [#21976](https://github.com/ClickHouse/ClickHouse/pull/21976) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Reverted [#15454](https://github.com/ClickHouse/ClickHouse/issues/15454) that may cause significant increase in memory usage while loading external dictionaries of hashed type. This closes [#21935](https://github.com/ClickHouse/ClickHouse/issues/21935). [#21948](https://github.com/ClickHouse/ClickHouse/pull/21948) ([Maksim Kita](https://github.com/kitaisreal)).
+* Prevent hedged connections overlaps (`Unknown packet 9 from server` error). [#21941](https://github.com/ClickHouse/ClickHouse/pull/21941) ([Azat Khuzhin](https://github.com/azat)).
+* Fix reading the HTTP POST request with "multipart/form-data" content type in some cases. [#21936](https://github.com/ClickHouse/ClickHouse/pull/21936) ([Ivan](https://github.com/abyss7)).
+* Fix wrong `ORDER BY` results when a query contains window functions, and optimization for reading in primary key order is applied. Fixes [#21828](https://github.com/ClickHouse/ClickHouse/issues/21828). [#21915](https://github.com/ClickHouse/ClickHouse/pull/21915) ([Alexander Kuzmenkov](https://github.com/akuzm)).
+* Fix deadlock in first catboost model execution. Closes [#13832](https://github.com/ClickHouse/ClickHouse/issues/13832). [#21844](https://github.com/ClickHouse/ClickHouse/pull/21844) ([Kruglov Pavel](https://github.com/Avogar)).
+* Fix incorrect query result (and possible crash) which could happen when `WHERE` or `HAVING` condition is pushed before `GROUP BY`. Fixes [#21773](https://github.com/ClickHouse/ClickHouse/issues/21773). [#21841](https://github.com/ClickHouse/ClickHouse/pull/21841) ([Nikolai Kochetov](https://github.com/KochetovNicolai)).
+* Better error handling and logging in `WriteBufferFromS3`. [#21836](https://github.com/ClickHouse/ClickHouse/pull/21836) ([Pavel Kovalenko](https://github.com/Jokser)).
+* Fix possible crashes in aggregate functions with combinator `Distinct`, while using two-level aggregation. This is a follow-up fix of [#18365](https://github.com/ClickHouse/ClickHouse/pull/18365) . Can only reproduced in production env. [#21818](https://github.com/ClickHouse/ClickHouse/pull/21818) ([Amos Bird](https://github.com/amosbird)).
+* Fix scalar subquery index analysis. This fixes [#21717](https://github.com/ClickHouse/ClickHouse/issues/21717) , which was introduced in [#18896](https://github.com/ClickHouse/ClickHouse/pull/18896). [#21766](https://github.com/ClickHouse/ClickHouse/pull/21766) ([Amos Bird](https://github.com/amosbird)).
+* Fix bug for `ReplicatedMerge` table engines when `ALTER MODIFY COLUMN` query doesn't change the type of `Decimal` column if its size (32 bit or 64 bit) doesn't change. [#21728](https://github.com/ClickHouse/ClickHouse/pull/21728) ([alesapin](https://github.com/alesapin)).
+* Fix possible infinite waiting when concurrent `OPTIMIZE` and `DROP` are run for `ReplicatedMergeTree`. [#21716](https://github.com/ClickHouse/ClickHouse/pull/21716) ([Azat Khuzhin](https://github.com/azat)).
+* Fix function `arrayElement` with type `Map` for constant integer arguments. [#21699](https://github.com/ClickHouse/ClickHouse/pull/21699) ([Anton Popov](https://github.com/CurtizJ)).
+* Fix SIGSEGV on not existing attributes from `ip_trie` with `access_to_key_from_attributes`. [#21692](https://github.com/ClickHouse/ClickHouse/pull/21692) ([Azat Khuzhin](https://github.com/azat)).
+* Server now start accepting connections only after `DDLWorker` and dictionaries initialization. [#21676](https://github.com/ClickHouse/ClickHouse/pull/21676) ([Azat Khuzhin](https://github.com/azat)).
+* Add type conversion for keys of tables of type `Join` (previously led to SIGSEGV). [#21646](https://github.com/ClickHouse/ClickHouse/pull/21646) ([Azat Khuzhin](https://github.com/azat)).
+* Fix distributed requests cancellation (for example simple select from multiple shards with limit, i.e. `select * from remote('127.{2,3}', system.numbers) limit 100`) with `async_socket_for_remote=1`. [#21643](https://github.com/ClickHouse/ClickHouse/pull/21643) ([Azat Khuzhin](https://github.com/azat)).
+* Fix `fsync_part_directory` for horizontal merge. [#21642](https://github.com/ClickHouse/ClickHouse/pull/21642) ([Azat Khuzhin](https://github.com/azat)).
+* Remove unknown columns from joined table in `WHERE` for queries to external database engines (MySQL, PostgreSQL). close [#14614](https://github.com/ClickHouse/ClickHouse/issues/14614), close [#19288](https://github.com/ClickHouse/ClickHouse/issues/19288) (dup), close [#19645](https://github.com/ClickHouse/ClickHouse/issues/19645) (dup). [#21640](https://github.com/ClickHouse/ClickHouse/pull/21640) ([Vladimir](https://github.com/vdimir)).
+* `std::terminate` was called if there is an error writing data into s3. [#21624](https://github.com/ClickHouse/ClickHouse/pull/21624) ([Vladimir](https://github.com/vdimir)).
+* Fix possible error `Cannot find column` when `optimize_skip_unused_shards` is enabled and zero shards are used. [#21579](https://github.com/ClickHouse/ClickHouse/pull/21579) ([Azat Khuzhin](https://github.com/azat)).
+* In case if query has constant `WHERE` condition, and setting `optimize_skip_unused_shards` enabled, all shards may be skipped and query could return incorrect empty result. [#21550](https://github.com/ClickHouse/ClickHouse/pull/21550) ([Amos Bird](https://github.com/amosbird)).
+* Fix table function `clusterAllReplicas` returns wrong `_shard_num`. close [#21481](https://github.com/ClickHouse/ClickHouse/issues/21481). [#21498](https://github.com/ClickHouse/ClickHouse/pull/21498) ([flynn](https://github.com/ucasFL)).
+* Fix that S3 table holds old credentials after config update. [#21457](https://github.com/ClickHouse/ClickHouse/pull/21457) ([Grigory Pervakov](https://github.com/GrigoryPervakov)).
+* Fixed race on SSL object inside `SecureSocket` in Poco. [#21456](https://github.com/ClickHouse/ClickHouse/pull/21456) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)).
+* Fix `Avro` format parsing for `Kafka`. Fixes [#21437](https://github.com/ClickHouse/ClickHouse/issues/21437). [#21438](https://github.com/ClickHouse/ClickHouse/pull/21438) ([Ilya Golshtein](https://github.com/ilejn)).
+* Fix receive and send timeouts and non-blocking read in secure socket. [#21429](https://github.com/ClickHouse/ClickHouse/pull/21429) ([Kruglov Pavel](https://github.com/Avogar)).
+* `force_drop_table` flag didn't work for `MATERIALIZED VIEW`, it's fixed. Fixes [#18943](https://github.com/ClickHouse/ClickHouse/issues/18943). [#20626](https://github.com/ClickHouse/ClickHouse/pull/20626) ([tavplubix](https://github.com/tavplubix)).
+* Fix name clashes in `PredicateRewriteVisitor`. It caused incorrect `WHERE` filtration after full join. Close [#20497](https://github.com/ClickHouse/ClickHouse/issues/20497). [#20622](https://github.com/ClickHouse/ClickHouse/pull/20622) ([Vladimir](https://github.com/vdimir)).
+* Fixed open behavior of remote host filter in case when there is `remote_url_allow_hosts` section in configuration but no entries there. [#20058](https://github.com/ClickHouse/ClickHouse/pull/20058) ([Vladimir Chebotarev](https://github.com/excitoon)).
+
+#### Build/Testing/Packaging Improvement
+
+* Add [Jepsen](https://github.com/jepsen-io/jepsen) tests for ClickHouse Keeper. [#21677](https://github.com/ClickHouse/ClickHouse/pull/21677) ([alesapin](https://github.com/alesapin)).
+* Run stateless tests in parallel in CI. Depends on [#22181](https://github.com/ClickHouse/ClickHouse/issues/22181). [#22300](https://github.com/ClickHouse/ClickHouse/pull/22300) ([alesapin](https://github.com/alesapin)).
+* Enable status check for [SQLancer](https://github.com/sqlancer/sqlancer) CI run. [#22015](https://github.com/ClickHouse/ClickHouse/pull/22015) ([Ilya Yatsishin](https://github.com/qoega)).
+* Multiple preparations for PowerPC builds: Enable the bundled openldap on `ppc64le`. [#22487](https://github.com/ClickHouse/ClickHouse/pull/22487) ([Kfir Itzhak](https://github.com/mastertheknife)).  Enable compiling on `ppc64le` with Clang. [#22476](https://github.com/ClickHouse/ClickHouse/pull/22476) ([Kfir Itzhak](https://github.com/mastertheknife)). Fix compiling boost on `ppc64le`. [#22474](https://github.com/ClickHouse/ClickHouse/pull/22474) ([Kfir Itzhak](https://github.com/mastertheknife)). Fix CMake error about internal CMake variable `CMAKE_ASM_COMPILE_OBJECT` not set on `ppc64le`. [#22469](https://github.com/ClickHouse/ClickHouse/pull/22469) ([Kfir Itzhak](https://github.com/mastertheknife)). Fix Fedora/RHEL/CentOS not finding `libclang_rt.builtins` on `ppc64le`. [#22458](https://github.com/ClickHouse/ClickHouse/pull/22458) ([Kfir Itzhak](https://github.com/mastertheknife)).  Enable building with `jemalloc` on `ppc64le`. [#22447](https://github.com/ClickHouse/ClickHouse/pull/22447) ([Kfir Itzhak](https://github.com/mastertheknife)). Fix ClickHouse's config embedding and cctz's timezone embedding on `ppc64le`. [#22445](https://github.com/ClickHouse/ClickHouse/pull/22445) ([Kfir Itzhak](https://github.com/mastertheknife)). Fixed compiling on `ppc64le` and use the correct instruction pointer register on `ppc64le`. [#22430](https://github.com/ClickHouse/ClickHouse/pull/22430) ([Kfir Itzhak](https://github.com/mastertheknife)).
+* Re-enable the S3 (AWS) library on `aarch64`. [#22484](https://github.com/ClickHouse/ClickHouse/pull/22484) ([Kfir Itzhak](https://github.com/mastertheknife)).
+* Add `tzdata` to Docker containers because reading `ORC` formats requires it. This closes [#14156](https://github.com/ClickHouse/ClickHouse/issues/14156). [#22000](https://github.com/ClickHouse/ClickHouse/pull/22000) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Introduce 2 arguments for `clickhouse-server` image Dockerfile: `deb_location` & `single_binary_location`. [#21977](https://github.com/ClickHouse/ClickHouse/pull/21977) ([filimonov](https://github.com/filimonov)).
+* Allow to use clang-tidy with release builds by enabling assertions if it is used. [#21914](https://github.com/ClickHouse/ClickHouse/pull/21914) ([alexey-milovidov](https://github.com/alexey-milovidov)).
+* Add llvm-12 binaries name to search in cmake scripts. Implicit constants conversions to mute clang warnings. Updated submodules to build with CMake 3.19. Mute recursion in macro expansion in `readpassphrase` library. Deprecated `-fuse-ld` changed to `--ld-path` for clang. [#21597](https://github.com/ClickHouse/ClickHouse/pull/21597) ([Ilya Yatsishin](https://github.com/qoega)).
+* Updating `docker/test/testflows/runner/dockerd-entrypoint.sh` to use Yandex dockerhub-proxy, because Docker Hub has enabled very restrictive rate limits [#21551](https://github.com/ClickHouse/ClickHouse/pull/21551) ([vzakaznikov](https://github.com/vzakaznikov)).
+* Fix macOS shared lib build. [#20184](https://github.com/ClickHouse/ClickHouse/pull/20184) ([nvartolomei](https://github.com/nvartolomei)).
+* Add `ctime` option to `zookeeper-dump-tree`. It allows to dump node creation time. [#21842](https://github.com/ClickHouse/ClickHouse/pull/21842) ([Ilya](https://github.com/HumanUser)).
+
+
 ## ClickHouse release 21.3 (LTS)
 
 ### ClickHouse release v21.3, 2021-03-12
@@ -26,7 +178,7 @@
 #### Experimental feature
 
 * Add experimental `Replicated` database engine. It replicates DDL queries across multiple hosts. [#16193](https://github.com/ClickHouse/ClickHouse/pull/16193) ([tavplubix](https://github.com/tavplubix)).
-* Introduce experimental support for window functions, enabled with `allow_experimental_functions = 1`. This is a preliminary, alpha-quality implementation that is not suitable for production use and will change in backward-incompatible ways in future releases. Please see [the documentation](https://github.com/ClickHouse/ClickHouse/blob/master/docs/en/sql-reference/window-functions/index.md#experimental-window-functions) for the list of supported features. [#20337](https://github.com/ClickHouse/ClickHouse/pull/20337) ([Alexander Kuzmenkov](https://github.com/akuzm)).
+* Introduce experimental support for window functions, enabled with `allow_experimental_window_functions = 1`. This is a preliminary, alpha-quality implementation that is not suitable for production use and will change in backward-incompatible ways in future releases. Please see [the documentation](https://github.com/ClickHouse/ClickHouse/blob/master/docs/en/sql-reference/window-functions/index.md#experimental-window-functions) for the list of supported features. [#20337](https://github.com/ClickHouse/ClickHouse/pull/20337) ([Alexander Kuzmenkov](https://github.com/akuzm)).
 * Add the ability to backup/restore metadata files for DiskS3. [#18377](https://github.com/ClickHouse/ClickHouse/pull/18377) ([Pavel Kovalenko](https://github.com/Jokser)).
 
 #### Performance Improvement
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c4d429c565f..736a6577660 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -68,17 +68,30 @@ endif ()
 
 include (cmake/find/ccache.cmake)
 
-option(ENABLE_CHECK_HEAVY_BUILDS "Don't allow C++ translation units to compile too long or to take too much memory while compiling" OFF)
+# Take care to add prlimit in command line before ccache, or else ccache thinks that
+# prlimit is compiler, and clang++ is its input file, and refuses to work  with
+# multiple inputs, e.g in ccache log:
+# [2021-03-31T18:06:32.655327 36900] Command line: /usr/bin/ccache prlimit --as=10000000000 --data=5000000000 --cpu=600 /usr/bin/clang++-11 - ...... std=gnu++2a -MD -MT src/CMakeFiles/dbms.dir/Storages/MergeTree/IMergeTreeDataPart.cpp.o -MF src/CMakeFiles/dbms.dir/Storages/MergeTree/IMergeTreeDataPart.cpp.o.d -o src/CMakeFiles/dbms.dir/Storages/MergeTree/IMergeTreeDataPart.cpp.o -c ../src/Storages/MergeTree/IMergeTreeDataPart.cpp
+#
+# [2021-03-31T18:06:32.656704 36900] Multiple input files: /usr/bin/clang++-11 and ../src/Storages/MergeTree/IMergeTreeDataPart.cpp
+#
+# Another way would be to use --ccache-skip option before clang++-11 to make
+# ccache ignore it.
+option(ENABLE_CHECK_HEAVY_BUILDS "Don't allow C++ translation units to compile too long or to take too much memory while compiling." OFF)
 if (ENABLE_CHECK_HEAVY_BUILDS)
     # set DATA (since RSS does not work since 2.6.x+) to 2G
     set (RLIMIT_DATA 5000000000)
     # set VIRT (RLIMIT_AS) to 10G (DATA*10)
     set (RLIMIT_AS 10000000000)
+    # set CPU time limit to 600 seconds
+    set (RLIMIT_CPU 600)
+
     # gcc10/gcc10/clang -fsanitize=memory is too heavy
     if (SANITIZE STREQUAL "memory" OR COMPILER_GCC)
        set (RLIMIT_DATA 10000000000)
     endif()
-    set (CMAKE_CXX_COMPILER_LAUNCHER prlimit --as=${RLIMIT_AS} --data=${RLIMIT_DATA} --cpu=600)
+
+    set (CMAKE_CXX_COMPILER_LAUNCHER prlimit --as=${RLIMIT_AS} --data=${RLIMIT_DATA} --cpu=${RLIMIT_CPU} ${CMAKE_CXX_COMPILER_LAUNCHER})
 endif ()
 
 if (NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "None")
@@ -499,6 +512,7 @@ include (cmake/find/fastops.cmake)
 include (cmake/find/odbc.cmake)
 include (cmake/find/rocksdb.cmake)
 include (cmake/find/libpqxx.cmake)
+include (cmake/find/nanodbc.cmake)
 include (cmake/find/nuraft.cmake)
 
 
diff --git a/base/CMakeLists.txt b/base/CMakeLists.txt
index 46bd57eda12..023dcaaccae 100644
--- a/base/CMakeLists.txt
+++ b/base/CMakeLists.txt
@@ -8,6 +8,7 @@ add_subdirectory (loggers)
 add_subdirectory (pcg-random)
 add_subdirectory (widechar_width)
 add_subdirectory (readpassphrase)
+add_subdirectory (bridge)
 
 if (USE_MYSQL)
     add_subdirectory (mysqlxx)
diff --git a/base/bridge/CMakeLists.txt b/base/bridge/CMakeLists.txt
new file mode 100644
index 00000000000..20b0b651677
--- /dev/null
+++ b/base/bridge/CMakeLists.txt
@@ -0,0 +1,7 @@
+add_library (bridge
+    IBridge.cpp
+)
+
+target_include_directories (daemon PUBLIC ..)
+target_link_libraries (bridge PRIVATE daemon dbms Poco::Data Poco::Data::ODBC)
+
diff --git a/base/bridge/IBridge.cpp b/base/bridge/IBridge.cpp
new file mode 100644
index 00000000000..b1f71315fef
--- /dev/null
+++ b/base/bridge/IBridge.cpp
@@ -0,0 +1,238 @@
+#include "IBridge.h"
+
+#include <IO/ReadHelpers.h>
+#include <boost/program_options.hpp>
+#include <Poco/Net/NetException.h>
+#include <Poco/Util/HelpFormatter.h>
+#include <Common/StringUtils/StringUtils.h>
+#include <Formats/registerFormats.h>
+#include <common/logger_useful.h>
+#include <Common/SensitiveDataMasker.h>
+#include <Server/HTTP/HTTPServer.h>
+
+#if USE_ODBC
+#    include <Poco/Data/ODBC/Connector.h>
+#endif
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int ARGUMENT_OUT_OF_BOUND;
+}
+
+namespace
+{
+    Poco::Net::SocketAddress makeSocketAddress(const std::string & host, UInt16 port, Poco::Logger * log)
+    {
+        Poco::Net::SocketAddress socket_address;
+        try
+        {
+            socket_address = Poco::Net::SocketAddress(host, port);
+        }
+        catch (const Poco::Net::DNSException & e)
+        {
+            const auto code = e.code();
+            if (code == EAI_FAMILY
+#if defined(EAI_ADDRFAMILY)
+                || code == EAI_ADDRFAMILY
+#endif
+            )
+            {
+                LOG_ERROR(log, "Cannot resolve listen_host ({}), error {}: {}. If it is an IPv6 address and your host has disabled IPv6, then consider to specify IPv4 address to listen in <listen_host> element of configuration file. Example: <listen_host>0.0.0.0</listen_host>", host, e.code(), e.message());
+            }
+
+            throw;
+        }
+        return socket_address;
+    }
+
+    Poco::Net::SocketAddress socketBindListen(Poco::Net::ServerSocket & socket, const std::string & host, UInt16 port, Poco::Logger * log)
+    {
+        auto address = makeSocketAddress(host, port, log);
+#if POCO_VERSION < 0x01080000
+        socket.bind(address, /* reuseAddress = */ true);
+#else
+        socket.bind(address, /* reuseAddress = */ true, /* reusePort = */ false);
+#endif
+
+        socket.listen(/* backlog = */ 64);
+
+        return address;
+    }
+}
+
+
+void IBridge::handleHelp(const std::string &, const std::string &)
+{
+    Poco::Util::HelpFormatter help_formatter(options());
+    help_formatter.setCommand(commandName());
+    help_formatter.setHeader("HTTP-proxy for odbc requests");
+    help_formatter.setUsage("--http-port <port>");
+    help_formatter.format(std::cerr);
+
+    stopOptionsProcessing();
+}
+
+
+void IBridge::defineOptions(Poco::Util::OptionSet & options)
+{
+    options.addOption(
+        Poco::Util::Option("http-port", "", "port to listen").argument("http-port", true) .binding("http-port"));
+
+    options.addOption(
+        Poco::Util::Option("listen-host", "", "hostname or address to listen, default 127.0.0.1").argument("listen-host").binding("listen-host"));
+
+    options.addOption(
+        Poco::Util::Option("http-timeout", "", "http timeout for socket, default 1800").argument("http-timeout").binding("http-timeout"));
+
+    options.addOption(
+        Poco::Util::Option("max-server-connections", "", "max connections to server, default 1024").argument("max-server-connections").binding("max-server-connections"));
+
+    options.addOption(
+        Poco::Util::Option("keep-alive-timeout", "", "keepalive timeout, default 10").argument("keep-alive-timeout").binding("keep-alive-timeout"));
+
+    options.addOption(
+        Poco::Util::Option("log-level", "", "sets log level, default info") .argument("log-level").binding("logger.level"));
+
+    options.addOption(
+        Poco::Util::Option("log-path", "", "log path for all logs, default console").argument("log-path").binding("logger.log"));
+
+    options.addOption(
+        Poco::Util::Option("err-log-path", "", "err log path for all logs, default no").argument("err-log-path").binding("logger.errorlog"));
+
+    options.addOption(
+        Poco::Util::Option("stdout-path", "", "stdout log path, default console").argument("stdout-path").binding("logger.stdout"));
+
+    options.addOption(
+        Poco::Util::Option("stderr-path", "", "stderr log path, default console").argument("stderr-path").binding("logger.stderr"));
+
+    using Me = std::decay_t<decltype(*this)>;
+
+    options.addOption(
+        Poco::Util::Option("help", "", "produce this help message").binding("help").callback(Poco::Util::OptionCallback<Me>(this, &Me::handleHelp)));
+
+    ServerApplication::defineOptions(options); // NOLINT Don't need complex BaseDaemon's .xml config
+}
+
+
+void IBridge::initialize(Application & self)
+{
+    BaseDaemon::closeFDs();
+    is_help = config().has("help");
+
+    if (is_help)
+        return;
+
+    config().setString("logger", bridgeName());
+
+    /// Redirect stdout, stderr to specified files.
+    /// Some libraries and sanitizers write to stderr in case of errors.
+    const auto stdout_path = config().getString("logger.stdout", "");
+    if (!stdout_path.empty())
+    {
+        if (!freopen(stdout_path.c_str(), "a+", stdout))
+            throw Poco::OpenFileException("Cannot attach stdout to " + stdout_path);
+
+        /// Disable buffering for stdout.
+        setbuf(stdout, nullptr);
+    }
+    const auto stderr_path = config().getString("logger.stderr", "");
+    if (!stderr_path.empty())
+    {
+        if (!freopen(stderr_path.c_str(), "a+", stderr))
+            throw Poco::OpenFileException("Cannot attach stderr to " + stderr_path);
+
+        /// Disable buffering for stderr.
+        setbuf(stderr, nullptr);
+    }
+
+    buildLoggers(config(), logger(), self.commandName());
+
+    BaseDaemon::logRevision();
+
+    log = &logger();
+    hostname = config().getString("listen-host", "127.0.0.1");
+    port = config().getUInt("http-port");
+    if (port > 0xFFFF)
+        throw Exception("Out of range 'http-port': " + std::to_string(port), ErrorCodes::ARGUMENT_OUT_OF_BOUND);
+
+    http_timeout = config().getUInt("http-timeout", DEFAULT_HTTP_READ_BUFFER_TIMEOUT);
+    max_server_connections = config().getUInt("max-server-connections", 1024);
+    keep_alive_timeout = config().getUInt("keep-alive-timeout", 10);
+
+    initializeTerminationAndSignalProcessing();
+
+#if USE_ODBC
+    if (bridgeName() == "ODBCBridge")
+        Poco::Data::ODBC::Connector::registerConnector();
+#endif
+
+    ServerApplication::initialize(self); // NOLINT
+}
+
+
+void IBridge::uninitialize()
+{
+    BaseDaemon::uninitialize();
+}
+
+
+int IBridge::main(const std::vector<std::string> & /*args*/)
+{
+    if (is_help)
+        return Application::EXIT_OK;
+
+    registerFormats();
+    LOG_INFO(log, "Starting up {} on host: {}, port: {}", bridgeName(), hostname, port);
+
+    Poco::Net::ServerSocket socket;
+    auto address = socketBindListen(socket, hostname, port, log);
+    socket.setReceiveTimeout(http_timeout);
+    socket.setSendTimeout(http_timeout);
+
+    Poco::ThreadPool server_pool(3, max_server_connections);
+
+    Poco::Net::HTTPServerParams::Ptr http_params = new Poco::Net::HTTPServerParams;
+    http_params->setTimeout(http_timeout);
+    http_params->setKeepAliveTimeout(keep_alive_timeout);
+
+    auto shared_context = Context::createShared();
+    auto context = Context::createGlobal(shared_context.get());
+    context->makeGlobalContext();
+
+    if (config().has("query_masking_rules"))
+        SensitiveDataMasker::setInstance(std::make_unique<SensitiveDataMasker>(config(), "query_masking_rules"));
+
+    auto server = HTTPServer(
+        context,
+        getHandlerFactoryPtr(context),
+        server_pool,
+        socket,
+        http_params);
+
+    SCOPE_EXIT({
+        LOG_DEBUG(log, "Received termination signal.");
+        LOG_DEBUG(log, "Waiting for current connections to close.");
+
+        server.stop();
+
+        for (size_t count : ext::range(1, 6))
+        {
+            if (server.currentConnections() == 0)
+                break;
+            LOG_DEBUG(log, "Waiting for {} connections, try {}", server.currentConnections(), count);
+            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+        }
+    });
+
+    server.start();
+    LOG_INFO(log, "Listening http://{}", address.toString());
+
+    waitForTerminationRequest();
+    return Application::EXIT_OK;
+}
+
+}
diff --git a/base/bridge/IBridge.h b/base/bridge/IBridge.h
new file mode 100644
index 00000000000..c64003d9959
--- /dev/null
+++ b/base/bridge/IBridge.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <Interpreters/Context.h>
+#include <Server/HTTP/HTTPRequestHandlerFactory.h>
+#include <daemon/BaseDaemon.h>
+
+#include <Poco/Logger.h>
+#include <Poco/Util/ServerApplication.h>
+
+
+namespace DB
+{
+
+/// Class represents base for clickhouse-odbc-bridge and clickhouse-library-bridge servers.
+/// Listens to incoming HTTP POST and GET requests on specified port and host.
+/// Has two handlers '/' for all incoming POST requests and /ping for GET request about service status.
+class IBridge : public BaseDaemon
+{
+
+public:
+    /// Define command line arguments
+    void defineOptions(Poco::Util::OptionSet & options) override;
+
+protected:
+    using HandlerFactoryPtr = std::shared_ptr<HTTPRequestHandlerFactory>;
+
+    void initialize(Application & self) override;
+
+    void uninitialize() override;
+
+    int main(const std::vector<std::string> & args) override;
+
+    virtual std::string bridgeName() const = 0;
+
+    virtual HandlerFactoryPtr getHandlerFactoryPtr(ContextPtr context) const = 0;
+
+    size_t keep_alive_timeout;
+
+private:
+    void handleHelp(const std::string &, const std::string &);
+
+    bool is_help;
+    std::string hostname;
+    size_t port;
+    std::string log_level;
+    size_t max_server_connections;
+    size_t http_timeout;
+
+    Poco::Logger * log;
+};
+}
diff --git a/base/daemon/SentryWriter.cpp b/base/daemon/SentryWriter.cpp
index 29430b65983..1b7d0064b99 100644
--- a/base/daemon/SentryWriter.cpp
+++ b/base/daemon/SentryWriter.cpp
@@ -9,6 +9,7 @@
 #include <common/getMemoryAmount.h>
 #include <common/logger_useful.h>
 
+#include <Common/formatReadable.h>
 #include <Common/SymbolIndex.h>
 #include <Common/StackTrace.h>
 #include <Common/getNumberOfPhysicalCPUCores.h>
diff --git a/base/ext/scope_guard_safe.h b/base/ext/scope_guard_safe.h
new file mode 100644
index 00000000000..7cfb3959a81
--- /dev/null
+++ b/base/ext/scope_guard_safe.h
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <ext/scope_guard.h>
+#include <common/logger_useful.h>
+#include <Common/MemoryTracker.h>
+
+/// Same as SCOPE_EXIT() but block the MEMORY_LIMIT_EXCEEDED errors.
+///
+/// Typical example of SCOPE_EXIT_MEMORY() usage is when code under it may do
+/// some tiny allocations, that may fail under high memory pressure or/and low
+/// max_memory_usage (and related limits).
+///
+/// NOTE: it should be used with caution.
+#define SCOPE_EXIT_MEMORY(...) SCOPE_EXIT(                    \
+    MemoryTracker::LockExceptionInThread lock_memory_tracker; \
+    __VA_ARGS__;                                              \
+)
+
+/// Same as SCOPE_EXIT() but try/catch/tryLogCurrentException any exceptions.
+///
+/// SCOPE_EXIT_SAFE() should be used in case the exception during the code
+/// under SCOPE_EXIT() is not "that fatal" and error message in log is enough.
+///
+/// Good example is calling CurrentThread::detachQueryIfNotDetached().
+///
+/// Anti-pattern is calling WriteBuffer::finalize() under SCOPE_EXIT_SAFE()
+/// (since finalize() can do final write and it is better to fail abnormally
+/// instead of ignoring write error).
+///
+/// NOTE: it should be used with double caution.
+#define SCOPE_EXIT_SAFE(...) SCOPE_EXIT(             \
+    try                                              \
+    {                                                \
+        __VA_ARGS__;                                 \
+    }                                                \
+    catch (...)                                      \
+    {                                                \
+        tryLogCurrentException(__PRETTY_FUNCTION__); \
+    }                                                \
+)
+
+/// Same as SCOPE_EXIT() but:
+/// - block the MEMORY_LIMIT_EXCEEDED errors,
+/// - try/catch/tryLogCurrentException any exceptions.
+///
+/// SCOPE_EXIT_MEMORY_SAFE() can be used when the error can be ignored, and in
+/// addition to SCOPE_EXIT_SAFE() it will also lock MEMORY_LIMIT_EXCEEDED to
+/// avoid such exceptions.
+///
+/// It does exists as a separate helper, since you do not need to lock
+/// MEMORY_LIMIT_EXCEEDED always (there are cases when code under SCOPE_EXIT does
+/// not do any allocations, while LockExceptionInThread increment atomic
+/// variable).
+///
+/// NOTE: it should be used with triple caution.
+#define SCOPE_EXIT_MEMORY_SAFE(...) SCOPE_EXIT(                   \
+    try                                                           \
+    {                                                             \
+        MemoryTracker::LockExceptionInThread lock_memory_tracker; \
+        __VA_ARGS__;                                              \
+    }                                                             \
+    catch (...)                                                   \
+    {                                                             \
+        tryLogCurrentException(__PRETTY_FUNCTION__);              \
+    }                                                             \
+)
diff --git a/base/mysqlxx/PoolWithFailover.cpp b/base/mysqlxx/PoolWithFailover.cpp
index 5e9f70f4ac1..ea2d060e596 100644
--- a/base/mysqlxx/PoolWithFailover.cpp
+++ b/base/mysqlxx/PoolWithFailover.cpp
@@ -2,7 +2,6 @@
 #include <ctime>
 #include <random>
 #include <thread>
-
 #include <mysqlxx/PoolWithFailover.h>
 
 
@@ -15,9 +14,12 @@ static bool startsWith(const std::string & s, const char * prefix)
 
 using namespace mysqlxx;
 
-PoolWithFailover::PoolWithFailover(const Poco::Util::AbstractConfiguration & config_,
-                                   const std::string & config_name_, const unsigned default_connections_,
-                                   const unsigned max_connections_, const size_t max_tries_)
+PoolWithFailover::PoolWithFailover(
+        const Poco::Util::AbstractConfiguration & config_,
+        const std::string & config_name_,
+        const unsigned default_connections_,
+        const unsigned max_connections_,
+        const size_t max_tries_)
     : max_tries(max_tries_)
 {
     shareable = config_.getBool(config_name_ + ".share_connection", false);
@@ -59,16 +61,38 @@ PoolWithFailover::PoolWithFailover(const Poco::Util::AbstractConfiguration & con
     }
 }
 
-PoolWithFailover::PoolWithFailover(const std::string & config_name_, const unsigned default_connections_,
-    const unsigned max_connections_, const size_t max_tries_)
-    : PoolWithFailover{
-        Poco::Util::Application::instance().config(), config_name_,
-        default_connections_, max_connections_, max_tries_}
+
+PoolWithFailover::PoolWithFailover(
+        const std::string & config_name_,
+        const unsigned default_connections_,
+        const unsigned max_connections_,
+        const size_t max_tries_)
+    : PoolWithFailover{Poco::Util::Application::instance().config(),
+            config_name_, default_connections_, max_connections_, max_tries_}
 {
 }
 
+
+PoolWithFailover::PoolWithFailover(
+        const std::string & database,
+        const RemoteDescription & addresses,
+        const std::string & user,
+        const std::string & password,
+        size_t max_tries_)
+    : max_tries(max_tries_)
+    , shareable(false)
+{
+    /// Replicas have the same priority, but traversed replicas are moved to the end of the queue.
+    for (const auto & [host, port] : addresses)
+    {
+        replicas_by_priority[0].emplace_back(std::make_shared<Pool>(database, host, user, password, port));
+    }
+}
+
+
 PoolWithFailover::PoolWithFailover(const PoolWithFailover & other)
-    : max_tries{other.max_tries}, shareable{other.shareable}
+    : max_tries{other.max_tries}
+    , shareable{other.shareable}
 {
     if (shareable)
     {
diff --git a/base/mysqlxx/PoolWithFailover.h b/base/mysqlxx/PoolWithFailover.h
index 029fc3ebad3..5154fc3e253 100644
--- a/base/mysqlxx/PoolWithFailover.h
+++ b/base/mysqlxx/PoolWithFailover.h
@@ -11,6 +11,8 @@
 namespace mysqlxx
 {
     /** MySQL connection pool with support of failover.
+      *
+      * For dictionary source:
       * Have information about replicas and their priorities.
       * Tries to connect to replica in an order of priority. When equal priority, choose replica with maximum time without connections.
       *
@@ -68,42 +70,58 @@ namespace mysqlxx
         using PoolPtr = std::shared_ptr<Pool>;
         using Replicas = std::vector<PoolPtr>;
 
-        /// [priority][index] -> replica.
+        /// [priority][index] -> replica. Highest priority is 0.
         using ReplicasByPriority = std::map<int, Replicas>;
-
         ReplicasByPriority replicas_by_priority;
 
         /// Number of connection tries.
         size_t max_tries;
         /// Mutex for set of replicas.
         std::mutex mutex;
-
         /// Can the Pool be shared
         bool shareable;
 
     public:
         using Entry = Pool::Entry;
+        using RemoteDescription = std::vector<std::pair<std::string, uint16_t>>;
 
         /**
-         * config_name           Name of parameter in configuration file.
+         * * Mysql dictionary sourse related params:
+         * config_name           Name of parameter in configuration file for dictionary source.
+         *
+         * * Mysql storage related parameters:
+         * replicas_description
+         *
+         * * Mutual parameters:
          * default_connections   Number of connection in pool to each replica at start.
          * max_connections       Maximum number of connections in pool to each replica.
          * max_tries_            Max number of connection tries.
          */
-        PoolWithFailover(const std::string & config_name_,
+        PoolWithFailover(
+            const std::string & config_name_,
             unsigned default_connections_ = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_START_CONNECTIONS,
             unsigned max_connections_ = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_MAX_CONNECTIONS,
             size_t max_tries_ = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES);
 
-        PoolWithFailover(const Poco::Util::AbstractConfiguration & config_,
+        PoolWithFailover(
+            const Poco::Util::AbstractConfiguration & config_,
             const std::string & config_name_,
             unsigned default_connections_ = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_START_CONNECTIONS,
             unsigned max_connections_ = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_MAX_CONNECTIONS,
             size_t max_tries_ = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES);
 
+        PoolWithFailover(
+            const std::string & database,
+            const RemoteDescription & addresses,
+            const std::string & user,
+            const std::string & password,
+            size_t max_tries_ = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES);
+
         PoolWithFailover(const PoolWithFailover & other);
 
         /** Allocates a connection to use. */
         Entry get();
     };
+
+    using PoolWithFailoverPtr = std::shared_ptr<PoolWithFailover>;
 }
diff --git a/cmake/darwin/default_libs.cmake b/cmake/darwin/default_libs.cmake
index 79ac675f234..6c298106c6b 100644
--- a/cmake/darwin/default_libs.cmake
+++ b/cmake/darwin/default_libs.cmake
@@ -1,11 +1,11 @@
 set (DEFAULT_LIBS "-nodefaultlibs")
 
-if (NOT COMPILER_CLANG)
-    message (FATAL_ERROR "Darwin build is supported only for Clang")
-endif ()
-
 set (DEFAULT_LIBS "${DEFAULT_LIBS} ${COVERAGE_OPTION} -lc -lm -lpthread -ldl")
 
+if (COMPILER_GCC)
+    set (DEFAULT_LIBS "${DEFAULT_LIBS} -lgcc_eh")
+endif ()
+
 message(STATUS "Default libraries: ${DEFAULT_LIBS}")
 
 set(CMAKE_CXX_STANDARD_LIBRARIES ${DEFAULT_LIBS})
diff --git a/cmake/find/amqpcpp.cmake b/cmake/find/amqpcpp.cmake
index 4191dce26bb..e3eaaf33ddb 100644
--- a/cmake/find/amqpcpp.cmake
+++ b/cmake/find/amqpcpp.cmake
@@ -1,3 +1,8 @@
+if (OS_DARWIN AND COMPILER_GCC)
+    # AMQP-CPP requires libuv which cannot be built with GCC in macOS due to a bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93082
+    set (ENABLE_AMQPCPP OFF CACHE INTERNAL "")
+endif()
+
 option(ENABLE_AMQPCPP "Enalbe AMQP-CPP" ${ENABLE_LIBRARIES})
 
 if (NOT ENABLE_AMQPCPP)
diff --git a/cmake/find/cassandra.cmake b/cmake/find/cassandra.cmake
index 037d6c3f131..ded25a5bf41 100644
--- a/cmake/find/cassandra.cmake
+++ b/cmake/find/cassandra.cmake
@@ -1,3 +1,8 @@
+if (OS_DARWIN AND COMPILER_GCC)
+    # Cassandra requires libuv which cannot be built with GCC in macOS due to a bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93082
+    set (ENABLE_CASSANDRA OFF CACHE INTERNAL "")
+endif()
+
 option(ENABLE_CASSANDRA "Enable Cassandra" ${ENABLE_LIBRARIES})
 
 if (NOT ENABLE_CASSANDRA)
diff --git a/cmake/find/ccache.cmake b/cmake/find/ccache.cmake
index fea1f8b4c97..986c9cb5fe2 100644
--- a/cmake/find/ccache.cmake
+++ b/cmake/find/ccache.cmake
@@ -32,7 +32,9 @@ if (CCACHE_FOUND AND NOT COMPILER_MATCHES_CCACHE)
    if (CCACHE_VERSION VERSION_GREATER "3.2.0" OR NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
       message(STATUS "Using ${CCACHE_FOUND} ${CCACHE_VERSION}")
 
-      set_property (GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_FOUND})
+      set (CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_FOUND} ${CMAKE_CXX_COMPILER_LAUNCHER})
+      set (CMAKE_C_COMPILER_LAUNCHER ${CCACHE_FOUND} ${CMAKE_C_COMPILER_LAUNCHER})
+
       set_property (GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE_FOUND})
 
       # debian (debhelpers) set SOURCE_DATE_EPOCH environment variable, that is
diff --git a/cmake/find/nanodbc.cmake b/cmake/find/nanodbc.cmake
new file mode 100644
index 00000000000..2c913abb13e
--- /dev/null
+++ b/cmake/find/nanodbc.cmake
@@ -0,0 +1,35 @@
+option(ENABLE_NANODBC "Enalbe nanodbc" ${ENABLE_LIBRARIES})
+
+if (NOT ENABLE_NANODBC)
+    set (USE_ODBC 0)
+    return()
+endif()
+
+if (NOT ENABLE_ODBC)
+    set (USE_NANODBC 0)
+    message (STATUS "Using nanodbc=${USE_NANODBC}")
+    return()
+endif()
+
+if (NOT EXISTS "${ClickHouse_SOURCE_DIR}/contrib/nanodbc/CMakeLists.txt")
+    message (WARNING "submodule contrib/nanodbc is missing. to fix try run: \n git submodule update --init --recursive")
+    message (${RECONFIGURE_MESSAGE_LEVEL} "Can't find internal nanodbc library")
+    set (USE_NANODBC 0)
+    return()
+endif()
+
+if (NOT EXISTS "${ClickHouse_SOURCE_DIR}/contrib/unixodbc/include")
+    message (ERROR "submodule contrib/unixodbc is missing. to fix try run: \n git submodule update --init --recursive")
+    message (${RECONFIGURE_MESSAGE_LEVEL} "Can't find internal unixodbc needed for nanodbc")
+    set (USE_NANODBC 0)
+    return()
+endif()
+
+set (USE_NANODBC 1)
+
+set (NANODBC_LIBRARY nanodbc)
+
+set (NANODBC_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/nanodbc/nanodbce")
+
+message (STATUS "Using nanodbc=${USE_NANODBC}: ${NANODBC_INCLUDE_DIR} : ${NANODBC_LIBRARY}")
+message (STATUS "Using unixodbc")
diff --git a/cmake/find/nuraft.cmake b/cmake/find/nuraft.cmake
index 7fa5251946e..4e5258e132f 100644
--- a/cmake/find/nuraft.cmake
+++ b/cmake/find/nuraft.cmake
@@ -11,7 +11,7 @@ if (NOT EXISTS "${ClickHouse_SOURCE_DIR}/contrib/NuRaft/CMakeLists.txt")
     return()
 endif ()
 
-if (NOT OS_FREEBSD AND NOT OS_DARWIN)
+if (NOT OS_FREEBSD)
     set (USE_NURAFT 1)
     set (NURAFT_LIBRARY nuraft)
 
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index 4aeb67a5085..d05177739fe 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -47,7 +47,10 @@ add_subdirectory (lz4-cmake)
 add_subdirectory (murmurhash)
 add_subdirectory (replxx-cmake)
 add_subdirectory (unixodbc-cmake)
-add_subdirectory (xz)
+
+if (USE_INTERNAL_XZ_LIBRARY)
+    add_subdirectory (xz)
+endif()
 
 add_subdirectory (poco-cmake)
 add_subdirectory (croaring-cmake)
@@ -323,6 +326,10 @@ if (USE_LIBPQXX)
     add_subdirectory (libpqxx-cmake)
 endif()
 
+if (USE_NANODBC)
+    add_subdirectory (nanodbc-cmake)
+endif()
+
 if (USE_NURAFT)
   add_subdirectory(nuraft-cmake)
 endif()
diff --git a/contrib/NuRaft b/contrib/NuRaft
index 241fd3754a1..d2feb5978b9 160000
--- a/contrib/NuRaft
+++ b/contrib/NuRaft
@@ -1 +1 @@
-Subproject commit 241fd3754a1eb4d82ab68a9a875dc99391ec9f02
+Subproject commit d2feb5978b979729a07c3ca76eaa4ab94cef4ceb
diff --git a/contrib/antlr4-runtime b/contrib/antlr4-runtime
index a2fa7b76e2e..672643e9a42 160000
--- a/contrib/antlr4-runtime
+++ b/contrib/antlr4-runtime
@@ -1 +1 @@
-Subproject commit a2fa7b76e2ee16d2ad955e9214a90bbf79da66fc
+Subproject commit 672643e9a427ef803abf13bc8cb4989606553d64
diff --git a/contrib/boringssl b/contrib/boringssl
index fd9ce1a0406..83c1cda8a02 160000
--- a/contrib/boringssl
+++ b/contrib/boringssl
@@ -1 +1 @@
-Subproject commit fd9ce1a0406f571507068b9555d0b545b8a18332
+Subproject commit 83c1cda8a0224dc817cbad2966c7ed4acc35f02a
diff --git a/contrib/boringssl-cmake/CMakeLists.txt b/contrib/boringssl-cmake/CMakeLists.txt
index 017a8a64c0e..adfee82dda4 100644
--- a/contrib/boringssl-cmake/CMakeLists.txt
+++ b/contrib/boringssl-cmake/CMakeLists.txt
@@ -16,7 +16,7 @@ endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX OR CLANG)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fvisibility=hidden -fno-common -fno-exceptions -fno-rtti")
-  if(APPLE)
+  if(APPLE AND CLANG)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
   endif()
 
diff --git a/contrib/flatbuffers b/contrib/flatbuffers
index 6df40a24717..22e3ffc66d2 160000
--- a/contrib/flatbuffers
+++ b/contrib/flatbuffers
@@ -1 +1 @@
-Subproject commit 6df40a2471737b27271bdd9b900ab5f3aec746c7
+Subproject commit 22e3ffc66d2d7d72d1414390aa0f04ffd114a5a1
diff --git a/contrib/jemalloc-cmake/CMakeLists.txt b/contrib/jemalloc-cmake/CMakeLists.txt
index 73afa99f1d8..b174d4d361e 100644
--- a/contrib/jemalloc-cmake/CMakeLists.txt
+++ b/contrib/jemalloc-cmake/CMakeLists.txt
@@ -121,12 +121,14 @@ target_include_directories(jemalloc SYSTEM PRIVATE
 target_compile_definitions(jemalloc PRIVATE -DJEMALLOC_NO_PRIVATE_NAMESPACE)
 
 if (CMAKE_BUILD_TYPE_UC STREQUAL "DEBUG")
-    target_compile_definitions(jemalloc PRIVATE -DJEMALLOC_DEBUG=1 -DJEMALLOC_PROF=1)
+    target_compile_definitions(jemalloc PRIVATE -DJEMALLOC_DEBUG=1)
+endif ()
 
-    if (USE_UNWIND)
-        target_compile_definitions (jemalloc PRIVATE -DJEMALLOC_PROF_LIBUNWIND=1)
-        target_link_libraries (jemalloc PRIVATE unwind)
-    endif ()
+target_compile_definitions(jemalloc PRIVATE -DJEMALLOC_PROF=1)
+
+if (USE_UNWIND)
+    target_compile_definitions (jemalloc PRIVATE -DJEMALLOC_PROF_LIBUNWIND=1)
+    target_link_libraries (jemalloc PRIVATE unwind)
 endif ()
 
 target_compile_options(jemalloc PRIVATE -Wno-redundant-decls)
diff --git a/contrib/libcxx b/contrib/libcxx
index 8b80a151d12..2fa892f69ac 160000
--- a/contrib/libcxx
+++ b/contrib/libcxx
@@ -1 +1 @@
-Subproject commit 8b80a151d12b98ffe2d0c22f7cec12c3b9ff88d7
+Subproject commit 2fa892f69acbaa40f8a18c6484854a6183a34482
diff --git a/contrib/libcxx-cmake/CMakeLists.txt b/contrib/libcxx-cmake/CMakeLists.txt
index 3b5d53cd1c0..59d23b2cd9e 100644
--- a/contrib/libcxx-cmake/CMakeLists.txt
+++ b/contrib/libcxx-cmake/CMakeLists.txt
@@ -56,6 +56,11 @@ if (USE_UNWIND)
     target_compile_definitions(cxx PUBLIC -DSTD_EXCEPTION_HAS_STACK_TRACE=1)
 endif ()
 
+# Override the deduced attribute support that causes error.
+if (OS_DARWIN AND COMPILER_GCC)
+    add_compile_definitions(_LIBCPP_INIT_PRIORITY_MAX)
+endif ()
+
 target_compile_options(cxx PUBLIC $<$<COMPILE_LANGUAGE:CXX>:-nostdinc++>)
 
 # Third party library may have substandard code.
diff --git a/contrib/librdkafka-cmake/config.h.in b/contrib/librdkafka-cmake/config.h.in
index 80b6ea61b6e..b3450c40a60 100644
--- a/contrib/librdkafka-cmake/config.h.in
+++ b/contrib/librdkafka-cmake/config.h.in
@@ -75,6 +75,8 @@
 #define HAVE_STRNDUP 1
 // strerror_r
 #define HAVE_STRERROR_R 1
+// rand_r
+#define HAVE_RAND_R 1
 
 #ifdef __APPLE__
 // pthread_setname_np
diff --git a/contrib/mariadb-connector-c b/contrib/mariadb-connector-c
index f4476ee7311..5f4034a3a63 160000
--- a/contrib/mariadb-connector-c
+++ b/contrib/mariadb-connector-c
@@ -1 +1 @@
-Subproject commit f4476ee7311b35b593750f6ae2cbdb62a4006374
+Subproject commit 5f4034a3a6376416504f17186c55fe401c6d8e5e
diff --git a/contrib/nanodbc b/contrib/nanodbc
new file mode 160000
index 00000000000..9fc45967551
--- /dev/null
+++ b/contrib/nanodbc
@@ -0,0 +1 @@
+Subproject commit 9fc459675515d491401727ec67fca38db721f28c
diff --git a/contrib/nanodbc-cmake/CMakeLists.txt b/contrib/nanodbc-cmake/CMakeLists.txt
new file mode 100644
index 00000000000..5de46d52a61
--- /dev/null
+++ b/contrib/nanodbc-cmake/CMakeLists.txt
@@ -0,0 +1,14 @@
+set (LIBRARY_DIR ${ClickHouse_SOURCE_DIR}/contrib/nanodbc)
+
+if (NOT TARGET unixodbc)
+    message(FATAL_ERROR "Configuration error: unixodbc is not a target")
+endif()
+
+set (SRCS
+    ${LIBRARY_DIR}/nanodbc/nanodbc.cpp
+)
+
+add_library(nanodbc ${SRCS})
+
+target_link_libraries (nanodbc PUBLIC unixodbc)
+target_include_directories (nanodbc SYSTEM PUBLIC ${LIBRARY_DIR}/)
diff --git a/debian/clickhouse-common-static.install b/debian/clickhouse-common-static.install
index 17c955a12a9..bd65f17ad42 100644
--- a/debian/clickhouse-common-static.install
+++ b/debian/clickhouse-common-static.install
@@ -1,5 +1,6 @@
 usr/bin/clickhouse
 usr/bin/clickhouse-odbc-bridge
+usr/bin/clickhouse-library-bridge
 usr/bin/clickhouse-extract-from-config
 usr/share/bash-completion/completions
 etc/security/limits.d/clickhouse.conf
diff --git a/docker/packager/binary/Dockerfile b/docker/packager/binary/Dockerfile
index 94c7f934f6e..6948aeb3b18 100644
--- a/docker/packager/binary/Dockerfile
+++ b/docker/packager/binary/Dockerfile
@@ -35,35 +35,38 @@ RUN apt-get update \
 RUN apt-get update \
     && apt-get install \
         bash \
-        cmake \
+        build-essential \
         ccache \
-        curl \
-        gcc-9 \
-        g++-9 \
         clang-10 \
-        clang-tidy-10 \
-        lld-10 \
-        llvm-10 \
-        llvm-10-dev \
         clang-11 \
+        clang-tidy-10 \
         clang-tidy-11 \
-        lld-11 \
-        llvm-11 \
-        llvm-11-dev \
+        cmake \
+        cmake \
+        curl \
+        g++-9 \
+        gcc-9 \
+        gdb \
+        git \
+        gperf \
+        gperf \
+        intel-opencl-icd \
         libicu-dev \
         libreadline-dev \
+        lld-10 \
+        lld-11 \
+        llvm-10 \
+        llvm-10-dev \
+        llvm-11 \
+        llvm-11-dev \
+        moreutils \
         ninja-build \
-        gperf \
-        git \
-        opencl-headers \
         ocl-icd-libopencl1 \
-        intel-opencl-icd \
-        tzdata \
-        gperf \
-        cmake \
-        gdb \
+        opencl-headers \
+        pigz \
+        pixz \
         rename \
-        build-essential \
+        tzdata \
         --yes --no-install-recommends
 
 # This symlink required by gcc to find lld compiler
@@ -111,4 +114,4 @@ RUN rm /etc/apt/sources.list.d/proposed-repositories.list && apt-get update
 
 
 COPY build.sh /
-CMD ["/bin/bash", "/build.sh"]
+CMD ["bash", "-c", "/build.sh 2>&1 | ts"]
diff --git a/docker/packager/binary/build.sh b/docker/packager/binary/build.sh
index a42789c6186..cf74105fbbb 100755
--- a/docker/packager/binary/build.sh
+++ b/docker/packager/binary/build.sh
@@ -11,17 +11,28 @@ tar xJf gcc-arm-8.3-2019.03-x86_64-aarch64-linux-gnu.tar.xz -C build/cmake/toolc
 mkdir -p build/cmake/toolchain/freebsd-x86_64
 tar xJf freebsd-11.3-toolchain.tar.xz -C build/cmake/toolchain/freebsd-x86_64 --strip-components=1
 
+# Uncomment to debug ccache. Don't put ccache log in /output right away, or it
+# will be confusingly packed into the "performance" package.
+# export CCACHE_LOGFILE=/build/ccache.log
+# export CCACHE_DEBUG=1
+
 mkdir -p build/build_docker
 cd build/build_docker
-ccache --show-stats ||:
-ccache --zero-stats ||:
-ln -s /usr/lib/x86_64-linux-gnu/libOpenCL.so.1.0.0 /usr/lib/libOpenCL.so ||:
 rm -f CMakeCache.txt
 # Read cmake arguments into array (possibly empty)
 read -ra CMAKE_FLAGS <<< "${CMAKE_FLAGS:-}"
 cmake --debug-trycompile --verbose=1 -DCMAKE_VERBOSE_MAKEFILE=1 -LA "-DCMAKE_BUILD_TYPE=$BUILD_TYPE" "-DSANITIZE=$SANITIZER" -DENABLE_CHECK_HEAVY_BUILDS=1 "${CMAKE_FLAGS[@]}" ..
+
+ccache --show-config ||:
+ccache --show-stats ||:
+ccache --zero-stats ||:
+
 # shellcheck disable=SC2086 # No quotes because I want it to expand to nothing if empty.
 ninja $NINJA_FLAGS clickhouse-bundle
+
+ccache --show-config ||:
+ccache --show-stats ||:
+
 mv ./programs/clickhouse* /output
 mv ./src/unit_tests_dbms /output ||: # may not exist for some binary builds
 find . -name '*.so' -print -exec mv '{}' /output \;
@@ -65,8 +76,21 @@ then
     cp ../programs/server/config.xml /output/config
     cp ../programs/server/users.xml /output/config
     cp -r --dereference ../programs/server/config.d /output/config
-    tar -czvf "$COMBINED_OUTPUT.tgz" /output
+    tar -cv -I pigz -f "$COMBINED_OUTPUT.tgz" /output
     rm -r /output/*
     mv "$COMBINED_OUTPUT.tgz" /output
 fi
-ccache --show-stats ||:
+
+if [ "${CCACHE_DEBUG:-}" == "1" ]
+then
+    find . -name '*.ccache-*' -print0 \
+        | tar -c -I pixz -f /output/ccache-debug.txz --null -T -
+fi
+
+if [ -n "$CCACHE_LOGFILE" ]
+then
+    # Compress the log as well, or else the CI will try to compress all log
+    # files in place, and will fail because this directory is not writable.
+    tar -cv -I pixz -f /output/ccache.log.txz "$CCACHE_LOGFILE"
+fi
+
diff --git a/docker/packager/deb/Dockerfile b/docker/packager/deb/Dockerfile
index 8fd89d60f85..902929a2644 100644
--- a/docker/packager/deb/Dockerfile
+++ b/docker/packager/deb/Dockerfile
@@ -34,31 +34,32 @@ RUN curl -O https://clickhouse-builds.s3.yandex.net/utils/1/dpkg-deb \
 # Libraries from OS are only needed to test the "unbundled" build (this is not used in production).
 RUN apt-get update \
     && apt-get install \
-        gcc-9 \
-        g++-9 \
-        clang-11 \
-        clang-tidy-11 \
-        lld-11 \
-        llvm-11 \
-        llvm-11-dev \
+        alien \
         clang-10 \
+        clang-11 \
         clang-tidy-10 \
+        clang-tidy-11 \
+        cmake \
+        debhelper \
+        devscripts \
+        g++-9 \
+        gcc-9 \
+        gdb  \
+        git \
+        gperf \
         lld-10 \
+        lld-11 \
         llvm-10 \
         llvm-10-dev \
+        llvm-11 \
+        llvm-11-dev \
+        moreutils \
         ninja-build \
         perl \
-        pkg-config \
-        devscripts \
-        debhelper \
-        git \
-        tzdata \
-        gperf \
-        alien \
-        cmake \
-        gdb  \
-        moreutils \
         pigz \
+        pixz \
+        pkg-config \
+        tzdata \
         --yes --no-install-recommends
 
 # NOTE: For some reason we have outdated version of gcc-10 in ubuntu 20.04 stable.
diff --git a/docker/packager/deb/build.sh b/docker/packager/deb/build.sh
index 6450e21d289..c1a0b27db5d 100755
--- a/docker/packager/deb/build.sh
+++ b/docker/packager/deb/build.sh
@@ -2,8 +2,14 @@
 
 set -x -e
 
+# Uncomment to debug ccache.
+# export CCACHE_LOGFILE=/build/ccache.log
+# export CCACHE_DEBUG=1
+
+ccache --show-config ||:
 ccache --show-stats ||:
 ccache --zero-stats ||:
+
 read -ra ALIEN_PKGS <<< "${ALIEN_PKGS:-}"
 build/release --no-pbuilder "${ALIEN_PKGS[@]}" | ts '%Y-%m-%d %H:%M:%S'
 mv /*.deb /output
@@ -22,5 +28,19 @@ then
     mv /build/obj-*/src/unit_tests_dbms /output/binary
   fi
 fi
+
+ccache --show-config ||:
 ccache --show-stats ||:
-ln -s /usr/lib/x86_64-linux-gnu/libOpenCL.so.1.0.0 /usr/lib/libOpenCL.so ||:
+
+if [ "${CCACHE_DEBUG:-}" == "1" ]
+then
+    find /build -name '*.ccache-*' -print0 \
+        | tar -c -I pixz -f /output/ccache-debug.txz --null -T -
+fi
+
+if [ -n "$CCACHE_LOGFILE" ]
+then
+    # Compress the log as well, or else the CI will try to compress all log
+    # files in place, and will fail because this directory is not writable.
+    tar -cv -I pixz -f /output/ccache.log.txz "$CCACHE_LOGFILE"
+fi
diff --git a/docker/packager/unbundled/build.sh b/docker/packager/unbundled/build.sh
index 54575ab977c..99fc34fd9f3 100755
--- a/docker/packager/unbundled/build.sh
+++ b/docker/packager/unbundled/build.sh
@@ -13,4 +13,3 @@ mv /*.rpm /output ||: # if exists
 mv /*.tgz /output ||: # if exists
 
 ccache --show-stats ||:
-ln -s /usr/lib/x86_64-linux-gnu/libOpenCL.so.1.0.0 /usr/lib/libOpenCL.so ||:
diff --git a/docker/test/fasttest/run.sh b/docker/test/fasttest/run.sh
index c53bf65aa68..033c03e6281 100755
--- a/docker/test/fasttest/run.sh
+++ b/docker/test/fasttest/run.sh
@@ -300,6 +300,7 @@ function run_tests
         01663_aes_msan                          # Depends on OpenSSL
         01667_aes_args_check                    # Depends on OpenSSL
         01776_decrypt_aead_size_check           # Depends on OpenSSL
+        01811_filter_by_null                    # Depends on OpenSSL
         01281_unsucceeded_insert_select_queries_counter
         01292_create_user
         01294_lazy_database_concurrent
diff --git a/docker/test/fuzzer/run-fuzzer.sh b/docker/test/fuzzer/run-fuzzer.sh
index 4bd3fa717a2..626bedb453c 100755
--- a/docker/test/fuzzer/run-fuzzer.sh
+++ b/docker/test/fuzzer/run-fuzzer.sh
@@ -198,7 +198,7 @@ case "$stage" in
         # Lost connection to the server. This probably means that the server died
         # with abort.
         echo "failure" > status.txt
-        if ! grep -ao "Received signal.*\|Logical error.*\|Assertion.*failed\|Failed assertion.*\|.*runtime error: .*\|.*is located.*\|SUMMARY: MemorySanitizer:.*\|SUMMARY: ThreadSanitizer:.*\|.*_LIBCPP_ASSERT.*" server.log > description.txt
+        if ! grep -ao "Received signal.*\|Logical error.*\|Assertion.*failed\|Failed assertion.*\|.*runtime error: .*\|.*is located.*\|SUMMARY: AddressSanitizer:.*\|SUMMARY: MemorySanitizer:.*\|SUMMARY: ThreadSanitizer:.*\|.*_LIBCPP_ASSERT.*" server.log > description.txt
         then
             echo "Lost connection to server. See the logs." > description.txt
         fi
diff --git a/docker/test/integration/base/Dockerfile b/docker/test/integration/base/Dockerfile
index 938d8d45ffd..1c962f1bf8f 100644
--- a/docker/test/integration/base/Dockerfile
+++ b/docker/test/integration/base/Dockerfile
@@ -19,7 +19,8 @@ RUN apt-get update \
         tar \
         krb5-user \
         iproute2 \
-        lsof
+        lsof \
+        g++
 RUN rm -rf \
         /var/lib/apt/lists/* \
         /var/cache/debconf \
diff --git a/docker/test/integration/runner/Dockerfile b/docker/test/integration/runner/Dockerfile
index e0e5e36a3d6..783e689ed01 100644
--- a/docker/test/integration/runner/Dockerfile
+++ b/docker/test/integration/runner/Dockerfile
@@ -31,6 +31,7 @@ RUN apt-get update \
     software-properties-common \
     libkrb5-dev \
     krb5-user \
+    g++ \
     && rm -rf \
         /var/lib/apt/lists/* \
         /var/cache/debconf \
diff --git a/docker/test/integration/runner/compose/docker_compose_mysql_cluster.yml b/docker/test/integration/runner/compose/docker_compose_mysql_cluster.yml
new file mode 100644
index 00000000000..d0674362709
--- /dev/null
+++ b/docker/test/integration/runner/compose/docker_compose_mysql_cluster.yml
@@ -0,0 +1,23 @@
+version: '2.3'
+services:
+    mysql2:
+        image: mysql:5.7
+        restart: always
+        environment:
+            MYSQL_ROOT_PASSWORD: clickhouse
+        ports:
+            - 3348:3306
+    mysql3:
+        image: mysql:5.7
+        restart: always
+        environment:
+            MYSQL_ROOT_PASSWORD: clickhouse
+        ports:
+            - 3388:3306
+    mysql4:
+        image: mysql:5.7
+        restart: always
+        environment:
+            MYSQL_ROOT_PASSWORD: clickhouse
+        ports:
+            - 3368:3306
diff --git a/docker/test/integration/runner/compose/docker_compose_postgres.yml b/docker/test/integration/runner/compose/docker_compose_postgres.yml
index 58ed97251fb..5657352e1b3 100644
--- a/docker/test/integration/runner/compose/docker_compose_postgres.yml
+++ b/docker/test/integration/runner/compose/docker_compose_postgres.yml
@@ -11,10 +11,3 @@ services:
             default:
                 aliases:
                     - postgre-sql.local
-    postgres2:
-        image: postgres
-        restart: always
-        environment:
-            POSTGRES_PASSWORD: mysecretpassword
-        ports:
-            - 5441:5432
diff --git a/docker/test/integration/runner/compose/docker_compose_postgres_cluster.yml b/docker/test/integration/runner/compose/docker_compose_postgres_cluster.yml
new file mode 100644
index 00000000000..d04c8a2f3a6
--- /dev/null
+++ b/docker/test/integration/runner/compose/docker_compose_postgres_cluster.yml
@@ -0,0 +1,23 @@
+version: '2.3'
+services:
+    postgres2:
+        image: postgres
+        restart: always
+        environment:
+            POSTGRES_PASSWORD: mysecretpassword
+        ports:
+            - 5421:5432
+    postgres3:
+        image: postgres
+        restart: always
+        environment:
+            POSTGRES_PASSWORD: mysecretpassword
+        ports:
+            - 5441:5432
+    postgres4:
+        image: postgres
+        restart: always
+        environment:
+            POSTGRES_PASSWORD: mysecretpassword
+        ports:
+            - 5461:5432
diff --git a/docker/test/integration/runner/dockerd-entrypoint.sh b/docker/test/integration/runner/dockerd-entrypoint.sh
index c0255d3d706..bda6f5a719d 100755
--- a/docker/test/integration/runner/dockerd-entrypoint.sh
+++ b/docker/test/integration/runner/dockerd-entrypoint.sh
@@ -21,6 +21,7 @@ export CLICKHOUSE_TESTS_SERVER_BIN_PATH=/clickhouse
 export CLICKHOUSE_TESTS_CLIENT_BIN_PATH=/clickhouse
 export CLICKHOUSE_TESTS_BASE_CONFIG_DIR=/clickhouse-config
 export CLICKHOUSE_ODBC_BRIDGE_BINARY_PATH=/clickhouse-odbc-bridge
+export CLICKHOUSE_LIBRARY_BRIDGE_BINARY_PATH=/clickhouse-library-bridge
 
 export DOCKER_MYSQL_GOLANG_CLIENT_TAG=${DOCKER_MYSQL_GOLANG_CLIENT_TAG:=latest}
 export DOCKER_MYSQL_JAVA_CLIENT_TAG=${DOCKER_MYSQL_JAVA_CLIENT_TAG:=latest}
diff --git a/docker/test/stress/run.sh b/docker/test/stress/run.sh
index 3594eead992..ad8ec731f23 100755
--- a/docker/test/stress/run.sh
+++ b/docker/test/stress/run.sh
@@ -108,6 +108,11 @@ zgrep -Fav "ASan doesn't fully support makecontext/swapcontext functions" > /dev
     || echo -e 'No sanitizer asserts\tOK' >> /test_output/test_results.tsv
 rm -f /test_output/tmp
 
+# OOM
+zgrep -Fa " <Fatal> Application: Child process was terminated by signal 9" /var/log/clickhouse-server/clickhouse-server.log > /dev/null \
+    && echo -e 'OOM killer (or signal 9) in clickhouse-server.log\tFAIL' >> /test_output/test_results.tsv \
+    || echo -e 'No OOM messages in clickhouse-server.log\tOK' >> /test_output/test_results.tsv
+
 # Logical errors
 zgrep -Fa "Code: 49, e.displayText() = DB::Exception:" /var/log/clickhouse-server/clickhouse-server.log > /dev/null \
     && echo -e 'Logical error thrown (see clickhouse-server.log)\tFAIL' >> /test_output/test_results.tsv \
@@ -118,7 +123,7 @@ zgrep -Fa "########################################" /var/log/clickhouse-server/
     && echo -e 'Killed by signal (in clickhouse-server.log)\tFAIL' >> /test_output/test_results.tsv \
     || echo -e 'Not crashed\tOK' >> /test_output/test_results.tsv
 
-# It also checks for OOM or crash without stacktrace (printed by watchdog)
+# It also checks for crash without stacktrace (printed by watchdog)
 zgrep -Fa " <Fatal> " /var/log/clickhouse-server/clickhouse-server.log > /dev/null \
     && echo -e 'Fatal message in clickhouse-server.log\tFAIL' >> /test_output/test_results.tsv \
     || echo -e 'No fatal messages in clickhouse-server.log\tOK' >> /test_output/test_results.tsv
diff --git a/docs/en/development/contrib.md b/docs/en/development/contrib.md
index 76a2f647231..64ca2387029 100644
--- a/docs/en/development/contrib.md
+++ b/docs/en/development/contrib.md
@@ -5,36 +5,87 @@ toc_title: Third-Party Libraries Used
 
 # Third-Party Libraries Used {#third-party-libraries-used}
 
-| Library             | License                                                                                                                                      |
-|---------------------|----------------------------------------------------------------------------------------------------------------------------------------------|
-| base64              | [BSD 2-Clause License](https://github.com/aklomp/base64/blob/a27c565d1b6c676beaf297fe503c4518185666f7/LICENSE)                               |
-| boost               | [Boost Software License 1.0](https://github.com/ClickHouse-Extras/boost-extra/blob/6883b40449f378019aec792f9983ce3afc7ff16e/LICENSE_1_0.txt) |
-| brotli              | [MIT](https://github.com/google/brotli/blob/master/LICENSE)                                                                                  |
-| capnproto           | [MIT](https://github.com/capnproto/capnproto/blob/master/LICENSE)                                                                            |
-| cctz                | [Apache License 2.0](https://github.com/google/cctz/blob/4f9776a310f4952454636363def82c2bf6641d5f/LICENSE.txt)                               |
-| double-conversion   | [BSD 3-Clause License](https://github.com/google/double-conversion/blob/cf2f0f3d547dc73b4612028a155b80536902ba02/LICENSE)                    |
-| FastMemcpy          | [MIT](https://github.com/ClickHouse/ClickHouse/blob/master/libs/libmemcpy/impl/LICENSE)                                                      |
-| googletest          | [BSD 3-Clause License](https://github.com/google/googletest/blob/master/LICENSE)                                                             |
-| h3                  | [Apache License 2.0](https://github.com/uber/h3/blob/master/LICENSE)                                                                         |
-| hyperscan           | [BSD 3-Clause License](https://github.com/intel/hyperscan/blob/master/LICENSE)                                                               |
-| libcxxabi           | [BSD + MIT](https://github.com/ClickHouse/ClickHouse/blob/master/libs/libglibc-compatibility/libcxxabi/LICENSE.TXT)                          |
-| libdivide           | [Zlib License](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libdivide/LICENSE.txt)                                           |
-| libgsasl            | [LGPL v2.1](https://github.com/ClickHouse-Extras/libgsasl/blob/3b8948a4042e34fb00b4fb987535dc9e02e39040/LICENSE)                             |
-| libhdfs3            | [Apache License 2.0](https://github.com/ClickHouse-Extras/libhdfs3/blob/bd6505cbb0c130b0db695305b9a38546fa880e5a/LICENSE.txt)                |
-| libmetrohash        | [Apache License 2.0](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libmetrohash/LICENSE)                                      |
-| libpcg-random       | [Apache License 2.0](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libpcg-random/LICENSE-APACHE.txt)                          |
-| libressl            | [OpenSSL License](https://github.com/ClickHouse-Extras/ssl/blob/master/COPYING)                                                              |
-| librdkafka          | [BSD 2-Clause License](https://github.com/edenhill/librdkafka/blob/363dcad5a23dc29381cc626620e68ae418b3af19/LICENSE)                         |
-| libwidechar_width  | [CC0 1.0 Universal](https://github.com/ClickHouse/ClickHouse/blob/master/libs/libwidechar_width/LICENSE)                                     |
-| llvm                | [BSD 3-Clause License](https://github.com/ClickHouse-Extras/llvm/blob/163def217817c90fb982a6daf384744d8472b92b/llvm/LICENSE.TXT)             |
-| lz4                 | [BSD 2-Clause License](https://github.com/lz4/lz4/blob/c10863b98e1503af90616ae99725ecd120265dfb/LICENSE)                                     |
-| mariadb-connector-c | [LGPL v2.1](https://github.com/ClickHouse-Extras/mariadb-connector-c/blob/3.1/COPYING.LIB)                                                   |
-| murmurhash          | [Public Domain](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/murmurhash/LICENSE)                                             |
-| pdqsort             | [Zlib License](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/pdqsort/license.txt)                                             |
-| poco                | [Boost Software License - Version 1.0](https://github.com/ClickHouse-Extras/poco/blob/fe5505e56c27b6ecb0dcbc40c49dc2caf4e9637f/LICENSE)      |
-| protobuf            | [BSD 3-Clause License](https://github.com/ClickHouse-Extras/protobuf/blob/12735370922a35f03999afff478e1c6d7aa917a4/LICENSE)                  |
-| re2                 | [BSD 3-Clause License](https://github.com/google/re2/blob/7cf8b88e8f70f97fd4926b56aa87e7f53b2717e0/LICENSE)                                  |
-| sentry-native       | [MIT License](https://github.com/getsentry/sentry-native/blob/master/LICENSE)                                                                 |
-| UnixODBC            | [LGPL v2.1](https://github.com/ClickHouse-Extras/UnixODBC/tree/b0ad30f7f6289c12b76f04bfb9d466374bb32168)                                     |
-| zlib-ng             | [Zlib License](https://github.com/ClickHouse-Extras/zlib-ng/blob/develop/LICENSE.md)                                                         |
-| zstd                | [BSD 3-Clause License](https://github.com/facebook/zstd/blob/dev/LICENSE)                                                                    |
+The list of third-party libraries can be obtained by the following query:
+
+```
+SELECT library_name, license_type, license_path FROM system.licenses ORDER BY library_name COLLATE 'en'
+```
+
+[Example](https://gh-api.clickhouse.tech/play?user=play#U0VMRUNUIGxpYnJhcnlfbmFtZSwgbGljZW5zZV90eXBlLCBsaWNlbnNlX3BhdGggRlJPTSBzeXN0ZW0ubGljZW5zZXMgT1JERVIgQlkgbGlicmFyeV9uYW1lIENPTExBVEUgJ2VuJw==)
+
+| library_name | license_type | license_path | 
+|:-|:-|:-|
+| abseil-cpp | Apache | /contrib/abseil-cpp/LICENSE |
+| AMQP-CPP | Apache | /contrib/AMQP-CPP/LICENSE |
+| arrow | Apache | /contrib/arrow/LICENSE.txt |
+| avro | Apache | /contrib/avro/LICENSE.txt |
+| aws | Apache | /contrib/aws/LICENSE.txt |
+| aws-c-common | Apache | /contrib/aws-c-common/LICENSE |
+| aws-c-event-stream | Apache | /contrib/aws-c-event-stream/LICENSE |
+| aws-checksums | Apache | /contrib/aws-checksums/LICENSE |
+| base64 | BSD 2-clause | /contrib/base64/LICENSE |
+| boost | Boost | /contrib/boost/LICENSE_1_0.txt |
+| boringssl | BSD | /contrib/boringssl/LICENSE |
+| brotli | MIT | /contrib/brotli/LICENSE |
+| capnproto | MIT | /contrib/capnproto/LICENSE |
+| cassandra | Apache | /contrib/cassandra/LICENSE.txt |
+| cctz | Apache | /contrib/cctz/LICENSE.txt |
+| cityhash102 | MIT | /contrib/cityhash102/COPYING |
+| cppkafka | BSD 2-clause | /contrib/cppkafka/LICENSE |
+| croaring | Apache | /contrib/croaring/LICENSE |
+| curl | Apache | /contrib/curl/docs/LICENSE-MIXING.md |
+| cyrus-sasl | BSD 2-clause | /contrib/cyrus-sasl/COPYING |
+| double-conversion | BSD 3-clause | /contrib/double-conversion/LICENSE |
+| dragonbox | Apache | /contrib/dragonbox/LICENSE-Apache2-LLVM |
+| fast_float | Apache | /contrib/fast_float/LICENSE |
+| fastops | MIT | /contrib/fastops/LICENSE |
+| flatbuffers | Apache | /contrib/flatbuffers/LICENSE.txt |
+| fmtlib | Unknown | /contrib/fmtlib/LICENSE.rst |
+| gcem | Apache | /contrib/gcem/LICENSE |
+| googletest | BSD 3-clause | /contrib/googletest/LICENSE |
+| grpc | Apache | /contrib/grpc/LICENSE |
+| h3 | Apache | /contrib/h3/LICENSE |
+| hyperscan | Boost | /contrib/hyperscan/LICENSE |
+| icu | Public Domain | /contrib/icu/icu4c/LICENSE |
+| icudata | Public Domain | /contrib/icudata/LICENSE |
+| jemalloc | BSD 2-clause | /contrib/jemalloc/COPYING |
+| krb5 | MIT | /contrib/krb5/src/lib/gssapi/LICENSE |
+| libc-headers | LGPL | /contrib/libc-headers/LICENSE |
+| libcpuid | BSD 2-clause | /contrib/libcpuid/COPYING |
+| libcxx | Apache | /contrib/libcxx/LICENSE.TXT |
+| libcxxabi | Apache | /contrib/libcxxabi/LICENSE.TXT |
+| libdivide | zLib | /contrib/libdivide/LICENSE.txt |
+| libfarmhash | MIT | /contrib/libfarmhash/COPYING |
+| libgsasl | LGPL | /contrib/libgsasl/LICENSE |
+| libhdfs3 | Apache | /contrib/libhdfs3/LICENSE.txt |
+| libmetrohash | Apache | /contrib/libmetrohash/LICENSE |
+| libpq | Unknown | /contrib/libpq/COPYRIGHT |
+| libpqxx | BSD 3-clause | /contrib/libpqxx/COPYING |
+| librdkafka | MIT | /contrib/librdkafka/LICENSE.murmur2 |
+| libunwind | Apache | /contrib/libunwind/LICENSE.TXT |
+| libuv | BSD | /contrib/libuv/LICENSE |
+| llvm | Apache | /contrib/llvm/llvm/LICENSE.TXT |
+| lz4 | BSD | /contrib/lz4/LICENSE |
+| mariadb-connector-c | LGPL | /contrib/mariadb-connector-c/COPYING.LIB |
+| miniselect | Boost | /contrib/miniselect/LICENSE_1_0.txt |
+| msgpack-c | Boost | /contrib/msgpack-c/LICENSE_1_0.txt |
+| murmurhash | Public Domain | /contrib/murmurhash/LICENSE |
+| NuRaft | Apache | /contrib/NuRaft/LICENSE |
+| openldap | Unknown | /contrib/openldap/LICENSE |
+| orc | Apache | /contrib/orc/LICENSE |
+| poco | Boost | /contrib/poco/LICENSE |
+| protobuf | BSD 3-clause | /contrib/protobuf/LICENSE |
+| rapidjson | MIT | /contrib/rapidjson/bin/jsonschema/LICENSE |
+| re2 | BSD 3-clause | /contrib/re2/LICENSE |
+| replxx | BSD 3-clause | /contrib/replxx/LICENSE.md |
+| rocksdb | BSD 3-clause | /contrib/rocksdb/LICENSE.leveldb |
+| sentry-native | MIT | /contrib/sentry-native/LICENSE |
+| simdjson | Apache | /contrib/simdjson/LICENSE |
+| snappy | Public Domain | /contrib/snappy/COPYING |
+| sparsehash-c11 | BSD 3-clause | /contrib/sparsehash-c11/LICENSE |
+| stats | Apache | /contrib/stats/LICENSE |
+| thrift | Apache | /contrib/thrift/LICENSE |
+| unixodbc | LGPL | /contrib/unixodbc/COPYING |
+| xz | Public Domain | /contrib/xz/COPYING |
+| zlib-ng | zLib | /contrib/zlib-ng/LICENSE.md |
+| zstd | BSD | /contrib/zstd/LICENSE |
diff --git a/docs/en/engines/table-engines/mergetree-family/aggregatingmergetree.md b/docs/en/engines/table-engines/mergetree-family/aggregatingmergetree.md
index 1a997b6b237..818830646cb 100644
--- a/docs/en/engines/table-engines/mergetree-family/aggregatingmergetree.md
+++ b/docs/en/engines/table-engines/mergetree-family/aggregatingmergetree.md
@@ -3,7 +3,7 @@ toc_priority: 35
 toc_title: AggregatingMergeTree
 ---
 
-# Aggregatingmergetree {#aggregatingmergetree}
+# AggregatingMergeTree {#aggregatingmergetree}
 
 The engine inherits from [MergeTree](../../../engines/table-engines/mergetree-family/mergetree.md#table_engines-mergetree), altering the logic for data parts merging. ClickHouse replaces all rows with the same primary key (or more accurately, with the same [sorting key](../../../engines/table-engines/mergetree-family/mergetree.md)) with a single row (within a one data part) that stores a combination of states of aggregate functions.
 
diff --git a/docs/en/getting-started/example-datasets/cell-towers.md b/docs/en/getting-started/example-datasets/cell-towers.md
index 76effdd4c62..7028b650ad1 100644
--- a/docs/en/getting-started/example-datasets/cell-towers.md
+++ b/docs/en/getting-started/example-datasets/cell-towers.md
@@ -3,31 +3,31 @@ toc_priority: 21
 toc_title: Cell Towers
 ---
 
-# Cell Towers
+# Cell Towers {#cell-towers}
 
 This dataset is from [OpenCellid](https://www.opencellid.org/) - The world's largest Open Database of Cell Towers.
 
-As of 2021 it contains more than 40 million records about cell towers (GSM, LTE, UMTS, etc.) around the world with their geographical coordinates and metadata (country code, network, etc).
+As of 2021, it contains more than 40 million records about cell towers (GSM, LTE, UMTS, etc.) around the world with their geographical coordinates and metadata (country code, network, etc).
 
-OpenCelliD Project is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License, and we redistribute a snapshot of this dataset under the terms of the same license. The up to date version of the dataset is available to download after sign in.
+OpenCelliD Project is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License, and we redistribute a snapshot of this dataset under the terms of the same license. The up-to-date version of the dataset is available to download after sign in.
 
 
-## Get the Dataset
+## Get the Dataset {#get-the-dataset}
 
-Download the snapshot of the dataset from Feb 2021: [https://datasets.clickhouse.tech/cell_towers.csv.xz] (729 MB).
+1. Download the snapshot of the dataset from February 2021: [https://datasets.clickhouse.tech/cell_towers.csv.xz] (729 MB).
 
-Optionally validate the integrity:
+2. Validate the integrity (optional step):
 ```
 md5sum cell_towers.csv.xz
 8cf986f4a0d9f12c6f384a0e9192c908  cell_towers.csv.xz
 ```
 
-Decompress it with the following command:
+3. Decompress it with the following command:
 ```
 xz -d cell_towers.csv.xz
 ```
 
-Create a table:
+4. Create a table:
 
 ```
 CREATE TABLE cell_towers
@@ -50,15 +50,15 @@ CREATE TABLE cell_towers
 ENGINE = MergeTree ORDER BY (radio, mcc, net, created);
 ```
 
-Insert the dataset:
+5. Insert the dataset:
 ```
 clickhouse-client --query "INSERT INTO cell_towers FORMAT CSVWithNames" < cell_towers.csv
 ```
 
+## Examples {#examples}
 
-## Run some queries
+1. A number of cell towers by type:
 
-Number of cell towers by type:
 ```
 SELECT radio, count() AS c FROM cell_towers GROUP BY radio ORDER BY c DESC
 
@@ -73,7 +73,8 @@ SELECT radio, count() AS c FROM cell_towers GROUP BY radio ORDER BY c DESC
 5 rows in set. Elapsed: 0.011 sec. Processed 43.28 million rows, 43.28 MB (3.83 billion rows/s., 3.83 GB/s.)
 ```
 
-Cell towers by mobile country code (MCC):
+2. Cell towers by [mobile country code (MCC)](https://en.wikipedia.org/wiki/Mobile_country_code):
+
 ```
 SELECT mcc, count() FROM cell_towers GROUP BY mcc ORDER BY count() DESC LIMIT 10
 
@@ -93,28 +94,28 @@ SELECT mcc, count() FROM cell_towers GROUP BY mcc ORDER BY count() DESC LIMIT 10
 10 rows in set. Elapsed: 0.019 sec. Processed 43.28 million rows, 86.55 MB (2.33 billion rows/s., 4.65 GB/s.)
 ```
 
-See the dictionary here: [https://en.wikipedia.org/wiki/Mobile_country_code](https://en.wikipedia.org/wiki/Mobile_country_code).
+So, the top countries are: the USA, Germany, and Russia.
 
-So, the top countries are USA, Germany and Russia.
-
-You may want to create an [External Dictionary](../../sql-reference/dictionaries/external-dictionaries/external-dicts/) in ClickHouse to decode these values.
+You may want to create an [External Dictionary](../../sql-reference/dictionaries/external-dictionaries/external-dicts.md) in ClickHouse to decode these values.
 
 
-### Example of using `pointInPolygon` function
+## Use case {#use-case}
 
-Create a table where we will store polygons:
+Using `pointInPolygon` function.
+
+1. Create a table where we will store polygons:
 
 ```
 CREATE TEMPORARY TABLE moscow (polygon Array(Tuple(Float64, Float64)));
 ```
 
-This is a rough shape of Moscow (without "new Moscow"):
+2. This is a rough shape of Moscow (without "new Moscow"):
 
 ```
 INSERT INTO moscow VALUES ([(37.84172564285271, 55.78000432402266), (37.8381207618713, 55.775874525970494), (37.83979446823122, 55.775626746008065), (37.84243326983639, 55.77446586811748), (37.84262672750849, 55.771974101091104), (37.84153238623039, 55.77114545193181), (37.841124690460184, 55.76722010265554), (37.84239076983644, 55.76654891107098), (37.842283558197025, 55.76258709833121), (37.8421759312134, 55.758073999993734), (37.84198330422974, 55.75381499999371), (37.8416827275085, 55.749277102484484), (37.84157576190186, 55.74794544108413), (37.83897929098507, 55.74525257875241), (37.83739676451868, 55.74404373042019), (37.838732481460525, 55.74298009816793), (37.841183997352545, 55.743060321833575), (37.84097476190185, 55.73938799999373), (37.84048155819702, 55.73570799999372), (37.840095812164286, 55.73228210777237), (37.83983814285274, 55.73080491981639), (37.83846476321406, 55.729799917464675), (37.83835745269769, 55.72919751082619), (37.838636380279524, 55.72859509486539), (37.8395161005249, 55.727705075632784), (37.83897964285276, 55.722727886185154), (37.83862557539366, 55.72034817326636), (37.83559735744853, 55.71944437307499), (37.835370708803126, 55.71831419154461), (37.83738169402022, 55.71765218986692), (37.83823396494291, 55.71691750159089), (37.838056931213345, 55.71547311301385), (37.836812846557606, 55.71221445615604), (37.83522525396725, 55.709331054395555), (37.83269301586908, 55.70953687463627), (37.829667367706236, 55.70903403789297), (37.83311126588435, 55.70552351822608), (37.83058993121339, 55.70041317726053), (37.82983872750851, 55.69883771404813), (37.82934501586913, 55.69718947487017), (37.828926414016685, 55.69504441658371), (37.82876530422971, 55.69287499999378), (37.82894754100031, 55.690759754047335), (37.827697554878185, 55.68951421135665), (37.82447346292115, 55.68965045405069), (37.83136543914793, 55.68322046195302), (37.833554015869154, 55.67814012759211), (37.83544184655761, 55.67295011628339), (37.837480388885474, 55.6672498719639), (37.838960677246064, 55.66316274139358), (37.83926093121332, 55.66046999999383), (37.839025050262435, 55.65869897264431), (37.83670784390257, 55.65794084879904), (37.835656529083245, 55.65694309303843), (37.83704060449217, 55.65689306460552), (37.83696819873806, 55.65550363526252), (37.83760389616388, 55.65487847246661), (37.83687972750851, 55.65356745541324), (37.83515216004943, 55.65155951234079), (37.83312418518067, 55.64979413590619), (37.82801726983639, 55.64640836412121), (37.820614174591, 55.64164525405531), (37.818908190475426, 55.6421883258084), (37.81717543386075, 55.64112490388471), (37.81690987037274, 55.63916106913107), (37.815099354492155, 55.637925371757085), (37.808769150787356, 55.633798276884455), (37.80100123544311, 55.62873670012244), (37.79598013491824, 55.62554336109055), (37.78634567724606, 55.62033499605651), (37.78334147619623, 55.618768681480326), (37.77746201055901, 55.619855533402706), (37.77527329626457, 55.61909966711279), (37.77801986242668, 55.618770300976294), (37.778212973541216, 55.617257701952106), (37.77784818518065, 55.61574504433011), (37.77016867724609, 55.61148576294007), (37.760191219573976, 55.60599579539028), (37.75338926983641, 55.60227892751446), (37.746329965606634, 55.59920577639331), (37.73939925396728, 55.59631430313617), (37.73273665739439, 55.5935318803559), (37.7299954450912, 55.59350760316188), (37.7268679946899, 55.59469840523759), (37.72626726983634, 55.59229549697373), (37.7262673598022, 55.59081598950582), (37.71897193121335, 55.5877595845419), (37.70871550793456, 55.58393177431724), (37.700497489410374, 55.580917323756644), (37.69204305026244, 55.57778089778455), (37.68544477378839, 55.57815154690915), (37.68391050793454, 55.57472945079756), (37.678803592590306, 55.57328235936491), (37.6743402539673, 55.57255251445782), (37.66813862698363, 55.57216388774464), (37.617927457672096, 55.57505691895805), (37.60443099999999, 55.5757737568051), (37.599683515869145, 55.57749105910326), (37.59754177842709, 55.57796291823627), (37.59625834786988, 55.57906686095235), (37.59501783265684, 55.57746616444403), (37.593090671936025, 55.57671634534502), (37.587018007904, 55.577944600233785), (37.578692203704804, 55.57982895000019), (37.57327546607398, 55.58116294118248), (37.57385012109279, 55.581550362779), (37.57399562266922, 55.5820107079112), (37.5735356072979, 55.58226289171689), (37.57290393054962, 55.582393529795155), (37.57037722355653, 55.581919415056234), (37.5592298306885, 55.584471614867844), (37.54189249206543, 55.58867650795186), (37.5297256269836, 55.59158133551745), (37.517837865081766, 55.59443656218868), (37.51200186508174, 55.59635625174229), (37.506808949737554, 55.59907823904434), (37.49820432275389, 55.6062944994944), (37.494406071441674, 55.60967103463367), (37.494760001358024, 55.61066689753365), (37.49397137107085, 55.61220931698269), (37.49016528606031, 55.613417718449064), (37.48773249206542, 55.61530616333343), (37.47921386508177, 55.622640129112334), (37.470652153442394, 55.62993723476164), (37.46273446298218, 55.6368075123157), (37.46350692265317, 55.64068225239439), (37.46050283203121, 55.640794546982576), (37.457627470916734, 55.64118904154646), (37.450718034393326, 55.64690488145138), (37.44239252645875, 55.65397824729769), (37.434587576721185, 55.66053543155961), (37.43582144975277, 55.661693766520735), (37.43576786245721, 55.662755031737014), (37.430982915344174, 55.664610641628116), (37.428547447097685, 55.66778515273695), (37.42945134592044, 55.668633314343566), (37.42859571562949, 55.66948145750025), (37.4262836402282, 55.670813882451405), (37.418709037048295, 55.6811141674414), (37.41922139651101, 55.68235377885389), (37.419218771842885, 55.68359335082235), (37.417196501327446, 55.684375235224735), (37.41607020370478, 55.68540557585352), (37.415640857147146, 55.68686637150793), (37.414632153442334, 55.68903015131686), (37.413344899475064, 55.690896881757396), (37.41171432275391, 55.69264232162232), (37.40948282275393, 55.69455101638112), (37.40703674603271, 55.69638690385348), (37.39607169577025, 55.70451821283731), (37.38952706878662, 55.70942491932811), (37.387778313491815, 55.71149057784176), (37.39049275399779, 55.71419814298992), (37.385557272491454, 55.7155489617061), (37.38388335714726, 55.71849856042102), (37.378368238098155, 55.7292763261685), (37.37763597123337, 55.730845879211614), (37.37890062088197, 55.73167906388319), (37.37750451918789, 55.734703664681774), (37.375610832015965, 55.734851959522246), (37.3723813571472, 55.74105626086403), (37.37014935714723, 55.746115620904355), (37.36944173016362, 55.750883999993725), (37.36975304365541, 55.76335905525834), (37.37244070571134, 55.76432079697595), (37.3724259757175, 55.76636979670426), (37.369922155757884, 55.76735417953104), (37.369892695770275, 55.76823419316575), (37.370214730163575, 55.782312184391266), (37.370493611114505, 55.78436801120489), (37.37120164550783, 55.78596427165359), (37.37284851456452, 55.7874378183096), (37.37608325135799, 55.7886695054807), (37.3764587460632, 55.78947647305964), (37.37530000265506, 55.79146512926804), (37.38235915344241, 55.79899647809345), (37.384344043655396, 55.80113596939471), (37.38594269577028, 55.80322699999366), (37.38711208598329, 55.804919036911976), (37.3880239841309, 55.806610999993666), (37.38928977249147, 55.81001864976979), (37.39038389947512, 55.81348641242801), (37.39235781481933, 55.81983538336746), (37.393709457672124, 55.82417822811877), (37.394685720901464, 55.82792275755836), (37.39557615344238, 55.830447148154136), (37.39844478226658, 55.83167107969975), (37.40019761214057, 55.83151823557964), (37.400398790382326, 55.83264967594742), (37.39659544313046, 55.83322180909622), (37.39667059524539, 55.83402792148566), (37.39682089947515, 55.83638877400216), (37.39643489154053, 55.83861656112751), (37.3955338994751, 55.84072348043264), (37.392680272491454, 55.84502158126453), (37.39241188227847, 55.84659117913199), (37.392529730163616, 55.84816071336481), (37.39486835714723, 55.85288092980303), (37.39873052645878, 55.859893456073635), (37.40272161111449, 55.86441833633205), (37.40697072750854, 55.867579567544375), (37.410007082016016, 55.868369880337), (37.4120992989502, 55.86920843741314), (37.412668021163924, 55.87055369615854), (37.41482461111453, 55.87170587948249), (37.41862266137694, 55.873183961039565), (37.42413732540892, 55.874879126654704), (37.4312182698669, 55.875614937236705), (37.43111093783558, 55.8762723478417), (37.43332105622856, 55.87706546369396), (37.43385747619623, 55.87790681284802), (37.441303050262405, 55.88027084462084), (37.44747234260555, 55.87942070143253), (37.44716141796871, 55.88072960917233), (37.44769797085568, 55.88121221323979), (37.45204320500181, 55.882080694420715), (37.45673176190186, 55.882346110794586), (37.463383999999984, 55.88252729504517), (37.46682797486874, 55.88294937719063), (37.470014457672086, 55.88361266759345), (37.47751410450743, 55.88546991372396), (37.47860317658232, 55.88534929207307), (37.48165826025772, 55.882563306475106), (37.48316434442331, 55.8815803226785), (37.483831555817645, 55.882427612793315), (37.483182967125686, 55.88372791409729), (37.483092277908824, 55.88495581062434), (37.4855716508179, 55.8875561994203), (37.486440636245746, 55.887827444039566), (37.49014203439328, 55.88897899871799), (37.493210285705544, 55.890208937135604), (37.497512451065035, 55.891342397444696), (37.49780744510645, 55.89174030252967), (37.49940333499519, 55.89239745507079), (37.50018383334346, 55.89339220941865), (37.52421672750851, 55.903869074155224), (37.52977457672118, 55.90564076517974), (37.53503220370484, 55.90661661218259), (37.54042858064267, 55.90714113744566), (37.54320461007303, 55.905645048442985), (37.545686966066306, 55.906608607018505), (37.54743976120755, 55.90788552162358), (37.55796999999999, 55.90901557907218), (37.572711542327866, 55.91059395704873), (37.57942799999998, 55.91073854155573), (37.58502865872187, 55.91009969268444), (37.58739968913264, 55.90794809960554), (37.59131567193598, 55.908713267595054), (37.612687423278814, 55.902866854295375), (37.62348079629517, 55.90041967242986), (37.635797880950896, 55.898141151686396), (37.649487626983664, 55.89639275532968), (37.65619302513125, 55.89572360207488), (37.66294133862307, 55.895295577183965), (37.66874564418033, 55.89505457604897), (37.67375601586915, 55.89254677027454), (37.67744661901856, 55.8947775867987), (37.688347, 55.89450045676125), (37.69480554232789, 55.89422926332761), (37.70107096560668, 55.89322256101114), (37.705962965606716, 55.891763491662616), (37.711885134918205, 55.889110234998974), (37.71682005026245, 55.886577568759876), (37.7199315476074, 55.88458159806678), (37.72234560316464, 55.882281005794134), (37.72364385977171, 55.8809452036196), (37.725371142837474, 55.8809722706006), (37.727870902099546, 55.88037213862385), (37.73394330422971, 55.877941504088696), (37.745339592590376, 55.87208120378722), (37.75525267724611, 55.86703807949492), (37.76919976190188, 55.859821640197474), (37.827835219574, 55.82962968399116), (37.83341438888553, 55.82575289922351), (37.83652584655761, 55.82188784027888), (37.83809213491821, 55.81612575504693), (37.83605359521481, 55.81460347077685), (37.83632178569025, 55.81276696067908), (37.838623105812026, 55.811486181656385), (37.83912198147584, 55.807329380532785), (37.839079078033414, 55.80510270463816), (37.83965844708251, 55.79940712529036), (37.840581150787344, 55.79131399999368), (37.84172564285271, 55.78000432402266)]);
 ```
 
-Check how many cell towers are in Moscow:
+3. Check how many cell towers are in Moscow:
 
 ```
 SELECT count() FROM cell_towers WHERE pointInPolygon((lon, lat), (SELECT * FROM moscow))
@@ -128,6 +129,4 @@ SELECT count() FROM cell_towers WHERE pointInPolygon((lon, lat), (SELECT * FROM
 
 The data is also available for interactive queries in the [Playground](https://gh-api.clickhouse.tech/play?user=play), [example](https://gh-api.clickhouse.tech/play?user=play#U0VMRUNUIG1jYywgY291bnQoKSBGUk9NIGNlbGxfdG93ZXJzIEdST1VQIEJZIG1jYyBPUkRFUiBCWSBjb3VudCgpIERFU0M=).
 
-Although you cannot create temporary tables there.
-
-[Original article](https://clickhouse.tech/docs/en/getting_started/example_datasets/cell-towers/) <!--hide-->
+Although you cannot create temporary tables there.
\ No newline at end of file
diff --git a/docs/en/interfaces/third-party/gui.md b/docs/en/interfaces/third-party/gui.md
index 5d14b3aa3cc..d2fd24ab9a4 100644
--- a/docs/en/interfaces/third-party/gui.md
+++ b/docs/en/interfaces/third-party/gui.md
@@ -184,4 +184,9 @@ SeekTable is [free](https://www.seektable.com/help/cloud-pricing) for personal/i
 
 [How to configure ClickHouse connection in SeekTable.](https://www.seektable.com/help/clickhouse-pivot-table)
 
+
+### Chadmin {#chadmin}
+
+[Chadmin](https://github.com/bun4uk/chadmin) is a simple UI where you can visualize your currently running queries on your ClickHouse cluster and info about them and kill them if you want.
+
 [Original article](https://clickhouse.tech/docs/en/interfaces/third-party/gui/) <!--hide-->
diff --git a/docs/en/introduction/adopters.md b/docs/en/introduction/adopters.md
index 012d86b1ef7..3b3c1203b50 100644
--- a/docs/en/introduction/adopters.md
+++ b/docs/en/introduction/adopters.md
@@ -13,6 +13,7 @@ toc_title: Adopters
 | <a href="https://2gis.ru" class="favicon">2gis</a> | Maps | Monitoring | — | — | [Talk in Russian, July 2019](https://youtu.be/58sPkXfq6nw) |
 | <a href="https://getadmiral.com/" class="favicon">Admiral</a> | Martech | Engagement Management | — | — | [Webinar Slides, June 2020](https://altinity.com/presentations/2020/06/16/big-data-in-real-time-how-clickhouse-powers-admirals-visitor-relationships-for-publishers) |
 | <a href="http://www.adscribe.tv/" class="favicon">AdScribe</a> | Ads | TV Analytics | — | — | [A quote from CTO](https://altinity.com/24x7-support/) |
+| <a href="https://ahrefs.com/" class="favicon">Ahrefs</a> | SEO | Analytics | — | — | [Job listing](https://ahrefs.com/jobs/data-scientist-search) |
 | <a href="https://cn.aliyun.com/" class="favicon">Alibaba Cloud</a> | Cloud | Managed Service | — | — | [Official Website](https://help.aliyun.com/product/144466.html) |
 | <a href="https://alohabrowser.com/" class="favicon">Aloha Browser</a> | Mobile App | Browser backend | — | — | [Slides in Russian, May 2019](https://presentations.clickhouse.tech/meetup22/aloha.pdf) |
 | <a href="https://altinity.com/" class="favicon">Altinity</a> | Cloud, SaaS | Main product | — | — | [Official Website](https://altinity.com/) |
@@ -47,7 +48,8 @@ toc_title: Adopters
 | <a href="https://www.diva-e.com" class="favicon">Diva-e</a> | Digital consulting | Main Product | — | — | [Slides in English, September 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup29/ClickHouse-MeetUp-Unusual-Applications-sd-2019-09-17.pdf) |
 | <a href="https://www.ecwid.com/" class="favicon">Ecwid</a> | E-commerce SaaS | Metrics, Logging | — | — | [Slides in Russian, April 2019](https://nastachku.ru/var/files/1/presentation/backend/2_Backend_6.pdf) |
 | <a href="https://www.ebay.com/" class="favicon">eBay</a> | E-commerce | Logs, Metrics and Events | — | — | [Official website, Sep 2020](https://tech.ebayinc.com/engineering/ou-online-analytical-processing/) |
-| <a href="https://www.exness.com" class="favicon">Exness</a> | Trading | Metrics, Logging | — | — | [Talk in Russian, May 2019](https://youtu.be/_rpU-TvSfZ8?t=3215) |
+| <a href="https://www.exness.com/" class="favicon">Exness</a> | Trading | Metrics, Logging | — | — | [Talk in Russian, May 2019](https://youtu.be/_rpU-TvSfZ8?t=3215) |
+| <a href="https://www.eventbunker.io/" class="favicon">EventBunker.io</a> | Serverless Data Processing | — | — | — | [Tweet, April 2021](https://twitter.com/Halil_D_/status/1379839133472985091) |
 | <a href="https://fastnetmon.com/" class="favicon">FastNetMon</a> | DDoS Protection | Main Product | | — | [Official website](https://fastnetmon.com/docs-fnm-advanced/fastnetmon-advanced-traffic-persistency/) |
 | <a href="https://www.flipkart.com/" class="favicon">Flipkart</a> | e-Commerce | — | — | — | [Talk in English, July 2020](https://youtu.be/GMiXCMFDMow?t=239) |
 | <a href="https://fun.co/rp" class="favicon">FunCorp</a> | Games | | — | 14 bn records/day as of Jan 2021 | [Article](https://www.altinity.com/blog/migrating-from-redshift-to-clickhouse) |
diff --git a/docs/en/operations/server-configuration-parameters/settings.md b/docs/en/operations/server-configuration-parameters/settings.md
index 2b3bdbd51ef..f86e9668f00 100644
--- a/docs/en/operations/server-configuration-parameters/settings.md
+++ b/docs/en/operations/server-configuration-parameters/settings.md
@@ -345,7 +345,8 @@ Similar to `interserver_http_host`, except that this hostname can be used by oth
 The username and password used to authenticate during [replication](../../engines/table-engines/mergetree-family/replication.md) with the Replicated\* engines. These credentials are used only for communication between replicas and are unrelated to credentials for ClickHouse clients. The server is checking these credentials for connecting replicas and use the same credentials when connecting to other replicas. So, these credentials should be set the same for all replicas in a cluster.
 By default, the authentication is not used.
 
-**Note:** These credentials are common for replication through `HTTP` and `HTTPS`.
+!!! note "Note"
+    These credentials are common for replication through `HTTP` and `HTTPS`.
 
 This section contains the following parameters:
 
diff --git a/docs/en/operations/settings/merge-tree-settings.md b/docs/en/operations/settings/merge-tree-settings.md
index 77b68715ba9..b2470207dcc 100644
--- a/docs/en/operations/settings/merge-tree-settings.md
+++ b/docs/en/operations/settings/merge-tree-settings.md
@@ -56,6 +56,26 @@ Default value: 150.
 
 ClickHouse artificially executes `INSERT` longer (adds ‘sleep’) so that the background merge process can merge parts faster than they are added.
 
+## inactive_parts_to_throw_insert {#inactive-parts-to-throw-insert}
+
+If the number of inactive parts in a single partition more than the `inactive_parts_to_throw_insert` value, `INSERT` is interrupted with the "Too many inactive parts (N). Parts cleaning are processing significantly slower than inserts" exception.
+
+Possible values:
+
+-   Any positive integer.
+
+Default value: 0 (unlimited).
+
+## inactive_parts_to_delay_insert {#inactive-parts-to-delay-insert}
+
+If the number of inactive parts in a single partition in the table at least that many the `inactive_parts_to_delay_insert` value, an `INSERT` artificially slows down. It is useful when a server fails to clean up parts quickly enough.
+
+Possible values:
+
+-   Any positive integer.
+
+Default value: 0 (unlimited).
+
 ## max_delay_to_insert {#max-delay-to-insert}
 
 The value in seconds, which is used to calculate the `INSERT` delay, if the number of active parts in a single partition exceeds the [parts_to_delay_insert](#parts-to-delay-insert) value.
diff --git a/docs/en/operations/settings/settings.md b/docs/en/operations/settings/settings.md
index 27bb6fee0e2..6a1b25982a0 100644
--- a/docs/en/operations/settings/settings.md
+++ b/docs/en/operations/settings/settings.md
@@ -1565,6 +1565,17 @@ Possible values:
 
 Default value: 0
 
+## optimize_skip_unused_shards_rewrite_in {#optimize-skip-unused-shardslrewrite-in}
+
+Rewrite IN in query for remote shards to exclude values that does not belong to the shard (requires optimize_skip_unused_shards).
+
+Possible values:
+
+-   0 — Disabled.
+-   1 — Enabled.
+
+Default value: 1 (since it requires `optimize_skip_unused_shards` anyway, which `0` by default)
+
 ## allow_nondeterministic_optimize_skip_unused_shards {#allow-nondeterministic-optimize-skip-unused-shards}
 
 Allow nondeterministic (like `rand` or `dictGet`, since later has some caveats with updates) functions in sharding key.
@@ -2844,4 +2855,15 @@ Sets the interval in seconds after which periodically refreshed [live view](../.
 
 Default value: `60`.
 
+## check_query_single_value_result {#check_query_single_value_result}
+
+Defines the level of detail for the [CHECK TABLE](../../sql-reference/statements/check-table.md#checking-mergetree-tables) query result for `MergeTree` family engines .
+
+Possible values:
+
+-   0 — the query shows a check status for every individual data part of a table.
+-   1 — the query shows the general table check status.
+
+Default value: `0`.
+
 [Original article](https://clickhouse.tech/docs/en/operations/settings/settings/) <!-- hide -->
diff --git a/docs/en/operations/tips.md b/docs/en/operations/tips.md
index e62dea0b04e..865fe58d7cd 100644
--- a/docs/en/operations/tips.md
+++ b/docs/en/operations/tips.md
@@ -191,8 +191,9 @@ dynamicConfigFile=/etc/zookeeper-{{ '{{' }} cluster['name'] {{ '}}' }}/conf/zoo.
 Java version:
 
 ``` text
-Java(TM) SE Runtime Environment (build 1.8.0_25-b17)
-Java HotSpot(TM) 64-Bit Server VM (build 25.25-b02, mixed mode)
+openjdk 11.0.5-shenandoah 2019-10-15
+OpenJDK Runtime Environment (build 11.0.5-shenandoah+10-adhoc.heretic.src)
+OpenJDK 64-Bit Server VM (build 11.0.5-shenandoah+10-adhoc.heretic.src, mixed mode)
 ```
 
 JVM parameters:
@@ -204,7 +205,7 @@ ZOOCFGDIR=/etc/$NAME/conf
 # TODO this is really ugly
 # How to find out, which jars are needed?
 # seems, that log4j requires the log4j.properties file to be in the classpath
-CLASSPATH="$ZOOCFGDIR:/usr/build/classes:/usr/build/lib/*.jar:/usr/share/zookeeper/zookeeper-3.5.1-metrika.jar:/usr/share/zookeeper/slf4j-log4j12-1.7.5.jar:/usr/share/zookeeper/slf4j-api-1.7.5.jar:/usr/share/zookeeper/servlet-api-2.5-20081211.jar:/usr/share/zookeeper/netty-3.7.0.Final.jar:/usr/share/zookeeper/log4j-1.2.16.jar:/usr/share/zookeeper/jline-2.11.jar:/usr/share/zookeeper/jetty-util-6.1.26.jar:/usr/share/zookeeper/jetty-6.1.26.jar:/usr/share/zookeeper/javacc.jar:/usr/share/zookeeper/jackson-mapper-asl-1.9.11.jar:/usr/share/zookeeper/jackson-core-asl-1.9.11.jar:/usr/share/zookeeper/commons-cli-1.2.jar:/usr/src/java/lib/*.jar:/usr/etc/zookeeper"
+CLASSPATH="$ZOOCFGDIR:/usr/build/classes:/usr/build/lib/*.jar:/usr/share/zookeeper-3.6.2/lib/audience-annotations-0.5.0.jar:/usr/share/zookeeper-3.6.2/lib/commons-cli-1.2.jar:/usr/share/zookeeper-3.6.2/lib/commons-lang-2.6.jar:/usr/share/zookeeper-3.6.2/lib/jackson-annotations-2.10.3.jar:/usr/share/zookeeper-3.6.2/lib/jackson-core-2.10.3.jar:/usr/share/zookeeper-3.6.2/lib/jackson-databind-2.10.3.jar:/usr/share/zookeeper-3.6.2/lib/javax.servlet-api-3.1.0.jar:/usr/share/zookeeper-3.6.2/lib/jetty-http-9.4.24.v20191120.jar:/usr/share/zookeeper-3.6.2/lib/jetty-io-9.4.24.v20191120.jar:/usr/share/zookeeper-3.6.2/lib/jetty-security-9.4.24.v20191120.jar:/usr/share/zookeeper-3.6.2/lib/jetty-server-9.4.24.v20191120.jar:/usr/share/zookeeper-3.6.2/lib/jetty-servlet-9.4.24.v20191120.jar:/usr/share/zookeeper-3.6.2/lib/jetty-util-9.4.24.v20191120.jar:/usr/share/zookeeper-3.6.2/lib/jline-2.14.6.jar:/usr/share/zookeeper-3.6.2/lib/json-simple-1.1.1.jar:/usr/share/zookeeper-3.6.2/lib/log4j-1.2.17.jar:/usr/share/zookeeper-3.6.2/lib/metrics-core-3.2.5.jar:/usr/share/zookeeper-3.6.2/lib/netty-buffer-4.1.50.Final.jar:/usr/share/zookeeper-3.6.2/lib/netty-codec-4.1.50.Final.jar:/usr/share/zookeeper-3.6.2/lib/netty-common-4.1.50.Final.jar:/usr/share/zookeeper-3.6.2/lib/netty-handler-4.1.50.Final.jar:/usr/share/zookeeper-3.6.2/lib/netty-resolver-4.1.50.Final.jar:/usr/share/zookeeper-3.6.2/lib/netty-transport-4.1.50.Final.jar:/usr/share/zookeeper-3.6.2/lib/netty-transport-native-epoll-4.1.50.Final.jar:/usr/share/zookeeper-3.6.2/lib/netty-transport-native-unix-common-4.1.50.Final.jar:/usr/share/zookeeper-3.6.2/lib/simpleclient-0.6.0.jar:/usr/share/zookeeper-3.6.2/lib/simpleclient_common-0.6.0.jar:/usr/share/zookeeper-3.6.2/lib/simpleclient_hotspot-0.6.0.jar:/usr/share/zookeeper-3.6.2/lib/simpleclient_servlet-0.6.0.jar:/usr/share/zookeeper-3.6.2/lib/slf4j-api-1.7.25.jar:/usr/share/zookeeper-3.6.2/lib/slf4j-log4j12-1.7.25.jar:/usr/share/zookeeper-3.6.2/lib/snappy-java-1.1.7.jar:/usr/share/zookeeper-3.6.2/lib/zookeeper-3.6.2.jar:/usr/share/zookeeper-3.6.2/lib/zookeeper-jute-3.6.2.jar:/usr/share/zookeeper-3.6.2/lib/zookeeper-prometheus-metrics-3.6.2.jar:/usr/share/zookeeper-3.6.2/etc"
 
 ZOOCFG="$ZOOCFGDIR/zoo.cfg"
 ZOO_LOG_DIR=/var/log/$NAME
@@ -213,27 +214,17 @@ GROUP=zookeeper
 PIDDIR=/var/run/$NAME
 PIDFILE=$PIDDIR/$NAME.pid
 SCRIPTNAME=/etc/init.d/$NAME
-JAVA=/usr/bin/java
+JAVA=/usr/local/jdk-11/bin/java
 ZOOMAIN="org.apache.zookeeper.server.quorum.QuorumPeerMain"
 ZOO_LOG4J_PROP="INFO,ROLLINGFILE"
 JMXLOCALONLY=false
 JAVA_OPTS="-Xms{{ '{{' }} cluster.get('xms','128M') {{ '}}' }} \
     -Xmx{{ '{{' }} cluster.get('xmx','1G') {{ '}}' }} \
-    -Xloggc:/var/log/$NAME/zookeeper-gc.log \
-    -XX:+UseGCLogFileRotation \
-    -XX:NumberOfGCLogFiles=16 \
-    -XX:GCLogFileSize=16M \
+    -Xlog:safepoint,gc*=info,age*=debug:file=/var/log/$NAME/zookeeper-gc.log:time,level,tags:filecount=16,filesize=16M
     -verbose:gc \
-    -XX:+PrintGCTimeStamps \
-    -XX:+PrintGCDateStamps \
-    -XX:+PrintGCDetails
-    -XX:+PrintTenuringDistribution \
-    -XX:+PrintGCApplicationStoppedTime \
-    -XX:+PrintGCApplicationConcurrentTime \
-    -XX:+PrintSafepointStatistics \
-    -XX:+UseParNewGC \
-    -XX:+UseConcMarkSweepGC \
--XX:+CMSParallelRemarkEnabled"
+    -XX:+UseG1GC \
+    -Djute.maxbuffer=8388608 \
+    -XX:MaxGCPauseMillis=50"
 ```
 
 Salt init:
diff --git a/docs/en/operations/update.md b/docs/en/operations/update.md
index 9fa9c44e130..22995705af9 100644
--- a/docs/en/operations/update.md
+++ b/docs/en/operations/update.md
@@ -15,7 +15,8 @@ $ sudo service clickhouse-server restart
 
 If you installed ClickHouse using something other than the recommended `deb` packages, use the appropriate update method.
 
-ClickHouse does not support a distributed update. The operation should be performed consecutively on each separate server. Do not update all the servers on a cluster simultaneously, or the cluster will be unavailable for some time.
+!!! note "Note"
+    You can update multiple servers at once as soon as there is no moment when all replicas of one shard are offline.    
 
 The upgrade of older version of ClickHouse to specific version:
 
@@ -31,4 +32,3 @@ $ sudo service clickhouse-server restart
 
 
 
-
diff --git a/docs/en/sql-reference/data-types/date.md b/docs/en/sql-reference/data-types/date.md
index 886e93f433c..0cfac4d59fe 100644
--- a/docs/en/sql-reference/data-types/date.md
+++ b/docs/en/sql-reference/data-types/date.md
@@ -5,7 +5,7 @@ toc_title: Date
 
 # Date {#data_type-date}
 
-A date. Stored in two bytes as the number of days since 1970-01-01 (unsigned). Allows storing values from just after the beginning of the Unix Epoch to the upper threshold defined by a constant at the compilation stage (currently, this is until the year 2106, but the final fully-supported year is 2105).
+A date. Stored in two bytes as the number of days since 1970-01-01 (unsigned). Allows storing values from just after the beginning of the Unix Epoch to the upper threshold defined by a constant at the compilation stage (currently, this is until the year 2149, but the final fully-supported year is 2148).
 
 The date value is stored without the time zone.
 
diff --git a/docs/en/sql-reference/data-types/datetime64.md b/docs/en/sql-reference/data-types/datetime64.md
index 5cba8315090..1d3725b9fb3 100644
--- a/docs/en/sql-reference/data-types/datetime64.md
+++ b/docs/en/sql-reference/data-types/datetime64.md
@@ -9,7 +9,7 @@ Allows to store an instant in time, that can be expressed as a calendar date and
 
 Tick size (precision): 10<sup>-precision</sup> seconds
 
-Syntax:
+**Syntax:**
 
 ``` sql
 DateTime64(precision, [timezone])
@@ -17,9 +17,11 @@ DateTime64(precision, [timezone])
 
 Internally, stores data as a number of ‘ticks’ since epoch start (1970-01-01 00:00:00 UTC) as Int64. The tick resolution is determined by the precision parameter. Additionally, the `DateTime64` type can store time zone that is the same for the entire column, that affects how the values of the `DateTime64` type values are displayed in text format and how the values specified as strings are parsed (‘2020-01-01 05:00:01.000’). The time zone is not stored in the rows of the table (or in resultset), but is stored in the column metadata. See details in [DateTime](../../sql-reference/data-types/datetime.md).
 
+Supported range from January 1, 1925 till December 31, 2283.
+
 ## Examples {#examples}
 
-**1.** Creating a table with `DateTime64`-type column and inserting data into it:
+1. Creating a table with `DateTime64`-type column and inserting data into it:
 
 ``` sql
 CREATE TABLE dt
@@ -27,15 +29,15 @@ CREATE TABLE dt
     `timestamp` DateTime64(3, 'Europe/Moscow'),
     `event_id` UInt8
 )
-ENGINE = TinyLog
+ENGINE = TinyLog;
 ```
 
 ``` sql
-INSERT INTO dt Values (1546300800000, 1), ('2019-01-01 00:00:00', 2)
+INSERT INTO dt Values (1546300800000, 1), ('2019-01-01 00:00:00', 2);
 ```
 
 ``` sql
-SELECT * FROM dt
+SELECT * FROM dt;
 ```
 
 ``` text
@@ -45,13 +47,13 @@ SELECT * FROM dt
 └─────────────────────────┴──────────┘
 ```
 
--   When inserting datetime as an integer, it is treated as an appropriately scaled Unix Timestamp (UTC). `1546300800000` (with precision 3) represents `'2019-01-01 00:00:00'` UTC. However, as `timestamp` column has `Europe/Moscow` (UTC+3) timezone specified, when outputting as a string the value will be shown as `'2019-01-01 03:00:00'`
+-   When inserting datetime as an integer, it is treated as an appropriately scaled Unix Timestamp (UTC). `1546300800000` (with precision 3) represents `'2019-01-01 00:00:00'` UTC. However, as `timestamp` column has `Europe/Moscow` (UTC+3) timezone specified, when outputting as a string the value will be shown as `'2019-01-01 03:00:00'`.
 -   When inserting string value as datetime, it is treated as being in column timezone. `'2019-01-01 00:00:00'` will be treated as being in `Europe/Moscow` timezone and stored as `1546290000000`.
 
-**2.** Filtering on `DateTime64` values
+2. Filtering on `DateTime64` values
 
 ``` sql
-SELECT * FROM dt WHERE timestamp = toDateTime64('2019-01-01 00:00:00', 3, 'Europe/Moscow')
+SELECT * FROM dt WHERE timestamp = toDateTime64('2019-01-01 00:00:00', 3, 'Europe/Moscow');
 ```
 
 ``` text
@@ -60,12 +62,12 @@ SELECT * FROM dt WHERE timestamp = toDateTime64('2019-01-01 00:00:00', 3, 'Europ
 └─────────────────────────┴──────────┘
 ```
 
-Unlike `DateTime`, `DateTime64` values are not converted from `String` automatically
+Unlike `DateTime`, `DateTime64` values are not converted from `String` automatically.
 
-**3.** Getting a time zone for a `DateTime64`-type value:
+3. Getting a time zone for a `DateTime64`-type value:
 
 ``` sql
-SELECT toDateTime64(now(), 3, 'Europe/Moscow') AS column, toTypeName(column) AS x
+SELECT toDateTime64(now(), 3, 'Europe/Moscow') AS column, toTypeName(column) AS x;
 ```
 
 ``` text
@@ -74,13 +76,13 @@ SELECT toDateTime64(now(), 3, 'Europe/Moscow') AS column, toTypeName(column) AS
 └─────────────────────────┴────────────────────────────────┘
 ```
 
-**4.** Timezone conversion
+4. Timezone conversion
 
 ``` sql
 SELECT
 toDateTime64(timestamp, 3, 'Europe/London') as lon_time,
 toDateTime64(timestamp, 3, 'Europe/Moscow') as mos_time
-FROM dt
+FROM dt;
 ```
 
 ``` text
@@ -90,7 +92,7 @@ FROM dt
 └─────────────────────────┴─────────────────────────┘
 ```
 
-## See Also {#see-also}
+**See Also**
 
 -   [Type conversion functions](../../sql-reference/functions/type-conversion-functions.md)
 -   [Functions for working with dates and times](../../sql-reference/functions/date-time-functions.md)
diff --git a/docs/en/sql-reference/dictionaries/external-dictionaries/external-dicts-dict-structure.md b/docs/en/sql-reference/dictionaries/external-dictionaries/external-dicts-dict-structure.md
index dbf2fa67ac5..f22d2a0b59e 100644
--- a/docs/en/sql-reference/dictionaries/external-dictionaries/external-dicts-dict-structure.md
+++ b/docs/en/sql-reference/dictionaries/external-dictionaries/external-dicts-dict-structure.md
@@ -159,14 +159,14 @@ Configuration fields:
 | Tag                                                  | Description                                                                                                                                                                                                                                                                                                                                     | Required |
 |------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------|
 | `name`                                               | Column name.                                                                                                                                                                                                                                                                                                                                    | Yes      |
-| `type`                                               | ClickHouse data type.<br/>ClickHouse tries to cast value from dictionary to the specified data type. For example, for MySQL, the field might be `TEXT`, `VARCHAR`, or `BLOB` in the MySQL source table, but it can be uploaded as `String` in ClickHouse.<br/>[Nullable](../../../sql-reference/data-types/nullable.md) is not supported.       | Yes      |
-| `null_value`                                         | Default value for a non-existing element.<br/>In the example, it is an empty string. You cannot use `NULL` in this field.                                                                                                                                                                                                                       | Yes      |
+| `type`                                               | ClickHouse data type.<br/>ClickHouse tries to cast value from dictionary to the specified data type. For example, for MySQL, the field might be `TEXT`, `VARCHAR`, or `BLOB` in the MySQL source table, but it can be uploaded as `String` in ClickHouse.<br/>[Nullable](../../../sql-reference/data-types/nullable.md) is currently supported for [Flat](external-dicts-dict-layout.md#flat), [Hashed](external-dicts-dict-layout.md#dicts-external_dicts_dict_layout-hashed), [ComplexKeyHashed](external-dicts-dict-layout.md#complex-key-hashed), [Direct](external-dicts-dict-layout.md#direct), [ComplexKeyDirect](external-dicts-dict-layout.md#complex-key-direct), [RangeHashed](external-dicts-dict-layout.md#range-hashed), [Polygon](external-dicts-dict-polygon.md) dictionaries. In [Cache](external-dicts-dict-layout.md#cache), [ComplexKeyCache](external-dicts-dict-layout.md#complex-key-cache), [SSDCache](external-dicts-dict-layout.md#ssd-cache), [SSDComplexKeyCache](external-dicts-dict-layout.md#complex-key-ssd-cache), [IPTrie](external-dicts-dict-layout.md#ip-trie) dictionaries `Nullable` types are not supported.       | Yes      |
+| `null_value`                                         | Default value for a non-existing element.<br/>In the example, it is an empty string. [NULL](../../syntax.md#null-literal) value can be used only for the `Nullable` types (see the previous line with types description).                                                                                                                                                                                                                       | Yes      |
 | `expression`                                         | [Expression](../../../sql-reference/syntax.md#syntax-expressions) that ClickHouse executes on the value.<br/>The expression can be a column name in the remote SQL database. Thus, you can use it to create an alias for the remote column.<br/><br/>Default value: no expression.                                                              | No       |
 | <a name="hierarchical-dict-attr"></a> `hierarchical` | If `true`, the attribute contains the value of a parent key for the current key. See [Hierarchical Dictionaries](../../../sql-reference/dictionaries/external-dictionaries/external-dicts-dict-hierarchical.md).<br/><br/>Default value: `false`.                                                                                               | No       |
 | `injective`                                          | Flag that shows whether the `id -> attribute` image is [injective](https://en.wikipedia.org/wiki/Injective_function).<br/>If `true`, ClickHouse can automatically place after the `GROUP BY` clause the requests to dictionaries with injection. Usually it significantly reduces the amount of such requests.<br/><br/>Default value: `false`. | No       |
 | `is_object_id`                                       | Flag that shows whether the query is executed for a MongoDB document by `ObjectID`.<br/><br/>Default value: `false`.                                                                                                                                                                                                                            | No       |
 
-## See Also {#see-also}
+**See Also**
 
 -   [Functions for working with external dictionaries](../../../sql-reference/functions/ext-dict-functions.md).
 
diff --git a/docs/en/sql-reference/dictionaries/index.md b/docs/en/sql-reference/dictionaries/index.md
index fa127dab103..22f4182a1c0 100644
--- a/docs/en/sql-reference/dictionaries/index.md
+++ b/docs/en/sql-reference/dictionaries/index.md
@@ -10,8 +10,6 @@ A dictionary is a mapping (`key -> attributes`) that is convenient for various t
 
 ClickHouse supports special functions for working with dictionaries that can be used in queries. It is easier and more efficient to use dictionaries with functions than a `JOIN` with reference tables.
 
-[NULL](../../sql-reference/syntax.md#null-literal) values can’t be stored in a dictionary.
-
 ClickHouse supports:
 
 -   [Built-in dictionaries](../../sql-reference/dictionaries/internal-dicts.md#internal_dicts) with a specific [set of functions](../../sql-reference/functions/ym-dict-functions.md).
diff --git a/docs/en/sql-reference/functions/date-time-functions.md b/docs/en/sql-reference/functions/date-time-functions.md
index 6b26dae4546..b0636b0305e 100644
--- a/docs/en/sql-reference/functions/date-time-functions.md
+++ b/docs/en/sql-reference/functions/date-time-functions.md
@@ -147,6 +147,9 @@ Result:
 └────────────────┘
 ```
 
+!!! attention "Attention"
+    The return type `toStartOf*` functions described below is `Date` or `DateTime`. Though these functions can take `DateTime64` as an argument, passing them a `DateTime64` that is out of normal range (years 1970 - 2105) will give incorrect result.
+
 ## toStartOfYear {#tostartofyear}
 
 Rounds down a date or date with time to the first day of the year.
@@ -388,13 +391,13 @@ SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(d
 
 Truncates date and time data to the specified part of date.
 
-**Syntax** 
+**Syntax**
 
 ``` sql
 date_trunc(unit, value[, timezone])
 ```
 
-Alias: `dateTrunc`. 
+Alias: `dateTrunc`.
 
 **Arguments**
 
@@ -457,13 +460,13 @@ Result:
 
 Adds the time interval or date interval to the provided date or date with time.
 
-**Syntax** 
+**Syntax**
 
 ``` sql
 date_add(unit, value, date)
 ```
 
-Aliases: `dateAdd`, `DATE_ADD`. 
+Aliases: `dateAdd`, `DATE_ADD`.
 
 **Arguments**
 
@@ -478,7 +481,7 @@ Aliases: `dateAdd`, `DATE_ADD`.
     - `month`
     - `quarter`
     - `year`
-	
+
 -   `value` — Value of interval to add. [Int](../../sql-reference/data-types/int-uint.md).  
 -   `date` — The date or date with time to which `value` is added. [Date](../../sql-reference/data-types/date.md) or [DateTime](../../sql-reference/data-types/datetime.md).
 
@@ -583,7 +586,7 @@ Aliases: `dateSub`, `DATE_SUB`.
     - `month`
     - `quarter`
     - `year`
-	
+
 -   `value` — Value of interval to subtract. [Int](../../sql-reference/data-types/int-uint.md).    
 -   `date` — The date or date with time from which `value` is subtracted. [Date](../../sql-reference/data-types/date.md) or [DateTime](../../sql-reference/data-types/datetime.md).
 
@@ -613,16 +616,16 @@ Result:
 
 Adds the specified time value with the provided date or date time value.
 
-**Syntax** 
+**Syntax**
 
 ``` sql
 timestamp_add(date, INTERVAL value unit)
 ```
 
-Aliases: `timeStampAdd`, `TIMESTAMP_ADD`. 
+Aliases: `timeStampAdd`, `TIMESTAMP_ADD`.
 
 **Arguments**
-    
+
 -   `date` — Date or date with time. [Date](../../sql-reference/data-types/date.md) or [DateTime](../../sql-reference/data-types/datetime.md).
 -   `value` — Value of interval to add. [Int](../../sql-reference/data-types/int-uint.md).
 -   `unit` — The type of interval to add. [String](../../sql-reference/data-types/string.md).
@@ -642,7 +645,7 @@ Aliases: `timeStampAdd`, `TIMESTAMP_ADD`.
 Date or date with time with the specified `value` expressed in `unit` added to `date`.
 
 Type: [Date](../../sql-reference/data-types/date.md) or [DateTime](../../sql-reference/data-types/datetime.md).
-    
+
 **Example**
 
 Query:
@@ -663,13 +666,13 @@ Result:
 
 Subtracts the time interval from the provided date or date with time.
 
-**Syntax** 
+**Syntax**
 
 ``` sql
 timestamp_sub(unit, value, date)
 ```
 
-Aliases: `timeStampSub`, `TIMESTAMP_SUB`. 
+Aliases: `timeStampSub`, `TIMESTAMP_SUB`.
 
 **Arguments**
 
@@ -684,7 +687,7 @@ Aliases: `timeStampSub`, `TIMESTAMP_SUB`.
     - `month`
     - `quarter`
     - `year`
-	
+
 -   `value` — Value of interval to subtract. [Int](../../sql-reference/data-types/int-uint.md).   
 -   `date` — Date or date with time. [Date](../../sql-reference/data-types/date.md) or [DateTime](../../sql-reference/data-types/datetime.md).
 
@@ -709,12 +712,12 @@ Result:
 │                                          2018-07-18 01:02:03 │
 └──────────────────────────────────────────────────────────────┘
 ```
-    
+
 ## now {#now}
 
-Returns the current date and time. 
+Returns the current date and time.
 
-**Syntax** 
+**Syntax**
 
 ``` sql
 now([timezone])
@@ -1069,4 +1072,3 @@ Result:
 │ 2020-01-01                         │
 └────────────────────────────────────┘
 ```
-
diff --git a/docs/en/sql-reference/functions/string-functions.md b/docs/en/sql-reference/functions/string-functions.md
index 3d3caaf6e23..85570cb408d 100644
--- a/docs/en/sql-reference/functions/string-functions.md
+++ b/docs/en/sql-reference/functions/string-functions.md
@@ -649,3 +649,65 @@ Result:
 -   [List of XML and HTML character entity references](https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references)
 
 
+
+## extractTextFromHTML {#extracttextfromhtml}
+
+A function to extract text from HTML or XHTML.
+It does not necessarily 100% conform to any of the HTML, XML or XHTML standards, but the implementation is reasonably accurate and it is fast. The rules are the following:
+
+1. Comments are skipped. Example: `<!-- test -->`. Comment must end with `-->`. Nested comments are not possible.
+Note: constructions like `<!-->` and `<!--->` are not valid comments in HTML but they are skipped by other rules.
+2. CDATA is pasted verbatim. Note: CDATA is XML/XHTML specific. But it is processed for "best-effort" approach.
+3. `script` and `style` elements are removed with all their content. Note: it is assumed that closing tag cannot appear inside content. For example, in JS string literal has to be escaped like `"<\/script>"`.
+Note: comments and CDATA are possible inside `script` or `style` - then closing tags are not searched inside CDATA. Example: `<script><![CDATA[</script>]]></script>`. But they are still searched inside comments. Sometimes it becomes complicated: `<script>var x = "<!--"; </script> var y = "-->"; alert(x + y);</script>`
+Note: `script` and `style` can be the names of XML namespaces - then they are not treated like usual `script` or `style` elements. Example: `<script:a>Hello</script:a>`.
+Note: whitespaces are possible after closing tag name: `</script >` but not before: `< / script>`.
+4. Other tags or tag-like elements are skipped without inner content. Example: `<a>.</a>`
+Note: it is expected that this HTML is illegal: `<a test=">"></a>`
+Note: it also skips something like tags: `<>`, `<!>`, etc.
+Note: tag without end is skipped to the end of input: `<hello   `
+5. HTML and XML entities are not decoded. They must be processed by separate function.
+6. Whitespaces in the text are collapsed or inserted by specific rules.
+    - Whitespaces at the beginning and at the end are removed.
+    - Consecutive whitespaces are collapsed.
+    - But if the text is separated by other elements and there is no whitespace, it is inserted.
+    - It may cause unnatural examples: `Hello<b>world</b>`, `Hello<!-- -->world` - there is no whitespace in HTML, but the function inserts it. Also consider: `Hello<p>world</p>`, `Hello<br>world`. This behavior is reasonable for data analysis, e.g. to convert HTML to a bag of words.
+7. Also note that correct handling of whitespaces requires the support of `<pre></pre>` and CSS `display` and `white-space` properties.
+
+**Syntax**
+
+``` sql
+extractTextFromHTML(x)
+```
+
+**Arguments**
+
+-   `x` — input text. [String](../../sql-reference/data-types/string.md). 
+
+**Returned value**
+
+-   Extracted text.
+
+Type: [String](../../sql-reference/data-types/string.md).
+
+**Example**
+
+The first example contains several tags and a comment and also shows whitespace processing.
+The second example shows `CDATA` and `script` tag processing.
+In the third example text is extracted from the full HTML response received by the [url](../../sql-reference/table-functions/url.md) function.
+
+Query:
+
+``` sql
+SELECT extractTextFromHTML(' <p> A text <i>with</i><b>tags</b>. <!-- comments --> </p> ');
+SELECT extractTextFromHTML('<![CDATA[The content within <b>CDATA</b>]]> <script>alert("Script");</script>');
+SELECT extractTextFromHTML(html) FROM url('http://www.donothingfor2minutes.com/', RawBLOB, 'html String');
+```
+
+Result:
+
+``` text
+A text with tags .
+The content within <b>CDATA</b>
+Do Nothing for 2 Minutes 2:00 &nbsp;
+```
diff --git a/docs/en/sql-reference/statements/alter/ttl.md b/docs/en/sql-reference/statements/alter/ttl.md
index aa7ee838e10..9cd63d3b8fe 100644
--- a/docs/en/sql-reference/statements/alter/ttl.md
+++ b/docs/en/sql-reference/statements/alter/ttl.md
@@ -79,7 +79,7 @@ The `TTL` is no longer there, so the second row is not deleted:
 └───────────────────────┴─────────┴──────────────┘
 ```
 
-### See Also
+**See Also**
 
 - More about the [TTL-expression](../../../sql-reference/statements/create/table.md#ttl-expression).
 - Modify column [with TTL](../../../sql-reference/statements/alter/column.md#alter_modify-column).
diff --git a/docs/en/sql-reference/statements/check-table.md b/docs/en/sql-reference/statements/check-table.md
index 450447acaf8..65e6238ebbc 100644
--- a/docs/en/sql-reference/statements/check-table.md
+++ b/docs/en/sql-reference/statements/check-table.md
@@ -30,9 +30,36 @@ Performed over the tables with another table engines causes an exception.
 
 Engines from the `*Log` family don’t provide automatic data recovery on failure. Use the `CHECK TABLE` query to track data loss in a timely manner.
 
-For `MergeTree` family engines, the `CHECK TABLE` query shows a check status for every individual data part of a table on the local server.
+## Checking the MergeTree Family Tables {#checking-mergetree-tables}
 
-**If the data is corrupted**
+For `MergeTree` family engines, if [check_query_single_value_result](../../operations/settings/settings.md#check_query_single_value_result) = 0, the `CHECK TABLE` query shows a check status for every individual data part of a table on the local server. 
+
+```sql
+SET check_query_single_value_result = 0;
+CHECK TABLE test_table;
+```
+
+```text
+┌─part_path─┬─is_passed─┬─message─┐
+│ all_1_4_1 │         1 │         │
+│ all_1_4_2 │         1 │         │
+└───────────┴───────────┴─────────┘
+```
+
+If `check_query_single_value_result` = 0, the `CHECK TABLE` query shows the general table check status.
+
+```sql
+SET check_query_single_value_result = 1;
+CHECK TABLE test_table;
+```
+
+```text
+┌─result─┐
+│      1 │
+└────────┘
+```
+
+## If the Data Is Corrupted {#if-data-is-corrupted}
 
 If the table is corrupted, you can copy the non-corrupted data to another table. To do this:
 
diff --git a/docs/en/sql-reference/statements/rename.md b/docs/en/sql-reference/statements/rename.md
index 4f14ad016a3..a9dda6ed3b2 100644
--- a/docs/en/sql-reference/statements/rename.md
+++ b/docs/en/sql-reference/statements/rename.md
@@ -5,6 +5,14 @@ toc_title: RENAME
 
 # RENAME Statement {#misc_operations-rename}
 
+## RENAME DATABASE {#misc_operations-rename_database}
+Renames database, support only for Atomic database engine
+
+```
+RENAME DATABASE atomic_database1 TO atomic_database2 [ON CLUSTER cluster]
+```
+
+## RENAME TABLE {#misc_operations-rename_table}
 Renames one or more tables.
 
 ``` sql
diff --git a/docs/en/sql-reference/statements/system.md b/docs/en/sql-reference/statements/system.md
index 2348a2a2668..919bd65d56b 100644
--- a/docs/en/sql-reference/statements/system.md
+++ b/docs/en/sql-reference/statements/system.md
@@ -169,7 +169,7 @@ SYSTEM START MERGES [ON VOLUME <volume_name> | [db.]merge_tree_family_table_name
 ### STOP TTL MERGES {#query_language-stop-ttl-merges}
 
 Provides possibility to stop background delete old data according to [TTL expression](../../engines/table-engines/mergetree-family/mergetree.md#table_engine-mergetree-ttl) for tables in the MergeTree family:
-Return `Ok.` even table doesn’t exists or table have not MergeTree engine. Return error when database doesn’t exists:
+Returns `Ok.` even if table doesn’t exist or table has not MergeTree engine. Returns error when database doesn’t exist:
 
 ``` sql
 SYSTEM STOP TTL MERGES [[db.]merge_tree_family_table_name]
@@ -178,7 +178,7 @@ SYSTEM STOP TTL MERGES [[db.]merge_tree_family_table_name]
 ### START TTL MERGES {#query_language-start-ttl-merges}
 
 Provides possibility to start background delete old data according to [TTL expression](../../engines/table-engines/mergetree-family/mergetree.md#table_engine-mergetree-ttl) for tables in the MergeTree family:
-Return `Ok.` even table doesn’t exists. Return error when database doesn’t exists:
+Returns `Ok.` even if table doesn’t exist. Returns error when database doesn’t exist:
 
 ``` sql
 SYSTEM START TTL MERGES [[db.]merge_tree_family_table_name]
@@ -187,7 +187,7 @@ SYSTEM START TTL MERGES [[db.]merge_tree_family_table_name]
 ### STOP MOVES {#query_language-stop-moves}
 
 Provides possibility to stop background move data according to [TTL table expression with TO VOLUME or TO DISK clause](../../engines/table-engines/mergetree-family/mergetree.md#mergetree-table-ttl) for tables in the MergeTree family:
-Return `Ok.` even table doesn’t exists. Return error when database doesn’t exists:
+Returns `Ok.` even if table doesn’t exist. Returns error when database doesn’t exist:
 
 ``` sql
 SYSTEM STOP MOVES [[db.]merge_tree_family_table_name]
@@ -196,7 +196,7 @@ SYSTEM STOP MOVES [[db.]merge_tree_family_table_name]
 ### START MOVES {#query_language-start-moves}
 
 Provides possibility to start background move data according to [TTL table expression with TO VOLUME and TO DISK clause](../../engines/table-engines/mergetree-family/mergetree.md#mergetree-table-ttl) for tables in the MergeTree family:
-Return `Ok.` even table doesn’t exists. Return error when database doesn’t exists:
+Returns `Ok.` even if table doesn’t exist. Returns error when database doesn’t exist:
 
 ``` sql
 SYSTEM STOP MOVES [[db.]merge_tree_family_table_name]
@@ -209,7 +209,7 @@ ClickHouse can manage background replication related processes in [ReplicatedMer
 ### STOP FETCHES {#query_language-system-stop-fetches}
 
 Provides possibility to stop background fetches for inserted parts for tables in the `ReplicatedMergeTree` family:
-Always returns `Ok.` regardless of the table engine and even table or database doesn’t exists.
+Always returns `Ok.` regardless of the table engine and even if table or database doesn’t exist.
 
 ``` sql
 SYSTEM STOP FETCHES [[db.]replicated_merge_tree_family_table_name]
@@ -218,7 +218,7 @@ SYSTEM STOP FETCHES [[db.]replicated_merge_tree_family_table_name]
 ### START FETCHES {#query_language-system-start-fetches}
 
 Provides possibility to start background fetches for inserted parts for tables in the `ReplicatedMergeTree` family:
-Always returns `Ok.` regardless of the table engine and even table or database doesn’t exists.
+Always returns `Ok.` regardless of the table engine and even if table or database doesn’t exist.
 
 ``` sql
 SYSTEM START FETCHES [[db.]replicated_merge_tree_family_table_name]
@@ -264,7 +264,7 @@ Wait until a `ReplicatedMergeTree` table will be synced with other replicas in a
 SYSTEM SYNC REPLICA [db.]replicated_merge_tree_family_table_name
 ```
 
-After running this statement the `[db.]replicated_merge_tree_family_table_name` fetches commands from 
+After running this statement the `[db.]replicated_merge_tree_family_table_name` fetches commands from
 the common replicated log into its own replication queue, and then the query waits till the replica processes all
 of the fetched commands.
 
@@ -280,4 +280,3 @@ SYSTEM RESTART REPLICA [db.]replicated_merge_tree_family_table_name
 ### RESTART REPLICAS {#query_language-system-restart-replicas}
 
 Provides possibility to reinitialize Zookeeper sessions state for all `ReplicatedMergeTree` tables, will compare current state with Zookeeper as source of true and add tasks to Zookeeper queue if needed
-
diff --git a/docs/ru/engines/table-engines/integrations/postgresql.md b/docs/ru/engines/table-engines/integrations/postgresql.md
index 8964b1dbf02..064665d49c1 100644
--- a/docs/ru/engines/table-engines/integrations/postgresql.md
+++ b/docs/ru/engines/table-engines/integrations/postgresql.md
@@ -22,7 +22,7 @@ CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
 
 Структура таблицы может отличаться от исходной структуры таблицы PostgreSQL:
 
--   Имена столбцов должны быть такими же, как в исходной таблице MySQL, но вы можете использовать только некоторые из этих столбцов и в любом порядке.
+-   Имена столбцов должны быть такими же, как в исходной таблице PostgreSQL, но вы можете использовать только некоторые из этих столбцов и в любом порядке.
 -   Типы столбцов могут отличаться от типов в исходной таблице PostgreSQL. ClickHouse пытается [приводить](../../../sql-reference/functions/type-conversion-functions.md#type_conversion_function-cast) values to the ClickHouse data types.
 -   Настройка `external_table_functions_use_nulls` определяет как обрабатывать Nullable столбцы. По умолчанию 1, если 0 - табличная функция не будет делать nullable столбцы и будет вместо null выставлять значения по умолчанию для скалярного типа. Это также применимо для null значений внутри массивов.
 
diff --git a/docs/ru/getting-started/example-datasets/cell-towers.md b/docs/ru/getting-started/example-datasets/cell-towers.md
new file mode 100644
index 00000000000..a5524248019
--- /dev/null
+++ b/docs/ru/getting-started/example-datasets/cell-towers.md
@@ -0,0 +1,128 @@
+---
+toc_priority: 21
+toc_title: Вышки сотовой связи
+---
+
+# Вышки сотовой связи {#cell-towers}
+
+Источник этого набора данных (dataset) - самая большая в мире открытая база данных о сотовых вышках - [OpenCellid](https://www.opencellid.org/). К 2021-му году здесь накопилось более, чем 40 миллионов записей о сотовых вышках (GSM, LTE, UMTS, и т.д.) по всему миру с их географическими координатами и метаданными (код страны, сети, и т.д.).
+
+OpenCelliD Project имеет лицензию Creative Commons Attribution-ShareAlike 4.0 International License, и мы распространяем снэпшот набора данных по условиям этой же лицензии. После авторизации можно загрузить последнюю версию набора данных.
+
+## Как получить набор данных {#get-the-dataset}
+
+1. Загрузите снэпшот набора данных за февраль 2021 [отсюда](https://datasets.clickhouse.tech/cell_towers.csv.xz) (729 MB).
+
+2. Если нужно, проверьте полноту и целостность при помощи команды:
+
+```
+md5sum cell_towers.csv.xz
+8cf986f4a0d9f12c6f384a0e9192c908  cell_towers.csv.xz
+```
+
+3. Распакуйте набор данных при помощи команды:
+
+```
+xz -d cell_towers.csv.xz
+```
+
+4. Создайте таблицу:
+
+```
+CREATE TABLE cell_towers
+(
+    radio Enum8('' = 0, 'CDMA' = 1, 'GSM' = 2, 'LTE' = 3, 'NR' = 4, 'UMTS' = 5),
+    mcc UInt16,
+    net UInt16,
+    area UInt16,
+    cell UInt64,
+    unit Int16,
+    lon Float64,
+    lat Float64,
+    range UInt32,
+    samples UInt32,
+    changeable UInt8,
+    created DateTime,
+    updated DateTime,
+    averageSignal UInt8
+)
+ENGINE = MergeTree ORDER BY (radio, mcc, net, created);
+```
+
+5. Вставьте данные:
+```
+clickhouse-client --query "INSERT INTO cell_towers FORMAT CSVWithNames" < cell_towers.csv
+```
+
+## Примеры {#examples}
+
+1. Количество вышек по типам:
+
+```
+SELECT radio, count() AS c FROM cell_towers GROUP BY radio ORDER BY c DESC
+
+┌─radio─┬────────c─┐
+│ UMTS  │ 20686487 │
+│ LTE   │ 12101148 │
+│ GSM   │  9931312 │
+│ CDMA  │   556344 │
+│ NR    │      867 │
+└───────┴──────────┘
+
+5 rows in set. Elapsed: 0.011 sec. Processed 43.28 million rows, 43.28 MB (3.83 billion rows/s., 3.83 GB/s.)
+```
+
+2. Количество вышек по [мобильному коду страны (MCC)](https://ru.wikipedia.org/wiki/Mobile_Country_Code):
+
+```
+SELECT mcc, count() FROM cell_towers GROUP BY mcc ORDER BY count() DESC LIMIT 10
+
+┌─mcc─┬─count()─┐
+│ 310 │ 5024650 │
+│ 262 │ 2622423 │
+│ 250 │ 1953176 │
+│ 208 │ 1891187 │
+│ 724 │ 1836150 │
+│ 404 │ 1729151 │
+│ 234 │ 1618924 │
+│ 510 │ 1353998 │
+│ 440 │ 1343355 │
+│ 311 │ 1332798 │
+└─────┴─────────┘
+
+10 rows in set. Elapsed: 0.019 sec. Processed 43.28 million rows, 86.55 MB (2.33 billion rows/s., 4.65 GB/s.)
+```
+
+Можно увидеть, что по количеству вышек лидируют следующие страны: США, Германия, Россия.
+
+Вы также можете создать [внешний словарь](../../sql-reference/dictionaries/external-dictionaries/external-dicts.md) в ClickHouse для того, чтобы расшифровать эти значения.
+
+## Пример использования {#use-case}
+
+Рассмотрим применение функции `pointInPolygon`.
+
+1. Создаем таблицу, в которой будем хранить многоугольники:
+
+```
+CREATE TEMPORARY TABLE moscow (polygon Array(Tuple(Float64, Float64)));
+```
+
+2. Очертания Москвы выглядят приблизительно так ("Новая Москва" в них не включена):
+
+```
+INSERT INTO moscow VALUES ([(37.84172564285271, 55.78000432402266), (37.8381207618713, 55.775874525970494), (37.83979446823122, 55.775626746008065), (37.84243326983639, 55.77446586811748), (37.84262672750849, 55.771974101091104), (37.84153238623039, 55.77114545193181), (37.841124690460184, 55.76722010265554), (37.84239076983644, 55.76654891107098), (37.842283558197025, 55.76258709833121), (37.8421759312134, 55.758073999993734), (37.84198330422974, 55.75381499999371), (37.8416827275085, 55.749277102484484), (37.84157576190186, 55.74794544108413), (37.83897929098507, 55.74525257875241), (37.83739676451868, 55.74404373042019), (37.838732481460525, 55.74298009816793), (37.841183997352545, 55.743060321833575), (37.84097476190185, 55.73938799999373), (37.84048155819702, 55.73570799999372), (37.840095812164286, 55.73228210777237), (37.83983814285274, 55.73080491981639), (37.83846476321406, 55.729799917464675), (37.83835745269769, 55.72919751082619), (37.838636380279524, 55.72859509486539), (37.8395161005249, 55.727705075632784), (37.83897964285276, 55.722727886185154), (37.83862557539366, 55.72034817326636), (37.83559735744853, 55.71944437307499), (37.835370708803126, 55.71831419154461), (37.83738169402022, 55.71765218986692), (37.83823396494291, 55.71691750159089), (37.838056931213345, 55.71547311301385), (37.836812846557606, 55.71221445615604), (37.83522525396725, 55.709331054395555), (37.83269301586908, 55.70953687463627), (37.829667367706236, 55.70903403789297), (37.83311126588435, 55.70552351822608), (37.83058993121339, 55.70041317726053), (37.82983872750851, 55.69883771404813), (37.82934501586913, 55.69718947487017), (37.828926414016685, 55.69504441658371), (37.82876530422971, 55.69287499999378), (37.82894754100031, 55.690759754047335), (37.827697554878185, 55.68951421135665), (37.82447346292115, 55.68965045405069), (37.83136543914793, 55.68322046195302), (37.833554015869154, 55.67814012759211), (37.83544184655761, 55.67295011628339), (37.837480388885474, 55.6672498719639), (37.838960677246064, 55.66316274139358), (37.83926093121332, 55.66046999999383), (37.839025050262435, 55.65869897264431), (37.83670784390257, 55.65794084879904), (37.835656529083245, 55.65694309303843), (37.83704060449217, 55.65689306460552), (37.83696819873806, 55.65550363526252), (37.83760389616388, 55.65487847246661), (37.83687972750851, 55.65356745541324), (37.83515216004943, 55.65155951234079), (37.83312418518067, 55.64979413590619), (37.82801726983639, 55.64640836412121), (37.820614174591, 55.64164525405531), (37.818908190475426, 55.6421883258084), (37.81717543386075, 55.64112490388471), (37.81690987037274, 55.63916106913107), (37.815099354492155, 55.637925371757085), (37.808769150787356, 55.633798276884455), (37.80100123544311, 55.62873670012244), (37.79598013491824, 55.62554336109055), (37.78634567724606, 55.62033499605651), (37.78334147619623, 55.618768681480326), (37.77746201055901, 55.619855533402706), (37.77527329626457, 55.61909966711279), (37.77801986242668, 55.618770300976294), (37.778212973541216, 55.617257701952106), (37.77784818518065, 55.61574504433011), (37.77016867724609, 55.61148576294007), (37.760191219573976, 55.60599579539028), (37.75338926983641, 55.60227892751446), (37.746329965606634, 55.59920577639331), (37.73939925396728, 55.59631430313617), (37.73273665739439, 55.5935318803559), (37.7299954450912, 55.59350760316188), (37.7268679946899, 55.59469840523759), (37.72626726983634, 55.59229549697373), (37.7262673598022, 55.59081598950582), (37.71897193121335, 55.5877595845419), (37.70871550793456, 55.58393177431724), (37.700497489410374, 55.580917323756644), (37.69204305026244, 55.57778089778455), (37.68544477378839, 55.57815154690915), (37.68391050793454, 55.57472945079756), (37.678803592590306, 55.57328235936491), (37.6743402539673, 55.57255251445782), (37.66813862698363, 55.57216388774464), (37.617927457672096, 55.57505691895805), (37.60443099999999, 55.5757737568051), (37.599683515869145, 55.57749105910326), (37.59754177842709, 55.57796291823627), (37.59625834786988, 55.57906686095235), (37.59501783265684, 55.57746616444403), (37.593090671936025, 55.57671634534502), (37.587018007904, 55.577944600233785), (37.578692203704804, 55.57982895000019), (37.57327546607398, 55.58116294118248), (37.57385012109279, 55.581550362779), (37.57399562266922, 55.5820107079112), (37.5735356072979, 55.58226289171689), (37.57290393054962, 55.582393529795155), (37.57037722355653, 55.581919415056234), (37.5592298306885, 55.584471614867844), (37.54189249206543, 55.58867650795186), (37.5297256269836, 55.59158133551745), (37.517837865081766, 55.59443656218868), (37.51200186508174, 55.59635625174229), (37.506808949737554, 55.59907823904434), (37.49820432275389, 55.6062944994944), (37.494406071441674, 55.60967103463367), (37.494760001358024, 55.61066689753365), (37.49397137107085, 55.61220931698269), (37.49016528606031, 55.613417718449064), (37.48773249206542, 55.61530616333343), (37.47921386508177, 55.622640129112334), (37.470652153442394, 55.62993723476164), (37.46273446298218, 55.6368075123157), (37.46350692265317, 55.64068225239439), (37.46050283203121, 55.640794546982576), (37.457627470916734, 55.64118904154646), (37.450718034393326, 55.64690488145138), (37.44239252645875, 55.65397824729769), (37.434587576721185, 55.66053543155961), (37.43582144975277, 55.661693766520735), (37.43576786245721, 55.662755031737014), (37.430982915344174, 55.664610641628116), (37.428547447097685, 55.66778515273695), (37.42945134592044, 55.668633314343566), (37.42859571562949, 55.66948145750025), (37.4262836402282, 55.670813882451405), (37.418709037048295, 55.6811141674414), (37.41922139651101, 55.68235377885389), (37.419218771842885, 55.68359335082235), (37.417196501327446, 55.684375235224735), (37.41607020370478, 55.68540557585352), (37.415640857147146, 55.68686637150793), (37.414632153442334, 55.68903015131686), (37.413344899475064, 55.690896881757396), (37.41171432275391, 55.69264232162232), (37.40948282275393, 55.69455101638112), (37.40703674603271, 55.69638690385348), (37.39607169577025, 55.70451821283731), (37.38952706878662, 55.70942491932811), (37.387778313491815, 55.71149057784176), (37.39049275399779, 55.71419814298992), (37.385557272491454, 55.7155489617061), (37.38388335714726, 55.71849856042102), (37.378368238098155, 55.7292763261685), (37.37763597123337, 55.730845879211614), (37.37890062088197, 55.73167906388319), (37.37750451918789, 55.734703664681774), (37.375610832015965, 55.734851959522246), (37.3723813571472, 55.74105626086403), (37.37014935714723, 55.746115620904355), (37.36944173016362, 55.750883999993725), (37.36975304365541, 55.76335905525834), (37.37244070571134, 55.76432079697595), (37.3724259757175, 55.76636979670426), (37.369922155757884, 55.76735417953104), (37.369892695770275, 55.76823419316575), (37.370214730163575, 55.782312184391266), (37.370493611114505, 55.78436801120489), (37.37120164550783, 55.78596427165359), (37.37284851456452, 55.7874378183096), (37.37608325135799, 55.7886695054807), (37.3764587460632, 55.78947647305964), (37.37530000265506, 55.79146512926804), (37.38235915344241, 55.79899647809345), (37.384344043655396, 55.80113596939471), (37.38594269577028, 55.80322699999366), (37.38711208598329, 55.804919036911976), (37.3880239841309, 55.806610999993666), (37.38928977249147, 55.81001864976979), (37.39038389947512, 55.81348641242801), (37.39235781481933, 55.81983538336746), (37.393709457672124, 55.82417822811877), (37.394685720901464, 55.82792275755836), (37.39557615344238, 55.830447148154136), (37.39844478226658, 55.83167107969975), (37.40019761214057, 55.83151823557964), (37.400398790382326, 55.83264967594742), (37.39659544313046, 55.83322180909622), (37.39667059524539, 55.83402792148566), (37.39682089947515, 55.83638877400216), (37.39643489154053, 55.83861656112751), (37.3955338994751, 55.84072348043264), (37.392680272491454, 55.84502158126453), (37.39241188227847, 55.84659117913199), (37.392529730163616, 55.84816071336481), (37.39486835714723, 55.85288092980303), (37.39873052645878, 55.859893456073635), (37.40272161111449, 55.86441833633205), (37.40697072750854, 55.867579567544375), (37.410007082016016, 55.868369880337), (37.4120992989502, 55.86920843741314), (37.412668021163924, 55.87055369615854), (37.41482461111453, 55.87170587948249), (37.41862266137694, 55.873183961039565), (37.42413732540892, 55.874879126654704), (37.4312182698669, 55.875614937236705), (37.43111093783558, 55.8762723478417), (37.43332105622856, 55.87706546369396), (37.43385747619623, 55.87790681284802), (37.441303050262405, 55.88027084462084), (37.44747234260555, 55.87942070143253), (37.44716141796871, 55.88072960917233), (37.44769797085568, 55.88121221323979), (37.45204320500181, 55.882080694420715), (37.45673176190186, 55.882346110794586), (37.463383999999984, 55.88252729504517), (37.46682797486874, 55.88294937719063), (37.470014457672086, 55.88361266759345), (37.47751410450743, 55.88546991372396), (37.47860317658232, 55.88534929207307), (37.48165826025772, 55.882563306475106), (37.48316434442331, 55.8815803226785), (37.483831555817645, 55.882427612793315), (37.483182967125686, 55.88372791409729), (37.483092277908824, 55.88495581062434), (37.4855716508179, 55.8875561994203), (37.486440636245746, 55.887827444039566), (37.49014203439328, 55.88897899871799), (37.493210285705544, 55.890208937135604), (37.497512451065035, 55.891342397444696), (37.49780744510645, 55.89174030252967), (37.49940333499519, 55.89239745507079), (37.50018383334346, 55.89339220941865), (37.52421672750851, 55.903869074155224), (37.52977457672118, 55.90564076517974), (37.53503220370484, 55.90661661218259), (37.54042858064267, 55.90714113744566), (37.54320461007303, 55.905645048442985), (37.545686966066306, 55.906608607018505), (37.54743976120755, 55.90788552162358), (37.55796999999999, 55.90901557907218), (37.572711542327866, 55.91059395704873), (37.57942799999998, 55.91073854155573), (37.58502865872187, 55.91009969268444), (37.58739968913264, 55.90794809960554), (37.59131567193598, 55.908713267595054), (37.612687423278814, 55.902866854295375), (37.62348079629517, 55.90041967242986), (37.635797880950896, 55.898141151686396), (37.649487626983664, 55.89639275532968), (37.65619302513125, 55.89572360207488), (37.66294133862307, 55.895295577183965), (37.66874564418033, 55.89505457604897), (37.67375601586915, 55.89254677027454), (37.67744661901856, 55.8947775867987), (37.688347, 55.89450045676125), (37.69480554232789, 55.89422926332761), (37.70107096560668, 55.89322256101114), (37.705962965606716, 55.891763491662616), (37.711885134918205, 55.889110234998974), (37.71682005026245, 55.886577568759876), (37.7199315476074, 55.88458159806678), (37.72234560316464, 55.882281005794134), (37.72364385977171, 55.8809452036196), (37.725371142837474, 55.8809722706006), (37.727870902099546, 55.88037213862385), (37.73394330422971, 55.877941504088696), (37.745339592590376, 55.87208120378722), (37.75525267724611, 55.86703807949492), (37.76919976190188, 55.859821640197474), (37.827835219574, 55.82962968399116), (37.83341438888553, 55.82575289922351), (37.83652584655761, 55.82188784027888), (37.83809213491821, 55.81612575504693), (37.83605359521481, 55.81460347077685), (37.83632178569025, 55.81276696067908), (37.838623105812026, 55.811486181656385), (37.83912198147584, 55.807329380532785), (37.839079078033414, 55.80510270463816), (37.83965844708251, 55.79940712529036), (37.840581150787344, 55.79131399999368), (37.84172564285271, 55.78000432402266)]);
+```
+
+3. Проверяем, сколько сотовых вышек находится в Москве:
+
+```
+SELECT count() FROM cell_towers WHERE pointInPolygon((lon, lat), (SELECT * FROM moscow))
+
+┌─count()─┐
+│  310463 │
+└─────────┘
+
+1 rows in set. Elapsed: 0.067 sec. Processed 43.28 million rows, 692.42 MB (645.83 million rows/s., 10.33 GB/s.)
+```
+
+Вы можете протестировать другие запросы с помощью интерактивного ресурса [Playground](https://gh-api.clickhouse.tech/play?user=play). Например, [вот так](https://gh-api.clickhouse.tech/play?user=play#U0VMRUNUIG1jYywgY291bnQoKSBGUk9NIGNlbGxfdG93ZXJzIEdST1VQIEJZIG1jYyBPUkRFUiBCWSBjb3VudCgpIERFU0M=). Однако, обратите внимание, что здесь нельзя создавать временные таблицы.
diff --git a/docs/ru/getting-started/example-datasets/index.md b/docs/ru/getting-started/example-datasets/index.md
index f590300adda..756b3a75dee 100644
--- a/docs/ru/getting-started/example-datasets/index.md
+++ b/docs/ru/getting-started/example-datasets/index.md
@@ -16,4 +16,5 @@ toc_title: "Введение"
 -   [AMPLab Big Data Benchmark](amplab-benchmark.md)
 -   [Данные о такси в Нью-Йорке](nyc-taxi.md)
 -   [OnTime](ontime.md)
+-   [Вышки сотовой связи](../../getting-started/example-datasets/cell-towers.md)
 
diff --git a/docs/ru/operations/server-configuration-parameters/settings.md b/docs/ru/operations/server-configuration-parameters/settings.md
index 84ef62650e1..be9e2deab74 100644
--- a/docs/ru/operations/server-configuration-parameters/settings.md
+++ b/docs/ru/operations/server-configuration-parameters/settings.md
@@ -291,7 +291,7 @@ ClickHouse проверяет условия для `min_part_size` и `min_part
 
 ## interserver_http_host {#interserver-http-host}
 
-Имя хоста, которое могут использовать другие серверы для обращения к этому.
+Имя хоста, которое могут использовать другие серверы для обращения к этому хосту.
 
 Если не указано, то определяется аналогично команде `hostname -f`.
 
@@ -303,11 +303,36 @@ ClickHouse проверяет условия для `min_part_size` и `min_part
 <interserver_http_host>example.yandex.ru</interserver_http_host>
 ```
 
+## interserver_https_port {#interserver-https-port}
+
+Порт для обмена данными между репликами ClickHouse по протоколу `HTTPS`.
+
+**Пример**
+
+``` xml
+<interserver_https_port>9010</interserver_https_port>
+```
+
+## interserver_https_host {#interserver-https-host}
+
+Имя хоста, которое могут использовать другие реплики для обращения к нему по протоколу `HTTPS`.
+
+**Пример**
+
+``` xml
+<interserver_https_host>example.yandex.ru</interserver_https_host>
+```
+
+
+
 ## interserver_http_credentials {#server-settings-interserver-http-credentials}
 
 Имя пользователя и пароль, использующиеся для аутентификации при [репликации](../../operations/server-configuration-parameters/settings.md) движками Replicated\*. Это имя пользователя и пароль используются только для взаимодействия между репликами кластера и никак не связаны с аутентификацией клиентов ClickHouse. Сервер проверяет совпадение имени и пароля для соединяющихся с ним реплик, а также использует это же имя и пароль для соединения с другими репликами. Соответственно, эти имя и пароль должны быть прописаны одинаковыми для всех реплик кластера.
 По умолчанию аутентификация не используется.
 
+!!! note "Примечание"
+    Эти учетные данные являются общими для обмена данными по протоколам `HTTP` и `HTTPS`.
+
 Раздел содержит следующие параметры:
 
 -   `user` — имя пользователя.
diff --git a/docs/ru/operations/settings/merge-tree-settings.md b/docs/ru/operations/settings/merge-tree-settings.md
index bfc0b0a2644..f9093d379e3 100644
--- a/docs/ru/operations/settings/merge-tree-settings.md
+++ b/docs/ru/operations/settings/merge-tree-settings.md
@@ -55,6 +55,26 @@ Eсли число кусков в партиции превышает знач
 
 ClickHouse искусственно выполняет `INSERT` дольше (добавляет ‘sleep’), чтобы фоновый механизм слияния успевал слиять куски быстрее, чем они добавляются.
 
+## inactive_parts_to_throw_insert {#inactive-parts-to-throw-insert}
+
+Если число неактивных кусков в партиции превышает значение `inactive_parts_to_throw_insert`, `INSERT` прерывается с исключением «Too many inactive parts (N). Parts cleaning are processing significantly slower than inserts».
+
+Возможные значения:
+
+-   Положительное целое число.
+
+Значение по умолчанию: 0 (не ограничено).
+
+## inactive_parts_to_delay_insert {#inactive-parts-to-delay-insert}
+
+Если число неактивных кусков в партиции больше или равно значению `inactive_parts_to_delay_insert`, `INSERT` искусственно замедляется. Это полезно, когда сервер не может быстро очистить неактивные куски.
+
+Возможные значения:
+
+-   Положительное целое число.
+
+Значение по умолчанию: 0 (не ограничено).
+
 ## max_delay_to_insert {#max-delay-to-insert}
 
 Величина в секундах, которая используется для расчета задержки `INSERT`, если число кусков в партиции превышает значение [parts_to_delay_insert](#parts-to-delay-insert).
diff --git a/docs/ru/operations/settings/settings.md b/docs/ru/operations/settings/settings.md
index 263b6904841..7acdd65051b 100644
--- a/docs/ru/operations/settings/settings.md
+++ b/docs/ru/operations/settings/settings.md
@@ -2746,4 +2746,15 @@ SELECT * FROM test2;
 
 Значение по умолчанию: `60`.
 
+## check_query_single_value_result {#check_query_single_value_result}
+
+Определяет уровень детализации результата для запросов [CHECK TABLE](../../sql-reference/statements/check-table.md#checking-mergetree-tables) для таблиц семейства `MergeTree`.
+
+Возможные значения:
+
+-   0 — запрос возвращает статус каждого куска данных таблицы.
+-   1 — запрос возвращает статус таблицы в целом.
+
+Значение по умолчанию: `0`.
+
 [Оригинальная статья](https://clickhouse.tech/docs/ru/operations/settings/settings/) <!--hide-->
diff --git a/docs/ru/operations/update.md b/docs/ru/operations/update.md
index 5c187ed1604..34f86656b61 100644
--- a/docs/ru/operations/update.md
+++ b/docs/ru/operations/update.md
@@ -3,7 +3,7 @@ toc_priority: 47
 toc_title: "Обновление ClickHouse"
 ---
 
-# Обновление ClickHouse {#obnovlenie-clickhouse}
+# Обновление ClickHouse {#clickhouse-upgrade}
 
 Если ClickHouse установлен с помощью deb-пакетов, выполните следующие команды на сервере:
 
@@ -15,4 +15,19 @@ $ sudo service clickhouse-server restart
 
 Если ClickHouse установлен не из рекомендуемых deb-пакетов, используйте соответствующий метод обновления.
 
-ClickHouse не поддерживает распределенное обновление. Операция должна выполняться последовательно на каждом отдельном сервере. Не обновляйте все серверы в кластере одновременно, иначе кластер становится недоступным в течение некоторого времени.
+!!! note "Примечание"
+    Вы можете обновить сразу несколько серверов, кроме случая, когда все реплики одного шарда отключены.
+
+Обновление ClickHouse до определенной версии:
+
+**Пример**
+
+`xx.yy.a.b` — это номер текущей стабильной версии. Последнюю стабильную версию можно узнать [здесь](https://github.com/ClickHouse/ClickHouse/releases)
+
+```bash
+$ sudo apt-get update
+$ sudo apt-get install clickhouse-server=xx.yy.a.b clickhouse-client=xx.yy.a.b clickhouse-common-static=xx.yy.a.b
+$ sudo service clickhouse-server restart
+```
+
+[Оригинальная статья](https://clickhouse.tech/docs/ru/operations/update/) <!--hide-->
diff --git a/docs/ru/sql-reference/data-types/datetime64.md b/docs/ru/sql-reference/data-types/datetime64.md
index 6576bf9dc0d..3a08da75bb7 100644
--- a/docs/ru/sql-reference/data-types/datetime64.md
+++ b/docs/ru/sql-reference/data-types/datetime64.md
@@ -7,9 +7,9 @@ toc_title: DateTime64
 
 Позволяет хранить момент времени, который может быть представлен как календарная дата и время, с заданной суб-секундной точностью.
 
-Размер тика/точность: 10<sup>-precision</sup> секунд, где precision - целочисленный параметр типа.
+Размер тика (точность, precision): 10<sup>-precision</sup> секунд, где precision - целочисленный параметр.
 
-Синтаксис:
+**Синтаксис:**
 
 ``` sql
 DateTime64(precision, [timezone])
@@ -17,9 +17,11 @@ DateTime64(precision, [timezone])
 
 Данные хранятся в виде количества ‘тиков’, прошедших с момента начала эпохи (1970-01-01 00:00:00 UTC), в Int64. Размер тика определяется параметром precision. Дополнительно, тип `DateTime64` позволяет хранить часовой пояс, единый для всей колонки, который влияет на то, как будут отображаться значения типа `DateTime64` в текстовом виде и как будут парситься значения заданные в виде строк (‘2020-01-01 05:00:01.000’). Часовой пояс не хранится в строках таблицы (выборки), а хранится в метаданных колонки. Подробнее см. [DateTime](datetime.md).
 
-## Пример {#primer}
+Поддерживаются значения от 1 января 1925 г. и до 31 декабря 2283 г.
 
-**1.** Создание таблицы с столбцом типа `DateTime64` и вставка данных в неё:
+## Примеры {#examples}
+
+1. Создание таблицы со столбцом типа `DateTime64` и вставка данных в неё:
 
 ``` sql
 CREATE TABLE dt
@@ -27,15 +29,15 @@ CREATE TABLE dt
     `timestamp` DateTime64(3, 'Europe/Moscow'),
     `event_id` UInt8
 )
-ENGINE = TinyLog
+ENGINE = TinyLog;
 ```
 
 ``` sql
-INSERT INTO dt Values (1546300800000, 1), ('2019-01-01 00:00:00', 2)
+INSERT INTO dt Values (1546300800000, 1), ('2019-01-01 00:00:00', 2);
 ```
 
 ``` sql
-SELECT * FROM dt
+SELECT * FROM dt;
 ```
 
 ``` text
@@ -46,12 +48,12 @@ SELECT * FROM dt
 ```
 
 -   При вставке даты-времени как числа (аналогично ‘Unix timestamp’), время трактуется как UTC. Unix timestamp `1546300800` в часовом поясе `Europe/London (UTC+0)` представляет время `'2019-01-01 00:00:00'`. Однако, столбец `timestamp` имеет тип `DateTime('Europe/Moscow (UTC+3)')`, так что при выводе в виде строки время отобразится как `2019-01-01 03:00:00`.
--   При вставке даты-времени в виде строки, время трактуется соответственно часовому поясу установленному для колонки. `'2019-01-01 00:00:00'` трактуется как время по Москве (и в базу сохраняется `'2018-12-31 21:00:00'` в виде Unix Timestamp)
+-   При вставке даты-времени в виде строки, время трактуется соответственно часовому поясу установленному для колонки. `'2019-01-01 00:00:00'` трактуется как время по Москве (и в базу сохраняется `'2018-12-31 21:00:00'` в виде Unix Timestamp).
 
-**2.** Фильтрация по значениям даты-времени
+2. Фильтрация по значениям даты и времени
 
 ``` sql
-SELECT * FROM dt WHERE timestamp = toDateTime64('2019-01-01 00:00:00', 3, 'Europe/Moscow')
+SELECT * FROM dt WHERE timestamp = toDateTime64('2019-01-01 00:00:00', 3, 'Europe/Moscow');
 ```
 
 ``` text
@@ -60,12 +62,12 @@ SELECT * FROM dt WHERE timestamp = toDateTime64('2019-01-01 00:00:00', 3, 'Europ
 └─────────────────────────┴──────────┘
 ```
 
-В отличие от типа `DateTime`, `DateTime64` не конвертируется из строк автоматически
+В отличие от типа `DateTime`, `DateTime64` не конвертируется из строк автоматически.
 
-**3.** Получение часового пояса для значения типа `DateTime64`:
+3. Получение часового пояса для значения типа `DateTime64`:
 
 ``` sql
-SELECT toDateTime64(now(), 3, 'Europe/Moscow') AS column, toTypeName(column) AS x
+SELECT toDateTime64(now(), 3, 'Europe/Moscow') AS column, toTypeName(column) AS x;
 ```
 
 ``` text
@@ -74,13 +76,13 @@ SELECT toDateTime64(now(), 3, 'Europe/Moscow') AS column, toTypeName(column) AS
 └─────────────────────────┴────────────────────────────────┘
 ```
 
-**4.** Конвертация часовых поясов
+4. Конвертация часовых поясов
 
 ``` sql
 SELECT
 toDateTime64(timestamp, 3, 'Europe/London') as lon_time,
 toDateTime64(timestamp, 3, 'Europe/Moscow') as mos_time
-FROM dt
+FROM dt;
 ```
 
 ``` text
@@ -90,7 +92,7 @@ FROM dt
 └─────────────────────────┴─────────────────────────┘
 ```
 
-## See Also {#see-also}
+**See Also**
 
 -   [Функции преобразования типов](../../sql-reference/functions/type-conversion-functions.md)
 -   [Функции для работы с датой и временем](../../sql-reference/functions/date-time-functions.md)
diff --git a/docs/ru/sql-reference/data-types/simpleaggregatefunction.md b/docs/ru/sql-reference/data-types/simpleaggregatefunction.md
index 0948153362b..33a64f6bf26 100644
--- a/docs/ru/sql-reference/data-types/simpleaggregatefunction.md
+++ b/docs/ru/sql-reference/data-types/simpleaggregatefunction.md
@@ -15,10 +15,12 @@
 -   [`groupBitOr`](../../sql-reference/aggregate-functions/reference/groupbitor.md#groupbitor)
 -   [`groupBitXor`](../../sql-reference/aggregate-functions/reference/groupbitxor.md#groupbitxor)
 -   [`groupArrayArray`](../../sql-reference/aggregate-functions/reference/grouparray.md#agg_function-grouparray)
--   [`groupUniqArrayArray`](../../sql-reference/aggregate-functions/reference/groupuniqarray.md#groupuniqarray)
+-   [`groupUniqArrayArray`](../../sql-reference/aggregate-functions/reference/groupuniqarray.md)
 -   [`sumMap`](../../sql-reference/aggregate-functions/reference/summap.md#agg_functions-summap)
 -   [`minMap`](../../sql-reference/aggregate-functions/reference/minmap.md#agg_functions-minmap)
 -   [`maxMap`](../../sql-reference/aggregate-functions/reference/maxmap.md#agg_functions-maxmap)
+-   [`argMin`](../../sql-reference/aggregate-functions/reference/argmin.md)
+-   [`argMax`](../../sql-reference/aggregate-functions/reference/argmax.md)
 
 !!! note "Примечание"
     Значения `SimpleAggregateFunction(func, Type)` отображаются и хранятся так же, как и `Type`, поэтому комбинаторы [-Merge](../../sql-reference/aggregate-functions/combinators.md#aggregate_functions_combinators-merge) и [-State](../../sql-reference/aggregate-functions/combinators.md#agg-functions-combinator-state) не требуются.
diff --git a/docs/ru/sql-reference/dictionaries/external-dictionaries/external-dicts-dict-structure.md b/docs/ru/sql-reference/dictionaries/external-dictionaries/external-dicts-dict-structure.md
index 57f53390d1c..609ee225ce2 100644
--- a/docs/ru/sql-reference/dictionaries/external-dictionaries/external-dicts-dict-structure.md
+++ b/docs/ru/sql-reference/dictionaries/external-dictionaries/external-dicts-dict-structure.md
@@ -3,7 +3,7 @@ toc_priority: 44
 toc_title: "Ключ и поля словаря"
 ---
 
-# Ключ и поля словаря {#kliuch-i-polia-slovaria}
+# Ключ и поля словаря {#dictionary-key-and-fields}
 
 Секция `<structure>` описывает ключ словаря и поля, доступные для запросов.
 
@@ -88,7 +88,7 @@ PRIMARY KEY Id
 
 -   `PRIMARY KEY` – имя столбца с ключами.
 
-### Составной ключ {#sostavnoi-kliuch}
+### Составной ключ {#composite-key}
 
 Ключом может быть кортеж (`tuple`) из полей произвольных типов. В этом случае [layout](external-dicts-dict-layout.md) должен быть `complex_key_hashed` или `complex_key_cache`.
 
@@ -159,13 +159,12 @@ CREATE DICTIONARY somename (
 | Тег                                                  | Описание                                                                                                                                                                                                                                                                                                                                                      | Обязательный |
 |------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
 | `name`                                               | Имя столбца.                                                                                                                                                                                                                                                                                                                                                  | Да           |
-| `type`                                               | Тип данных ClickHouse.<br/>ClickHouse пытается привести значение из словаря к заданному типу данных. Например, в случае MySQL, в таблице-источнике поле может быть `TEXT`, `VARCHAR`, `BLOB`, но загружено может быть как `String`. [Nullable](../../../sql-reference/data-types/nullable.md) не поддерживается. | Да           |
-| `null_value`                                         | Значение по умолчанию для несуществующего элемента.<br/>В примере это пустая строка. Нельзя указать значение `NULL`.                                                                                                                                                                                                                                          | Да           |
+| `type`                                               | Тип данных ClickHouse.<br/>ClickHouse пытается привести значение из словаря к заданному типу данных. Например, в случае MySQL, в таблице-источнике поле может быть `TEXT`, `VARCHAR`, `BLOB`, но загружено может быть как `String`. <br/>[Nullable](../../../sql-reference/data-types/nullable.md) в настоящее время поддерживается для словарей [Flat](external-dicts-dict-layout.md#flat), [Hashed](external-dicts-dict-layout.md#dicts-external_dicts_dict_layout-hashed), [ComplexKeyHashed](external-dicts-dict-layout.md#complex-key-hashed), [Direct](external-dicts-dict-layout.md#direct), [ComplexKeyDirect](external-dicts-dict-layout.md#complex-key-direct), [RangeHashed](external-dicts-dict-layout.md#range-hashed), [Polygon](external-dicts-dict-polygon.md). Для словарей [Cache](external-dicts-dict-layout.md#cache), [ComplexKeyCache](external-dicts-dict-layout.md#complex-key-cache), [SSDCache](external-dicts-dict-layout.md#ssd-cache), [SSDComplexKeyCache](external-dicts-dict-layout.md#complex-key-ssd-cache) и [IPTrie](external-dicts-dict-layout.md#ip-trie) `Nullable`-типы не поддерживаются. | Да           |
+| `null_value`                                         | Значение по умолчанию для несуществующего элемента.<br/>В примере это пустая строка. Значение [NULL](../../syntax.md#null-literal) можно указывать только для типов `Nullable` (см. предыдущую строку с описанием типов).                                                                                                                                                                                                                                          | Да           |
 | `expression`                                         | [Выражение](../../syntax.md#syntax-expressions), которое ClickHouse выполняет со значением.<br/>Выражением может быть имя столбца в удаленной SQL базе. Таким образом, вы можете использовать его для создания псевдонима удаленного столбца.<br/><br/>Значение по умолчанию: нет выражения.                                                                  | Нет          |
-| <a name="hierarchical-dict-attr"></a> `hierarchical` | Если `true`, то атрибут содержит ключ предка для текущего элемента. Смотрите [Иерархические словари](external-dicts-dict-hierarchical.md).<br/><br/>Default value: `false`.                                                                                                                                                                                   | No           |
+| <a name="hierarchical-dict-attr"></a> `hierarchical` | Если `true`, то атрибут содержит ключ предка для текущего элемента. Смотрите [Иерархические словари](external-dicts-dict-hierarchical.md).<br/><br/>Значение по умолчанию: `false`.                                                                                                                                                                                   | Нет           |
 | `is_object_id`                                       | Признак того, что запрос выполняется к документу MongoDB по `ObjectID`.<br/><br/>Значение по умолчанию: `false`.                                                                                                                                                                                                                                              | Нет          |
 
-## Смотрите также {#smotrite-takzhe}
+**Смотрите также**
 
 -   [Функции для работы с внешними словарями](../../../sql-reference/functions/ext-dict-functions.md).
-
diff --git a/docs/ru/sql-reference/dictionaries/index.md b/docs/ru/sql-reference/dictionaries/index.md
index bd432497be8..59c7518d0c5 100644
--- a/docs/ru/sql-reference/dictionaries/index.md
+++ b/docs/ru/sql-reference/dictionaries/index.md
@@ -10,8 +10,6 @@ toc_title: "Введение"
 
 ClickHouse поддерживает специальные функции для работы со словарями, которые можно использовать в запросах. Проще и эффективнее использовать словари с помощью функций, чем `JOIN` с таблицами-справочниками.
 
-В словаре нельзя хранить значения [NULL](../../sql-reference/syntax.md#null-literal).
-
 ClickHouse поддерживает:
 
 -   [Встроенные словари](internal-dicts.md#internal_dicts) со специфическим [набором функций](../../sql-reference/dictionaries/external-dictionaries/index.md).
diff --git a/docs/ru/sql-reference/functions/string-functions.md b/docs/ru/sql-reference/functions/string-functions.md
index 6ef7dc01b6a..04af599c09a 100644
--- a/docs/ru/sql-reference/functions/string-functions.md
+++ b/docs/ru/sql-reference/functions/string-functions.md
@@ -645,3 +645,66 @@ SELECT decodeXMLComponent('&lt; &#x3A3; &gt;');
 
 -   [Мнемоники в HTML](https://ru.wikipedia.org/wiki/%D0%9C%D0%BD%D0%B5%D0%BC%D0%BE%D0%BD%D0%B8%D0%BA%D0%B8_%D0%B2_HTML)
 
+
+
+## extractTextFromHTML {#extracttextfromhtml}
+
+Функция для извлечения текста из HTML или XHTML.
+Она не соответствует всем HTML, XML или XHTML стандартам на 100%, но ее реализация достаточно точная и быстрая. Правила обработки следующие:
+
+1. Комментарии удаляются. Пример: `<!-- test -->`. Комментарий должен оканчиваться символами `-->`. Вложенные комментарии недопустимы.
+Примечание: конструкции наподобие `<!-->` и `<!--->` не являются допустимыми комментариями в HTML, но они будут удалены согласно другим правилам.
+2. Содержимое CDATA вставляется дословно. Примечание: формат CDATA специфичен для XML/XHTML. Но он обрабатывается всегда по принципу "наилучшего возможного результата".
+3. Элементы `script` и `style` удаляются вместе со всем содержимым. Примечание: предполагается, что закрывающий тег не может появиться внутри содержимого. Например, в JS строковый литерал должен быть экранирован как `"<\/script>"`.
+Примечание: комментарии и CDATA возможны внутри `script` или `style` - тогда закрывающие теги не ищутся внутри CDATA. Пример: `<script><![CDATA[</script>]]></script>`. Но они ищутся внутри комментариев. Иногда возникают сложные случаи: `<script>var x = "<!--"; </script> var y = "-->"; alert(x + y);</script>`
+Примечание: `script` и `style` могут быть названиями пространств имен XML - тогда они не обрабатываются как обычные элементы `script` или `style`. Пример: `<script:a>Hello</script:a>`.
+Примечание: пробелы возможны после имени закрывающего тега: `</script >`, но не перед ним: `< / script>`.
+4. Другие теги или элементы, подобные тегам, удаляются, а их внутреннее содержимое остается. Пример: `<a>.</a>`
+Примечание: ожидается, что такой HTML является недопустимым: `<a test=">"></a>`
+Примечание: функция также удаляет подобные тегам элементы: `<>`, `<!>`, и т. д.
+Примечание: если встречается тег без завершающего символа `>`, то удаляется этот тег и весь следующий за ним текст: `<hello `
+5. Мнемоники HTML и XML не декодируются. Они должны быть обработаны отдельной функцией.
+6. Пробелы в тексте удаляются и добавляются по следующим правилам:
+- Пробелы в начале и в конце извлеченного текста удаляются.
+- Несколько пробелов подряд заменяются одним пробелом.
+- Если текст разделен другими удаляемыми элементами и в этом месте нет пробела, он добавляется.
+- Это может привести к появлению неестественного написания, например: `Hello<b>world</b>`, `Hello<!-- -->world` — в HTML нет пробелов, но функция вставляет их. Также следует учитывать такие варианты написания: `Hello<p>world</p>`, `Hello<br>world`. Подобные результаты выполнения функции могут использоваться для анализа данных, например, для преобразования HTML-текста в набор используемых слов.
+7. Также обратите внимание, что правильная обработка пробелов требует поддержки `<pre></pre>` и свойств CSS `display` и `white-space`.
+
+**Синтаксис**
+
+``` sql
+extractTextFromHTML(x)
+```
+
+**Аргументы**
+
+-   `x` — текст для обработки. [String](../../sql-reference/data-types/string.md). 
+
+**Возвращаемое значение**
+
+-   Извлеченный текст.
+
+Тип: [String](../../sql-reference/data-types/string.md).
+
+**Пример**
+
+Первый пример содержит несколько тегов и комментарий. На этом примере также видно, как обрабатываются пробелы.
+Второй пример показывает обработку `CDATA` и тега `script`.
+В третьем примере текст выделяется из полного HTML ответа, полученного с помощью функции [url](../../sql-reference/table-functions/url.md).
+
+Запрос:
+
+``` sql
+SELECT extractTextFromHTML(' <p> A text <i>with</i><b>tags</b>. <!-- comments --> </p> ');
+SELECT extractTextFromHTML('<![CDATA[The content within <b>CDATA</b>]]> <script>alert("Script");</script>');
+SELECT extractTextFromHTML(html) FROM url('http://www.donothingfor2minutes.com/', RawBLOB, 'html String');
+```
+
+Результат:
+
+``` text
+A text with tags .
+The content within <b>CDATA</b>
+Do Nothing for 2 Minutes 2:00 &nbsp;
+```
diff --git a/docs/ru/sql-reference/statements/alter/ttl.md b/docs/ru/sql-reference/statements/alter/ttl.md
index e949c992bbe..2a2d10b69de 100644
--- a/docs/ru/sql-reference/statements/alter/ttl.md
+++ b/docs/ru/sql-reference/statements/alter/ttl.md
@@ -82,4 +82,4 @@ SELECT * FROM table_with_ttl;
 ### Смотрите также
 
 - Подробнее о [свойстве TTL](../../../engines/table-engines/mergetree-family/mergetree.md#mergetree-column-ttl).
-
+- Изменить столбец [с TTL](../../../sql-reference/statements/alter/column.md#alter_modify-column).
\ No newline at end of file
diff --git a/docs/ru/sql-reference/statements/check-table.md b/docs/ru/sql-reference/statements/check-table.md
index 10336f821d0..9592c1a5bc2 100644
--- a/docs/ru/sql-reference/statements/check-table.md
+++ b/docs/ru/sql-reference/statements/check-table.md
@@ -29,9 +29,36 @@ CHECK TABLE [db.]name
 
 В движках `*Log` не предусмотрено автоматическое восстановление данных после сбоя. Используйте запрос `CHECK TABLE`, чтобы своевременно выявлять повреждение данных.
 
-Для движков из семейства `MergeTree` запрос `CHECK TABLE` показывает статус проверки для каждого отдельного куска данных таблицы на локальном сервере.
+## Проверка таблиц семейства MergeTree {#checking-mergetree-tables}
 
-**Что делать, если данные повреждены**
+Для таблиц семейства `MergeTree` если [check_query_single_value_result](../../operations/settings/settings.md#check_query_single_value_result) = 0, запрос `CHECK TABLE` возвращает статус каждого куска данных таблицы на локальном сервере. 
+
+```sql
+SET check_query_single_value_result = 0;
+CHECK TABLE test_table;
+```
+
+```text
+┌─part_path─┬─is_passed─┬─message─┐
+│ all_1_4_1 │         1 │         │
+│ all_1_4_2 │         1 │         │
+└───────────┴───────────┴─────────┘
+```
+
+Если `check_query_single_value_result` = 0, запрос `CHECK TABLE` возвращает статус таблицы в целом.
+
+```sql
+SET check_query_single_value_result = 1;
+CHECK TABLE test_table;
+```
+
+```text
+┌─result─┐
+│      1 │
+└────────┘
+```
+
+## Что делать, если данные повреждены {#if-data-is-corrupted}
 
 В этом случае можно скопировать оставшиеся неповрежденные данные в другую таблицу. Для этого:
 
diff --git a/docs/ru/sql-reference/statements/rename.md b/docs/ru/sql-reference/statements/rename.md
index 104918c1a73..192426dbafa 100644
--- a/docs/ru/sql-reference/statements/rename.md
+++ b/docs/ru/sql-reference/statements/rename.md
@@ -3,8 +3,16 @@ toc_priority: 48
 toc_title: RENAME
 ---
 
-# RENAME {#misc_operations-rename}
+# RENAME Statement {#misc_operations-rename}
 
+## RENAME DATABASE {#misc_operations-rename_database}
+Переименование базы данных
+
+```
+RENAME DATABASE atomic_database1 TO atomic_database2 [ON CLUSTER cluster]
+```
+
+## RENAME TABLE {#misc_operations-rename_table}
 Переименовывает одну или несколько таблиц.
 
 ``` sql
@@ -12,5 +20,3 @@ RENAME TABLE [db11.]name11 TO [db12.]name12, [db21.]name21 TO [db22.]name22, ...
 ```
 
 Переименовывание таблицы является лёгкой операцией. Если вы указали после `TO` другую базу данных, то таблица будет перенесена в эту базу данных. При этом, директории с базами данных должны быть расположены в одной файловой системе (иначе возвращается ошибка). В случае переименования нескольких таблиц в одном запросе — это неатомарная операция,  может выполнится частично, запросы в других сессиях могут получить ошибку `Table ... doesn't exist...`.
-
-
diff --git a/programs/CMakeLists.txt b/programs/CMakeLists.txt
index c3600e5812a..c917dbe30a3 100644
--- a/programs/CMakeLists.txt
+++ b/programs/CMakeLists.txt
@@ -36,6 +36,9 @@ option (ENABLE_CLICKHOUSE_OBFUSCATOR "Table data obfuscator (convert real data t
 option (ENABLE_CLICKHOUSE_ODBC_BRIDGE "HTTP-server working like a proxy to ODBC driver"
     ${ENABLE_CLICKHOUSE_ALL})
 
+option (ENABLE_CLICKHOUSE_LIBRARY_BRIDGE "HTTP-server working like a proxy to Library dictionary source"
+    ${ENABLE_CLICKHOUSE_ALL})
+
 # https://presentations.clickhouse.tech/matemarketing_2020/
 option (ENABLE_CLICKHOUSE_GIT_IMPORT "A tool to analyze Git repositories"
     ${ENABLE_CLICKHOUSE_ALL})
@@ -109,6 +112,12 @@ else()
     message(STATUS "ODBC bridge mode: OFF")
 endif()
 
+if (ENABLE_CLICKHOUSE_LIBRARY_BRIDGE)
+    message(STATUS "Library bridge mode: ON")
+else()
+    message(STATUS "Library bridge mode: OFF")
+endif()
+
 if (ENABLE_CLICKHOUSE_INSTALL)
     message(STATUS "ClickHouse install: ON")
 else()
@@ -194,6 +203,10 @@ if (ENABLE_CLICKHOUSE_ODBC_BRIDGE)
     add_subdirectory (odbc-bridge)
 endif ()
 
+if (ENABLE_CLICKHOUSE_LIBRARY_BRIDGE)
+    add_subdirectory (library-bridge)
+endif ()
+
 if (CLICKHOUSE_ONE_SHARED)
     add_library(clickhouse-lib SHARED ${CLICKHOUSE_SERVER_SOURCES} ${CLICKHOUSE_CLIENT_SOURCES} ${CLICKHOUSE_LOCAL_SOURCES} ${CLICKHOUSE_BENCHMARK_SOURCES} ${CLICKHOUSE_COPIER_SOURCES} ${CLICKHOUSE_EXTRACT_FROM_CONFIG_SOURCES} ${CLICKHOUSE_COMPRESSOR_SOURCES} ${CLICKHOUSE_FORMAT_SOURCES} ${CLICKHOUSE_OBFUSCATOR_SOURCES} ${CLICKHOUSE_GIT_IMPORT_SOURCES} ${CLICKHOUSE_ODBC_BRIDGE_SOURCES})
     target_link_libraries(clickhouse-lib ${CLICKHOUSE_SERVER_LINK} ${CLICKHOUSE_CLIENT_LINK} ${CLICKHOUSE_LOCAL_LINK} ${CLICKHOUSE_BENCHMARK_LINK} ${CLICKHOUSE_COPIER_LINK} ${CLICKHOUSE_EXTRACT_FROM_CONFIG_LINK} ${CLICKHOUSE_COMPRESSOR_LINK} ${CLICKHOUSE_FORMAT_LINK} ${CLICKHOUSE_OBFUSCATOR_LINK} ${CLICKHOUSE_GIT_IMPORT_LINK} ${CLICKHOUSE_ODBC_BRIDGE_LINK})
@@ -209,6 +222,10 @@ if (CLICKHOUSE_SPLIT_BINARY)
         list (APPEND CLICKHOUSE_ALL_TARGETS clickhouse-odbc-bridge)
     endif ()
 
+    if (ENABLE_CLICKHOUSE_LIBRARY_BRIDGE)
+        list (APPEND CLICKHOUSE_ALL_TARGETS clickhouse-library-bridge)
+    endif ()
+
     set_target_properties(${CLICKHOUSE_ALL_TARGETS} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ..)
 
     add_custom_target (clickhouse-bundle ALL DEPENDS ${CLICKHOUSE_ALL_TARGETS})
diff --git a/programs/benchmark/Benchmark.cpp b/programs/benchmark/Benchmark.cpp
index a0e2ea155ba..1d2b579db3a 100644
--- a/programs/benchmark/Benchmark.cpp
+++ b/programs/benchmark/Benchmark.cpp
@@ -95,8 +95,8 @@ public:
             comparison_info_total.emplace_back(std::make_shared<Stats>());
         }
 
-        global_context.makeGlobalContext();
-        global_context.setSettings(settings);
+        global_context->makeGlobalContext();
+        global_context->setSettings(settings);
 
         std::cerr << std::fixed << std::setprecision(3);
 
@@ -159,7 +159,7 @@ private:
     bool print_stacktrace;
     const Settings & settings;
     SharedContextHolder shared_context;
-    Context global_context;
+    ContextPtr global_context;
     QueryProcessingStage::Enum query_processing_stage;
 
     /// Don't execute new queries after timelimit or SIGINT or exception
diff --git a/programs/client/Client.cpp b/programs/client/Client.cpp
index 0c5bbaf3edd..1aec3677b41 100644
--- a/programs/client/Client.cpp
+++ b/programs/client/Client.cpp
@@ -21,7 +21,7 @@
 #include <unordered_set>
 #include <algorithm>
 #include <optional>
-#include <ext/scope_guard.h>
+#include <ext/scope_guard_safe.h>
 #include <boost/program_options.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <Poco/String.h>
@@ -191,7 +191,7 @@ private:
     bool has_vertical_output_suffix = false; /// Is \G present at the end of the query string?
 
     SharedContextHolder shared_context = Context::createShared();
-    Context context = Context::createGlobal(shared_context.get());
+    ContextPtr context = Context::createGlobal(shared_context.get());
 
     /// Buffer that reads from stdin in batch mode.
     ReadBufferFromFileDescriptor std_in {STDIN_FILENO};
@@ -274,20 +274,20 @@ private:
 
         configReadClient(config(), home_path);
 
-        context.setApplicationType(Context::ApplicationType::CLIENT);
-        context.setQueryParameters(query_parameters);
+        context->setApplicationType(Context::ApplicationType::CLIENT);
+        context->setQueryParameters(query_parameters);
 
         /// settings and limits could be specified in config file, but passed settings has higher priority
-        for (const auto & setting : context.getSettingsRef().allUnchanged())
+        for (const auto & setting : context->getSettingsRef().allUnchanged())
         {
             const auto & name = setting.getName();
             if (config().has(name))
-                context.setSetting(name, config().getString(name));
+                context->setSetting(name, config().getString(name));
         }
 
         /// Set path for format schema files
         if (config().has("format_schema_path"))
-            context.setFormatSchemaPath(Poco::Path(config().getString("format_schema_path")).toString());
+            context->setFormatSchemaPath(Poco::Path(config().getString("format_schema_path")).toString());
 
         /// Initialize query_id_formats if any
         if (config().has("query_id_formats"))
@@ -538,15 +538,15 @@ private:
         else
             format = config().getString("format", is_interactive ? "PrettyCompact" : "TabSeparated");
 
-        format_max_block_size = config().getInt("format_max_block_size", context.getSettingsRef().max_block_size);
+        format_max_block_size = config().getInt("format_max_block_size", context->getSettingsRef().max_block_size);
 
         insert_format = "Values";
 
         /// Setting value from cmd arg overrides one from config
-        if (context.getSettingsRef().max_insert_block_size.changed)
-            insert_format_max_block_size = context.getSettingsRef().max_insert_block_size;
+        if (context->getSettingsRef().max_insert_block_size.changed)
+            insert_format_max_block_size = context->getSettingsRef().max_insert_block_size;
         else
-            insert_format_max_block_size = config().getInt("insert_format_max_block_size", context.getSettingsRef().max_insert_block_size);
+            insert_format_max_block_size = config().getInt("insert_format_max_block_size", context->getSettingsRef().max_insert_block_size);
 
         if (!is_interactive)
         {
@@ -555,7 +555,7 @@ private:
             ignore_error = config().getBool("ignore-error", false);
         }
 
-        ClientInfo & client_info = context.getClientInfo();
+        ClientInfo & client_info = context->getClientInfo();
         client_info.setInitialQuery();
         client_info.quota_key = config().getString("quota_key", "");
 
@@ -563,7 +563,7 @@ private:
 
         /// Initialize DateLUT here to avoid counting time spent here as query execution time.
         const auto local_tz = DateLUT::instance().getTimeZone();
-        if (!context.getSettingsRef().use_client_time_zone)
+        if (!context->getSettingsRef().use_client_time_zone)
         {
             const auto & time_zone = connection->getServerTimezone(connection_parameters.timeouts);
             if (!time_zone.empty())
@@ -738,7 +738,7 @@ private:
         {
             auto query_id = config().getString("query_id", "");
             if (!query_id.empty())
-                context.setCurrentQueryId(query_id);
+                context->setCurrentQueryId(query_id);
 
             nonInteractive();
 
@@ -1038,7 +1038,7 @@ private:
             {
                 Tokens tokens(this_query_begin, all_queries_end);
                 IParser::Pos token_iterator(tokens,
-                    context.getSettingsRef().max_parser_depth);
+                    context->getSettingsRef().max_parser_depth);
                 if (!token_iterator.isValid())
                 {
                     break;
@@ -1087,7 +1087,7 @@ private:
                 if (ignore_error)
                 {
                     Tokens tokens(this_query_begin, all_queries_end);
-                    IParser::Pos token_iterator(tokens, context.getSettingsRef().max_parser_depth);
+                    IParser::Pos token_iterator(tokens, context->getSettingsRef().max_parser_depth);
                     while (token_iterator->type != TokenType::Semicolon && token_iterator.isValid())
                         ++token_iterator;
                     this_query_begin = token_iterator->end;
@@ -1133,7 +1133,7 @@ private:
             // beneficial so that we see proper trailing comments in "echo" and
             // server log.
             adjustQueryEnd(this_query_end, all_queries_end,
-                context.getSettingsRef().max_parser_depth);
+                context->getSettingsRef().max_parser_depth);
 
             // full_query is the query + inline INSERT data + trailing comments
             // (the latter is our best guess for now).
@@ -1173,7 +1173,7 @@ private:
             {
                 this_query_end = insert_ast->end;
                 adjustQueryEnd(this_query_end, all_queries_end,
-                    context.getSettingsRef().max_parser_depth);
+                    context->getSettingsRef().max_parser_depth);
             }
 
             // Now we know for sure where the query ends.
@@ -1290,7 +1290,7 @@ private:
     // Prints changed settings to stderr. Useful for debugging fuzzing failures.
     void printChangedSettings() const
     {
-        const auto & changes = context.getSettingsRef().changes();
+        const auto & changes = context->getSettingsRef().changes();
         if (!changes.empty())
         {
             fmt::print(stderr, "Changed settings: ");
@@ -1590,11 +1590,11 @@ private:
         if (is_interactive)
         {
             // Generate a new query_id
-            context.setCurrentQueryId("");
+            context->setCurrentQueryId("");
             for (const auto & query_id_format : query_id_formats)
             {
                 writeString(query_id_format.first, std_out);
-                writeString(fmt::format(query_id_format.second, fmt::arg("query_id", context.getCurrentQueryId())), std_out);
+                writeString(fmt::format(query_id_format.second, fmt::arg("query_id", context->getCurrentQueryId())), std_out);
                 writeChar('\n', std_out);
                 std_out.next();
             }
@@ -1610,12 +1610,12 @@ private:
         {
             /// Temporarily apply query settings to context.
             std::optional<Settings> old_settings;
-            SCOPE_EXIT({ if (old_settings) context.setSettings(*old_settings); });
+            SCOPE_EXIT_SAFE({ if (old_settings) context->setSettings(*old_settings); });
             auto apply_query_settings = [&](const IAST & settings_ast)
             {
                 if (!old_settings)
-                    old_settings.emplace(context.getSettingsRef());
-                context.applySettingsChanges(settings_ast.as<ASTSetQuery>()->changes);
+                    old_settings.emplace(context->getSettingsRef());
+                context->applySettingsChanges(settings_ast.as<ASTSetQuery>()->changes);
             };
             const auto * insert = parsed_query->as<ASTInsertQuery>();
             if (insert && insert->settings_ast)
@@ -1653,7 +1653,7 @@ private:
                     if (change.name == "profile")
                         current_profile = change.value.safeGet<String>();
                     else
-                        context.applySettingChange(change);
+                        context->applySettingChange(change);
                 }
             }
 
@@ -1725,10 +1725,10 @@ private:
                 connection->sendQuery(
                     connection_parameters.timeouts,
                     query_to_send,
-                    context.getCurrentQueryId(),
+                    context->getCurrentQueryId(),
                     query_processing_stage,
-                    &context.getSettingsRef(),
-                    &context.getClientInfo(),
+                    &context->getSettingsRef(),
+                    &context->getClientInfo(),
                     true);
 
                 sendExternalTables();
@@ -1766,10 +1766,10 @@ private:
         connection->sendQuery(
             connection_parameters.timeouts,
             query_to_send,
-            context.getCurrentQueryId(),
+            context->getCurrentQueryId(),
             query_processing_stage,
-            &context.getSettingsRef(),
-            &context.getClientInfo(),
+            &context->getSettingsRef(),
+            &context->getClientInfo(),
             true);
 
         sendExternalTables();
@@ -1792,7 +1792,7 @@ private:
         ParserQuery parser(end);
         ASTPtr res;
 
-        const auto & settings = context.getSettingsRef();
+        const auto & settings = context->getSettingsRef();
         size_t max_length = 0;
         if (!allow_multi_statements)
             max_length = settings.max_query_size;
@@ -1880,7 +1880,7 @@ private:
                 current_format = insert->format;
         }
 
-        BlockInputStreamPtr block_input = context.getInputFormat(
+        BlockInputStreamPtr block_input = context->getInputFormat(
             current_format, buf, sample, insert_format_max_block_size);
 
         if (columns_description.hasDefaults())
@@ -2204,9 +2204,9 @@ private:
 
             /// It is not clear how to write progress with parallel formatting. It may increase code complexity significantly.
             if (!need_render_progress)
-                block_out_stream = context.getOutputStreamParallelIfPossible(current_format, *out_buf, block);
+                block_out_stream = context->getOutputStreamParallelIfPossible(current_format, *out_buf, block);
             else
-                block_out_stream = context.getOutputStream(current_format, *out_buf, block);
+                block_out_stream = context->getOutputStream(current_format, *out_buf, block);
 
             block_out_stream->writePrefix();
         }
@@ -2710,12 +2710,12 @@ public:
             }
         }
 
-        context.makeGlobalContext();
-        context.setSettings(cmd_settings);
+        context->makeGlobalContext();
+        context->setSettings(cmd_settings);
 
         /// Copy settings-related program options to config.
         /// TODO: Is this code necessary?
-        for (const auto & setting : context.getSettingsRef().all())
+        for (const auto & setting : context->getSettingsRef().all())
         {
             const auto & name = setting.getName();
             if (options.count(name))
@@ -2807,7 +2807,7 @@ public:
         {
             std::string traceparent = options["opentelemetry-traceparent"].as<std::string>();
             std::string error;
-            if (!context.getClientInfo().client_trace_context.parseTraceparentHeader(
+            if (!context->getClientInfo().client_trace_context.parseTraceparentHeader(
                 traceparent, error))
             {
                 throw Exception(ErrorCodes::BAD_ARGUMENTS,
@@ -2818,7 +2818,7 @@ public:
 
         if (options.count("opentelemetry-tracestate"))
         {
-            context.getClientInfo().client_trace_context.tracestate =
+            context->getClientInfo().client_trace_context.tracestate =
                 options["opentelemetry-tracestate"].as<std::string>();
         }
 
diff --git a/programs/client/QueryFuzzer.cpp b/programs/client/QueryFuzzer.cpp
index 0c8dc0731f9..6243e2c82ec 100644
--- a/programs/client/QueryFuzzer.cpp
+++ b/programs/client/QueryFuzzer.cpp
@@ -37,34 +37,33 @@ namespace ErrorCodes
 
 Field QueryFuzzer::getRandomField(int type)
 {
+    static constexpr Int64 bad_int64_values[]
+        = {-2, -1, 0, 1, 2, 3, 7, 10, 100, 255, 256, 257, 1023, 1024,
+           1025, 65535, 65536, 65537, 1024 * 1024 - 1, 1024 * 1024,
+           1024 * 1024 + 1, INT_MIN - 1ll, INT_MIN, INT_MIN + 1,
+           INT_MAX - 1, INT_MAX, INT_MAX + 1ll, INT64_MIN, INT64_MIN + 1,
+           INT64_MAX - 1, INT64_MAX};
     switch (type)
     {
     case 0:
     {
-        static constexpr Int64 values[]
-                = {-2, -1, 0, 1, 2, 3, 7, 10, 100, 255, 256, 257, 1023, 1024,
-                   1025, 65535, 65536, 65537, 1024 * 1024 - 1, 1024 * 1024,
-                   1024 * 1024 + 1, INT64_MIN, INT64_MAX};
-        return values[fuzz_rand() % (sizeof(values) / sizeof(*values))];
+        return bad_int64_values[fuzz_rand() % (sizeof(bad_int64_values)
+                / sizeof(*bad_int64_values))];
     }
     case 1:
     {
         static constexpr float values[]
-                = {NAN, INFINITY, -INFINITY, 0., 0.0001, 0.5, 0.9999,
-                   1., 1.0001, 2., 10.0001, 100.0001, 1000.0001};
-        return values[fuzz_rand() % (sizeof(values) / sizeof(*values))];
+                = {NAN, INFINITY, -INFINITY, 0., -0., 0.0001, 0.5, 0.9999,
+                   1., 1.0001, 2., 10.0001, 100.0001, 1000.0001, 1e10, 1e20,
+                  FLT_MIN, FLT_MIN + FLT_EPSILON, FLT_MAX, FLT_MAX + FLT_EPSILON}; return values[fuzz_rand() % (sizeof(values) / sizeof(*values))];
     }
     case 2:
     {
-        static constexpr Int64 values[]
-                = {-2, -1, 0, 1, 2, 3, 7, 10, 100, 255, 256, 257, 1023, 1024,
-                   1025, 65535, 65536, 65537, 1024 * 1024 - 1, 1024 * 1024,
-                   1024 * 1024 + 1, INT64_MIN, INT64_MAX};
         static constexpr UInt64 scales[] = {0, 1, 2, 10};
         return DecimalField<Decimal64>(
-                    values[fuzz_rand() % (sizeof(values) / sizeof(*values))],
-                scales[fuzz_rand() % (sizeof(scales) / sizeof(*scales))]
-                );
+            bad_int64_values[fuzz_rand() % (sizeof(bad_int64_values)
+                / sizeof(*bad_int64_values))],
+            scales[fuzz_rand() % (sizeof(scales) / sizeof(*scales))]);
     }
     default:
         assert(false);
diff --git a/programs/config_tools.h.in b/programs/config_tools.h.in
index 7cb5a6d883a..abe9ef8c562 100644
--- a/programs/config_tools.h.in
+++ b/programs/config_tools.h.in
@@ -15,3 +15,4 @@
 #cmakedefine01 ENABLE_CLICKHOUSE_GIT_IMPORT
 #cmakedefine01 ENABLE_CLICKHOUSE_INSTALL
 #cmakedefine01 ENABLE_CLICKHOUSE_ODBC_BRIDGE
+#cmakedefine01 ENABLE_CLICKHOUSE_LIBRARY_BRIDGE
diff --git a/programs/copier/ClusterCopier.cpp b/programs/copier/ClusterCopier.cpp
index bede40d65f5..aa9b359993e 100644
--- a/programs/copier/ClusterCopier.cpp
+++ b/programs/copier/ClusterCopier.cpp
@@ -22,7 +22,7 @@ namespace ErrorCodes
 
 void ClusterCopier::init()
 {
-    auto zookeeper = context.getZooKeeper();
+    auto zookeeper = getContext()->getZooKeeper();
 
     task_description_watch_callback = [this] (const Coordination::WatchResponse & response)
     {
@@ -39,14 +39,14 @@ void ClusterCopier::init()
     task_cluster_initial_config = task_cluster_current_config;
 
     task_cluster->loadTasks(*task_cluster_initial_config);
-    context.setClustersConfig(task_cluster_initial_config, task_cluster->clusters_prefix);
+    getContext()->setClustersConfig(task_cluster_initial_config, task_cluster->clusters_prefix);
 
     /// Set up shards and their priority
     task_cluster->random_engine.seed(task_cluster->random_device());
     for (auto & task_table : task_cluster->table_tasks)
     {
-        task_table.cluster_pull = context.getCluster(task_table.cluster_pull_name);
-        task_table.cluster_push = context.getCluster(task_table.cluster_push_name);
+        task_table.cluster_pull = getContext()->getCluster(task_table.cluster_pull_name);
+        task_table.cluster_push = getContext()->getCluster(task_table.cluster_push_name);
         task_table.initShards(task_cluster->random_engine);
     }
 
@@ -206,7 +206,7 @@ void ClusterCopier::uploadTaskDescription(const std::string & task_path, const s
     if (task_config_str.empty())
         return;
 
-    auto zookeeper = context.getZooKeeper();
+    auto zookeeper = getContext()->getZooKeeper();
 
     zookeeper->createAncestors(local_task_description_path);
     auto code = zookeeper->tryCreate(local_task_description_path, task_config_str, zkutil::CreateMode::Persistent);
@@ -219,7 +219,7 @@ void ClusterCopier::uploadTaskDescription(const std::string & task_path, const s
 
 void ClusterCopier::reloadTaskDescription()
 {
-    auto zookeeper = context.getZooKeeper();
+    auto zookeeper = getContext()->getZooKeeper();
     task_description_watch_zookeeper = zookeeper;
 
     String task_config_str;
@@ -235,7 +235,7 @@ void ClusterCopier::reloadTaskDescription()
 
     /// Setup settings
     task_cluster->reloadSettings(*config);
-    context.setSettings(task_cluster->settings_common);
+    getContext()->setSettings(task_cluster->settings_common);
 
     task_cluster_current_config = config;
     task_description_current_stat = stat;
@@ -440,7 +440,7 @@ bool ClusterCopier::checkPartitionPieceIsDone(const TaskTable & task_table, cons
 {
     LOG_DEBUG(log, "Check that all shards processed partition {} piece {} successfully", partition_name, piece_number);
 
-    auto zookeeper = context.getZooKeeper();
+    auto zookeeper = getContext()->getZooKeeper();
 
     /// Collect all shards that contain partition piece number piece_number.
     Strings piece_status_paths;
@@ -532,7 +532,7 @@ TaskStatus ClusterCopier::tryMoveAllPiecesToDestinationTable(const TaskTable & t
 
     LOG_DEBUG(log, "Try to move {} to destination table", partition_name);
 
-    auto zookeeper = context.getZooKeeper();
+    auto zookeeper = getContext()->getZooKeeper();
 
     const auto current_partition_attach_is_active = task_table.getPartitionAttachIsActivePath(partition_name);
     const auto current_partition_attach_is_done   = task_table.getPartitionAttachIsDonePath(partition_name);
@@ -1095,7 +1095,7 @@ TaskStatus ClusterCopier::tryCreateDestinationTable(const ConnectionTimeouts & t
             = rewriteCreateQueryStorage(task_shard->current_pull_table_create_query, task_table.table_push, task_table.engine_push_ast);
         auto & create = create_query_push_ast->as<ASTCreateQuery &>();
         create.if_not_exists = true;
-        InterpreterCreateQuery::prepareOnClusterQuery(create, context, task_table.cluster_push_name);
+        InterpreterCreateQuery::prepareOnClusterQuery(create, getContext(), task_table.cluster_push_name);
         String query = queryToString(create_query_push_ast);
 
         LOG_DEBUG(log, "Create destination tables. Query: {}", query);
@@ -1211,7 +1211,7 @@ TaskStatus ClusterCopier::processPartitionPieceTaskImpl(
 
     auto split_table_for_current_piece = task_shard.list_of_split_tables_on_shard[current_piece_number];
 
-    auto zookeeper = context.getZooKeeper();
+    auto zookeeper = getContext()->getZooKeeper();
 
     const String piece_is_dirty_flag_path          = partition_piece.getPartitionPieceIsDirtyPath();
     const String piece_is_dirty_cleaned_path       = partition_piece.getPartitionPieceIsCleanedPath();
@@ -1262,7 +1262,7 @@ TaskStatus ClusterCopier::processPartitionPieceTaskImpl(
 
         ParserQuery p_query(query.data() + query.size());
 
-        const auto & settings = context.getSettingsRef();
+        const auto & settings = getContext()->getSettingsRef();
         return parseQuery(p_query, query, settings.max_query_size, settings.max_parser_depth);
     };
 
@@ -1366,10 +1366,10 @@ TaskStatus ClusterCopier::processPartitionPieceTaskImpl(
         ASTPtr query_select_ast = get_select_query(split_table_for_current_piece, "count()", /*enable_splitting*/ true);
         UInt64 count;
         {
-            Context local_context = context;
+            auto local_context = Context::createCopy(context);
             // Use pull (i.e. readonly) settings, but fetch data from destination servers
-            local_context.setSettings(task_cluster->settings_pull);
-            local_context.setSetting("skip_unavailable_shards", true);
+            local_context->setSettings(task_cluster->settings_pull);
+            local_context->setSetting("skip_unavailable_shards", true);
 
             Block block = getBlockWithAllStreamData(InterpreterFactory::get(query_select_ast, local_context)->execute().getInputStream());
             count = (block) ? block.safeGetByPosition(0).column->getUInt(0) : 0;
@@ -1468,7 +1468,7 @@ TaskStatus ClusterCopier::processPartitionPieceTaskImpl(
             query += "INSERT INTO " + getQuotedTable(split_table_for_current_piece) + " VALUES ";
 
             ParserQuery p_query(query.data() + query.size());
-            const auto & settings = context.getSettingsRef();
+            const auto & settings = getContext()->getSettingsRef();
             query_insert_ast = parseQuery(p_query, query, settings.max_query_size, settings.max_parser_depth);
 
             LOG_DEBUG(log, "Executing INSERT query: {}", query);
@@ -1476,18 +1476,18 @@ TaskStatus ClusterCopier::processPartitionPieceTaskImpl(
 
         try
         {
-            std::unique_ptr<Context> context_select = std::make_unique<Context>(context);
+            auto context_select = Context::createCopy(context);
             context_select->setSettings(task_cluster->settings_pull);
 
-            std::unique_ptr<Context> context_insert = std::make_unique<Context>(context);
+            auto context_insert = Context::createCopy(context);
             context_insert->setSettings(task_cluster->settings_push);
 
             /// Custom INSERT SELECT implementation
             BlockInputStreamPtr input;
             BlockOutputStreamPtr output;
             {
-                BlockIO io_select = InterpreterFactory::get(query_select_ast, *context_select)->execute();
-                BlockIO io_insert = InterpreterFactory::get(query_insert_ast, *context_insert)->execute();
+                BlockIO io_select = InterpreterFactory::get(query_select_ast, context_select)->execute();
+                BlockIO io_insert = InterpreterFactory::get(query_insert_ast, context_insert)->execute();
 
                 input = io_select.getInputStream();
                 output = io_insert.out;
@@ -1581,7 +1581,7 @@ void ClusterCopier::dropAndCreateLocalTable(const ASTPtr & create_ast)
     const auto & create = create_ast->as<ASTCreateQuery &>();
     dropLocalTableIfExists({create.database, create.table});
 
-    InterpreterCreateQuery interpreter(create_ast, context);
+    InterpreterCreateQuery interpreter(create_ast, getContext());
     interpreter.execute();
 }
 
@@ -1592,7 +1592,7 @@ void ClusterCopier::dropLocalTableIfExists(const DatabaseAndTableName & table_na
     drop_ast->database = table_name.first;
     drop_ast->table = table_name.second;
 
-    InterpreterDropQuery interpreter(drop_ast, context);
+    InterpreterDropQuery interpreter(drop_ast, getContext());
     interpreter.execute();
 }
 
@@ -1654,8 +1654,8 @@ void ClusterCopier::dropParticularPartitionPieceFromAllHelpingTables(const TaskT
 
 String ClusterCopier::getRemoteCreateTable(const DatabaseAndTableName & table, Connection & connection, const Settings & settings)
 {
-    Context remote_context(context);
-    remote_context.setSettings(settings);
+    auto remote_context = Context::createCopy(context);
+    remote_context->setSettings(settings);
 
     String query = "SHOW CREATE TABLE " + getQuotedTable(table);
     Block block = getBlockWithAllStreamData(std::make_shared<RemoteBlockInputStream>(
@@ -1674,7 +1674,7 @@ ASTPtr ClusterCopier::getCreateTableForPullShard(const ConnectionTimeouts & time
             task_cluster->settings_pull);
 
     ParserCreateQuery parser_create_query;
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = getContext()->getSettingsRef();
     return parseQuery(parser_create_query, create_query_pull_str, settings.max_query_size, settings.max_parser_depth);
 }
 
@@ -1703,7 +1703,7 @@ void ClusterCopier::createShardInternalTables(const ConnectionTimeouts & timeout
     /// Create special cluster with single shard
     String shard_read_cluster_name = read_shard_prefix + task_table.cluster_pull_name;
     ClusterPtr cluster_pull_current_shard = task_table.cluster_pull->getClusterWithSingleShard(task_shard.indexInCluster());
-    context.setCluster(shard_read_cluster_name, cluster_pull_current_shard);
+    getContext()->setCluster(shard_read_cluster_name, cluster_pull_current_shard);
 
     auto storage_shard_ast = createASTStorageDistributed(shard_read_cluster_name, task_table.table_pull.first, task_table.table_pull.second);
 
@@ -1763,13 +1763,13 @@ std::set<String> ClusterCopier::getShardPartitions(const ConnectionTimeouts & ti
     }
 
     ParserQuery parser_query(query.data() + query.size());
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = getContext()->getSettingsRef();
     ASTPtr query_ast = parseQuery(parser_query, query, settings.max_query_size, settings.max_parser_depth);
 
     LOG_DEBUG(log, "Computing destination partition set, executing query: {}", query);
 
-    Context local_context = context;
-    local_context.setSettings(task_cluster->settings_pull);
+    auto local_context = Context::createCopy(context);
+    local_context->setSettings(task_cluster->settings_pull);
     Block block = getBlockWithAllStreamData(InterpreterFactory::get(query_ast, local_context)->execute().getInputStream());
 
     if (block)
@@ -1809,11 +1809,11 @@ bool ClusterCopier::checkShardHasPartition(const ConnectionTimeouts & timeouts,
     LOG_DEBUG(log, "Checking shard {} for partition {} existence, executing query: {}", task_shard.getDescription(), partition_quoted_name, query);
 
     ParserQuery parser_query(query.data() + query.size());
-const auto & settings = context.getSettingsRef();
+    const auto & settings = getContext()->getSettingsRef();
     ASTPtr query_ast = parseQuery(parser_query, query, settings.max_query_size, settings.max_parser_depth);
 
-    Context local_context = context;
-    local_context.setSettings(task_cluster->settings_pull);
+    auto local_context = Context::createCopy(context);
+    local_context->setSettings(task_cluster->settings_pull);
     return InterpreterFactory::get(query_ast, local_context)->execute().getInputStream()->read().rows() != 0;
 }
 
@@ -1848,11 +1848,11 @@ bool ClusterCopier::checkPresentPartitionPiecesOnCurrentShard(const ConnectionTi
     LOG_DEBUG(log, "Checking shard {} for partition {} piece {} existence, executing query: {}", task_shard.getDescription(), partition_quoted_name, std::to_string(current_piece_number), query);
 
     ParserQuery parser_query(query.data() + query.size());
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = getContext()->getSettingsRef();
     ASTPtr query_ast = parseQuery(parser_query, query, settings.max_query_size, settings.max_parser_depth);
 
-    Context local_context = context;
-    local_context.setSettings(task_cluster->settings_pull);
+    auto local_context = Context::createCopy(context);
+    local_context->setSettings(task_cluster->settings_pull);
     auto result = InterpreterFactory::get(query_ast, local_context)->execute().getInputStream()->read().rows();
     if (result != 0)
         LOG_DEBUG(log, "Partition {} piece number {} is PRESENT on shard {}", partition_quoted_name, std::to_string(current_piece_number), task_shard.getDescription());
@@ -1908,7 +1908,7 @@ UInt64 ClusterCopier::executeQueryOnCluster(
         /// In that case we don't have local replicas, but do it just in case
         for (UInt64 i = 0; i < num_local_replicas; ++i)
         {
-            auto interpreter = InterpreterFactory::get(query_ast, context);
+            auto interpreter = InterpreterFactory::get(query_ast, getContext());
             interpreter->execute();
 
             if (increment_and_check_exit())
@@ -1923,8 +1923,8 @@ UInt64 ClusterCopier::executeQueryOnCluster(
             auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(shard_settings).getSaturated(shard_settings.max_execution_time);
             auto connections = shard.pool->getMany(timeouts, &shard_settings, pool_mode);
 
-            Context shard_context(context);
-            shard_context.setSettings(shard_settings);
+            auto shard_context = Context::createCopy(context);
+            shard_context->setSettings(shard_settings);
 
             for (auto & connection : connections)
             {
diff --git a/programs/copier/ClusterCopier.h b/programs/copier/ClusterCopier.h
index 95bb54cf4e1..e875ca7df2e 100644
--- a/programs/copier/ClusterCopier.h
+++ b/programs/copier/ClusterCopier.h
@@ -12,18 +12,17 @@
 namespace DB
 {
 
-class ClusterCopier
+class ClusterCopier : WithContext
 {
 public:
     ClusterCopier(const String & task_path_,
                   const String & host_id_,
                   const String & proxy_database_name_,
-                  Context & context_)
-            :
+                  ContextPtr context_)
+            : WithContext(context_),
             task_zookeeper_path(task_path_),
             host_id(host_id_),
             working_database_name(proxy_database_name_),
-            context(context_),
             log(&Poco::Logger::get("ClusterCopier")) {}
 
     void init();
@@ -36,7 +35,7 @@ public:
     /// Compute set of partitions, assume set of partitions aren't changed during the processing
     void discoverTablePartitions(const ConnectionTimeouts & timeouts, TaskTable & task_table, UInt64 num_threads = 0);
 
-    void uploadTaskDescription(const std::string & task_path, const std::string & task_file, const bool force);
+    void uploadTaskDescription(const std::string & task_path, const std::string & task_file, bool force);
 
     void reloadTaskDescription();
 
@@ -120,7 +119,7 @@ protected:
     /// Removes MATERIALIZED and ALIAS columns from create table query
     static ASTPtr removeAliasColumnsFromCreateQuery(const ASTPtr & query_ast);
 
-    bool tryDropPartitionPiece(ShardPartition & task_partition, const size_t current_piece_number,
+    bool tryDropPartitionPiece(ShardPartition & task_partition, size_t current_piece_number,
             const zkutil::ZooKeeperPtr & zookeeper, const CleanStateClock & clean_state_clock);
 
     static constexpr UInt64 max_table_tries = 3;
@@ -141,7 +140,7 @@ protected:
 
     TaskStatus processPartitionPieceTaskImpl(const ConnectionTimeouts & timeouts,
                                              ShardPartition & task_partition,
-                                             const size_t current_piece_number,
+                                             size_t current_piece_number,
                                              bool is_unprioritized_task);
 
     void dropAndCreateLocalTable(const ASTPtr & create_ast);
@@ -219,7 +218,6 @@ private:
 
     bool experimental_use_sample_offset{false};
 
-    Context & context;
     Poco::Logger * log;
 
     std::chrono::milliseconds default_sleep_time{1000};
diff --git a/programs/copier/ClusterCopierApp.cpp b/programs/copier/ClusterCopierApp.cpp
index e3169a49ecf..d3fff616b65 100644
--- a/programs/copier/ClusterCopierApp.cpp
+++ b/programs/copier/ClusterCopierApp.cpp
@@ -3,6 +3,7 @@
 #include <Common/TerminalSize.h>
 #include <IO/ConnectionTimeoutsContext.h>
 #include <Formats/registerFormats.h>
+#include <ext/scope_guard_safe.h>
 #include <unistd.h>
 
 
@@ -110,9 +111,9 @@ void ClusterCopierApp::mainImpl()
     LOG_INFO(log, "Starting clickhouse-copier (id {}, host_id {}, path {}, revision {})", process_id, host_id, process_path, ClickHouseRevision::getVersionRevision());
 
     SharedContextHolder shared_context = Context::createShared();
-    auto context = std::make_unique<Context>(Context::createGlobal(shared_context.get()));
+    auto context = Context::createGlobal(shared_context.get());
     context->makeGlobalContext();
-    SCOPE_EXIT(context->shutdown());
+    SCOPE_EXIT_SAFE(context->shutdown());
 
     context->setConfig(loaded_config.configuration);
     context->setApplicationType(Context::ApplicationType::LOCAL);
@@ -127,13 +128,13 @@ void ClusterCopierApp::mainImpl()
     registerFormats();
 
     static const std::string default_database = "_local";
-    DatabaseCatalog::instance().attachDatabase(default_database, std::make_shared<DatabaseMemory>(default_database, *context));
+    DatabaseCatalog::instance().attachDatabase(default_database, std::make_shared<DatabaseMemory>(default_database, context));
     context->setCurrentDatabase(default_database);
 
     /// Initialize query scope just in case.
-    CurrentThread::QueryScope query_scope(*context);
+    CurrentThread::QueryScope query_scope(context);
 
-    auto copier = std::make_unique<ClusterCopier>(task_path, host_id, default_database, *context);
+    auto copier = std::make_unique<ClusterCopier>(task_path, host_id, default_database, context);
     copier->setSafeMode(is_safe_mode);
     copier->setCopyFaultProbability(copy_fault_probability);
     copier->setMoveFaultProbability(move_fault_probability);
diff --git a/programs/copier/Internals.cpp b/programs/copier/Internals.cpp
index ea2be469945..bec612a8226 100644
--- a/programs/copier/Internals.cpp
+++ b/programs/copier/Internals.cpp
@@ -222,8 +222,8 @@ Names extractPrimaryKeyColumnNames(const ASTPtr & storage_ast)
         {
             String pk_column = primary_key_expr_list->children[i]->getColumnName();
             if (pk_column != sorting_key_column)
-                throw Exception("Primary key must be a prefix of the sorting key, but in position "
-                                + toString(i) + " its column is " + pk_column + ", not " + sorting_key_column,
+                throw Exception("Primary key must be a prefix of the sorting key, but the column in the position "
+                                + toString(i) + " is " + sorting_key_column +", not " + pk_column,
                                 ErrorCodes::BAD_ARGUMENTS);
 
             if (!primary_key_columns_set.emplace(pk_column).second)
diff --git a/programs/format/Format.cpp b/programs/format/Format.cpp
index ba3d6e8557b..5bf19191353 100644
--- a/programs/format/Format.cpp
+++ b/programs/format/Format.cpp
@@ -102,8 +102,8 @@ int mainEntryClickHouseFormat(int argc, char ** argv)
             }
 
             SharedContextHolder shared_context = Context::createShared();
-            Context context = Context::createGlobal(shared_context.get());
-            context.makeGlobalContext();
+            auto context = Context::createGlobal(shared_context.get());
+            context->makeGlobalContext();
 
             registerFunctions();
             registerAggregateFunctions();
diff --git a/programs/library-bridge/CMakeLists.txt b/programs/library-bridge/CMakeLists.txt
new file mode 100644
index 00000000000..5ceff47ee0c
--- /dev/null
+++ b/programs/library-bridge/CMakeLists.txt
@@ -0,0 +1,25 @@
+set (CLICKHOUSE_LIBRARY_BRIDGE_SOURCES
+    library-bridge.cpp
+    library-log.cpp
+    LibraryBridge.cpp
+    Handlers.cpp
+    HandlerFactory.cpp
+    SharedLibraryHandler.cpp
+    SharedLibraryHandlerFactory.cpp
+)
+
+if (OS_LINUX)
+    set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--no-export-dynamic")
+endif ()
+
+add_executable(clickhouse-library-bridge ${CLICKHOUSE_LIBRARY_BRIDGE_SOURCES})
+
+target_link_libraries(clickhouse-library-bridge PRIVATE
+    daemon
+    dbms
+    bridge
+)
+
+set_target_properties(clickhouse-library-bridge PROPERTIES RUNTIME_OUTPUT_DIRECTORY ..)
+
+install(TARGETS clickhouse-library-bridge RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
diff --git a/programs/library-bridge/HandlerFactory.cpp b/programs/library-bridge/HandlerFactory.cpp
new file mode 100644
index 00000000000..9f53a24156f
--- /dev/null
+++ b/programs/library-bridge/HandlerFactory.cpp
@@ -0,0 +1,23 @@
+#include "HandlerFactory.h"
+
+#include <Poco/Net/HTTPServerRequest.h>
+#include <Server/HTTP/HTMLForm.h>
+#include "Handlers.h"
+
+
+namespace DB
+{
+    std::unique_ptr<HTTPRequestHandler> LibraryBridgeHandlerFactory::createRequestHandler(const HTTPServerRequest & request)
+    {
+        Poco::URI uri{request.getURI()};
+        LOG_DEBUG(log, "Request URI: {}", uri.toString());
+
+        if (uri == "/ping" && request.getMethod() == Poco::Net::HTTPRequest::HTTP_GET)
+            return std::make_unique<PingHandler>(keep_alive_timeout);
+
+        if (request.getMethod() == Poco::Net::HTTPRequest::HTTP_POST)
+            return std::make_unique<LibraryRequestHandler>(keep_alive_timeout, getContext());
+
+        return nullptr;
+    }
+}
diff --git a/programs/library-bridge/HandlerFactory.h b/programs/library-bridge/HandlerFactory.h
new file mode 100644
index 00000000000..93f0721bf01
--- /dev/null
+++ b/programs/library-bridge/HandlerFactory.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <Interpreters/Context.h>
+#include <Server/HTTP/HTTPRequestHandlerFactory.h>
+#include <common/logger_useful.h>
+
+
+namespace DB
+{
+
+class SharedLibraryHandler;
+using SharedLibraryHandlerPtr = std::shared_ptr<SharedLibraryHandler>;
+
+/// Factory for '/ping', '/' handlers.
+class LibraryBridgeHandlerFactory : public HTTPRequestHandlerFactory, WithContext
+{
+public:
+    LibraryBridgeHandlerFactory(
+            const std::string & name_,
+            size_t keep_alive_timeout_,
+            ContextPtr context_)
+        : WithContext(context_)
+        , log(&Poco::Logger::get(name_))
+        , name(name_)
+        , keep_alive_timeout(keep_alive_timeout_)
+    {
+    }
+
+    std::unique_ptr<HTTPRequestHandler> createRequestHandler(const HTTPServerRequest & request) override;
+
+private:
+    Poco::Logger * log;
+    std::string name;
+    size_t keep_alive_timeout;
+};
+
+}
diff --git a/programs/library-bridge/Handlers.cpp b/programs/library-bridge/Handlers.cpp
new file mode 100644
index 00000000000..6a1bfbbccb7
--- /dev/null
+++ b/programs/library-bridge/Handlers.cpp
@@ -0,0 +1,288 @@
+#include "Handlers.h"
+#include "SharedLibraryHandlerFactory.h"
+
+#include <DataStreams/copyData.h>
+#include <Formats/FormatFactory.h>
+#include <Server/HTTP/WriteBufferFromHTTPServerResponse.h>
+#include <IO/WriteHelpers.h>
+#include <IO/ReadHelpers.h>
+#include <Poco/Net/HTTPServerRequest.h>
+#include <Poco/Net/HTTPServerResponse.h>
+#include <Poco/Net/HTMLForm.h>
+#include <Poco/ThreadPool.h>
+#include <Processors/Formats/InputStreamFromInputFormat.h>
+#include <Server/HTTP/HTMLForm.h>
+#include <IO/ReadBufferFromString.h>
+
+
+namespace DB
+{
+namespace
+{
+    std::shared_ptr<Block> parseColumns(std::string && column_string)
+    {
+        auto sample_block = std::make_shared<Block>();
+        auto names_and_types = NamesAndTypesList::parse(column_string);
+
+        for (const NameAndTypePair & column_data : names_and_types)
+            sample_block->insert({column_data.type, column_data.name});
+
+        return sample_block;
+    }
+
+    std::vector<uint64_t> parseIdsFromBinary(const std::string & ids_string)
+    {
+        ReadBufferFromString buf(ids_string);
+        std::vector<uint64_t> ids;
+        readVectorBinary(ids, buf);
+        return ids;
+    }
+
+    std::vector<std::string> parseNamesFromBinary(const std::string & names_string)
+    {
+        ReadBufferFromString buf(names_string);
+        std::vector<std::string> names;
+        readVectorBinary(names, buf);
+        return names;
+    }
+}
+
+
+void LibraryRequestHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response)
+{
+    LOG_TRACE(log, "Request URI: {}", request.getURI());
+    HTMLForm params(request);
+
+    if (!params.has("method"))
+    {
+        processError(response, "No 'method' in request URL");
+        return;
+    }
+
+    if (!params.has("dictionary_id"))
+    {
+        processError(response, "No 'dictionary_id in request URL");
+        return;
+    }
+
+    std::string method = params.get("method");
+    std::string dictionary_id = params.get("dictionary_id");
+    LOG_TRACE(log, "Library method: '{}', dictionary id: {}", method, dictionary_id);
+
+    WriteBufferFromHTTPServerResponse out(response, request.getMethod() == Poco::Net::HTTPRequest::HTTP_HEAD, keep_alive_timeout);
+
+    try
+    {
+        if (method == "libNew")
+        {
+            auto & read_buf = request.getStream();
+            params.read(read_buf);
+
+            if (!params.has("library_path"))
+            {
+                processError(response, "No 'library_path' in request URL");
+                return;
+            }
+
+            if (!params.has("library_settings"))
+            {
+                processError(response, "No 'library_settings' in request URL");
+                return;
+            }
+
+            std::string library_path = params.get("library_path");
+            const auto & settings_string = params.get("library_settings");
+            std::vector<std::string> library_settings = parseNamesFromBinary(settings_string);
+
+            /// Needed for library dictionary
+            if (!params.has("attributes_names"))
+            {
+                processError(response, "No 'attributes_names' in request URL");
+                return;
+            }
+
+            const auto & attributes_string = params.get("attributes_names");
+            std::vector<std::string> attributes_names = parseNamesFromBinary(attributes_string);
+
+            /// Needed to parse block from binary string format
+            if (!params.has("sample_block"))
+            {
+                processError(response, "No 'sample_block' in request URL");
+                return;
+            }
+            std::string sample_block_string = params.get("sample_block");
+
+            std::shared_ptr<Block> sample_block;
+            try
+            {
+                sample_block = parseColumns(std::move(sample_block_string));
+            }
+            catch (const Exception & ex)
+            {
+                processError(response, "Invalid 'sample_block' parameter in request body '" + ex.message() + "'");
+                LOG_WARNING(log, ex.getStackTraceString());
+                return;
+            }
+
+            if (!params.has("null_values"))
+            {
+                processError(response, "No 'null_values' in request URL");
+                return;
+            }
+
+            ReadBufferFromString read_block_buf(params.get("null_values"));
+            auto format = FormatFactory::instance().getInput(FORMAT, read_block_buf, *sample_block, getContext(), DEFAULT_BLOCK_SIZE);
+            auto reader = std::make_shared<InputStreamFromInputFormat>(format);
+            auto sample_block_with_nulls = reader->read();
+
+            LOG_DEBUG(log, "Dictionary sample block with null values: {}", sample_block_with_nulls.dumpStructure());
+
+            SharedLibraryHandlerFactory::instance().create(dictionary_id, library_path, library_settings, sample_block_with_nulls, attributes_names);
+            writeStringBinary("1", out);
+        }
+        else if (method == "libClone")
+        {
+            if (!params.has("from_dictionary_id"))
+            {
+                processError(response, "No 'from_dictionary_id' in request URL");
+                return;
+            }
+
+            std::string from_dictionary_id = params.get("from_dictionary_id");
+            LOG_TRACE(log, "Calling libClone from {} to {}", from_dictionary_id, dictionary_id);
+            SharedLibraryHandlerFactory::instance().clone(from_dictionary_id, dictionary_id);
+            writeStringBinary("1", out);
+        }
+        else if (method == "libDelete")
+        {
+            SharedLibraryHandlerFactory::instance().remove(dictionary_id);
+            writeStringBinary("1", out);
+        }
+        else if (method == "isModified")
+        {
+            auto library_handler = SharedLibraryHandlerFactory::instance().get(dictionary_id);
+            bool res = library_handler->isModified();
+            writeStringBinary(std::to_string(res), out);
+        }
+        else if (method == "supportsSelectiveLoad")
+        {
+            auto library_handler = SharedLibraryHandlerFactory::instance().get(dictionary_id);
+            bool res = library_handler->supportsSelectiveLoad();
+            writeStringBinary(std::to_string(res), out);
+        }
+        else if (method == "loadAll")
+        {
+            auto library_handler = SharedLibraryHandlerFactory::instance().get(dictionary_id);
+            const auto & sample_block = library_handler->getSampleBlock();
+            auto input = library_handler->loadAll();
+
+            BlockOutputStreamPtr output = FormatFactory::instance().getOutputStream(FORMAT, out, sample_block, getContext());
+            copyData(*input, *output);
+        }
+        else if (method == "loadIds")
+        {
+            params.read(request.getStream());
+
+            if (!params.has("ids"))
+            {
+                processError(response, "No 'ids' in request URL");
+                return;
+            }
+
+            std::vector<uint64_t> ids = parseIdsFromBinary(params.get("ids"));
+            auto library_handler = SharedLibraryHandlerFactory::instance().get(dictionary_id);
+            const auto & sample_block = library_handler->getSampleBlock();
+            auto input = library_handler->loadIds(ids);
+            BlockOutputStreamPtr output = FormatFactory::instance().getOutputStream(FORMAT, out, sample_block, getContext());
+            copyData(*input, *output);
+        }
+        else if (method == "loadKeys")
+        {
+            if (!params.has("requested_block_sample"))
+            {
+                processError(response, "No 'requested_block_sample' in request URL");
+                return;
+            }
+
+            std::string requested_block_string = params.get("requested_block_sample");
+
+            std::shared_ptr<Block> requested_sample_block;
+            try
+            {
+                requested_sample_block = parseColumns(std::move(requested_block_string));
+            }
+            catch (const Exception & ex)
+            {
+                processError(response, "Invalid 'requested_block' parameter in request body '" + ex.message() + "'");
+                LOG_WARNING(log, ex.getStackTraceString());
+                return;
+            }
+
+            auto & read_buf = request.getStream();
+            auto format = FormatFactory::instance().getInput(FORMAT, read_buf, *requested_sample_block, getContext(), DEFAULT_BLOCK_SIZE);
+            auto reader = std::make_shared<InputStreamFromInputFormat>(format);
+            auto block = reader->read();
+
+            auto library_handler = SharedLibraryHandlerFactory::instance().get(dictionary_id);
+            const auto & sample_block = library_handler->getSampleBlock();
+            auto input = library_handler->loadKeys(block.getColumns());
+            BlockOutputStreamPtr output = FormatFactory::instance().getOutputStream(FORMAT, out, sample_block, getContext());
+            copyData(*input, *output);
+        }
+    }
+    catch (...)
+    {
+        auto message = getCurrentExceptionMessage(true);
+        response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR, message); // can't call process_error, because of too soon response sending
+
+        try
+        {
+            writeStringBinary(message, out);
+            out.finalize();
+        }
+        catch (...)
+        {
+            tryLogCurrentException(log);
+        }
+
+        tryLogCurrentException(log);
+    }
+
+    try
+    {
+        out.finalize();
+    }
+    catch (...)
+    {
+        tryLogCurrentException(log);
+    }
+}
+
+
+void LibraryRequestHandler::processError(HTTPServerResponse & response, const std::string & message)
+{
+    response.setStatusAndReason(HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
+
+    if (!response.sent())
+        *response.send() << message << std::endl;
+
+    LOG_WARNING(log, message);
+}
+
+
+void PingHandler::handleRequest(HTTPServerRequest & /* request */, HTTPServerResponse & response)
+{
+    try
+    {
+        setResponseDefaultHeaders(response, keep_alive_timeout);
+        const char * data = "Ok.\n";
+        response.sendBuffer(data, strlen(data));
+    }
+    catch (...)
+    {
+        tryLogCurrentException("PingHandler");
+    }
+}
+
+
+}
diff --git a/programs/library-bridge/Handlers.h b/programs/library-bridge/Handlers.h
new file mode 100644
index 00000000000..dac61d3a735
--- /dev/null
+++ b/programs/library-bridge/Handlers.h
@@ -0,0 +1,59 @@
+#pragma once
+
+#include <Interpreters/Context.h>
+#include <Server/HTTP/HTTPRequestHandler.h>
+#include <common/logger_useful.h>
+#include "SharedLibraryHandler.h"
+
+
+namespace DB
+{
+
+
+/// Handler for requests to Library Dictionary Source, returns response in RowBinary format.
+/// When a library dictionary source is created, it sends libNew request to library bridge (which is started on first
+/// request to it, if it was not yet started). On this request a new sharedLibrayHandler is added to a
+/// sharedLibraryHandlerFactory by a dictionary uuid. With libNew request come: library_path, library_settings,
+/// names of dictionary attributes, sample block to parse block of null values, block of null values. Everything is
+/// passed in binary format and is urlencoded. When dictionary is cloned, a new handler is created.
+/// Each handler is unique to dictionary.
+class LibraryRequestHandler : public HTTPRequestHandler, WithContext
+{
+public:
+
+    LibraryRequestHandler(
+        size_t keep_alive_timeout_,
+        ContextPtr context_)
+        : WithContext(context_)
+        , log(&Poco::Logger::get("LibraryRequestHandler"))
+        , keep_alive_timeout(keep_alive_timeout_)
+    {
+    }
+
+    void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response) override;
+
+private:
+    static constexpr inline auto FORMAT = "RowBinary";
+
+    void processError(HTTPServerResponse & response, const std::string & message);
+
+    Poco::Logger * log;
+    size_t keep_alive_timeout;
+};
+
+
+class PingHandler : public HTTPRequestHandler
+{
+public:
+    explicit PingHandler(size_t keep_alive_timeout_)
+        : keep_alive_timeout(keep_alive_timeout_)
+    {
+    }
+
+    void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response) override;
+
+private:
+    const size_t keep_alive_timeout;
+};
+
+}
diff --git a/programs/library-bridge/LibraryBridge.cpp b/programs/library-bridge/LibraryBridge.cpp
new file mode 100644
index 00000000000..2e5d6041151
--- /dev/null
+++ b/programs/library-bridge/LibraryBridge.cpp
@@ -0,0 +1,17 @@
+#include "LibraryBridge.h"
+
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+int mainEntryClickHouseLibraryBridge(int argc, char ** argv)
+{
+    DB::LibraryBridge app;
+    try
+    {
+        return app.run(argc, argv);
+    }
+    catch (...)
+    {
+        std::cerr << DB::getCurrentExceptionMessage(true) << "\n";
+        auto code = DB::getCurrentExceptionCode();
+        return code ? code : 1;
+    }
+}
diff --git a/programs/library-bridge/LibraryBridge.h b/programs/library-bridge/LibraryBridge.h
new file mode 100644
index 00000000000..9f2dafb89ab
--- /dev/null
+++ b/programs/library-bridge/LibraryBridge.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <Interpreters/Context.h>
+#include <bridge/IBridge.h>
+#include "HandlerFactory.h"
+
+
+namespace DB
+{
+
+class LibraryBridge : public IBridge
+{
+
+protected:
+    std::string bridgeName() const override
+    {
+        return "LibraryBridge";
+    }
+
+    HandlerFactoryPtr getHandlerFactoryPtr(ContextPtr context) const override
+    {
+        return std::make_shared<LibraryBridgeHandlerFactory>("LibraryRequestHandlerFactory-factory", keep_alive_timeout, context);
+    }
+};
+
+}
diff --git a/programs/library-bridge/LibraryUtils.h b/programs/library-bridge/LibraryUtils.h
new file mode 100644
index 00000000000..359d1de93e3
--- /dev/null
+++ b/programs/library-bridge/LibraryUtils.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <Common/StringUtils/StringUtils.h>
+#include <Dictionaries/LibraryDictionarySourceExternal.h>
+#include <Core/Block.h>
+#include <ext/bit_cast.h>
+#include <ext/range.h>
+
+
+namespace DB
+{
+
+class CStringsHolder
+{
+
+public:
+    using Container = std::vector<std::string>;
+
+    explicit CStringsHolder(const Container & strings_pass)
+    {
+        strings_holder = strings_pass;
+        strings.size = strings_holder.size();
+
+        ptr_holder = std::make_unique<ClickHouseLibrary::CString[]>(strings.size);
+        strings.data = ptr_holder.get();
+
+        size_t i = 0;
+        for (auto & str : strings_holder)
+        {
+            strings.data[i] = str.c_str();
+            ++i;
+        }
+    }
+
+    ClickHouseLibrary::CStrings strings; // will pass pointer to lib
+
+private:
+    std::unique_ptr<ClickHouseLibrary::CString[]> ptr_holder = nullptr;
+    Container strings_holder;
+};
+
+
+}
diff --git a/programs/library-bridge/SharedLibraryHandler.cpp b/programs/library-bridge/SharedLibraryHandler.cpp
new file mode 100644
index 00000000000..ab8cf2417c2
--- /dev/null
+++ b/programs/library-bridge/SharedLibraryHandler.cpp
@@ -0,0 +1,219 @@
+#include "SharedLibraryHandler.h"
+
+#include <ext/scope_guard.h>
+#include <IO/ReadHelpers.h>
+#include <common/find_symbols.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int EXTERNAL_LIBRARY_ERROR;
+    extern const int SIZES_OF_COLUMNS_DOESNT_MATCH;
+}
+
+
+SharedLibraryHandler::SharedLibraryHandler(
+    const std::string & library_path_,
+    const std::vector<std::string> & library_settings,
+    const Block & sample_block_,
+    const std::vector<std::string> & attributes_names_)
+    : library_path(library_path_)
+    , sample_block(sample_block_)
+    , attributes_names(attributes_names_)
+{
+    library = std::make_shared<SharedLibrary>(library_path, RTLD_LAZY);
+    settings_holder = std::make_shared<CStringsHolder>(CStringsHolder(library_settings));
+
+    auto lib_new = library->tryGet<ClickHouseLibrary::LibraryNewFunc>(ClickHouseLibrary::LIBRARY_CREATE_NEW_FUNC_NAME);
+
+    if (lib_new)
+        lib_data = lib_new(&settings_holder->strings, ClickHouseLibrary::log);
+    else
+        throw Exception("Method libNew failed", ErrorCodes::EXTERNAL_LIBRARY_ERROR);
+}
+
+
+SharedLibraryHandler::SharedLibraryHandler(const SharedLibraryHandler & other)
+    : library_path{other.library_path}
+    , sample_block{other.sample_block}
+    , attributes_names{other.attributes_names}
+    , library{other.library}
+    , settings_holder{other.settings_holder}
+{
+
+    auto lib_clone = library->tryGet<ClickHouseLibrary::LibraryCloneFunc>(ClickHouseLibrary::LIBRARY_CLONE_FUNC_NAME);
+
+    if (lib_clone)
+    {
+        lib_data = lib_clone(other.lib_data);
+    }
+    else
+    {
+        auto lib_new = library->tryGet<ClickHouseLibrary::LibraryNewFunc>(ClickHouseLibrary::LIBRARY_CREATE_NEW_FUNC_NAME);
+
+        if (lib_new)
+            lib_data = lib_new(&settings_holder->strings, ClickHouseLibrary::log);
+    }
+}
+
+
+SharedLibraryHandler::~SharedLibraryHandler()
+{
+    auto lib_delete = library->tryGet<ClickHouseLibrary::LibraryDeleteFunc>(ClickHouseLibrary::LIBRARY_DELETE_FUNC_NAME);
+
+    if (lib_delete)
+        lib_delete(lib_data);
+}
+
+
+bool SharedLibraryHandler::isModified()
+{
+    auto func_is_modified = library->tryGet<ClickHouseLibrary::LibraryIsModifiedFunc>(ClickHouseLibrary::LIBRARY_IS_MODIFIED_FUNC_NAME);
+
+    if (func_is_modified)
+        return func_is_modified(lib_data, &settings_holder->strings);
+
+    return true;
+}
+
+
+bool SharedLibraryHandler::supportsSelectiveLoad()
+{
+    auto func_supports_selective_load = library->tryGet<ClickHouseLibrary::LibrarySupportsSelectiveLoadFunc>(ClickHouseLibrary::LIBRARY_SUPPORTS_SELECTIVE_LOAD_FUNC_NAME);
+
+    if (func_supports_selective_load)
+        return func_supports_selective_load(lib_data, &settings_holder->strings);
+
+    return true;
+}
+
+
+BlockInputStreamPtr SharedLibraryHandler::loadAll()
+{
+    auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(attributes_names.size());
+    ClickHouseLibrary::CStrings columns{static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), attributes_names.size()};
+    for (size_t i = 0; i < attributes_names.size(); ++i)
+        columns.data[i] = attributes_names[i].c_str();
+
+    auto load_all_func = library->get<ClickHouseLibrary::LibraryLoadAllFunc>(ClickHouseLibrary::LIBRARY_LOAD_ALL_FUNC_NAME);
+    auto data_new_func = library->get<ClickHouseLibrary::LibraryDataNewFunc>(ClickHouseLibrary::LIBRARY_DATA_NEW_FUNC_NAME);
+    auto data_delete_func = library->get<ClickHouseLibrary::LibraryDataDeleteFunc>(ClickHouseLibrary::LIBRARY_DATA_DELETE_FUNC_NAME);
+
+    ClickHouseLibrary::LibraryData data_ptr = data_new_func(lib_data);
+    SCOPE_EXIT(data_delete_func(lib_data, data_ptr));
+
+    ClickHouseLibrary::RawClickHouseLibraryTable data = load_all_func(data_ptr, &settings_holder->strings, &columns);
+    auto block = dataToBlock(data);
+
+    return std::make_shared<OneBlockInputStream>(block);
+}
+
+
+BlockInputStreamPtr SharedLibraryHandler::loadIds(const std::vector<uint64_t> & ids)
+{
+    const ClickHouseLibrary::VectorUInt64 ids_data{ext::bit_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(ids.data()), ids.size()};
+
+    auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(attributes_names.size());
+    ClickHouseLibrary::CStrings columns_pass{static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), attributes_names.size()};
+
+    auto load_ids_func = library->get<ClickHouseLibrary::LibraryLoadIdsFunc>(ClickHouseLibrary::LIBRARY_LOAD_IDS_FUNC_NAME);
+    auto data_new_func = library->get<ClickHouseLibrary::LibraryDataNewFunc>(ClickHouseLibrary::LIBRARY_DATA_NEW_FUNC_NAME);
+    auto data_delete_func = library->get<ClickHouseLibrary::LibraryDataDeleteFunc>(ClickHouseLibrary::LIBRARY_DATA_DELETE_FUNC_NAME);
+
+    ClickHouseLibrary::LibraryData data_ptr = data_new_func(lib_data);
+    SCOPE_EXIT(data_delete_func(lib_data, data_ptr));
+
+    ClickHouseLibrary::RawClickHouseLibraryTable data = load_ids_func(data_ptr, &settings_holder->strings, &columns_pass, &ids_data);
+    auto block = dataToBlock(data);
+
+    return std::make_shared<OneBlockInputStream>(block);
+}
+
+
+BlockInputStreamPtr SharedLibraryHandler::loadKeys(const Columns & key_columns)
+{
+    auto holder = std::make_unique<ClickHouseLibrary::Row[]>(key_columns.size());
+    std::vector<std::unique_ptr<ClickHouseLibrary::Field[]>> column_data_holders;
+
+    for (size_t i = 0; i < key_columns.size(); ++i)
+    {
+        auto cell_holder = std::make_unique<ClickHouseLibrary::Field[]>(key_columns[i]->size());
+
+        for (size_t j = 0; j < key_columns[i]->size(); ++j)
+        {
+            auto data_ref = key_columns[i]->getDataAt(j);
+
+            cell_holder[j] = ClickHouseLibrary::Field{
+                    .data = static_cast<const void *>(data_ref.data),
+                    .size = data_ref.size};
+        }
+
+        holder[i] = ClickHouseLibrary::Row{
+                    .data = static_cast<ClickHouseLibrary::Field *>(cell_holder.get()),
+                    .size = key_columns[i]->size()};
+
+        column_data_holders.push_back(std::move(cell_holder));
+    }
+
+    ClickHouseLibrary::Table request_cols{
+            .data = static_cast<ClickHouseLibrary::Row *>(holder.get()),
+            .size = key_columns.size()};
+
+    auto load_keys_func = library->get<ClickHouseLibrary::LibraryLoadKeysFunc>(ClickHouseLibrary::LIBRARY_LOAD_KEYS_FUNC_NAME);
+    auto data_new_func = library->get<ClickHouseLibrary::LibraryDataNewFunc>(ClickHouseLibrary::LIBRARY_DATA_NEW_FUNC_NAME);
+    auto data_delete_func = library->get<ClickHouseLibrary::LibraryDataDeleteFunc>(ClickHouseLibrary::LIBRARY_DATA_DELETE_FUNC_NAME);
+
+    ClickHouseLibrary::LibraryData data_ptr = data_new_func(lib_data);
+    SCOPE_EXIT(data_delete_func(lib_data, data_ptr));
+
+    ClickHouseLibrary::RawClickHouseLibraryTable data = load_keys_func(data_ptr, &settings_holder->strings, &request_cols);
+    auto block = dataToBlock(data);
+
+    return std::make_shared<OneBlockInputStream>(block);
+}
+
+
+Block SharedLibraryHandler::dataToBlock(const ClickHouseLibrary::RawClickHouseLibraryTable data)
+{
+    if (!data)
+        throw Exception("LibraryDictionarySource: No data returned", ErrorCodes::EXTERNAL_LIBRARY_ERROR);
+
+    const auto * columns_received = static_cast<const ClickHouseLibrary::Table *>(data);
+    if (columns_received->error_code)
+        throw Exception(
+            "LibraryDictionarySource: Returned error: " + std::to_string(columns_received->error_code) + " " + (columns_received->error_string ? columns_received->error_string : ""),
+            ErrorCodes::EXTERNAL_LIBRARY_ERROR);
+
+    MutableColumns columns = sample_block.cloneEmptyColumns();
+
+    for (size_t col_n = 0; col_n < columns_received->size; ++col_n)
+    {
+        if (columns.size() != columns_received->data[col_n].size)
+            throw Exception(
+                "LibraryDictionarySource: Returned unexpected number of columns: " + std::to_string(columns_received->data[col_n].size) + ", must be " + std::to_string(columns.size()),
+                ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
+
+        for (size_t row_n = 0; row_n < columns_received->data[col_n].size; ++row_n)
+        {
+            const auto & field = columns_received->data[col_n].data[row_n];
+            if (!field.data)
+            {
+                /// sample_block contains null_value (from config) inside corresponding column
+                const auto & col = sample_block.getByPosition(row_n);
+                columns[row_n]->insertFrom(*(col.column), 0);
+            }
+            else
+            {
+                const auto & size = field.size;
+                columns[row_n]->insertData(static_cast<const char *>(field.data), size);
+            }
+        }
+    }
+
+    return sample_block.cloneWithColumns(std::move(columns));
+}
+
+}
diff --git a/programs/library-bridge/SharedLibraryHandler.h b/programs/library-bridge/SharedLibraryHandler.h
new file mode 100644
index 00000000000..5c0334ac89f
--- /dev/null
+++ b/programs/library-bridge/SharedLibraryHandler.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <Common/SharedLibrary.h>
+#include <common/logger_useful.h>
+#include <DataStreams/OneBlockInputStream.h>
+#include "LibraryUtils.h"
+
+
+namespace DB
+{
+
+/// A class that manages all operations with library dictionary.
+/// Every library dictionary source has its own object of this class, accessed by UUID.
+class SharedLibraryHandler
+{
+
+public:
+    SharedLibraryHandler(
+        const std::string & library_path_,
+        const std::vector<std::string> & library_settings,
+        const Block & sample_block_,
+        const std::vector<std::string> & attributes_names_);
+
+    SharedLibraryHandler(const SharedLibraryHandler & other);
+
+    ~SharedLibraryHandler();
+
+    BlockInputStreamPtr loadAll();
+
+    BlockInputStreamPtr loadIds(const std::vector<uint64_t> & ids);
+
+    BlockInputStreamPtr loadKeys(const Columns & key_columns);
+
+    bool isModified();
+
+    bool supportsSelectiveLoad();
+
+    const Block & getSampleBlock() { return sample_block; }
+
+private:
+    Block dataToBlock(const ClickHouseLibrary::RawClickHouseLibraryTable data);
+
+    std::string library_path;
+    const Block sample_block;
+    std::vector<std::string> attributes_names;
+
+    SharedLibraryPtr library;
+    std::shared_ptr<CStringsHolder> settings_holder;
+    void * lib_data;
+};
+
+using SharedLibraryHandlerPtr = std::shared_ptr<SharedLibraryHandler>;
+
+}
diff --git a/programs/library-bridge/SharedLibraryHandlerFactory.cpp b/programs/library-bridge/SharedLibraryHandlerFactory.cpp
new file mode 100644
index 00000000000..05494c313c4
--- /dev/null
+++ b/programs/library-bridge/SharedLibraryHandlerFactory.cpp
@@ -0,0 +1,67 @@
+#include "SharedLibraryHandlerFactory.h"
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+SharedLibraryHandlerPtr SharedLibraryHandlerFactory::get(const std::string & dictionary_id)
+{
+    std::lock_guard lock(mutex);
+    auto library_handler = library_handlers.find(dictionary_id);
+
+    if (library_handler != library_handlers.end())
+        return library_handler->second;
+
+    return nullptr;
+}
+
+
+void SharedLibraryHandlerFactory::create(
+    const std::string & dictionary_id,
+    const std::string & library_path,
+    const std::vector<std::string> & library_settings,
+    const Block & sample_block,
+    const std::vector<std::string> & attributes_names)
+{
+    std::lock_guard lock(mutex);
+    library_handlers[dictionary_id] = std::make_shared<SharedLibraryHandler>(library_path, library_settings, sample_block, attributes_names);
+}
+
+
+void SharedLibraryHandlerFactory::clone(const std::string & from_dictionary_id, const std::string & to_dictionary_id)
+{
+    std::lock_guard lock(mutex);
+    auto from_library_handler = library_handlers.find(from_dictionary_id);
+
+    /// This is not supposed to happen as libClone is called from copy constructor of LibraryDictionarySource
+    /// object, and shared library handler of from_dictionary is removed only in its destructor.
+    /// And if for from_dictionary there was no shared library handler, it would have received and exception in
+    /// its constructor, so no libClone would be made from it.
+    if (from_library_handler == library_handlers.end())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "No shared library handler found");
+
+    /// libClone method will be called in copy constructor
+    library_handlers[to_dictionary_id] = std::make_shared<SharedLibraryHandler>(*from_library_handler->second);
+}
+
+
+void SharedLibraryHandlerFactory::remove(const std::string & dictionary_id)
+{
+    std::lock_guard lock(mutex);
+    /// libDelete is called in destructor.
+    library_handlers.erase(dictionary_id);
+}
+
+
+SharedLibraryHandlerFactory & SharedLibraryHandlerFactory::instance()
+{
+    static SharedLibraryHandlerFactory ret;
+    return ret;
+}
+
+}
diff --git a/programs/library-bridge/SharedLibraryHandlerFactory.h b/programs/library-bridge/SharedLibraryHandlerFactory.h
new file mode 100644
index 00000000000..473d90618a2
--- /dev/null
+++ b/programs/library-bridge/SharedLibraryHandlerFactory.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "SharedLibraryHandler.h"
+#include <unordered_map>
+#include <mutex>
+
+
+namespace DB
+{
+
+/// Each library dictionary source has unique UUID. When clone() method is called, a new UUID is generated.
+/// There is a unique mapping from diciotnary UUID to sharedLibraryHandler.
+class SharedLibraryHandlerFactory final : private boost::noncopyable
+{
+public:
+    static SharedLibraryHandlerFactory & instance();
+
+    SharedLibraryHandlerPtr get(const std::string & dictionary_id);
+
+    void create(
+        const std::string & dictionary_id,
+        const std::string & library_path,
+        const std::vector<std::string> & library_settings,
+        const Block & sample_block,
+        const std::vector<std::string> & attributes_names);
+
+    void clone(const std::string & from_dictionary_id, const std::string & to_dictionary_id);
+
+    void remove(const std::string & dictionary_id);
+
+private:
+    /// map: dict_id -> sharedLibraryHandler
+    std::unordered_map<std::string, SharedLibraryHandlerPtr> library_handlers;
+    std::mutex mutex;
+};
+
+}
diff --git a/programs/library-bridge/library-bridge.cpp b/programs/library-bridge/library-bridge.cpp
new file mode 100644
index 00000000000..5fff2ffe525
--- /dev/null
+++ b/programs/library-bridge/library-bridge.cpp
@@ -0,0 +1,3 @@
+int mainEntryClickHouseLibraryBridge(int argc, char ** argv);
+int main(int argc_, char ** argv_) { return mainEntryClickHouseLibraryBridge(argc_, argv_); }
+
diff --git a/programs/library-bridge/library-log.cpp b/programs/library-bridge/library-log.cpp
new file mode 100644
index 00000000000..89fb31623b3
--- /dev/null
+++ b/programs/library-bridge/library-log.cpp
@@ -0,0 +1,66 @@
+#include <Dictionaries/LibraryDictionarySourceExternal.h>
+#include <common/logger_useful.h>
+
+namespace
+{
+const char DICT_LOGGER_NAME[] = "LibraryDictionarySourceExternal";
+}
+
+namespace ClickHouseLibrary
+{
+
+std::string_view LIBRARY_CREATE_NEW_FUNC_NAME = "ClickHouseDictionary_v3_libNew";
+std::string_view LIBRARY_CLONE_FUNC_NAME = "ClickHouseDictionary_v3_libClone";
+std::string_view LIBRARY_DELETE_FUNC_NAME = "ClickHouseDictionary_v3_libDelete";
+
+std::string_view LIBRARY_DATA_NEW_FUNC_NAME = "ClickHouseDictionary_v3_dataNew";
+std::string_view LIBRARY_DATA_DELETE_FUNC_NAME = "ClickHouseDictionary_v3_dataDelete";
+
+std::string_view LIBRARY_LOAD_ALL_FUNC_NAME = "ClickHouseDictionary_v3_loadAll";
+std::string_view LIBRARY_LOAD_IDS_FUNC_NAME = "ClickHouseDictionary_v3_loadIds";
+std::string_view LIBRARY_LOAD_KEYS_FUNC_NAME = "ClickHouseDictionary_v3_loadKeys";
+
+std::string_view LIBRARY_IS_MODIFIED_FUNC_NAME = "ClickHouseDictionary_v3_isModified";
+std::string_view LIBRARY_SUPPORTS_SELECTIVE_LOAD_FUNC_NAME = "ClickHouseDictionary_v3_supportsSelectiveLoad";
+
+void log(LogLevel level, CString msg)
+{
+    auto & logger = Poco::Logger::get(DICT_LOGGER_NAME);
+    switch (level)
+    {
+        case LogLevel::TRACE:
+            if (logger.trace())
+                logger.trace(msg);
+            break;
+        case LogLevel::DEBUG:
+            if (logger.debug())
+                logger.debug(msg);
+            break;
+        case LogLevel::INFORMATION:
+            if (logger.information())
+                logger.information(msg);
+            break;
+        case LogLevel::NOTICE:
+            if (logger.notice())
+                logger.notice(msg);
+            break;
+        case LogLevel::WARNING:
+            if (logger.warning())
+                logger.warning(msg);
+            break;
+        case LogLevel::ERROR:
+            if (logger.error())
+                logger.error(msg);
+            break;
+        case LogLevel::CRITICAL:
+            if (logger.critical())
+                logger.critical(msg);
+            break;
+        case LogLevel::FATAL:
+            if (logger.fatal())
+                logger.fatal(msg);
+            break;
+    }
+}
+
+}
diff --git a/programs/local/LocalServer.cpp b/programs/local/LocalServer.cpp
index 2909b838c84..f680c2c2da6 100644
--- a/programs/local/LocalServer.cpp
+++ b/programs/local/LocalServer.cpp
@@ -99,9 +99,9 @@ void LocalServer::initialize(Poco::Util::Application & self)
     }
 }
 
-void LocalServer::applyCmdSettings(Context & context)
+void LocalServer::applyCmdSettings(ContextPtr context)
 {
-    context.applySettingsChanges(cmd_settings.changes());
+    context->applySettingsChanges(cmd_settings.changes());
 }
 
 /// If path is specified and not empty, will try to setup server environment and load existing metadata
@@ -176,7 +176,7 @@ void LocalServer::tryInitPath()
 }
 
 
-static void attachSystemTables(const Context & context)
+static void attachSystemTables(ContextPtr context)
 {
     DatabasePtr system_database = DatabaseCatalog::instance().tryGetDatabase(DatabaseCatalog::SYSTEM_DATABASE);
     if (!system_database)
@@ -211,7 +211,7 @@ try
     }
 
     shared_context = Context::createShared();
-    global_context = std::make_unique<Context>(Context::createGlobal(shared_context.get()));
+    global_context = Context::createGlobal(shared_context.get());
     global_context->makeGlobalContext();
     global_context->setApplicationType(Context::ApplicationType::LOCAL);
     tryInitPath();
@@ -274,9 +274,9 @@ try
       *  if such tables will not be dropped, clickhouse-server will not be able to load them due to security reasons.
       */
     std::string default_database = config().getString("default_database", "_local");
-    DatabaseCatalog::instance().attachDatabase(default_database, std::make_shared<DatabaseMemory>(default_database, *global_context));
+    DatabaseCatalog::instance().attachDatabase(default_database, std::make_shared<DatabaseMemory>(default_database, global_context));
     global_context->setCurrentDatabase(default_database);
-    applyCmdOptions(*global_context);
+    applyCmdOptions(global_context);
 
     if (config().has("path"))
     {
@@ -288,15 +288,15 @@ try
         LOG_DEBUG(log, "Loading metadata from {}", path);
         Poco::File(path + "data/").createDirectories();
         Poco::File(path + "metadata/").createDirectories();
-        loadMetadataSystem(*global_context);
-        attachSystemTables(*global_context);
-        loadMetadata(*global_context);
+        loadMetadataSystem(global_context);
+        attachSystemTables(global_context);
+        loadMetadata(global_context);
         DatabaseCatalog::instance().loadDatabases();
         LOG_DEBUG(log, "Loaded metadata.");
     }
     else if (!config().has("no-system-tables"))
     {
-        attachSystemTables(*global_context);
+        attachSystemTables(global_context);
     }
 
     processQueries();
@@ -375,13 +375,13 @@ void LocalServer::processQueries()
 
     /// we can't mutate global global_context (can lead to races, as it was already passed to some background threads)
     /// so we can't reuse it safely as a query context and need a copy here
-    auto context = Context(*global_context);
+    auto context = Context::createCopy(global_context);
 
-    context.makeSessionContext();
-    context.makeQueryContext();
+    context->makeSessionContext();
+    context->makeQueryContext();
 
-    context.setUser("default", "", Poco::Net::SocketAddress{});
-    context.setCurrentQueryId("");
+    context->setUser("default", "", Poco::Net::SocketAddress{});
+    context->setCurrentQueryId("");
     applyCmdSettings(context);
 
     /// Use the same query_id (and thread group) for all queries
@@ -618,9 +618,9 @@ void LocalServer::init(int argc, char ** argv)
     argsToConfig(arguments, config(), 100);
 }
 
-void LocalServer::applyCmdOptions(Context & context)
+void LocalServer::applyCmdOptions(ContextPtr context)
 {
-    context.setDefaultFormat(config().getString("output-format", config().getString("format", "TSV")));
+    context->setDefaultFormat(config().getString("output-format", config().getString("format", "TSV")));
     applyCmdSettings(context);
 }
 
diff --git a/programs/local/LocalServer.h b/programs/local/LocalServer.h
index 02778bd86cb..3555e8a38ad 100644
--- a/programs/local/LocalServer.h
+++ b/programs/local/LocalServer.h
@@ -36,15 +36,15 @@ private:
     std::string getInitialCreateTableQuery();
 
     void tryInitPath();
-    void applyCmdOptions(Context & context);
-    void applyCmdSettings(Context & context);
+    void applyCmdOptions(ContextPtr context);
+    void applyCmdSettings(ContextPtr context);
     void processQueries();
     void setupUsers();
     void cleanup();
 
 protected:
     SharedContextHolder shared_context;
-    std::unique_ptr<Context> global_context;
+    ContextPtr global_context;
 
     /// Settings specified via command line args
     Settings cmd_settings;
diff --git a/programs/obfuscator/Obfuscator.cpp b/programs/obfuscator/Obfuscator.cpp
index aea70ba0986..c92eb5c6647 100644
--- a/programs/obfuscator/Obfuscator.cpp
+++ b/programs/obfuscator/Obfuscator.cpp
@@ -1129,8 +1129,8 @@ try
     }
 
     SharedContextHolder shared_context = Context::createShared();
-    Context context = Context::createGlobal(shared_context.get());
-    context.makeGlobalContext();
+    ContextPtr context = Context::createGlobal(shared_context.get());
+    context->makeGlobalContext();
 
     ReadBufferFromFileDescriptor file_in(STDIN_FILENO);
     WriteBufferFromFileDescriptor file_out(STDOUT_FILENO);
@@ -1152,7 +1152,7 @@ try
         if (!silent)
             std::cerr << "Training models\n";
 
-        BlockInputStreamPtr input = context.getInputFormat(input_format, file_in, header, max_block_size);
+        BlockInputStreamPtr input = context->getInputFormat(input_format, file_in, header, max_block_size);
 
         input->readPrefix();
         while (Block block = input->read())
@@ -1179,8 +1179,8 @@ try
 
         file_in.seek(0, SEEK_SET);
 
-        BlockInputStreamPtr input = context.getInputFormat(input_format, file_in, header, max_block_size);
-        BlockOutputStreamPtr output = context.getOutputStreamParallelIfPossible(output_format, file_out, header);
+        BlockInputStreamPtr input = context->getInputFormat(input_format, file_in, header, max_block_size);
+        BlockOutputStreamPtr output = context->getOutputStreamParallelIfPossible(output_format, file_out, header);
 
         if (processed_rows + source_rows > limit)
             input = std::make_shared<LimitBlockInputStream>(input, limit - processed_rows, 0);
diff --git a/programs/odbc-bridge/CMakeLists.txt b/programs/odbc-bridge/CMakeLists.txt
index 11864354619..7b232f2b5dc 100644
--- a/programs/odbc-bridge/CMakeLists.txt
+++ b/programs/odbc-bridge/CMakeLists.txt
@@ -24,12 +24,14 @@ add_executable(clickhouse-odbc-bridge ${CLICKHOUSE_ODBC_BRIDGE_SOURCES})
 target_link_libraries(clickhouse-odbc-bridge PRIVATE
     daemon
     dbms
+    bridge
     clickhouse_parsers
-    Poco::Data
-    Poco::Data::ODBC
+    nanodbc
+    unixodbc
 )
 
 set_target_properties(clickhouse-odbc-bridge PROPERTIES RUNTIME_OUTPUT_DIRECTORY ..)
+target_compile_options (clickhouse-odbc-bridge PRIVATE -Wno-reserved-id-macro -Wno-keyword-macro)
 
 if (USE_GDB_ADD_INDEX)
     add_custom_command(TARGET clickhouse-odbc-bridge POST_BUILD COMMAND ${GDB_ADD_INDEX_EXE} ../clickhouse-odbc-bridge COMMENT "Adding .gdb-index to clickhouse-odbc-bridge" VERBATIM)
diff --git a/programs/odbc-bridge/ColumnInfoHandler.cpp b/programs/odbc-bridge/ColumnInfoHandler.cpp
index 14fa734f246..e33858583c2 100644
--- a/programs/odbc-bridge/ColumnInfoHandler.cpp
+++ b/programs/odbc-bridge/ColumnInfoHandler.cpp
@@ -2,29 +2,36 @@
 
 #if USE_ODBC
 
-#    include <DataTypes/DataTypeFactory.h>
-#    include <DataTypes/DataTypeNullable.h>
-#    include <Server/HTTP/WriteBufferFromHTTPServerResponse.h>
-#    include <IO/WriteHelpers.h>
-#    include <Parsers/ParserQueryWithOutput.h>
-#    include <Parsers/parseQuery.h>
-#    include <Poco/Data/ODBC/ODBCException.h>
-#    include <Poco/Data/ODBC/SessionImpl.h>
-#    include <Poco/Data/ODBC/Utility.h>
-#    include <Server/HTTP/HTMLForm.h>
-#    include <Poco/Net/HTTPServerRequest.h>
-#    include <Poco/Net/HTTPServerResponse.h>
-#    include <Poco/NumberParser.h>
-#    include <common/logger_useful.h>
-#    include <Common/quoteString.h>
-#    include <ext/scope_guard.h>
-#    include "getIdentifierQuote.h"
-#    include "validateODBCConnectionString.h"
+#include <DataTypes/DataTypeFactory.h>
+#include <DataTypes/DataTypeNullable.h>
+#include <Server/HTTP/WriteBufferFromHTTPServerResponse.h>
+#include <IO/WriteHelpers.h>
+#include <Parsers/ParserQueryWithOutput.h>
+#include <Parsers/parseQuery.h>
+#include <Server/HTTP/HTMLForm.h>
+#include <Poco/Net/HTTPServerRequest.h>
+#include <Poco/Net/HTTPServerResponse.h>
+#include <Poco/NumberParser.h>
+#include <common/logger_useful.h>
+#include <Common/quoteString.h>
+#include <ext/scope_guard.h>
+#include "getIdentifierQuote.h"
+#include "validateODBCConnectionString.h"
+#include "ODBCConnectionFactory.h"
+
+#include <sql.h>
+#include <sqlext.h>
 
-#    define POCO_SQL_ODBC_CLASS Poco::Data::ODBC
 
 namespace DB
 {
+
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+    extern const int BAD_ARGUMENTS;
+}
+
 namespace
 {
     DataTypePtr getDataType(SQLSMALLINT type)
@@ -59,6 +66,7 @@ namespace
     }
 }
 
+
 void ODBCColumnsInfoHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response)
 {
     HTMLForm params(request, request.getStream());
@@ -77,88 +85,79 @@ void ODBCColumnsInfoHandler::handleRequest(HTTPServerRequest & request, HTTPServ
         process_error("No 'table' param in request URL");
         return;
     }
+
     if (!params.has("connection_string"))
     {
         process_error("No 'connection_string' in request URL");
         return;
     }
+
     std::string schema_name;
     std::string table_name = params.get("table");
     std::string connection_string = params.get("connection_string");
 
     if (params.has("schema"))
-    {
         schema_name = params.get("schema");
-        LOG_TRACE(log, "Will fetch info for table '{}'", schema_name + "." + table_name);
-    }
-    else
-        LOG_TRACE(log, "Will fetch info for table '{}'", table_name);
+
     LOG_TRACE(log, "Got connection str '{}'", connection_string);
 
     try
     {
         const bool external_table_functions_use_nulls = Poco::NumberParser::parseBool(params.get("external_table_functions_use_nulls", "false"));
 
-        POCO_SQL_ODBC_CLASS::SessionImpl session(validateODBCConnectionString(connection_string), DBMS_DEFAULT_CONNECT_TIMEOUT_SEC);
-        SQLHDBC hdbc = session.dbc().handle();
+        auto connection = ODBCConnectionFactory::instance().get(
+                validateODBCConnectionString(connection_string),
+                getContext()->getSettingsRef().odbc_bridge_connection_pool_size);
 
-        SQLHSTMT hstmt = nullptr;
+        nanodbc::catalog catalog(*connection);
+        std::string catalog_name;
 
-        if (POCO_SQL_ODBC_CLASS::Utility::isError(SQLAllocStmt(hdbc, &hstmt)))
-            throw POCO_SQL_ODBC_CLASS::ODBCException("Could not allocate connection handle.");
-
-        SCOPE_EXIT(SQLFreeStmt(hstmt, SQL_DROP));
-
-        const auto & context_settings = context.getSettingsRef();
-
-        /// TODO Why not do SQLColumns instead?
-        std::string name = schema_name.empty() ? backQuoteIfNeed(table_name) : backQuoteIfNeed(schema_name) + "." + backQuoteIfNeed(table_name);
-        WriteBufferFromOwnString buf;
-        std::string input = "SELECT * FROM " + name + " WHERE 1 = 0";
-        ParserQueryWithOutput parser(input.data() + input.size());
-        ASTPtr select = parseQuery(parser, input.data(), input.data() + input.size(), "", context_settings.max_query_size, context_settings.max_parser_depth);
-
-        IAST::FormatSettings settings(buf, true);
-        settings.always_quote_identifiers = true;
-        settings.identifier_quoting_style = getQuotingStyle(hdbc);
-        select->format(settings);
-        std::string query = buf.str();
-
-        LOG_TRACE(log, "Inferring structure with query '{}'", query);
-
-        if (POCO_SQL_ODBC_CLASS::Utility::isError(POCO_SQL_ODBC_CLASS::SQLPrepare(hstmt, reinterpret_cast<SQLCHAR *>(query.data()), query.size())))
-            throw POCO_SQL_ODBC_CLASS::DescriptorException(session.dbc());
-
-        if (POCO_SQL_ODBC_CLASS::Utility::isError(SQLExecute(hstmt)))
-            throw POCO_SQL_ODBC_CLASS::StatementException(hstmt);
-
-        SQLSMALLINT cols = 0;
-        if (POCO_SQL_ODBC_CLASS::Utility::isError(SQLNumResultCols(hstmt, &cols)))
-            throw POCO_SQL_ODBC_CLASS::StatementException(hstmt);
-
-        /// TODO cols not checked
-
-        NamesAndTypesList columns;
-        for (SQLSMALLINT ncol = 1; ncol <= cols; ++ncol)
+        /// In XDBC tables it is allowed to pass either database_name or schema_name in table definion, but not both of them.
+        /// They both are passed as 'schema' parameter in request URL, so it is not clear whether it is database_name or schema_name passed.
+        /// If it is schema_name then we know that database is added in odbc.ini. But if we have database_name as 'schema',
+        /// it is not guaranteed. For nanodbc database_name must be either in odbc.ini or passed as catalog_name.
+        auto get_columns = [&]()
         {
-            SQLSMALLINT type = 0;
-            /// TODO Why 301?
-            SQLCHAR column_name[301];
-
-            SQLSMALLINT is_nullable;
-            const auto result = POCO_SQL_ODBC_CLASS::SQLDescribeCol(hstmt, ncol, column_name, sizeof(column_name), nullptr, &type, nullptr, nullptr, &is_nullable);
-            if (POCO_SQL_ODBC_CLASS::Utility::isError(result))
-                throw POCO_SQL_ODBC_CLASS::StatementException(hstmt);
-
-            auto column_type = getDataType(type);
-            if (external_table_functions_use_nulls && is_nullable == SQL_NULLABLE)
+            nanodbc::catalog::tables tables = catalog.find_tables(table_name, /* type = */ "", /* schema = */ "", /* catalog = */ schema_name);
+            if (tables.next())
             {
-                column_type = std::make_shared<DataTypeNullable>(column_type);
+                catalog_name = tables.table_catalog();
+                LOG_TRACE(log, "Will fetch info for table '{}.{}'", catalog_name, table_name);
+                return catalog.find_columns(/* column = */ "", table_name, /* schema = */ "", catalog_name);
             }
 
-            columns.emplace_back(reinterpret_cast<char *>(column_name), std::move(column_type));
+            tables = catalog.find_tables(table_name, /* type = */ "", /* schema = */ schema_name);
+            if (tables.next())
+            {
+                catalog_name = tables.table_catalog();
+                LOG_TRACE(log, "Will fetch info for table '{}.{}.{}'", catalog_name, schema_name, table_name);
+                return catalog.find_columns(/* column = */ "", table_name, schema_name, catalog_name);
+            }
+
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Table {} not found", schema_name.empty() ? table_name : schema_name + '.' + table_name);
+        };
+
+        nanodbc::catalog::columns columns_definition = get_columns();
+
+        NamesAndTypesList columns;
+        while (columns_definition.next())
+        {
+            SQLSMALLINT type = columns_definition.sql_data_type();
+            std::string column_name = columns_definition.column_name();
+
+            bool is_nullable = columns_definition.nullable() == SQL_NULLABLE;
+
+            auto column_type = getDataType(type);
+
+            if (external_table_functions_use_nulls && is_nullable == SQL_NULLABLE)
+                column_type = std::make_shared<DataTypeNullable>(column_type);
+
+            columns.emplace_back(column_name, std::move(column_type));
         }
 
+        if (columns.empty())
+            throw Exception("Columns definition was not returned", ErrorCodes::LOGICAL_ERROR);
+
         WriteBufferFromHTTPServerResponse out(response, request.getMethod() == Poco::Net::HTTPRequest::HTTP_HEAD, keep_alive_timeout);
         try
         {
diff --git a/programs/odbc-bridge/ColumnInfoHandler.h b/programs/odbc-bridge/ColumnInfoHandler.h
index 9b5b470b31d..bc976f54aee 100644
--- a/programs/odbc-bridge/ColumnInfoHandler.h
+++ b/programs/odbc-bridge/ColumnInfoHandler.h
@@ -2,24 +2,23 @@
 
 #if USE_ODBC
 
-#    include <Interpreters/Context.h>
-#    include <Server/HTTP/HTTPRequestHandler.h>
-#    include <Common/config.h>
+#include <Interpreters/Context_fwd.h>
+#include <Interpreters/Context.h>
+#include <Server/HTTP/HTTPRequestHandler.h>
+#include <Common/config.h>
+#include <Poco/Logger.h>
 
-#    include <Poco/Logger.h>
 
-/** The structure of the table is taken from the query "SELECT * FROM table WHERE 1=0".
-  * TODO: It would be much better to utilize ODBC methods dedicated for columns description.
-  * If there is no such table, an exception is thrown.
-  */
 namespace DB
 {
 
-class ODBCColumnsInfoHandler : public HTTPRequestHandler
+class ODBCColumnsInfoHandler : public HTTPRequestHandler, WithContext
 {
 public:
-    ODBCColumnsInfoHandler(size_t keep_alive_timeout_, Context & context_)
-        : log(&Poco::Logger::get("ODBCColumnsInfoHandler")), keep_alive_timeout(keep_alive_timeout_), context(context_)
+    ODBCColumnsInfoHandler(size_t keep_alive_timeout_, ContextPtr context_)
+        : WithContext(context_)
+        , log(&Poco::Logger::get("ODBCColumnsInfoHandler"))
+        , keep_alive_timeout(keep_alive_timeout_)
     {
     }
 
@@ -28,7 +27,6 @@ public:
 private:
     Poco::Logger * log;
     size_t keep_alive_timeout;
-    Context & context;
 };
 
 }
diff --git a/programs/odbc-bridge/HandlerFactory.cpp b/programs/odbc-bridge/HandlerFactory.cpp
index 9ac48af4ace..49984453d33 100644
--- a/programs/odbc-bridge/HandlerFactory.cpp
+++ b/programs/odbc-bridge/HandlerFactory.cpp
@@ -8,7 +8,7 @@
 namespace DB
 {
 
-std::unique_ptr<HTTPRequestHandler> HandlerFactory::createRequestHandler(const HTTPServerRequest & request)
+std::unique_ptr<HTTPRequestHandler> ODBCBridgeHandlerFactory::createRequestHandler(const HTTPServerRequest & request)
 {
     Poco::URI uri{request.getURI()};
     LOG_TRACE(log, "Request URI: {}", uri.toString());
@@ -21,26 +21,26 @@ std::unique_ptr<HTTPRequestHandler> HandlerFactory::createRequestHandler(const H
 
         if (uri.getPath() == "/columns_info")
 #if USE_ODBC
-            return std::make_unique<ODBCColumnsInfoHandler>(keep_alive_timeout, context);
+            return std::make_unique<ODBCColumnsInfoHandler>(keep_alive_timeout, getContext());
 #else
             return nullptr;
 #endif
         else if (uri.getPath() == "/identifier_quote")
 #if USE_ODBC
-            return std::make_unique<IdentifierQuoteHandler>(keep_alive_timeout, context);
+            return std::make_unique<IdentifierQuoteHandler>(keep_alive_timeout, getContext());
 #else
             return nullptr;
 #endif
         else if (uri.getPath() == "/schema_allowed")
 #if USE_ODBC
-            return std::make_unique<SchemaAllowedHandler>(keep_alive_timeout, context);
+            return std::make_unique<SchemaAllowedHandler>(keep_alive_timeout, getContext());
 #else
             return nullptr;
 #endif
         else if (uri.getPath() == "/write")
-            return std::make_unique<ODBCHandler>(pool_map, keep_alive_timeout, context, "write");
+            return std::make_unique<ODBCHandler>(keep_alive_timeout, getContext(), "write");
         else
-            return std::make_unique<ODBCHandler>(pool_map, keep_alive_timeout, context, "read");
+            return std::make_unique<ODBCHandler>(keep_alive_timeout, getContext(), "read");
     }
     return nullptr;
 }
diff --git a/programs/odbc-bridge/HandlerFactory.h b/programs/odbc-bridge/HandlerFactory.h
index 5dce6f02ecd..ffbbe3670af 100644
--- a/programs/odbc-bridge/HandlerFactory.h
+++ b/programs/odbc-bridge/HandlerFactory.h
@@ -1,32 +1,28 @@
 #pragma once
 
-#include <Interpreters/Context.h>
+#include <Interpreters/Context_fwd.h>
 #include <Server/HTTP/HTTPRequestHandlerFactory.h>
 #include "ColumnInfoHandler.h"
 #include "IdentifierQuoteHandler.h"
 #include "MainHandler.h"
 #include "SchemaAllowedHandler.h"
-
 #include <Poco/Logger.h>
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#include <Poco/Data/SessionPool.h>
-#pragma GCC diagnostic pop
-
 
 namespace DB
 {
 /** Factory for '/ping', '/', '/columns_info', '/identifier_quote', '/schema_allowed' handlers.
   * Also stores Session pools for ODBC connections
   */
-class HandlerFactory : public HTTPRequestHandlerFactory
+class ODBCBridgeHandlerFactory : public HTTPRequestHandlerFactory, WithContext
 {
 public:
-    HandlerFactory(const std::string & name_, size_t keep_alive_timeout_, Context & context_)
-        : log(&Poco::Logger::get(name_)), name(name_), keep_alive_timeout(keep_alive_timeout_), context(context_)
+    ODBCBridgeHandlerFactory(const std::string & name_, size_t keep_alive_timeout_, ContextPtr context_)
+        : WithContext(context_)
+        , log(&Poco::Logger::get(name_))
+        , name(name_)
+        , keep_alive_timeout(keep_alive_timeout_)
     {
-        pool_map = std::make_shared<ODBCHandler::PoolMap>();
     }
 
     std::unique_ptr<HTTPRequestHandler> createRequestHandler(const HTTPServerRequest & request) override;
@@ -35,7 +31,6 @@ private:
     Poco::Logger * log;
     std::string name;
     size_t keep_alive_timeout;
-    Context & context;
-    std::shared_ptr<ODBCHandler::PoolMap> pool_map;
 };
+
 }
diff --git a/programs/odbc-bridge/IdentifierQuoteHandler.cpp b/programs/odbc-bridge/IdentifierQuoteHandler.cpp
index 5060d37c479..a5a97cb8086 100644
--- a/programs/odbc-bridge/IdentifierQuoteHandler.cpp
+++ b/programs/odbc-bridge/IdentifierQuoteHandler.cpp
@@ -2,23 +2,20 @@
 
 #if USE_ODBC
 
-#    include <DataTypes/DataTypeFactory.h>
-#    include <Server/HTTP/HTMLForm.h>
-#    include <Server/HTTP/WriteBufferFromHTTPServerResponse.h>
-#    include <IO/WriteHelpers.h>
-#    include <Parsers/ParserQueryWithOutput.h>
-#    include <Parsers/parseQuery.h>
-#    include <Poco/Data/ODBC/ODBCException.h>
-#    include <Poco/Data/ODBC/SessionImpl.h>
-#    include <Poco/Data/ODBC/Utility.h>
-#    include <Poco/Net/HTTPServerRequest.h>
-#    include <Poco/Net/HTTPServerResponse.h>
-#    include <common/logger_useful.h>
-#    include <ext/scope_guard.h>
-#    include "getIdentifierQuote.h"
-#    include "validateODBCConnectionString.h"
+#include <DataTypes/DataTypeFactory.h>
+#include <Server/HTTP/HTMLForm.h>
+#include <Server/HTTP/WriteBufferFromHTTPServerResponse.h>
+#include <IO/WriteHelpers.h>
+#include <Parsers/ParserQueryWithOutput.h>
+#include <Parsers/parseQuery.h>
+#include <Poco/Net/HTTPServerRequest.h>
+#include <Poco/Net/HTTPServerResponse.h>
+#include <common/logger_useful.h>
+#include <ext/scope_guard.h>
+#include "getIdentifierQuote.h"
+#include "validateODBCConnectionString.h"
+#include "ODBCConnectionFactory.h"
 
-#    define POCO_SQL_ODBC_CLASS Poco::Data::ODBC
 
 namespace DB
 {
@@ -44,10 +41,12 @@ void IdentifierQuoteHandler::handleRequest(HTTPServerRequest & request, HTTPServ
     try
     {
         std::string connection_string = params.get("connection_string");
-        POCO_SQL_ODBC_CLASS::SessionImpl session(validateODBCConnectionString(connection_string), DBMS_DEFAULT_CONNECT_TIMEOUT_SEC);
-        SQLHDBC hdbc = session.dbc().handle();
 
-        auto identifier = getIdentifierQuote(hdbc);
+        auto connection = ODBCConnectionFactory::instance().get(
+                validateODBCConnectionString(connection_string),
+                getContext()->getSettingsRef().odbc_bridge_connection_pool_size);
+
+        auto identifier = getIdentifierQuote(*connection);
 
         WriteBufferFromHTTPServerResponse out(response, request.getMethod() == Poco::Net::HTTPRequest::HTTP_HEAD, keep_alive_timeout);
         try
diff --git a/programs/odbc-bridge/IdentifierQuoteHandler.h b/programs/odbc-bridge/IdentifierQuoteHandler.h
index dad88c72ad8..ef3806fd802 100644
--- a/programs/odbc-bridge/IdentifierQuoteHandler.h
+++ b/programs/odbc-bridge/IdentifierQuoteHandler.h
@@ -11,11 +11,13 @@
 namespace DB
 {
 
-class IdentifierQuoteHandler : public HTTPRequestHandler
+class IdentifierQuoteHandler : public HTTPRequestHandler, WithContext
 {
 public:
-    IdentifierQuoteHandler(size_t keep_alive_timeout_, Context &)
-        : log(&Poco::Logger::get("IdentifierQuoteHandler")), keep_alive_timeout(keep_alive_timeout_)
+    IdentifierQuoteHandler(size_t keep_alive_timeout_, ContextPtr context_)
+        : WithContext(context_)
+        , log(&Poco::Logger::get("IdentifierQuoteHandler"))
+        , keep_alive_timeout(keep_alive_timeout_)
     {
     }
 
diff --git a/programs/odbc-bridge/MainHandler.cpp b/programs/odbc-bridge/MainHandler.cpp
index 079fc371ab4..24bcaf63c69 100644
--- a/programs/odbc-bridge/MainHandler.cpp
+++ b/programs/odbc-bridge/MainHandler.cpp
@@ -18,18 +18,17 @@
 #include <Processors/Formats/InputStreamFromInputFormat.h>
 #include <common/logger_useful.h>
 #include <Server/HTTP/HTMLForm.h>
+#include "ODBCConnectionFactory.h"
 
 #include <mutex>
 #include <memory>
 
+#include <nanodbc/nanodbc.h>
 
-#if USE_ODBC
-#include <Poco/Data/ODBC/SessionImpl.h>
-#define POCO_SQL_ODBC_CLASS Poco::Data::ODBC
-#endif
 
 namespace DB
 {
+
 namespace
 {
     std::unique_ptr<Block> parseColumns(std::string && column_string)
@@ -42,37 +41,6 @@ namespace
     }
 }
 
-using PocoSessionPoolConstructor = std::function<std::shared_ptr<Poco::Data::SessionPool>()>;
-/** Is used to adjust max size of default Poco thread pool. See issue #750
-  * Acquire the lock, resize pool and construct new Session.
-  */
-static std::shared_ptr<Poco::Data::SessionPool> createAndCheckResizePocoSessionPool(PocoSessionPoolConstructor pool_constr)
-{
-    static std::mutex mutex;
-
-    Poco::ThreadPool & pool = Poco::ThreadPool::defaultPool();
-
-    /// NOTE: The lock don't guarantee that external users of the pool don't change its capacity
-    std::unique_lock lock(mutex);
-
-    if (pool.available() == 0)
-        pool.addCapacity(2 * std::max(pool.capacity(), 1));
-
-    return pool_constr();
-}
-
-ODBCHandler::PoolPtr ODBCHandler::getPool(const std::string & connection_str)
-{
-    std::lock_guard lock(mutex);
-    if (!pool_map->count(connection_str))
-    {
-        pool_map->emplace(connection_str, createAndCheckResizePocoSessionPool([connection_str]
-        {
-            return std::make_shared<Poco::Data::SessionPool>("ODBC", validateODBCConnectionString(connection_str));
-        }));
-    }
-    return pool_map->at(connection_str);
-}
 
 void ODBCHandler::processError(HTTPServerResponse & response, const std::string & message)
 {
@@ -82,6 +50,7 @@ void ODBCHandler::processError(HTTPServerResponse & response, const std::string
     LOG_WARNING(log, message);
 }
 
+
 void ODBCHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response)
 {
     HTMLForm params(request);
@@ -141,6 +110,10 @@ void ODBCHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse
 
     try
     {
+        auto connection = ODBCConnectionFactory::instance().get(
+                validateODBCConnectionString(connection_string),
+                getContext()->getSettingsRef().odbc_bridge_connection_pool_size);
+
         if (mode == "write")
         {
             if (!params.has("db_name"))
@@ -159,15 +132,12 @@ void ODBCHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse
 
             auto quoting_style = IdentifierQuotingStyle::None;
 #if USE_ODBC
-            POCO_SQL_ODBC_CLASS::SessionImpl session(validateODBCConnectionString(connection_string), DBMS_DEFAULT_CONNECT_TIMEOUT_SEC);
-            quoting_style = getQuotingStyle(session.dbc().handle());
+            quoting_style = getQuotingStyle(*connection);
 #endif
-
-            auto pool = getPool(connection_string);
             auto & read_buf = request.getStream();
-            auto input_format = FormatFactory::instance().getInput(format, read_buf, *sample_block, context, max_block_size);
+            auto input_format = FormatFactory::instance().getInput(format, read_buf, *sample_block, getContext(), max_block_size);
             auto input_stream = std::make_shared<InputStreamFromInputFormat>(input_format);
-            ODBCBlockOutputStream output_stream(pool->get(), db_name, table_name, *sample_block, quoting_style);
+            ODBCBlockOutputStream output_stream(*connection, db_name, table_name, *sample_block, getContext(), quoting_style);
             copyData(*input_stream, output_stream);
             writeStringBinary("Ok.", out);
         }
@@ -176,9 +146,8 @@ void ODBCHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse
             std::string query = params.get("query");
             LOG_TRACE(log, "Query: {}", query);
 
-            BlockOutputStreamPtr writer = FormatFactory::instance().getOutputStreamParallelIfPossible(format, out, *sample_block, context);
-            auto pool = getPool(connection_string);
-            ODBCBlockInputStream inp(pool->get(), query, *sample_block, max_block_size);
+            BlockOutputStreamPtr writer = FormatFactory::instance().getOutputStreamParallelIfPossible(format, out, *sample_block, getContext());
+            ODBCBlockInputStream inp(*connection, query, *sample_block, max_block_size);
             copyData(inp, *writer);
         }
     }
diff --git a/programs/odbc-bridge/MainHandler.h b/programs/odbc-bridge/MainHandler.h
index e237ede5814..bc0fca8b9a5 100644
--- a/programs/odbc-bridge/MainHandler.h
+++ b/programs/odbc-bridge/MainHandler.h
@@ -1,14 +1,13 @@
 #pragma once
 
-#include <Interpreters/Context.h>
+#include <Interpreters/Context_fwd.h>
 #include <Server/HTTP/HTTPRequestHandler.h>
-
 #include <Poco/Logger.h>
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#include <Poco/Data/SessionPool.h>
-#pragma GCC diagnostic pop
+
+#include <mutex>
+#include <unordered_map>
+
 
 namespace DB
 {
@@ -17,20 +16,16 @@ namespace DB
   * and also query in request body
   * response in RowBinary format
   */
-class ODBCHandler : public HTTPRequestHandler
+class ODBCHandler : public HTTPRequestHandler, WithContext
 {
 public:
-    using PoolPtr = std::shared_ptr<Poco::Data::SessionPool>;
-    using PoolMap = std::unordered_map<std::string, PoolPtr>;
-
-    ODBCHandler(std::shared_ptr<PoolMap> pool_map_,
+    ODBCHandler(
         size_t keep_alive_timeout_,
-        Context & context_,
+        ContextPtr context_,
         const String & mode_)
-        : log(&Poco::Logger::get("ODBCHandler"))
-        , pool_map(pool_map_)
+        : WithContext(context_)
+        , log(&Poco::Logger::get("ODBCHandler"))
         , keep_alive_timeout(keep_alive_timeout_)
-        , context(context_)
         , mode(mode_)
     {
     }
@@ -40,14 +35,11 @@ public:
 private:
     Poco::Logger * log;
 
-    std::shared_ptr<PoolMap> pool_map;
     size_t keep_alive_timeout;
-    Context & context;
     String mode;
 
     static inline std::mutex mutex;
 
-    PoolPtr getPool(const std::string & connection_str);
     void processError(HTTPServerResponse & response, const std::string & message);
 };
 
diff --git a/programs/odbc-bridge/ODBCBlockInputStream.cpp b/programs/odbc-bridge/ODBCBlockInputStream.cpp
index b8a4209ac94..3a73cb9f601 100644
--- a/programs/odbc-bridge/ODBCBlockInputStream.cpp
+++ b/programs/odbc-bridge/ODBCBlockInputStream.cpp
@@ -1,5 +1,7 @@
 #include "ODBCBlockInputStream.h"
 #include <vector>
+#include <IO/ReadBufferFromString.h>
+#include <DataTypes/DataTypeNullable.h>
 #include <Columns/ColumnNullable.h>
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnsNumber.h>
@@ -14,137 +16,143 @@ namespace DB
 {
 namespace ErrorCodes
 {
-    extern const int NUMBER_OF_COLUMNS_DOESNT_MATCH;
     extern const int UNKNOWN_TYPE;
 }
 
 
 ODBCBlockInputStream::ODBCBlockInputStream(
-    Poco::Data::Session && session_, const std::string & query_str, const Block & sample_block, const UInt64 max_block_size_)
-    : session{session_}
-    , statement{(this->session << query_str, Poco::Data::Keywords::now)}
-    , result{statement}
-    , iterator{result.begin()}
+    nanodbc::connection & connection_, const std::string & query_str, const Block & sample_block, const UInt64 max_block_size_)
+    : log(&Poco::Logger::get("ODBCBlockInputStream"))
     , max_block_size{max_block_size_}
-    , log(&Poco::Logger::get("ODBCBlockInputStream"))
+    , connection(connection_)
+    , query(query_str)
 {
-    if (sample_block.columns() != result.columnCount())
-        throw Exception{"RecordSet contains " + toString(result.columnCount()) + " columns while " + toString(sample_block.columns())
-                            + " expected",
-                        ErrorCodes::NUMBER_OF_COLUMNS_DOESNT_MATCH};
-
     description.init(sample_block);
-}
-
-
-namespace
-{
-    using ValueType = ExternalResultDescription::ValueType;
-
-    void insertValue(IColumn & column, const ValueType type, const Poco::Dynamic::Var & value)
-    {
-        switch (type)
-        {
-            case ValueType::vtUInt8:
-                assert_cast<ColumnUInt8 &>(column).insertValue(value.convert<UInt64>());
-                break;
-            case ValueType::vtUInt16:
-                assert_cast<ColumnUInt16 &>(column).insertValue(value.convert<UInt64>());
-                break;
-            case ValueType::vtUInt32:
-                assert_cast<ColumnUInt32 &>(column).insertValue(value.convert<UInt64>());
-                break;
-            case ValueType::vtUInt64:
-                assert_cast<ColumnUInt64 &>(column).insertValue(value.convert<UInt64>());
-                break;
-            case ValueType::vtInt8:
-                assert_cast<ColumnInt8 &>(column).insertValue(value.convert<Int64>());
-                break;
-            case ValueType::vtInt16:
-                assert_cast<ColumnInt16 &>(column).insertValue(value.convert<Int64>());
-                break;
-            case ValueType::vtInt32:
-                assert_cast<ColumnInt32 &>(column).insertValue(value.convert<Int64>());
-                break;
-            case ValueType::vtInt64:
-                assert_cast<ColumnInt64 &>(column).insertValue(value.convert<Int64>());
-                break;
-            case ValueType::vtFloat32:
-                assert_cast<ColumnFloat32 &>(column).insertValue(value.convert<Float64>());
-                break;
-            case ValueType::vtFloat64:
-                assert_cast<ColumnFloat64 &>(column).insertValue(value.convert<Float64>());
-                break;
-            case ValueType::vtString:
-                assert_cast<ColumnString &>(column).insert(value.convert<String>());
-                break;
-            case ValueType::vtDate:
-            {
-                Poco::DateTime date = value.convert<Poco::DateTime>();
-                assert_cast<ColumnUInt16 &>(column).insertValue(UInt16{LocalDate(date.year(), date.month(), date.day()).getDayNum()});
-                break;
-            }
-            case ValueType::vtDateTime:
-            {
-                Poco::DateTime datetime = value.convert<Poco::DateTime>();
-                assert_cast<ColumnUInt32 &>(column).insertValue(DateLUT::instance().makeDateTime(
-                    datetime.year(), datetime.month(), datetime.day(), datetime.hour(), datetime.minute(), datetime.second()));
-                break;
-            }
-            case ValueType::vtUUID:
-                assert_cast<ColumnUInt128 &>(column).insert(parse<UUID>(value.convert<std::string>()));
-                break;
-            default:
-                throw Exception("Unsupported value type", ErrorCodes::UNKNOWN_TYPE);
-        }
-    }
-
-    void insertDefaultValue(IColumn & column, const IColumn & sample_column) { column.insertFrom(sample_column, 0); }
+    result = execute(connection, NANODBC_TEXT(query));
 }
 
 
 Block ODBCBlockInputStream::readImpl()
 {
-    if (iterator == result.end())
-        return {};
-
-    MutableColumns columns(description.sample_block.columns());
-    for (const auto i : ext::range(0, columns.size()))
-        columns[i] = description.sample_block.getByPosition(i).column->cloneEmpty();
+    if (finished)
+        return Block();
 
+    MutableColumns columns(description.sample_block.cloneEmptyColumns());
     size_t num_rows = 0;
-    while (iterator != result.end())
+
+    while (true)
     {
-        Poco::Data::Row & row = *iterator;
-
-        for (const auto idx : ext::range(0, row.fieldCount()))
+        if (!result.next())
         {
-            /// TODO This is extremely slow.
-            const Poco::Dynamic::Var & value = row[idx];
+            finished = true;
+            break;
+        }
 
-            if (!value.isEmpty())
+        for (int idx = 0; idx < result.columns(); ++idx)
+        {
+            const auto & sample = description.sample_block.getByPosition(idx);
+
+            if (!result.is_null(idx))
             {
-                if (description.types[idx].second)
+                bool is_nullable = description.types[idx].second;
+
+                if (is_nullable)
                 {
                     ColumnNullable & column_nullable = assert_cast<ColumnNullable &>(*columns[idx]);
-                    insertValue(column_nullable.getNestedColumn(), description.types[idx].first, value);
+                    const auto & data_type = assert_cast<const DataTypeNullable &>(*sample.type);
+                    insertValue(column_nullable.getNestedColumn(), data_type.getNestedType(), description.types[idx].first, result, idx);
                     column_nullable.getNullMapData().emplace_back(0);
                 }
                 else
-                    insertValue(*columns[idx], description.types[idx].first, value);
+                {
+                    insertValue(*columns[idx], sample.type, description.types[idx].first, result, idx);
+                }
             }
             else
-                insertDefaultValue(*columns[idx], *description.sample_block.getByPosition(idx).column);
+                insertDefaultValue(*columns[idx], *sample.column);
         }
 
-        ++iterator;
-
-        ++num_rows;
-        if (num_rows == max_block_size)
+        if (++num_rows == max_block_size)
             break;
     }
 
     return description.sample_block.cloneWithColumns(std::move(columns));
 }
 
+
+void ODBCBlockInputStream::insertValue(
+        IColumn & column, const DataTypePtr data_type, const ValueType type, nanodbc::result & row, size_t idx)
+{
+    switch (type)
+    {
+        case ValueType::vtUInt8:
+            assert_cast<ColumnUInt8 &>(column).insertValue(row.get<uint16_t>(idx));
+            break;
+        case ValueType::vtUInt16:
+            assert_cast<ColumnUInt16 &>(column).insertValue(row.get<uint16_t>(idx));
+            break;
+        case ValueType::vtUInt32:
+            assert_cast<ColumnUInt32 &>(column).insertValue(row.get<uint32_t>(idx));
+            break;
+        case ValueType::vtUInt64:
+            assert_cast<ColumnUInt64 &>(column).insertValue(row.get<uint64_t>(idx));
+            break;
+        case ValueType::vtInt8:
+            assert_cast<ColumnInt8 &>(column).insertValue(row.get<int16_t>(idx));
+            break;
+        case ValueType::vtInt16:
+            assert_cast<ColumnInt16 &>(column).insertValue(row.get<int16_t>(idx));
+            break;
+        case ValueType::vtInt32:
+            assert_cast<ColumnInt32 &>(column).insertValue(row.get<int32_t>(idx));
+            break;
+        case ValueType::vtInt64:
+            assert_cast<ColumnInt64 &>(column).insertValue(row.get<int64_t>(idx));
+            break;
+        case ValueType::vtFloat32:
+            assert_cast<ColumnFloat32 &>(column).insertValue(row.get<float>(idx));
+            break;
+        case ValueType::vtFloat64:
+            assert_cast<ColumnFloat64 &>(column).insertValue(row.get<double>(idx));
+            break;
+        case ValueType::vtFixedString:[[fallthrough]];
+        case ValueType::vtString:
+            assert_cast<ColumnString &>(column).insert(row.get<std::string>(idx));
+            break;
+        case ValueType::vtUUID:
+        {
+            auto value = row.get<std::string>(idx);
+            assert_cast<ColumnUInt128 &>(column).insert(parse<UUID>(value.data(), value.size()));
+            break;
+        }
+        case ValueType::vtDate:
+            assert_cast<ColumnUInt16 &>(column).insertValue(UInt16{LocalDate{row.get<std::string>(idx)}.getDayNum()});
+            break;
+        case ValueType::vtDateTime:
+        {
+            auto value = row.get<std::string>(idx);
+            ReadBufferFromString in(value);
+            time_t time = 0;
+            readDateTimeText(time, in);
+            if (time < 0)
+                time = 0;
+            assert_cast<ColumnUInt32 &>(column).insertValue(time);
+            break;
+        }
+        case ValueType::vtDateTime64:[[fallthrough]];
+        case ValueType::vtDecimal32: [[fallthrough]];
+        case ValueType::vtDecimal64: [[fallthrough]];
+        case ValueType::vtDecimal128: [[fallthrough]];
+        case ValueType::vtDecimal256:
+        {
+            auto value = row.get<std::string>(idx);
+            ReadBufferFromString istr(value);
+            data_type->getDefaultSerialization()->deserializeWholeText(column, istr, FormatSettings{});
+            break;
+        }
+        default:
+            throw Exception("Unsupported value type", ErrorCodes::UNKNOWN_TYPE);
+    }
+}
+
 }
diff --git a/programs/odbc-bridge/ODBCBlockInputStream.h b/programs/odbc-bridge/ODBCBlockInputStream.h
index 13491e05822..bbd90ce4d6c 100644
--- a/programs/odbc-bridge/ODBCBlockInputStream.h
+++ b/programs/odbc-bridge/ODBCBlockInputStream.h
@@ -3,10 +3,8 @@
 #include <string>
 #include <Core/Block.h>
 #include <DataStreams/IBlockInputStream.h>
-#include <Poco/Data/RecordSet.h>
-#include <Poco/Data/Session.h>
-#include <Poco/Data/Statement.h>
 #include <Core/ExternalResultDescription.h>
+#include <nanodbc/nanodbc.h>
 
 
 namespace DB
@@ -15,25 +13,33 @@ namespace DB
 class ODBCBlockInputStream final : public IBlockInputStream
 {
 public:
-    ODBCBlockInputStream(
-        Poco::Data::Session && session_, const std::string & query_str, const Block & sample_block, const UInt64 max_block_size_);
+    ODBCBlockInputStream(nanodbc::connection & connection_, const std::string & query_str, const Block & sample_block, const UInt64 max_block_size_);
 
     String getName() const override { return "ODBC"; }
 
     Block getHeader() const override { return description.sample_block.cloneEmpty(); }
 
 private:
+    using QueryResult = std::shared_ptr<nanodbc::result>;
+    using ValueType = ExternalResultDescription::ValueType;
+
     Block readImpl() override;
 
-    Poco::Data::Session session;
-    Poco::Data::Statement statement;
-    Poco::Data::RecordSet result;
-    Poco::Data::RecordSet::Iterator iterator;
+    static void insertValue(IColumn & column, const DataTypePtr data_type, const ValueType type, nanodbc::result & row, size_t idx);
 
+    static void insertDefaultValue(IColumn & column, const IColumn & sample_column)
+    {
+        column.insertFrom(sample_column, 0);
+    }
+
+    Poco::Logger * log;
     const UInt64 max_block_size;
     ExternalResultDescription description;
 
-    Poco::Logger * log;
+    nanodbc::connection & connection;
+    nanodbc::result result;
+    String query;
+    bool finished = false;
 };
 
 }
diff --git a/programs/odbc-bridge/ODBCBlockOutputStream.cpp b/programs/odbc-bridge/ODBCBlockOutputStream.cpp
index db3c9441419..e4614204178 100644
--- a/programs/odbc-bridge/ODBCBlockOutputStream.cpp
+++ b/programs/odbc-bridge/ODBCBlockOutputStream.cpp
@@ -8,16 +8,14 @@
 #include <Parsers/ASTExpressionList.h>
 #include <Parsers/ASTIdentifier.h>
 #include "getIdentifierQuote.h"
+#include <IO/WriteHelpers.h>
+#include <IO/Operators.h>
+#include <Formats/FormatFactory.h>
 
 
 namespace DB
 {
 
-namespace ErrorCodes
-{
-    extern const int UNKNOWN_TYPE;
-}
-
 namespace
 {
     using ValueType = ExternalResultDescription::ValueType;
@@ -40,69 +38,21 @@ namespace
         return buf.str();
     }
 
-    std::string getQuestionMarks(size_t n)
-    {
-        std::string result = "(";
-        for (size_t i = 0; i < n; ++i)
-        {
-            if (i > 0)
-                result += ",";
-            result += "?";
-        }
-        return result + ")";
-    }
-
-    Poco::Dynamic::Var getVarFromField(const Field & field, const ValueType type)
-    {
-        switch (type)
-        {
-            case ValueType::vtUInt8:
-                return Poco::Dynamic::Var(static_cast<UInt64>(field.get<UInt64>())).convert<UInt64>();
-            case ValueType::vtUInt16:
-                return Poco::Dynamic::Var(static_cast<UInt64>(field.get<UInt64>())).convert<UInt64>();
-            case ValueType::vtUInt32:
-                return Poco::Dynamic::Var(static_cast<UInt64>(field.get<UInt64>())).convert<UInt64>();
-            case ValueType::vtUInt64:
-                return Poco::Dynamic::Var(field.get<UInt64>()).convert<UInt64>();
-            case ValueType::vtInt8:
-                return Poco::Dynamic::Var(static_cast<Int64>(field.get<Int64>())).convert<Int64>();
-            case ValueType::vtInt16:
-                return Poco::Dynamic::Var(static_cast<Int64>(field.get<Int64>())).convert<Int64>();
-            case ValueType::vtInt32:
-                return Poco::Dynamic::Var(static_cast<Int64>(field.get<Int64>())).convert<Int64>();
-            case ValueType::vtInt64:
-                return Poco::Dynamic::Var(field.get<Int64>()).convert<Int64>();
-            case ValueType::vtFloat32:
-                return Poco::Dynamic::Var(field.get<Float64>()).convert<Float64>();
-            case ValueType::vtFloat64:
-                return Poco::Dynamic::Var(field.get<Float64>()).convert<Float64>();
-            case ValueType::vtString:
-                return Poco::Dynamic::Var(field.get<String>()).convert<String>();
-            case ValueType::vtDate:
-                return Poco::Dynamic::Var(LocalDate(DayNum(field.get<UInt64>())).toString()).convert<String>();
-            case ValueType::vtDateTime:
-                return Poco::Dynamic::Var(DateLUT::instance().timeToString(time_t(field.get<UInt64>()))).convert<String>();
-            case ValueType::vtUUID:
-                return Poco::Dynamic::Var(UUID(field.get<UInt128>()).toUnderType().toHexString()).convert<std::string>();
-             default:
-                 throw Exception("Unsupported value type", ErrorCodes::UNKNOWN_TYPE);
-
-        }
-        __builtin_unreachable();
-    }
 }
 
-ODBCBlockOutputStream::ODBCBlockOutputStream(Poco::Data::Session && session_,
+ODBCBlockOutputStream::ODBCBlockOutputStream(nanodbc::connection & connection_,
                                              const std::string & remote_database_name_,
                                              const std::string & remote_table_name_,
                                              const Block & sample_block_,
+                                             ContextPtr local_context_,
                                              IdentifierQuotingStyle quoting_)
-    : session(session_)
+    : log(&Poco::Logger::get("ODBCBlockOutputStream"))
+    , connection(connection_)
     , db_name(remote_database_name_)
     , table_name(remote_table_name_)
     , sample_block(sample_block_)
+    , local_context(local_context_)
     , quoting(quoting_)
-    , log(&Poco::Logger::get("ODBCBlockOutputStream"))
 {
     description.init(sample_block);
 }
@@ -114,28 +64,12 @@ Block ODBCBlockOutputStream::getHeader() const
 
 void ODBCBlockOutputStream::write(const Block & block)
 {
-    ColumnsWithTypeAndName columns;
-    for (size_t i = 0; i < block.columns(); ++i)
-        columns.push_back({block.getColumns()[i], sample_block.getDataTypes()[i], sample_block.getNames()[i]});
+    WriteBufferFromOwnString values_buf;
+    auto writer = FormatFactory::instance().getOutputStream("Values", values_buf, sample_block, local_context);
+    writer->write(block);
 
-    std::vector<Poco::Dynamic::Var> row_to_insert(block.columns());
-    Poco::Data::Statement statement(session << getInsertQuery(db_name, table_name, columns, quoting) + getQuestionMarks(block.columns()));
-    for (size_t i = 0; i < block.columns(); ++i)
-        statement.addBind(Poco::Data::Keywords::use(row_to_insert[i]));
-
-    for (size_t i = 0; i < block.rows(); ++i)
-    {
-        for (size_t col_idx = 0; col_idx < block.columns(); ++col_idx)
-        {
-            Field val;
-            columns[col_idx].column->get(i, val);
-            if (val.isNull())
-                row_to_insert[col_idx] = Poco::Dynamic::Var();
-            else
-                row_to_insert[col_idx] = getVarFromField(val, description.types[col_idx].first);
-        }
-        statement.execute();
-    }
+    std::string query = getInsertQuery(db_name, table_name, block.getColumnsWithTypeAndName(), quoting) + values_buf.str();
+    execute(connection, query);
 }
 
 }
diff --git a/programs/odbc-bridge/ODBCBlockOutputStream.h b/programs/odbc-bridge/ODBCBlockOutputStream.h
index 39e1d6f77ac..0b13f7039b5 100644
--- a/programs/odbc-bridge/ODBCBlockOutputStream.h
+++ b/programs/odbc-bridge/ODBCBlockOutputStream.h
@@ -2,30 +2,41 @@
 
 #include <Core/Block.h>
 #include <DataStreams/IBlockOutputStream.h>
-#include <Poco/Data/Session.h>
 #include <Core/ExternalResultDescription.h>
 #include <Parsers/IdentifierQuotingStyle.h>
+#include <Interpreters/Context_fwd.h>
+#include <nanodbc/nanodbc.h>
+
 
 namespace DB
 {
+
 class ODBCBlockOutputStream : public IBlockOutputStream
 {
+
 public:
-    ODBCBlockOutputStream(Poco::Data::Session && session_, const std::string & remote_database_name_,
-                          const std::string & remote_table_name_, const Block & sample_block_, IdentifierQuotingStyle quoting);
+    ODBCBlockOutputStream(
+            nanodbc::connection & connection_,
+            const std::string & remote_database_name_,
+            const std::string & remote_table_name_,
+            const Block & sample_block_,
+            ContextPtr local_context_,
+            IdentifierQuotingStyle quoting);
 
     Block getHeader() const override;
     void write(const Block & block) override;
 
 private:
-    Poco::Data::Session session;
+    Poco::Logger * log;
+
+    nanodbc::connection & connection;
     std::string db_name;
     std::string table_name;
     Block sample_block;
+    ContextPtr local_context;
     IdentifierQuotingStyle quoting;
 
     ExternalResultDescription description;
-    Poco::Logger * log;
 };
 
 }
diff --git a/programs/odbc-bridge/ODBCBridge.cpp b/programs/odbc-bridge/ODBCBridge.cpp
index 8869a2639c1..0deefe46014 100644
--- a/programs/odbc-bridge/ODBCBridge.cpp
+++ b/programs/odbc-bridge/ODBCBridge.cpp
@@ -1,244 +1,4 @@
 #include "ODBCBridge.h"
-#include "HandlerFactory.h"
-
-#include <string>
-#include <errno.h>
-#include <IO/ReadHelpers.h>
-#include <boost/program_options.hpp>
-
-#if USE_ODBC
-// It doesn't make much sense to build this bridge without ODBC, but we still do this.
-#    include <Poco/Data/ODBC/Connector.h>
-#endif
-
-#include <Poco/Net/NetException.h>
-#include <Poco/String.h>
-#include <Poco/Util/HelpFormatter.h>
-#include <Common/Exception.h>
-#include <Common/StringUtils/StringUtils.h>
-#include <Common/config.h>
-#include <Formats/registerFormats.h>
-#include <common/logger_useful.h>
-#include <ext/scope_guard.h>
-#include <ext/range.h>
-#include <Common/SensitiveDataMasker.h>
-#include <Server/HTTP/HTTPServer.h>
-
-
-namespace DB
-{
-namespace ErrorCodes
-{
-    extern const int ARGUMENT_OUT_OF_BOUND;
-}
-
-namespace
-{
-    Poco::Net::SocketAddress makeSocketAddress(const std::string & host, UInt16 port, Poco::Logger * log)
-    {
-        Poco::Net::SocketAddress socket_address;
-        try
-        {
-            socket_address = Poco::Net::SocketAddress(host, port);
-        }
-        catch (const Poco::Net::DNSException & e)
-        {
-            const auto code = e.code();
-            if (code == EAI_FAMILY
-#if defined(EAI_ADDRFAMILY)
-                || code == EAI_ADDRFAMILY
-#endif
-            )
-            {
-                LOG_ERROR(log, "Cannot resolve listen_host ({}), error {}: {}. If it is an IPv6 address and your host has disabled IPv6, then consider to specify IPv4 address to listen in <listen_host> element of configuration file. Example: <listen_host>0.0.0.0</listen_host>", host, e.code(), e.message());
-            }
-
-            throw;
-        }
-        return socket_address;
-    }
-
-    Poco::Net::SocketAddress socketBindListen(Poco::Net::ServerSocket & socket, const std::string & host, UInt16 port, Poco::Logger * log)
-    {
-        auto address = makeSocketAddress(host, port, log);
-#if POCO_VERSION < 0x01080000
-        socket.bind(address, /* reuseAddress = */ true);
-#else
-        socket.bind(address, /* reuseAddress = */ true, /* reusePort = */ false);
-#endif
-
-        socket.listen(/* backlog = */ 64);
-
-        return address;
-    }
-}
-
-void ODBCBridge::handleHelp(const std::string &, const std::string &)
-{
-    Poco::Util::HelpFormatter help_formatter(options());
-    help_formatter.setCommand(commandName());
-    help_formatter.setHeader("HTTP-proxy for odbc requests");
-    help_formatter.setUsage("--http-port <port>");
-    help_formatter.format(std::cerr);
-
-    stopOptionsProcessing();
-}
-
-
-void ODBCBridge::defineOptions(Poco::Util::OptionSet & options)
-{
-    options.addOption(Poco::Util::Option("http-port", "", "port to listen").argument("http-port", true).binding("http-port"));
-    options.addOption(
-        Poco::Util::Option("listen-host", "", "hostname or address to listen, default 127.0.0.1").argument("listen-host").binding("listen-host"));
-    options.addOption(
-        Poco::Util::Option("http-timeout", "", "http timeout for socket, default 1800").argument("http-timeout").binding("http-timeout"));
-
-    options.addOption(Poco::Util::Option("max-server-connections", "", "max connections to server, default 1024")
-                          .argument("max-server-connections")
-                          .binding("max-server-connections"));
-    options.addOption(Poco::Util::Option("keep-alive-timeout", "", "keepalive timeout, default 10")
-                          .argument("keep-alive-timeout")
-                          .binding("keep-alive-timeout"));
-
-    options.addOption(Poco::Util::Option("log-level", "", "sets log level, default info").argument("log-level").binding("logger.level"));
-
-    options.addOption(
-        Poco::Util::Option("log-path", "", "log path for all logs, default console").argument("log-path").binding("logger.log"));
-
-    options.addOption(Poco::Util::Option("err-log-path", "", "err log path for all logs, default no")
-                          .argument("err-log-path")
-                          .binding("logger.errorlog"));
-
-    options.addOption(Poco::Util::Option("stdout-path", "", "stdout log path, default console")
-                          .argument("stdout-path")
-                          .binding("logger.stdout"));
-
-    options.addOption(Poco::Util::Option("stderr-path", "", "stderr log path, default console")
-                          .argument("stderr-path")
-                          .binding("logger.stderr"));
-
-    using Me = std::decay_t<decltype(*this)>;
-    options.addOption(Poco::Util::Option("help", "", "produce this help message")
-                          .binding("help")
-                          .callback(Poco::Util::OptionCallback<Me>(this, &Me::handleHelp)));
-
-    ServerApplication::defineOptions(options); // NOLINT Don't need complex BaseDaemon's .xml config
-}
-
-void ODBCBridge::initialize(Application & self)
-{
-    BaseDaemon::closeFDs();
-    is_help = config().has("help");
-
-    if (is_help)
-        return;
-
-    config().setString("logger", "ODBCBridge");
-
-    /// Redirect stdout, stderr to specified files.
-    /// Some libraries and sanitizers write to stderr in case of errors.
-    const auto stdout_path = config().getString("logger.stdout", "");
-    if (!stdout_path.empty())
-    {
-        if (!freopen(stdout_path.c_str(), "a+", stdout))
-            throw Poco::OpenFileException("Cannot attach stdout to " + stdout_path);
-
-        /// Disable buffering for stdout.
-        setbuf(stdout, nullptr);
-    }
-    const auto stderr_path = config().getString("logger.stderr", "");
-    if (!stderr_path.empty())
-    {
-        if (!freopen(stderr_path.c_str(), "a+", stderr))
-            throw Poco::OpenFileException("Cannot attach stderr to " + stderr_path);
-
-        /// Disable buffering for stderr.
-        setbuf(stderr, nullptr);
-    }
-
-    buildLoggers(config(), logger(), self.commandName());
-
-    BaseDaemon::logRevision();
-
-    log = &logger();
-    hostname = config().getString("listen-host", "127.0.0.1");
-    port = config().getUInt("http-port");
-    if (port > 0xFFFF)
-        throw Exception("Out of range 'http-port': " + std::to_string(port), ErrorCodes::ARGUMENT_OUT_OF_BOUND);
-
-    http_timeout = config().getUInt("http-timeout", DEFAULT_HTTP_READ_BUFFER_TIMEOUT);
-    max_server_connections = config().getUInt("max-server-connections", 1024);
-    keep_alive_timeout = config().getUInt("keep-alive-timeout", 10);
-
-    initializeTerminationAndSignalProcessing();
-
-#if USE_ODBC
-    // It doesn't make much sense to build this bridge without ODBC, but we
-    // still do this.
-    Poco::Data::ODBC::Connector::registerConnector();
-#endif
-
-    ServerApplication::initialize(self); // NOLINT
-}
-
-void ODBCBridge::uninitialize()
-{
-    BaseDaemon::uninitialize();
-}
-
-int ODBCBridge::main(const std::vector<std::string> & /*args*/)
-{
-    if (is_help)
-        return Application::EXIT_OK;
-
-    registerFormats();
-
-    LOG_INFO(log, "Starting up");
-    Poco::Net::ServerSocket socket;
-    auto address = socketBindListen(socket, hostname, port, log);
-    socket.setReceiveTimeout(http_timeout);
-    socket.setSendTimeout(http_timeout);
-    Poco::ThreadPool server_pool(3, max_server_connections);
-    Poco::Net::HTTPServerParams::Ptr http_params = new Poco::Net::HTTPServerParams;
-    http_params->setTimeout(http_timeout);
-    http_params->setKeepAliveTimeout(keep_alive_timeout);
-
-    auto shared_context = Context::createShared();
-    Context context(Context::createGlobal(shared_context.get()));
-    context.makeGlobalContext();
-
-    if (config().has("query_masking_rules"))
-    {
-        SensitiveDataMasker::setInstance(std::make_unique<SensitiveDataMasker>(config(), "query_masking_rules"));
-    }
-
-    auto server = HTTPServer(
-        context,
-        std::make_shared<HandlerFactory>("ODBCRequestHandlerFactory-factory", keep_alive_timeout, context),
-        server_pool,
-        socket,
-        http_params);
-    server.start();
-
-    LOG_INFO(log, "Listening http://{}", address.toString());
-
-    SCOPE_EXIT({
-        LOG_DEBUG(log, "Received termination signal.");
-        LOG_DEBUG(log, "Waiting for current connections to close.");
-        server.stop();
-        for (size_t count : ext::range(1, 6))
-        {
-            if (server.currentConnections() == 0)
-                break;
-            LOG_DEBUG(log, "Waiting for {} connections, try {}", server.currentConnections(), count);
-            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-        }
-    });
-
-    waitForTerminationRequest();
-    return Application::EXIT_OK;
-}
-}
 
 #pragma GCC diagnostic ignored "-Wmissing-declarations"
 int mainEntryClickHouseODBCBridge(int argc, char ** argv)
diff --git a/programs/odbc-bridge/ODBCBridge.h b/programs/odbc-bridge/ODBCBridge.h
index 9a0d37fa0f9..b17051dce91 100644
--- a/programs/odbc-bridge/ODBCBridge.h
+++ b/programs/odbc-bridge/ODBCBridge.h
@@ -2,38 +2,25 @@
 
 #include <Interpreters/Context.h>
 #include <Poco/Logger.h>
-#include <daemon/BaseDaemon.h>
+#include <bridge/IBridge.h>
+#include "HandlerFactory.h"
+
 
 namespace DB
 {
-/** Class represents clickhouse-odbc-bridge server, which listen
-  * incoming HTTP POST and GET requests on specified port and host.
-  * Has two handlers '/' for all incoming POST requests to ODBC driver
-  * and /ping for GET request about service status
-  */
-class ODBCBridge : public BaseDaemon
+
+class ODBCBridge : public IBridge
 {
-public:
-    void defineOptions(Poco::Util::OptionSet & options) override;
 
 protected:
-    void initialize(Application & self) override;
+    std::string bridgeName() const override
+    {
+        return "ODBCBridge";
+    }
 
-    void uninitialize() override;
-
-    int main(const std::vector<std::string> & args) override;
-
-private:
-    void handleHelp(const std::string &, const std::string &);
-
-    bool is_help;
-    std::string hostname;
-    size_t port;
-    size_t http_timeout;
-    std::string log_level;
-    size_t max_server_connections;
-    size_t keep_alive_timeout;
-
-    Poco::Logger * log;
+    HandlerFactoryPtr getHandlerFactoryPtr(ContextPtr context) const override
+    {
+        return std::make_shared<ODBCBridgeHandlerFactory>("ODBCRequestHandlerFactory-factory", keep_alive_timeout, context);
+    }
 };
 }
diff --git a/programs/odbc-bridge/ODBCConnectionFactory.h b/programs/odbc-bridge/ODBCConnectionFactory.h
new file mode 100644
index 00000000000..958cf03cfce
--- /dev/null
+++ b/programs/odbc-bridge/ODBCConnectionFactory.h
@@ -0,0 +1,82 @@
+#pragma once
+
+#include <common/logger_useful.h>
+#include <nanodbc/nanodbc.h>
+#include <mutex>
+#include <Common/BorrowedObjectPool.h>
+#include <unordered_map>
+
+
+namespace nanodbc
+{
+
+static constexpr inline auto ODBC_CONNECT_TIMEOUT = 100;
+
+using ConnectionPtr = std::shared_ptr<nanodbc::connection>;
+using Pool = BorrowedObjectPool<ConnectionPtr>;
+using PoolPtr = std::shared_ptr<Pool>;
+
+class ConnectionHolder
+{
+
+public:
+    ConnectionHolder(const std::string & connection_string_, PoolPtr pool_) : connection_string(connection_string_), pool(pool_) {}
+
+    ~ConnectionHolder()
+    {
+        if (connection)
+            pool->returnObject(std::move(connection));
+    }
+
+    nanodbc::connection & operator*()
+    {
+        if (!connection)
+        {
+            pool->borrowObject(connection, [&]()
+            {
+                return std::make_shared<nanodbc::connection>(connection_string, ODBC_CONNECT_TIMEOUT);
+            });
+        }
+
+        return *connection;
+    }
+
+private:
+    std::string connection_string;
+    PoolPtr pool;
+    ConnectionPtr connection;
+};
+
+}
+
+
+namespace DB
+{
+
+class ODBCConnectionFactory final : private boost::noncopyable
+{
+public:
+    static ODBCConnectionFactory & instance()
+    {
+        static ODBCConnectionFactory ret;
+        return ret;
+    }
+
+    nanodbc::ConnectionHolder get(const std::string & connection_string, size_t pool_size)
+    {
+        std::lock_guard lock(mutex);
+
+        if (!factory.count(connection_string))
+            factory.emplace(std::make_pair(connection_string, std::make_shared<nanodbc::Pool>(pool_size)));
+
+        return nanodbc::ConnectionHolder(connection_string, factory[connection_string]);
+    }
+
+private:
+    /// [connection_settings_string] -> [connection_pool]
+    using PoolFactory = std::unordered_map<std::string, nanodbc::PoolPtr>;
+    PoolFactory factory;
+    std::mutex mutex;
+};
+
+}
diff --git a/programs/odbc-bridge/SchemaAllowedHandler.cpp b/programs/odbc-bridge/SchemaAllowedHandler.cpp
index d4a70db61f4..4cceaee962c 100644
--- a/programs/odbc-bridge/SchemaAllowedHandler.cpp
+++ b/programs/odbc-bridge/SchemaAllowedHandler.cpp
@@ -2,33 +2,26 @@
 
 #if USE_ODBC
 
-#    include <Server/HTTP/HTMLForm.h>
-#    include <Server/HTTP/WriteBufferFromHTTPServerResponse.h>
-#    include <IO/WriteHelpers.h>
-#    include <Poco/Data/ODBC/ODBCException.h>
-#    include <Poco/Data/ODBC/SessionImpl.h>
-#    include <Poco/Data/ODBC/Utility.h>
-#    include <Poco/Net/HTTPServerRequest.h>
-#    include <Poco/Net/HTTPServerResponse.h>
-#    include <common/logger_useful.h>
-#    include "validateODBCConnectionString.h"
+#include <Server/HTTP/HTMLForm.h>
+#include <Server/HTTP/WriteBufferFromHTTPServerResponse.h>
+#include <IO/WriteHelpers.h>
+#include <Poco/Net/HTTPServerRequest.h>
+#include <Poco/Net/HTTPServerResponse.h>
+#include <common/logger_useful.h>
+#include "validateODBCConnectionString.h"
+#include "ODBCConnectionFactory.h"
+#include <sql.h>
+#include <sqlext.h>
 
-#    define POCO_SQL_ODBC_CLASS Poco::Data::ODBC
 
 namespace DB
 {
 namespace
 {
-    bool isSchemaAllowed(SQLHDBC hdbc)
+    bool isSchemaAllowed(nanodbc::connection & connection)
     {
-        SQLUINTEGER value;
-        SQLSMALLINT value_length = sizeof(value);
-        SQLRETURN r = POCO_SQL_ODBC_CLASS::SQLGetInfo(hdbc, SQL_SCHEMA_USAGE, &value, sizeof(value), &value_length);
-
-        if (POCO_SQL_ODBC_CLASS::Utility::isError(r))
-            throw POCO_SQL_ODBC_CLASS::ConnectionException(hdbc);
-
-        return value != 0;
+        uint32_t result = connection.get_info<uint32_t>(SQL_SCHEMA_USAGE);
+        return result != 0;
     }
 }
 
@@ -55,10 +48,12 @@ void SchemaAllowedHandler::handleRequest(HTTPServerRequest & request, HTTPServer
     try
     {
         std::string connection_string = params.get("connection_string");
-        POCO_SQL_ODBC_CLASS::SessionImpl session(validateODBCConnectionString(connection_string), DBMS_DEFAULT_CONNECT_TIMEOUT_SEC);
-        SQLHDBC hdbc = session.dbc().handle();
 
-        bool result = isSchemaAllowed(hdbc);
+        auto connection = ODBCConnectionFactory::instance().get(
+                validateODBCConnectionString(connection_string),
+                getContext()->getSettingsRef().odbc_bridge_connection_pool_size);
+
+        bool result = isSchemaAllowed(*connection);
 
         WriteBufferFromHTTPServerResponse out(response, request.getMethod() == Poco::Net::HTTPRequest::HTTP_HEAD, keep_alive_timeout);
         try
diff --git a/programs/odbc-bridge/SchemaAllowedHandler.h b/programs/odbc-bridge/SchemaAllowedHandler.h
index 91eddf67803..d7b922ed05b 100644
--- a/programs/odbc-bridge/SchemaAllowedHandler.h
+++ b/programs/odbc-bridge/SchemaAllowedHandler.h
@@ -1,22 +1,25 @@
 #pragma once
 
+#include <Interpreters/Context.h>
 #include <Server/HTTP/HTTPRequestHandler.h>
-
 #include <Poco/Logger.h>
 
 #if USE_ODBC
 
+
 namespace DB
 {
 
 class Context;
 
 /// This handler establishes connection to database, and retrieves whether schema is allowed.
-class SchemaAllowedHandler : public HTTPRequestHandler
+class SchemaAllowedHandler : public HTTPRequestHandler, WithContext
 {
 public:
-    SchemaAllowedHandler(size_t keep_alive_timeout_, Context &)
-        : log(&Poco::Logger::get("SchemaAllowedHandler")), keep_alive_timeout(keep_alive_timeout_)
+    SchemaAllowedHandler(size_t keep_alive_timeout_, ContextPtr context_)
+        : WithContext(context_)
+        , log(&Poco::Logger::get("SchemaAllowedHandler"))
+        , keep_alive_timeout(keep_alive_timeout_)
     {
     }
 
diff --git a/programs/odbc-bridge/getIdentifierQuote.cpp b/programs/odbc-bridge/getIdentifierQuote.cpp
index 15b3749d37d..d16d2a9eea0 100644
--- a/programs/odbc-bridge/getIdentifierQuote.cpp
+++ b/programs/odbc-bridge/getIdentifierQuote.cpp
@@ -2,11 +2,10 @@
 
 #if USE_ODBC
 
-#    include <Poco/Data/ODBC/ODBCException.h>
-#    include <Poco/Data/ODBC/SessionImpl.h>
-#    include <Poco/Data/ODBC/Utility.h>
-
-#    define POCO_SQL_ODBC_CLASS Poco::Data::ODBC
+#include <common/logger_useful.h>
+#include <nanodbc/nanodbc.h>
+#include <sql.h>
+#include <sqlext.h>
 
 
 namespace DB
@@ -17,33 +16,16 @@ namespace ErrorCodes
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
 }
 
-std::string getIdentifierQuote(SQLHDBC hdbc)
+
+std::string getIdentifierQuote(nanodbc::connection & connection)
 {
-    std::string identifier;
-
-    SQLSMALLINT t;
-    SQLRETURN r = POCO_SQL_ODBC_CLASS::SQLGetInfo(hdbc, SQL_IDENTIFIER_QUOTE_CHAR, nullptr, 0, &t);
-
-    if (POCO_SQL_ODBC_CLASS::Utility::isError(r))
-        throw POCO_SQL_ODBC_CLASS::ConnectionException(hdbc);
-
-    if (t > 0)
-    {
-        // I have no idea, why to add '2' here, got from: contrib/poco/Data/ODBC/src/ODBCStatementImpl.cpp:60 (SQL_DRIVER_NAME)
-        identifier.resize(static_cast<std::size_t>(t) + 2);
-
-        if (POCO_SQL_ODBC_CLASS::Utility::isError(POCO_SQL_ODBC_CLASS::SQLGetInfo(
-                hdbc, SQL_IDENTIFIER_QUOTE_CHAR, &identifier[0], SQLSMALLINT((identifier.length() - 1) * sizeof(identifier[0])), &t)))
-            throw POCO_SQL_ODBC_CLASS::ConnectionException(hdbc);
-
-        identifier.resize(static_cast<std::size_t>(t));
-    }
-    return identifier;
+    return connection.get_info<std::string>(SQL_IDENTIFIER_QUOTE_CHAR);
 }
 
-IdentifierQuotingStyle getQuotingStyle(SQLHDBC hdbc)
+
+IdentifierQuotingStyle getQuotingStyle(nanodbc::connection & connection)
 {
-    auto identifier_quote = getIdentifierQuote(hdbc);
+    auto identifier_quote = getIdentifierQuote(connection);
     if (identifier_quote.length() == 0)
         return IdentifierQuotingStyle::None;
     else if (identifier_quote[0] == '`')
diff --git a/programs/odbc-bridge/getIdentifierQuote.h b/programs/odbc-bridge/getIdentifierQuote.h
index 0fb4c3bddb1..7f7156eff82 100644
--- a/programs/odbc-bridge/getIdentifierQuote.h
+++ b/programs/odbc-bridge/getIdentifierQuote.h
@@ -2,20 +2,19 @@
 
 #if USE_ODBC
 
-#    include <Interpreters/Context.h>
-#    include <Poco/Logger.h>
-#    include <Poco/Net/HTTPRequestHandler.h>
-
-#    include <Poco/Data/ODBC/Utility.h>
-
+#include <Interpreters/Context.h>
+#include <Poco/Logger.h>
+#include <Poco/Net/HTTPRequestHandler.h>
 #include <Parsers/IdentifierQuotingStyle.h>
+#include <nanodbc/nanodbc.h>
+
 
 namespace DB
 {
 
-std::string getIdentifierQuote(SQLHDBC hdbc);
+std::string getIdentifierQuote(nanodbc::connection & connection);
 
-IdentifierQuotingStyle getQuotingStyle(SQLHDBC hdbc);
+IdentifierQuotingStyle getQuotingStyle(nanodbc::connection & connection);
 
 }
 
diff --git a/programs/server/Server.cpp b/programs/server/Server.cpp
index f2f43aabc7d..8a96612721d 100644
--- a/programs/server/Server.cpp
+++ b/programs/server/Server.cpp
@@ -47,6 +47,7 @@
 #include <Interpreters/DatabaseCatalog.h>
 #include <Interpreters/DNSCacheUpdater.h>
 #include <Interpreters/ExternalLoaderXMLConfigRepository.h>
+#include <Interpreters/InterserverCredentials.h>
 #include <Interpreters/ExpressionJIT.h>
 #include <Access/AccessControlManager.h>
 #include <Storages/StorageReplicatedMergeTree.h>
@@ -425,8 +426,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
       *  settings, available functions, data types, aggregate functions, databases, ...
       */
     auto shared_context = Context::createShared();
-    auto global_context = std::make_unique<Context>(Context::createGlobal(shared_context.get()));
-    global_context_ptr = global_context.get();
+    global_context = Context::createGlobal(shared_context.get());
 
     global_context->makeGlobalContext();
     global_context->setApplicationType(Context::ApplicationType::SERVER);
@@ -688,16 +688,8 @@ int Server::main(const std::vector<std::string> & /*args*/)
         }
     }
 
-    if (config().has("interserver_http_credentials"))
-    {
-        String user = config().getString("interserver_http_credentials.user", "");
-        String password = config().getString("interserver_http_credentials.password", "");
-
-        if (user.empty())
-            throw Exception("Configuration parameter interserver_http_credentials user can't be empty", ErrorCodes::NO_ELEMENTS_IN_CONFIG);
-
-        global_context->setInterserverCredentials(user, password);
-    }
+    LOG_DEBUG(log, "Initiailizing interserver credentials.");
+    global_context->updateInterserverCredentials(config());
 
     if (config().has("macros"))
         global_context->setMacros(std::make_unique<Macros>(config(), "macros", log));
@@ -758,6 +750,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
             global_context->setClustersConfig(config);
             global_context->setMacros(std::make_unique<Macros>(*config, "macros", log));
             global_context->setExternalAuthenticatorsConfig(*config);
+            global_context->setExternalModelsConfig(config);
 
             /// Setup protection to avoid accidental DROP for big tables (that are greater than 50 GB by default)
             if (config->has("max_table_size_to_drop"))
@@ -777,6 +770,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
             }
 
             global_context->updateStorageConfiguration(*config);
+            global_context->updateInterserverCredentials(*config);
         },
         /* already_loaded = */ false);  /// Reload it right now (initial loading)
 
@@ -885,10 +879,30 @@ int Server::main(const std::vector<std::string> & /*args*/)
                 servers_to_start_before_tables->emplace_back(
                     port_name,
                     std::make_unique<Poco::Net::TCPServer>(
-                        new KeeperTCPHandlerFactory(*this), server_pool, socket, new Poco::Net::TCPServerParams));
+                        new KeeperTCPHandlerFactory(*this, false), server_pool, socket, new Poco::Net::TCPServerParams));
 
                 LOG_INFO(log, "Listening for connections to Keeper (tcp): {}", address.toString());
             });
+
+            const char * secure_port_name = "keeper_server.tcp_port_secure";
+            createServer(listen_host, secure_port_name, listen_try, [&](UInt16 port)
+            {
+#if USE_SSL
+                Poco::Net::SecureServerSocket socket;
+                auto address = socketBindListen(socket, listen_host, port, /* secure = */ true);
+                socket.setReceiveTimeout(settings.receive_timeout);
+                socket.setSendTimeout(settings.send_timeout);
+                servers_to_start_before_tables->emplace_back(
+                    secure_port_name,
+                    std::make_unique<Poco::Net::TCPServer>(
+                        new KeeperTCPHandlerFactory(*this, true), server_pool, socket, new Poco::Net::TCPServerParams));
+                LOG_INFO(log, "Listening for connections to Keeper with secure protocol (tcp_secure): {}", address.toString());
+#else
+                UNUSED(port);
+                throw Exception{"SSL support for TCP protocol is disabled because Poco library was built without NetSSL support.",
+                    ErrorCodes::SUPPORT_IS_DISABLED};
+#endif
+            });
         }
 #else
         throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, "ClickHouse server built without NuRaft library. Cannot use internal coordination.");
@@ -940,7 +954,6 @@ int Server::main(const std::vector<std::string> & /*args*/)
         /** Explicitly destroy Context. It is more convenient than in destructor of Server, because logger is still available.
           * At this moment, no one could own shared part of Context.
           */
-        global_context_ptr = nullptr;
         global_context.reset();
         shared_context.reset();
         LOG_DEBUG(log, "Destroyed global context.");
@@ -954,14 +967,14 @@ int Server::main(const std::vector<std::string> & /*args*/)
 
     try
     {
-        loadMetadataSystem(*global_context);
+        loadMetadataSystem(global_context);
         /// After attaching system databases we can initialize system log.
         global_context->initializeSystemLogs();
         auto & database_catalog = DatabaseCatalog::instance();
         /// After the system database is created, attach virtual system tables (in addition to query_log and part_log)
         attachSystemTablesServer(*database_catalog.getSystemDatabase(), has_zookeeper);
         /// Then, load remaining databases
-        loadMetadata(*global_context, default_database);
+        loadMetadata(global_context, default_database);
         database_catalog.loadDatabases();
         /// After loading validate that default database exists
         database_catalog.assertDatabaseExists(default_database);
@@ -1041,7 +1054,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
     else
     {
         /// Initialize a watcher periodically updating DNS cache
-        dns_cache_updater = std::make_unique<DNSCacheUpdater>(*global_context, config().getInt("dns_cache_update_period", 15));
+        dns_cache_updater = std::make_unique<DNSCacheUpdater>(global_context, config().getInt("dns_cache_update_period", 15));
     }
 
 #if defined(OS_LINUX)
@@ -1073,7 +1086,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
     {
         /// This object will periodically calculate some metrics.
         AsynchronousMetrics async_metrics(
-            *global_context, config().getUInt("asynchronous_metrics_update_period_s", 60), servers_to_start_before_tables, servers);
+            global_context, config().getUInt("asynchronous_metrics_update_period_s", 60), servers_to_start_before_tables, servers);
         attachSystemTablesAsync(*DatabaseCatalog::instance().getSystemDatabase(), async_metrics);
 
         for (const auto & listen_host : listen_hosts)
@@ -1310,7 +1323,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
         }
 
         /// try to load dictionaries immediately, throw on error and die
-        ext::scope_guard dictionaries_xmls, models_xmls;
+        ext::scope_guard dictionaries_xmls;
         try
         {
             if (!config().getBool("dictionaries_lazy_load", true))
@@ -1320,8 +1333,6 @@ int Server::main(const std::vector<std::string> & /*args*/)
             }
             dictionaries_xmls = global_context->getExternalDictionariesLoader().addConfigRepository(
                 std::make_unique<ExternalLoaderXMLConfigRepository>(config(), "dictionaries_config"));
-            models_xmls = global_context->getExternalModelsLoader().addConfigRepository(
-                std::make_unique<ExternalLoaderXMLConfigRepository>(config(), "models_config"));
         }
         catch (...)
         {
@@ -1336,7 +1347,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
             int pool_size = config().getInt("distributed_ddl.pool_size", 1);
             if (pool_size < 1)
                 throw Exception("distributed_ddl.pool_size should be greater then 0", ErrorCodes::ARGUMENT_OUT_OF_BOUND);
-            global_context->setDDLWorker(std::make_unique<DDLWorker>(pool_size, ddl_zookeeper_path, *global_context, &config(),
+            global_context->setDDLWorker(std::make_unique<DDLWorker>(pool_size, ddl_zookeeper_path, global_context, &config(),
                                                                      "distributed_ddl", "DDLWorker", &CurrentMetrics::MaxDDLEntryID));
         }
 
diff --git a/programs/server/Server.h b/programs/server/Server.h
index fbfc26f6ee5..c698108767c 100644
--- a/programs/server/Server.h
+++ b/programs/server/Server.h
@@ -40,9 +40,9 @@ public:
         return BaseDaemon::logger();
     }
 
-    Context & context() const override
+    ContextPtr context() const override
     {
-        return *global_context_ptr;
+        return global_context;
     }
 
     bool isCancelled() const override
@@ -64,8 +64,7 @@ protected:
     std::string getDefaultCorePath() const override;
 
 private:
-    Context * global_context_ptr = nullptr;
-
+    ContextPtr global_context;
     Poco::Net::SocketAddress socketBindListen(Poco::Net::ServerSocket & socket, const std::string & host, UInt16 port, [[maybe_unused]] bool secure = false) const;
 
     using CreateServerFunc = std::function<void(UInt16)>;
diff --git a/src/AggregateFunctions/AggregateFunctionAggThrow.cpp b/src/AggregateFunctions/AggregateFunctionAggThrow.cpp
index c699dd4f217..09e343b2dc5 100644
--- a/src/AggregateFunctions/AggregateFunctionAggThrow.cpp
+++ b/src/AggregateFunctions/AggregateFunctionAggThrow.cpp
@@ -60,6 +60,8 @@ public:
         return std::make_shared<DataTypeUInt8>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void create(AggregateDataPtr __restrict place) const override
     {
         if (std::uniform_real_distribution<>(0.0, 1.0)(thread_local_rng) <= throw_probability)
diff --git a/src/AggregateFunctions/AggregateFunctionAvg.h b/src/AggregateFunctions/AggregateFunctionAvg.h
index 7bf742294b4..96d48941f8b 100644
--- a/src/AggregateFunctions/AggregateFunctionAvg.h
+++ b/src/AggregateFunctions/AggregateFunctionAvg.h
@@ -98,6 +98,8 @@ public:
 
     DataTypePtr getReturnType() const final { return std::make_shared<DataTypeNumber<Float64>>(); }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void NO_SANITIZE_UNDEFINED merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena *) const override
     {
         this->data(place).numerator += this->data(rhs).numerator;
diff --git a/src/AggregateFunctions/AggregateFunctionBitwise.h b/src/AggregateFunctions/AggregateFunctionBitwise.h
index 3ba8e045069..b48b1960329 100644
--- a/src/AggregateFunctions/AggregateFunctionBitwise.h
+++ b/src/AggregateFunctions/AggregateFunctionBitwise.h
@@ -54,6 +54,8 @@ public:
         return std::make_shared<DataTypeNumber<T>>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         this->data(place).update(assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
diff --git a/src/AggregateFunctions/AggregateFunctionBoundingRatio.h b/src/AggregateFunctions/AggregateFunctionBoundingRatio.h
index 32ae22fd573..0cfb33efc10 100644
--- a/src/AggregateFunctions/AggregateFunctionBoundingRatio.h
+++ b/src/AggregateFunctions/AggregateFunctionBoundingRatio.h
@@ -127,6 +127,8 @@ public:
         return std::make_shared<DataTypeFloat64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, const size_t row_num, Arena *) const override
     {
         /// NOTE Slightly inefficient.
diff --git a/src/AggregateFunctions/AggregateFunctionCategoricalInformationValue.h b/src/AggregateFunctions/AggregateFunctionCategoricalInformationValue.h
index ba8acb208ea..fb3e35fbcf1 100644
--- a/src/AggregateFunctions/AggregateFunctionCategoricalInformationValue.h
+++ b/src/AggregateFunctions/AggregateFunctionCategoricalInformationValue.h
@@ -33,6 +33,8 @@ public:
         return "categoricalInformationValue";
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void create(AggregateDataPtr __restrict place) const override
     {
         memset(place, 0, sizeOfData());
diff --git a/src/AggregateFunctions/AggregateFunctionCombinatorFactory.cpp b/src/AggregateFunctions/AggregateFunctionCombinatorFactory.cpp
index a20d355bb2f..e4ff8c134c5 100644
--- a/src/AggregateFunctions/AggregateFunctionCombinatorFactory.cpp
+++ b/src/AggregateFunctions/AggregateFunctionCombinatorFactory.cpp
@@ -13,17 +13,25 @@ namespace ErrorCodes
 
 void AggregateFunctionCombinatorFactory::registerCombinator(const AggregateFunctionCombinatorPtr & value)
 {
-    if (!dict.emplace(value->getName(), value).second)
-        throw Exception("AggregateFunctionCombinatorFactory: the name '" + value->getName() + "' is not unique",
-            ErrorCodes::LOGICAL_ERROR);
+    CombinatorPair pair{
+        .name = value->getName(),
+        .combinator_ptr = value,
+    };
+
+    /// lower_bound() cannot be used since sort order of the dict is by length of the combinator
+    /// but there are just a few combiners, so not a problem.
+    if (std::find(dict.begin(), dict.end(), pair) != dict.end())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "AggregateFunctionCombinatorFactory: the name '{}' is not unique",
+            value->getName());
+    dict.emplace(std::lower_bound(dict.begin(), dict.end(), pair), pair);
 }
 
 AggregateFunctionCombinatorPtr AggregateFunctionCombinatorFactory::tryFindSuffix(const std::string & name) const
 {
     /// O(N) is ok for just a few combinators.
     for (const auto & suffix_value : dict)
-        if (endsWith(name, suffix_value.first))
-            return suffix_value.second;
+        if (endsWith(name, suffix_value.name))
+            return suffix_value.combinator_ptr;
     return {};
 }
 
diff --git a/src/AggregateFunctions/AggregateFunctionCombinatorFactory.h b/src/AggregateFunctions/AggregateFunctionCombinatorFactory.h
index b535475d111..5f7658c16af 100644
--- a/src/AggregateFunctions/AggregateFunctionCombinatorFactory.h
+++ b/src/AggregateFunctions/AggregateFunctionCombinatorFactory.h
@@ -15,7 +15,17 @@ namespace DB
 class AggregateFunctionCombinatorFactory final: private boost::noncopyable
 {
 private:
-    using Dict = std::unordered_map<std::string, AggregateFunctionCombinatorPtr>;
+    struct CombinatorPair
+    {
+        std::string name;
+        AggregateFunctionCombinatorPtr combinator_ptr;
+
+        bool operator==(const CombinatorPair & rhs) const { return name == rhs.name; }
+        /// Sort by the length of the combinator name for proper tryFindSuffix()
+        /// for combiners with common prefix (i.e. "State" and "SimpleState").
+        bool operator<(const CombinatorPair & rhs) const { return name.length() > rhs.name.length(); }
+    };
+    using Dict = std::vector<CombinatorPair>;
     Dict dict;
 
 public:
diff --git a/src/AggregateFunctions/AggregateFunctionCount.h b/src/AggregateFunctions/AggregateFunctionCount.h
index 1b3a0acb528..71db28390af 100644
--- a/src/AggregateFunctions/AggregateFunctionCount.h
+++ b/src/AggregateFunctions/AggregateFunctionCount.h
@@ -38,6 +38,8 @@ public:
         return std::make_shared<DataTypeUInt64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn **, size_t, Arena *) const override
     {
         ++data(place).count;
@@ -126,6 +128,8 @@ public:
         return std::make_shared<DataTypeUInt64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         data(place).count += !assert_cast<const ColumnNullable &>(*columns[0]).isNullAt(row_num);
diff --git a/src/AggregateFunctions/AggregateFunctionDeltaSum.h b/src/AggregateFunctions/AggregateFunctionDeltaSum.h
index d5760de84ae..99406618da5 100644
--- a/src/AggregateFunctions/AggregateFunctionDeltaSum.h
+++ b/src/AggregateFunctions/AggregateFunctionDeltaSum.h
@@ -43,6 +43,8 @@ public:
 
     DataTypePtr getReturnType() const override { return std::make_shared<DataTypeNumber<T>>(); }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void NO_SANITIZE_UNDEFINED ALWAYS_INLINE add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         auto value = assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num];
diff --git a/src/AggregateFunctions/AggregateFunctionEntropy.h b/src/AggregateFunctions/AggregateFunctionEntropy.h
index 9bb1bc039c5..587f5aa3fc7 100644
--- a/src/AggregateFunctions/AggregateFunctionEntropy.h
+++ b/src/AggregateFunctions/AggregateFunctionEntropy.h
@@ -103,6 +103,8 @@ public:
         return std::make_shared<DataTypeNumber<Float64>>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         if constexpr (!std::is_same_v<UInt128, Value>)
diff --git a/src/AggregateFunctions/AggregateFunctionFactory.cpp b/src/AggregateFunctions/AggregateFunctionFactory.cpp
index c0011b6ebec..eec8b374424 100644
--- a/src/AggregateFunctions/AggregateFunctionFactory.cpp
+++ b/src/AggregateFunctions/AggregateFunctionFactory.cpp
@@ -121,7 +121,7 @@ AggregateFunctionPtr AggregateFunctionFactory::getImpl(
         is_case_insensitive = true;
     }
 
-    const Context * query_context = nullptr;
+    ContextPtr query_context;
     if (CurrentThread::isInitialized())
         query_context = CurrentThread::get().getQueryContext();
 
diff --git a/src/AggregateFunctions/AggregateFunctionGroupArrayInsertAt.h b/src/AggregateFunctions/AggregateFunctionGroupArrayInsertAt.h
index 35913f133b1..723ee7140bc 100644
--- a/src/AggregateFunctions/AggregateFunctionGroupArrayInsertAt.h
+++ b/src/AggregateFunctions/AggregateFunctionGroupArrayInsertAt.h
@@ -104,6 +104,8 @@ public:
         return std::make_shared<DataTypeArray>(type);
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         /// TODO Do positions need to be 1-based for this function?
diff --git a/src/AggregateFunctions/AggregateFunctionGroupBitmap.h b/src/AggregateFunctions/AggregateFunctionGroupBitmap.h
index 4628410286d..83db274752b 100644
--- a/src/AggregateFunctions/AggregateFunctionGroupBitmap.h
+++ b/src/AggregateFunctions/AggregateFunctionGroupBitmap.h
@@ -22,6 +22,8 @@ public:
 
     DataTypePtr getReturnType() const override { return std::make_shared<DataTypeNumber<T>>(); }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         this->data(place).rbs.add(assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
@@ -56,6 +58,8 @@ public:
 
     DataTypePtr getReturnType() const override { return std::make_shared<DataTypeNumber<T>>(); }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         Data & data_lhs = this->data(place);
diff --git a/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h b/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
index 435efdd2373..16911184f31 100644
--- a/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
+++ b/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
@@ -59,6 +59,8 @@ public:
         return std::make_shared<DataTypeArray>(this->argument_types[0]);
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         if (limit_num_elems && this->data(place).value.size() >= max_elems)
diff --git a/src/AggregateFunctions/AggregateFunctionHistogram.h b/src/AggregateFunctions/AggregateFunctionHistogram.h
index 76aa96ba663..c44cb61b275 100644
--- a/src/AggregateFunctions/AggregateFunctionHistogram.h
+++ b/src/AggregateFunctions/AggregateFunctionHistogram.h
@@ -332,6 +332,8 @@ public:
         return std::make_shared<DataTypeArray>(tuple);
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         auto val = assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num];
diff --git a/src/AggregateFunctions/AggregateFunctionMLMethod.cpp b/src/AggregateFunctions/AggregateFunctionMLMethod.cpp
index 6c5c5af2f1d..145660e881b 100644
--- a/src/AggregateFunctions/AggregateFunctionMLMethod.cpp
+++ b/src/AggregateFunctions/AggregateFunctionMLMethod.cpp
@@ -146,7 +146,7 @@ void LinearModelData::predict(
     const ColumnsWithTypeAndName & arguments,
     size_t offset,
     size_t limit,
-    const Context & context) const
+    ContextPtr context) const
 {
     gradient_computer->predict(container, arguments, offset, limit, weights, bias, context);
 }
@@ -453,7 +453,7 @@ void LogisticRegression::predict(
     size_t limit,
     const std::vector<Float64> & weights,
     Float64 bias,
-    const Context & /*context*/) const
+    ContextPtr /*context*/) const
 {
     size_t rows_num = arguments.front().column->size();
 
@@ -521,7 +521,7 @@ void LinearRegression::predict(
     size_t limit,
     const std::vector<Float64> & weights,
     Float64 bias,
-    const Context & /*context*/) const
+    ContextPtr /*context*/) const
 {
     if (weights.size() + 1 != arguments.size())
     {
diff --git a/src/AggregateFunctions/AggregateFunctionMLMethod.h b/src/AggregateFunctions/AggregateFunctionMLMethod.h
index 0c88f9d877d..6d97feb3193 100644
--- a/src/AggregateFunctions/AggregateFunctionMLMethod.h
+++ b/src/AggregateFunctions/AggregateFunctionMLMethod.h
@@ -3,10 +3,10 @@
 #include <Columns/ColumnVector.h>
 #include <Columns/ColumnsCommon.h>
 #include <Columns/ColumnsNumber.h>
-#include <Common/typeid_cast.h>
-#include <DataTypes/DataTypesNumber.h>
-#include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypeArray.h>
+#include <DataTypes/DataTypeTuple.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <Common/typeid_cast.h>
 #include "IAggregateFunction.h"
 
 namespace DB
@@ -44,7 +44,7 @@ public:
         size_t limit,
         const std::vector<Float64> & weights,
         Float64 bias,
-        const Context & context) const = 0;
+        ContextPtr context) const = 0;
 };
 
 
@@ -69,7 +69,7 @@ public:
         size_t limit,
         const std::vector<Float64> & weights,
         Float64 bias,
-        const Context & context) const override;
+        ContextPtr context) const override;
 };
 
 
@@ -94,7 +94,7 @@ public:
         size_t limit,
         const std::vector<Float64> & weights,
         Float64 bias,
-        const Context & context) const override;
+        ContextPtr context) const override;
 };
 
 
@@ -264,7 +264,7 @@ public:
         const ColumnsWithTypeAndName & arguments,
         size_t offset,
         size_t limit,
-        const Context & context) const;
+        ContextPtr context) const;
 
     void returnWeights(IColumn & to) const;
 private:
@@ -323,6 +323,8 @@ public:
         return std::make_shared<DataTypeArray>(std::make_shared<DataTypeFloat64>());
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     /// This function is called from evalMLMethod function for correct predictValues call
     DataTypePtr getReturnTypeToPredict() const override
     {
@@ -363,7 +365,7 @@ public:
         const ColumnsWithTypeAndName & arguments,
         size_t offset,
         size_t limit,
-        const Context & context) const override
+        ContextPtr context) const override
     {
         if (arguments.size() != param_num + 1)
             throw Exception(
diff --git a/src/AggregateFunctions/AggregateFunctionMannWhitney.h b/src/AggregateFunctions/AggregateFunctionMannWhitney.h
index 1451536d519..7efdebf1639 100644
--- a/src/AggregateFunctions/AggregateFunctionMannWhitney.h
+++ b/src/AggregateFunctions/AggregateFunctionMannWhitney.h
@@ -174,6 +174,8 @@ public:
         return "mannWhitneyUTest";
     }
 
+    bool allocatesMemoryInArena() const override { return true; }
+
     DataTypePtr getReturnType() const override
     {
         DataTypes types
@@ -208,7 +210,7 @@ public:
     void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena * arena) const override
     {
         auto & a = this->data(place);
-        auto & b = this->data(rhs);
+        const auto & b = this->data(rhs);
 
         a.merge(b, arena);
     }
diff --git a/src/AggregateFunctions/AggregateFunctionMaxIntersections.h b/src/AggregateFunctions/AggregateFunctionMaxIntersections.h
index d4946ad2c9d..94509a40ada 100644
--- a/src/AggregateFunctions/AggregateFunctionMaxIntersections.h
+++ b/src/AggregateFunctions/AggregateFunctionMaxIntersections.h
@@ -87,6 +87,8 @@ public:
             return std::make_shared<DataTypeNumber<PointType>>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena * arena) const override
     {
         PointType left = assert_cast<const ColumnVector<PointType> &>(*columns[0]).getData()[row_num];
diff --git a/src/AggregateFunctions/AggregateFunctionNothing.h b/src/AggregateFunctions/AggregateFunctionNothing.h
index f373b3b55b0..a094c1e0fac 100644
--- a/src/AggregateFunctions/AggregateFunctionNothing.h
+++ b/src/AggregateFunctions/AggregateFunctionNothing.h
@@ -28,6 +28,8 @@ public:
         return argument_types.front();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void create(AggregateDataPtr) const override
     {
     }
diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index edd24add736..209784361dd 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -103,6 +103,8 @@ public:
             return res;
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         auto value = static_cast<const ColVecType &>(*columns[0]).getData()[row_num];
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorrelation.h b/src/AggregateFunctions/AggregateFunctionRankCorrelation.h
index a7e0852378c..fbba1b99ab9 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorrelation.h
+++ b/src/AggregateFunctions/AggregateFunctionRankCorrelation.h
@@ -58,6 +58,8 @@ public:
         return "rankCorr";
     }
 
+    bool allocatesMemoryInArena() const override { return true; }
+
     DataTypePtr getReturnType() const override
     {
         return std::make_shared<DataTypeNumber<Float64>>();
diff --git a/src/AggregateFunctions/AggregateFunctionRetention.h b/src/AggregateFunctions/AggregateFunctionRetention.h
index 5f0d9907280..aee74cb7324 100644
--- a/src/AggregateFunctions/AggregateFunctionRetention.h
+++ b/src/AggregateFunctions/AggregateFunctionRetention.h
@@ -94,6 +94,8 @@ public:
         return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt8>());
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, const size_t row_num, Arena *) const override
     {
         for (const auto i : ext::range(0, events_size))
diff --git a/src/AggregateFunctions/AggregateFunctionSequenceMatch.h b/src/AggregateFunctions/AggregateFunctionSequenceMatch.h
index 48015a6d282..2c2a4d4c75a 100644
--- a/src/AggregateFunctions/AggregateFunctionSequenceMatch.h
+++ b/src/AggregateFunctions/AggregateFunctionSequenceMatch.h
@@ -560,6 +560,8 @@ public:
 
     DataTypePtr getReturnType() const override { return std::make_shared<DataTypeUInt8>(); }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void insertResultInto(AggregateDataPtr __restrict place, IColumn & to, Arena *) const override
     {
         this->data(place).sort();
@@ -588,6 +590,8 @@ public:
 
     DataTypePtr getReturnType() const override { return std::make_shared<DataTypeUInt64>(); }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void insertResultInto(AggregateDataPtr __restrict place, IColumn & to, Arena *) const override
     {
         this->data(place).sort();
diff --git a/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.h b/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.h
index 8c029855a26..61f10895de6 100644
--- a/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.h
+++ b/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.h
@@ -168,6 +168,8 @@ public:
         );
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void insertResultInto(
         AggregateDataPtr place,
         IColumn & to,
diff --git a/src/AggregateFunctions/AggregateFunctionStatistics.h b/src/AggregateFunctions/AggregateFunctionStatistics.h
index 76b6e843c15..473bce1d89a 100644
--- a/src/AggregateFunctions/AggregateFunctionStatistics.h
+++ b/src/AggregateFunctions/AggregateFunctionStatistics.h
@@ -123,6 +123,8 @@ public:
         return std::make_shared<DataTypeFloat64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         this->data(place).update(*columns[0], row_num);
@@ -375,6 +377,8 @@ public:
         return std::make_shared<DataTypeFloat64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         this->data(place).update(*columns[0], *columns[1], row_num);
diff --git a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
index 9903e2f6eaa..a5d6bbb7dc8 100644
--- a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
+++ b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
@@ -121,6 +121,8 @@ public:
         return std::make_shared<DataTypeNumber<ResultType>>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         if constexpr (StatFunc::num_args == 2)
diff --git a/src/AggregateFunctions/AggregateFunctionSum.h b/src/AggregateFunctions/AggregateFunctionSum.h
index bd1f9fc302e..1748458f6d8 100644
--- a/src/AggregateFunctions/AggregateFunctionSum.h
+++ b/src/AggregateFunctions/AggregateFunctionSum.h
@@ -314,6 +314,8 @@ public:
             return std::make_shared<ResultDataType>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         const auto & column = assert_cast<const ColVecType &>(*columns[0]);
diff --git a/src/AggregateFunctions/AggregateFunctionSumMap.h b/src/AggregateFunctions/AggregateFunctionSumMap.h
index d8b19bad62f..7819bb8752c 100644
--- a/src/AggregateFunctions/AggregateFunctionSumMap.h
+++ b/src/AggregateFunctions/AggregateFunctionSumMap.h
@@ -140,6 +140,8 @@ public:
         return std::make_shared<DataTypeTuple>(types);
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     static const auto & getArgumentColumns(const IColumn**& columns)
     {
         if constexpr (tuple_argument)
diff --git a/src/AggregateFunctions/AggregateFunctionTTest.h b/src/AggregateFunctions/AggregateFunctionTTest.h
index 3c9873ebd1e..5617adf38dd 100644
--- a/src/AggregateFunctions/AggregateFunctionTTest.h
+++ b/src/AggregateFunctions/AggregateFunctionTTest.h
@@ -109,6 +109,8 @@ public:
         );
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         Float64 value = columns[0]->getFloat64(row_num);
diff --git a/src/AggregateFunctions/AggregateFunctionTopK.h b/src/AggregateFunctions/AggregateFunctionTopK.h
index 43320a96b99..dbc471687ea 100644
--- a/src/AggregateFunctions/AggregateFunctionTopK.h
+++ b/src/AggregateFunctions/AggregateFunctionTopK.h
@@ -50,6 +50,8 @@ public:
         return std::make_shared<DataTypeArray>(this->argument_types[0]);
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         auto & set = this->data(place).value;
diff --git a/src/AggregateFunctions/AggregateFunctionUniq.h b/src/AggregateFunctions/AggregateFunctionUniq.h
index bddd28e9718..191fc873bb6 100644
--- a/src/AggregateFunctions/AggregateFunctionUniq.h
+++ b/src/AggregateFunctions/AggregateFunctionUniq.h
@@ -230,6 +230,8 @@ public:
         return std::make_shared<DataTypeUInt64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     /// ALWAYS_INLINE is required to have better code layout for uniqHLL12 function
     void ALWAYS_INLINE add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
@@ -285,6 +287,8 @@ public:
         return std::make_shared<DataTypeUInt64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         this->data(place).set.insert(typename Data::Set::value_type(
diff --git a/src/AggregateFunctions/AggregateFunctionUniqCombined.h b/src/AggregateFunctions/AggregateFunctionUniqCombined.h
index c9327594670..31bd8021dcf 100644
--- a/src/AggregateFunctions/AggregateFunctionUniqCombined.h
+++ b/src/AggregateFunctions/AggregateFunctionUniqCombined.h
@@ -141,6 +141,8 @@ public:
         return std::make_shared<DataTypeUInt64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         if constexpr (!std::is_same_v<T, String>)
@@ -211,6 +213,8 @@ public:
         return std::make_shared<DataTypeUInt64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         this->data(place).set.insert(typename AggregateFunctionUniqCombinedData<UInt64, K, HashValueType>::Set::value_type(
diff --git a/src/AggregateFunctions/AggregateFunctionUniqUpTo.h b/src/AggregateFunctions/AggregateFunctionUniqUpTo.h
index d2c765137bc..88f26ab312e 100644
--- a/src/AggregateFunctions/AggregateFunctionUniqUpTo.h
+++ b/src/AggregateFunctions/AggregateFunctionUniqUpTo.h
@@ -184,6 +184,8 @@ public:
         return std::make_shared<DataTypeUInt64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     /// ALWAYS_INLINE is required to have better code layout for uniqUpTo function
     void ALWAYS_INLINE add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
@@ -247,6 +249,8 @@ public:
         return std::make_shared<DataTypeUInt64>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         this->data(place).insert(UInt64(UniqVariadicHash<is_exact, argument_is_tuple>::apply(num_args, columns, row_num)), threshold);
diff --git a/src/AggregateFunctions/AggregateFunctionWindowFunnel.h b/src/AggregateFunctions/AggregateFunctionWindowFunnel.h
index 9644b8d9ea4..9f399a9f25b 100644
--- a/src/AggregateFunctions/AggregateFunctionWindowFunnel.h
+++ b/src/AggregateFunctions/AggregateFunctionWindowFunnel.h
@@ -247,6 +247,8 @@ public:
         return std::make_shared<DataTypeUInt8>();
     }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     AggregateFunctionPtr getOwnNullAdapter(
         const AggregateFunctionPtr & nested_function, const DataTypes & arguments, const Array & params,
         const AggregateFunctionProperties & /*properties*/) const override
diff --git a/src/AggregateFunctions/IAggregateFunction.h b/src/AggregateFunctions/IAggregateFunction.h
index 168d12fb2b9..dbb0a9f4349 100644
--- a/src/AggregateFunctions/IAggregateFunction.h
+++ b/src/AggregateFunctions/IAggregateFunction.h
@@ -1,21 +1,23 @@
 #pragma once
 
+#include <Columns/ColumnTuple.h>
+#include <Columns/ColumnsNumber.h>
+#include <Core/Block.h>
+#include <Core/ColumnNumbers.h>
+#include <Core/Field.h>
+#include <Interpreters/Context_fwd.h>
+#include <Common/Exception.h>
+#include <common/types.h>
+
 #include <cstddef>
 #include <memory>
 #include <type_traits>
 #include <vector>
 
-#include <common/types.h>
-#include <Common/Exception.h>
-#include <Core/Block.h>
-#include <Core/ColumnNumbers.h>
-#include <Core/Field.h>
-#include <Columns/ColumnTuple.h>
-#include <Columns/ColumnsNumber.h>
-
 
 namespace DB
 {
+
 namespace ErrorCodes
 {
     extern const int NOT_IMPLEMENTED;
@@ -104,7 +106,7 @@ public:
     virtual void deserialize(AggregateDataPtr __restrict place, ReadBuffer & buf, Arena * arena) const = 0;
 
     /// Returns true if a function requires Arena to handle own states (see add(), merge(), deserialize()).
-    virtual bool allocatesMemoryInArena() const { return false; }
+    virtual bool allocatesMemoryInArena() const = 0;
 
     /// Inserts results into a column. This method might modify the state (e.g.
     /// sort an array), so must be called once, from single thread. The state
@@ -122,7 +124,7 @@ public:
         const ColumnsWithTypeAndName & /*arguments*/,
         size_t /*offset*/,
         size_t /*limit*/,
-        const Context & /*context*/) const
+        ContextPtr /*context*/) const
     {
         throw Exception("Method predictValues is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
diff --git a/src/Bridge/IBridgeHelper.cpp b/src/Bridge/IBridgeHelper.cpp
new file mode 100644
index 00000000000..16886bae4fe
--- /dev/null
+++ b/src/Bridge/IBridgeHelper.cpp
@@ -0,0 +1,132 @@
+#include "IBridgeHelper.h"
+
+#include <IO/ReadWriteBufferFromHTTP.h>
+#include <IO/ReadHelpers.h>
+#include <Poco/Net/HTTPRequest.h>
+#include <Poco/Path.h>
+#include <Poco/URI.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int EXTERNAL_SERVER_IS_NOT_RESPONDING;
+}
+
+
+Poco::URI IBridgeHelper::getMainURI() const
+{
+    auto uri = createBaseURI();
+    uri.setPath(MAIN_HANDLER);
+    return uri;
+}
+
+
+Poco::URI IBridgeHelper::getPingURI() const
+{
+    auto uri = createBaseURI();
+    uri.setPath(PING_HANDLER);
+    return uri;
+}
+
+
+bool IBridgeHelper::checkBridgeIsRunning() const
+{
+    try
+    {
+        ReadWriteBufferFromHTTP buf(
+            getPingURI(), Poco::Net::HTTPRequest::HTTP_GET, {}, ConnectionTimeouts::getHTTPTimeouts(getContext()));
+        return checkString(PING_OK_ANSWER, buf);
+    }
+    catch (...)
+    {
+        return false;
+    }
+}
+
+
+void IBridgeHelper::startBridgeSync() const
+{
+    if (!checkBridgeIsRunning())
+    {
+        LOG_TRACE(getLog(), "{} is not running, will try to start it", serviceAlias());
+        startBridge(startBridgeCommand());
+        bool started = false;
+
+        uint64_t milliseconds_to_wait = 10; /// Exponential backoff
+        uint64_t counter = 0;
+
+        while (milliseconds_to_wait < 10000)
+        {
+            ++counter;
+            LOG_TRACE(getLog(), "Checking {} is running, try {}", serviceAlias(), counter);
+
+            if (checkBridgeIsRunning())
+            {
+                started = true;
+                break;
+            }
+
+            std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds_to_wait));
+            milliseconds_to_wait *= 2;
+        }
+
+        if (!started)
+            throw Exception("BridgeHelper: " + serviceAlias() + " is not responding",
+                ErrorCodes::EXTERNAL_SERVER_IS_NOT_RESPONDING);
+    }
+}
+
+
+std::unique_ptr<ShellCommand> IBridgeHelper::startBridgeCommand() const
+{
+    if (startBridgeManually())
+        throw Exception(serviceAlias() + " is not running. Please, start it manually", ErrorCodes::EXTERNAL_SERVER_IS_NOT_RESPONDING);
+
+    const auto & config = getConfig();
+    /// Path to executable folder
+    Poco::Path path{config.getString("application.dir", "/usr/bin")};
+
+    std::vector<std::string> cmd_args;
+    path.setFileName(serviceFileName());
+
+    cmd_args.push_back("--http-port");
+    cmd_args.push_back(std::to_string(config.getUInt(configPrefix() + ".port", getDefaultPort())));
+    cmd_args.push_back("--listen-host");
+    cmd_args.push_back(config.getString(configPrefix() + ".listen_host", DEFAULT_HOST));
+    cmd_args.push_back("--http-timeout");
+    cmd_args.push_back(std::to_string(getHTTPTimeout().totalMicroseconds()));
+    if (config.has("logger." + configPrefix() + "_log"))
+    {
+        cmd_args.push_back("--log-path");
+        cmd_args.push_back(config.getString("logger." + configPrefix() + "_log"));
+    }
+    if (config.has("logger." + configPrefix() + "_errlog"))
+    {
+        cmd_args.push_back("--err-log-path");
+        cmd_args.push_back(config.getString("logger." + configPrefix() + "_errlog"));
+    }
+    if (config.has("logger." + configPrefix() + "_stdout"))
+    {
+        cmd_args.push_back("--stdout-path");
+        cmd_args.push_back(config.getString("logger." + configPrefix() + "_stdout"));
+    }
+    if (config.has("logger." + configPrefix() + "_stderr"))
+    {
+        cmd_args.push_back("--stderr-path");
+        cmd_args.push_back(config.getString("logger." + configPrefix() + "_stderr"));
+    }
+    if (config.has("logger." + configPrefix() + "_level"))
+    {
+        cmd_args.push_back("--log-level");
+        cmd_args.push_back(config.getString("logger." + configPrefix() + "_level"));
+    }
+
+    LOG_TRACE(getLog(), "Starting {}", serviceAlias());
+
+    return ShellCommand::executeDirect(path.toString(), cmd_args, ShellCommandDestructorStrategy(true));
+}
+
+}
diff --git a/src/Bridge/IBridgeHelper.h b/src/Bridge/IBridgeHelper.h
new file mode 100644
index 00000000000..3473e24047e
--- /dev/null
+++ b/src/Bridge/IBridgeHelper.h
@@ -0,0 +1,69 @@
+#pragma once
+
+#include <Interpreters/Context.h>
+#include <Poco/Logger.h>
+#include <Poco/Util/AbstractConfiguration.h>
+#include <Poco/Net/HTTPRequest.h>
+#include <Common/ShellCommand.h>
+#include <IO/ConnectionTimeoutsContext.h>
+#include <common/logger_useful.h>
+
+
+namespace DB
+{
+
+/// Common base class for XDBC and Library bridge helpers.
+/// Contains helper methods to check/start bridge sync.
+class IBridgeHelper: protected WithContext
+{
+
+public:
+    static constexpr inline auto DEFAULT_HOST = "127.0.0.1";
+    static constexpr inline auto PING_HANDLER = "/ping";
+    static constexpr inline auto MAIN_HANDLER = "/";
+    static constexpr inline auto DEFAULT_FORMAT = "RowBinary";
+    static constexpr inline auto PING_OK_ANSWER = "Ok.";
+
+    static const inline std::string PING_METHOD = Poco::Net::HTTPRequest::HTTP_GET;
+    static const inline std::string MAIN_METHOD = Poco::Net::HTTPRequest::HTTP_POST;
+
+    explicit IBridgeHelper(ContextPtr context_) : WithContext(context_) {}
+    virtual ~IBridgeHelper() = default;
+
+    void startBridgeSync() const;
+
+    Poco::URI getMainURI() const;
+
+    Poco::URI getPingURI() const;
+
+
+protected:
+    /// clickhouse-odbc-bridge, clickhouse-library-bridge
+    virtual String serviceAlias() const = 0;
+
+    virtual String serviceFileName() const = 0;
+
+    virtual size_t getDefaultPort() const = 0;
+
+    virtual bool startBridgeManually() const = 0;
+
+    virtual void startBridge(std::unique_ptr<ShellCommand> cmd) const = 0;
+
+    virtual String configPrefix() const = 0;
+
+    virtual const Poco::Util::AbstractConfiguration & getConfig() const = 0;
+
+    virtual Poco::Logger * getLog() const = 0;
+
+    virtual const Poco::Timespan & getHTTPTimeout() const = 0;
+
+    virtual Poco::URI createBaseURI() const = 0;
+
+
+private:
+    bool checkBridgeIsRunning() const;
+
+    std::unique_ptr<ShellCommand> startBridgeCommand() const;
+};
+
+}
diff --git a/src/Bridge/LibraryBridgeHelper.cpp b/src/Bridge/LibraryBridgeHelper.cpp
new file mode 100644
index 00000000000..3ab01e18b11
--- /dev/null
+++ b/src/Bridge/LibraryBridgeHelper.cpp
@@ -0,0 +1,182 @@
+#include "LibraryBridgeHelper.h"
+
+#include <IO/ReadHelpers.h>
+#include <DataStreams/OneBlockInputStream.h>
+#include <DataStreams/OwningBlockInputStream.h>
+#include <Dictionaries/DictionarySourceHelpers.h>
+#include <Processors/Formats/InputStreamFromInputFormat.h>
+#include <IO/WriteBufferFromOStream.h>
+#include <IO/WriteBufferFromString.h>
+#include <Formats/FormatFactory.h>
+#include <Poco/Path.h>
+#include <Poco/Util/AbstractConfiguration.h>
+#include <Common/ShellCommand.h>
+#include <common/logger_useful.h>
+#include <ext/range.h>
+#include <Core/Field.h>
+#include <Common/escapeForFileName.h>
+
+
+namespace DB
+{
+
+LibraryBridgeHelper::LibraryBridgeHelper(
+        ContextPtr context_,
+        const Block & sample_block_,
+        const Field & dictionary_id_)
+    : IBridgeHelper(context_)
+    , log(&Poco::Logger::get("LibraryBridgeHelper"))
+    , sample_block(sample_block_)
+    , config(context_->getConfigRef())
+    , http_timeout(context_->getSettingsRef().http_receive_timeout.value.totalSeconds())
+    , dictionary_id(dictionary_id_)
+{
+    bridge_port = config.getUInt("library_bridge.port", DEFAULT_PORT);
+    bridge_host = config.getString("library_bridge.host", DEFAULT_HOST);
+}
+
+
+Poco::URI LibraryBridgeHelper::createRequestURI(const String & method) const
+{
+    auto uri = getMainURI();
+    uri.addQueryParameter("dictionary_id", toString(dictionary_id));
+    uri.addQueryParameter("method", method);
+    return uri;
+}
+
+
+Poco::URI LibraryBridgeHelper::createBaseURI() const
+{
+    Poco::URI uri;
+    uri.setHost(bridge_host);
+    uri.setPort(bridge_port);
+    uri.setScheme("http");
+    return uri;
+}
+
+
+void LibraryBridgeHelper::startBridge(std::unique_ptr<ShellCommand> cmd) const
+{
+    getContext()->addBridgeCommand(std::move(cmd));
+}
+
+
+bool LibraryBridgeHelper::initLibrary(const std::string & library_path, const std::string library_settings, const std::string attributes_names)
+{
+    startBridgeSync();
+    auto uri = createRequestURI(LIB_NEW_METHOD);
+
+    /// Sample block must contain null values
+    WriteBufferFromOwnString out;
+    auto output_stream = getContext()->getOutputStream(LibraryBridgeHelper::DEFAULT_FORMAT, out, sample_block);
+    formatBlock(output_stream, sample_block);
+    auto block_string = out.str();
+
+    auto out_stream_callback = [library_path, library_settings, attributes_names, block_string, this](std::ostream & os)
+    {
+        os << "library_path=" << escapeForFileName(library_path) << "&";
+        os << "library_settings=" << escapeForFileName(library_settings) << "&";
+        os << "attributes_names=" << escapeForFileName(attributes_names) << "&";
+        os << "sample_block=" << escapeForFileName(sample_block.getNamesAndTypesList().toString()) << "&";
+        os << "null_values=" << escapeForFileName(block_string);
+    };
+    return executeRequest(uri, out_stream_callback);
+}
+
+
+bool LibraryBridgeHelper::cloneLibrary(const Field & other_dictionary_id)
+{
+    startBridgeSync();
+    auto uri = createRequestURI(LIB_CLONE_METHOD);
+    uri.addQueryParameter("from_dictionary_id", toString(other_dictionary_id));
+    return executeRequest(uri);
+}
+
+
+bool LibraryBridgeHelper::removeLibrary()
+{
+    startBridgeSync();
+    auto uri = createRequestURI(LIB_DELETE_METHOD);
+    return executeRequest(uri);
+}
+
+
+bool LibraryBridgeHelper::isModified()
+{
+    startBridgeSync();
+    auto uri = createRequestURI(IS_MODIFIED_METHOD);
+    return executeRequest(uri);
+}
+
+
+bool LibraryBridgeHelper::supportsSelectiveLoad()
+{
+    startBridgeSync();
+    auto uri = createRequestURI(SUPPORTS_SELECTIVE_LOAD_METHOD);
+    return executeRequest(uri);
+}
+
+
+BlockInputStreamPtr LibraryBridgeHelper::loadAll()
+{
+    startBridgeSync();
+    auto uri = createRequestURI(LOAD_ALL_METHOD);
+    return loadBase(uri);
+}
+
+
+BlockInputStreamPtr LibraryBridgeHelper::loadIds(const std::string ids_string)
+{
+    startBridgeSync();
+    auto uri = createRequestURI(LOAD_IDS_METHOD);
+    return loadBase(uri, [ids_string](std::ostream & os) { os << "ids=" << ids_string; });
+}
+
+
+BlockInputStreamPtr LibraryBridgeHelper::loadKeys(const Block & requested_block)
+{
+    startBridgeSync();
+    auto uri = createRequestURI(LOAD_KEYS_METHOD);
+    /// Sample block to parse block from callback
+    uri.addQueryParameter("requested_block_sample", requested_block.getNamesAndTypesList().toString());
+    ReadWriteBufferFromHTTP::OutStreamCallback out_stream_callback = [requested_block, this](std::ostream & os)
+    {
+        WriteBufferFromOStream out_buffer(os);
+        auto output_stream = getContext()->getOutputStream(LibraryBridgeHelper::DEFAULT_FORMAT, out_buffer, sample_block);
+        formatBlock(output_stream, requested_block);
+    };
+    return loadBase(uri, out_stream_callback);
+}
+
+
+bool LibraryBridgeHelper::executeRequest(const Poco::URI & uri, ReadWriteBufferFromHTTP::OutStreamCallback out_stream_callback)
+{
+    ReadWriteBufferFromHTTP buf(
+        uri,
+        Poco::Net::HTTPRequest::HTTP_POST,
+        std::move(out_stream_callback),
+        ConnectionTimeouts::getHTTPTimeouts(getContext()));
+
+    bool res;
+    readBoolText(res, buf);
+    return res;
+}
+
+
+BlockInputStreamPtr LibraryBridgeHelper::loadBase(const Poco::URI & uri, ReadWriteBufferFromHTTP::OutStreamCallback out_stream_callback)
+{
+    auto read_buf_ptr = std::make_unique<ReadWriteBufferFromHTTP>(
+        uri,
+        Poco::Net::HTTPRequest::HTTP_POST,
+        std::move(out_stream_callback),
+        ConnectionTimeouts::getHTTPTimeouts(getContext()),
+        0,
+        Poco::Net::HTTPBasicCredentials{},
+        DBMS_DEFAULT_BUFFER_SIZE,
+        ReadWriteBufferFromHTTP::HTTPHeaderEntries{});
+
+    auto input_stream = getContext()->getInputFormat(LibraryBridgeHelper::DEFAULT_FORMAT, *read_buf_ptr, sample_block, DEFAULT_BLOCK_SIZE);
+    return std::make_shared<OwningBlockInputStream<ReadWriteBufferFromHTTP>>(input_stream, std::move(read_buf_ptr));
+}
+
+}
diff --git a/src/Bridge/LibraryBridgeHelper.h b/src/Bridge/LibraryBridgeHelper.h
new file mode 100644
index 00000000000..dc3f9020e71
--- /dev/null
+++ b/src/Bridge/LibraryBridgeHelper.h
@@ -0,0 +1,86 @@
+#pragma once
+
+#include <Interpreters/Context.h>
+#include <IO/ReadWriteBufferFromHTTP.h>
+#include <Poco/Logger.h>
+#include <Poco/Net/HTTPRequest.h>
+#include <Poco/URI.h>
+#include <Bridge/IBridgeHelper.h>
+
+
+namespace DB
+{
+
+class LibraryBridgeHelper : public IBridgeHelper
+{
+
+public:
+    static constexpr inline size_t DEFAULT_PORT = 9012;
+
+    LibraryBridgeHelper(ContextPtr context_, const Block & sample_block, const Field & dictionary_id_);
+
+    bool initLibrary(const std::string & library_path, std::string library_settings, std::string attributes_names);
+
+    bool cloneLibrary(const Field & other_dictionary_id);
+
+    bool removeLibrary();
+
+    bool isModified();
+
+    bool supportsSelectiveLoad();
+
+    BlockInputStreamPtr loadAll();
+
+    BlockInputStreamPtr loadIds(std::string ids_string);
+
+    BlockInputStreamPtr loadKeys(const Block & requested_block);
+
+    BlockInputStreamPtr loadBase(const Poco::URI & uri, ReadWriteBufferFromHTTP::OutStreamCallback out_stream_callback = {});
+
+    bool executeRequest(const Poco::URI & uri, ReadWriteBufferFromHTTP::OutStreamCallback out_stream_callback = {});
+
+
+protected:
+    void startBridge(std::unique_ptr<ShellCommand> cmd) const override;
+
+    String serviceAlias() const override { return "clickhouse-library-bridge"; }
+
+    String serviceFileName() const override { return serviceAlias(); }
+
+    size_t getDefaultPort() const override { return DEFAULT_PORT; }
+
+    bool startBridgeManually() const override { return false; }
+
+    String configPrefix() const override { return "library_bridge"; }
+
+    const Poco::Util::AbstractConfiguration & getConfig() const override { return config; }
+
+    Poco::Logger * getLog() const override { return log; }
+
+    const Poco::Timespan & getHTTPTimeout() const override { return http_timeout; }
+
+    Poco::URI createBaseURI() const override;
+
+private:
+    static constexpr inline auto LIB_NEW_METHOD = "libNew";
+    static constexpr inline auto LIB_CLONE_METHOD = "libClone";
+    static constexpr inline auto LIB_DELETE_METHOD = "libDelete";
+    static constexpr inline auto LOAD_ALL_METHOD = "loadAll";
+    static constexpr inline auto LOAD_IDS_METHOD = "loadIds";
+    static constexpr inline auto LOAD_KEYS_METHOD = "loadKeys";
+    static constexpr inline auto IS_MODIFIED_METHOD = "isModified";
+    static constexpr inline auto SUPPORTS_SELECTIVE_LOAD_METHOD = "supportsSelectiveLoad";
+
+    Poco::URI createRequestURI(const String & method) const;
+
+    Poco::Logger * log;
+    const Block sample_block;
+    const Poco::Util::AbstractConfiguration & config;
+    const Poco::Timespan http_timeout;
+
+    Field dictionary_id;
+    std::string bridge_host;
+    size_t bridge_port;
+};
+
+}
diff --git a/src/Bridge/XDBCBridgeHelper.h b/src/Bridge/XDBCBridgeHelper.h
new file mode 100644
index 00000000000..8a31171111d
--- /dev/null
+++ b/src/Bridge/XDBCBridgeHelper.h
@@ -0,0 +1,266 @@
+#pragma once
+
+#include <IO/ReadHelpers.h>
+#include <IO/ReadWriteBufferFromHTTP.h>
+#include <Interpreters/Context.h>
+#include <Access/AccessType.h>
+#include <Parsers/IdentifierQuotingStyle.h>
+#include <Poco/File.h>
+#include <Poco/Logger.h>
+#include <Poco/Net/HTTPRequest.h>
+#include <Poco/Path.h>
+#include <Poco/URI.h>
+#include <Poco/Util/AbstractConfiguration.h>
+#include <Common/ShellCommand.h>
+#include <IO/ConnectionTimeoutsContext.h>
+#include <common/logger_useful.h>
+#include <ext/range.h>
+#include <Bridge/IBridgeHelper.h>
+
+#if !defined(ARCADIA_BUILD)
+#    include <Common/config.h>
+#endif
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+}
+
+/// Class for Helpers for XDBC-bridges, provide utility methods, not main request.
+class IXDBCBridgeHelper : public IBridgeHelper
+{
+
+public:
+    explicit IXDBCBridgeHelper(ContextPtr context_) : IBridgeHelper(context_) {}
+
+    virtual std::vector<std::pair<std::string, std::string>> getURLParams(const std::string & cols, UInt64 max_block_size) const = 0;
+
+    virtual Poco::URI getColumnsInfoURI() const = 0;
+
+    virtual IdentifierQuotingStyle getIdentifierQuotingStyle() = 0;
+
+    virtual bool isSchemaAllowed() = 0;
+
+    virtual String getName() const = 0;
+};
+
+using BridgeHelperPtr = std::shared_ptr<IXDBCBridgeHelper>;
+
+
+template <typename BridgeHelperMixin>
+class XDBCBridgeHelper : public IXDBCBridgeHelper
+{
+
+public:
+    static constexpr inline auto DEFAULT_PORT = BridgeHelperMixin::DEFAULT_PORT;
+    static constexpr inline auto COL_INFO_HANDLER = "/columns_info";
+    static constexpr inline auto IDENTIFIER_QUOTE_HANDLER = "/identifier_quote";
+    static constexpr inline auto SCHEMA_ALLOWED_HANDLER = "/schema_allowed";
+
+    XDBCBridgeHelper(
+            ContextPtr global_context_,
+            const Poco::Timespan & http_timeout_,
+            const std::string & connection_string_)
+    : IXDBCBridgeHelper(global_context_)
+    , log(&Poco::Logger::get(BridgeHelperMixin::getName() + "BridgeHelper"))
+    , connection_string(connection_string_)
+    , http_timeout(http_timeout_)
+    , config(global_context_->getConfigRef())
+{
+    bridge_host = config.getString(BridgeHelperMixin::configPrefix() + ".host", DEFAULT_HOST);
+    bridge_port = config.getUInt(BridgeHelperMixin::configPrefix() + ".port", DEFAULT_PORT);
+}
+
+
+protected:
+    auto getConnectionString() const { return connection_string; }
+
+    String getName() const override { return BridgeHelperMixin::getName(); }
+
+    size_t getDefaultPort() const override { return DEFAULT_PORT; }
+
+    String serviceAlias() const override { return BridgeHelperMixin::serviceAlias(); }
+
+    /// Same for odbc and jdbc
+    String serviceFileName() const override { return "clickhouse-odbc-bridge"; }
+
+    String configPrefix() const override { return BridgeHelperMixin::configPrefix(); }
+
+    const Poco::Timespan & getHTTPTimeout() const override { return http_timeout; }
+
+    const Poco::Util::AbstractConfiguration & getConfig() const override { return config; }
+
+    Poco::Logger * getLog() const override { return log; }
+
+    bool startBridgeManually() const override { return BridgeHelperMixin::startBridgeManually(); }
+
+    Poco::URI createBaseURI() const override
+    {
+        Poco::URI uri;
+        uri.setHost(bridge_host);
+        uri.setPort(bridge_port);
+        uri.setScheme("http");
+        return uri;
+    }
+
+    void startBridge(std::unique_ptr<ShellCommand> cmd) const override
+    {
+        getContext()->addBridgeCommand(std::move(cmd));
+    }
+
+
+private:
+    using Configuration = Poco::Util::AbstractConfiguration;
+
+    Poco::Logger * log;
+    std::string connection_string;
+    const Poco::Timespan & http_timeout;
+    std::string bridge_host;
+    size_t bridge_port;
+
+    const Configuration & config;
+
+    std::optional<IdentifierQuotingStyle> quote_style;
+    std::optional<bool> is_schema_allowed;
+
+
+protected:
+    using URLParams = std::vector<std::pair<std::string, std::string>>;
+
+    Poco::URI getColumnsInfoURI() const override
+    {
+        auto uri = createBaseURI();
+        uri.setPath(COL_INFO_HANDLER);
+        return uri;
+    }
+
+    URLParams getURLParams(const std::string & cols, UInt64 max_block_size) const override
+    {
+        std::vector<std::pair<std::string, std::string>> result;
+
+        result.emplace_back("connection_string", connection_string); /// already validated
+        result.emplace_back("columns", cols);
+        result.emplace_back("max_block_size", std::to_string(max_block_size));
+
+        return result;
+    }
+
+    bool isSchemaAllowed() override
+    {
+        if (!is_schema_allowed.has_value())
+        {
+            startBridgeSync();
+
+            auto uri = createBaseURI();
+            uri.setPath(SCHEMA_ALLOWED_HANDLER);
+            uri.addQueryParameter("connection_string", getConnectionString());
+
+            ReadWriteBufferFromHTTP buf(uri, Poco::Net::HTTPRequest::HTTP_POST, {}, ConnectionTimeouts::getHTTPTimeouts(getContext()));
+
+            bool res;
+            readBoolText(res, buf);
+            is_schema_allowed = res;
+        }
+
+        return *is_schema_allowed;
+    }
+
+    IdentifierQuotingStyle getIdentifierQuotingStyle() override
+    {
+        if (!quote_style.has_value())
+        {
+            startBridgeSync();
+
+            auto uri = createBaseURI();
+            uri.setPath(IDENTIFIER_QUOTE_HANDLER);
+            uri.addQueryParameter("connection_string", getConnectionString());
+
+            ReadWriteBufferFromHTTP buf(uri, Poco::Net::HTTPRequest::HTTP_POST, {}, ConnectionTimeouts::getHTTPTimeouts(getContext()));
+
+            std::string character;
+            readStringBinary(character, buf);
+            if (character.length() > 1)
+                throw Exception(
+                    "Failed to parse quoting style from '" + character + "' for service " + BridgeHelperMixin::serviceAlias(),
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            else if (character.length() == 0)
+                quote_style = IdentifierQuotingStyle::None;
+            else if (character[0] == '`')
+                quote_style = IdentifierQuotingStyle::Backticks;
+            else if (character[0] == '"')
+                quote_style = IdentifierQuotingStyle::DoubleQuotes;
+            else
+                throw Exception("Can not map quote identifier '" + character + "' to enum value", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        }
+
+        return *quote_style;
+    }
+};
+
+
+struct JDBCBridgeMixin
+{
+    static constexpr inline auto DEFAULT_PORT = 9019;
+
+    static String configPrefix()
+    {
+        return "jdbc_bridge";
+    }
+
+    static String serviceAlias()
+    {
+        return "clickhouse-jdbc-bridge";
+    }
+
+    static String getName()
+    {
+        return "JDBC";
+    }
+
+    static AccessType getSourceAccessType()
+    {
+        return AccessType::JDBC;
+    }
+
+    static bool startBridgeManually()
+    {
+        return true;
+    }
+};
+
+
+struct ODBCBridgeMixin
+{
+    static constexpr inline auto DEFAULT_PORT = 9018;
+
+    static String configPrefix()
+    {
+        return "odbc_bridge";
+    }
+
+    static String serviceAlias()
+    {
+        return "clickhouse-odbc-bridge";
+    }
+
+    static String getName()
+    {
+        return "ODBC";
+    }
+
+    static AccessType getSourceAccessType()
+    {
+        return AccessType::ODBC;
+    }
+
+    static bool startBridgeManually()
+    {
+        return false;
+    }
+};
+
+}
diff --git a/src/Bridge/ya.make b/src/Bridge/ya.make
new file mode 100644
index 00000000000..e900bab036e
--- /dev/null
+++ b/src/Bridge/ya.make
@@ -0,0 +1,17 @@
+# This file is generated automatically, do not edit. See 'ya.make.in' and use 'utils/generate-ya-make' to regenerate it.
+OWNER(g:clickhouse)
+
+LIBRARY()
+
+PEERDIR(
+    clickhouse/src/Common
+)
+
+
+SRCS(
+    IBridgeHelper.cpp
+    LibraryBridgeHelper.cpp
+
+)
+
+END()
diff --git a/src/Bridge/ya.make.in b/src/Bridge/ya.make.in
new file mode 100644
index 00000000000..01edf8dca82
--- /dev/null
+++ b/src/Bridge/ya.make.in
@@ -0,0 +1,14 @@
+OWNER(g:clickhouse)
+
+LIBRARY()
+
+PEERDIR(
+    clickhouse/src/Common
+)
+
+
+SRCS(
+<? find . -name '*.cpp' | grep -v -F tests | sed 's/^\.\//    /' | sort ?>
+)
+
+END()
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index a41ddada5a9..43f6ae8fea5 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -190,6 +190,7 @@ add_object_library(clickhouse_storages_distributed Storages/Distributed)
 add_object_library(clickhouse_storages_mergetree Storages/MergeTree)
 add_object_library(clickhouse_storages_liveview Storages/LiveView)
 add_object_library(clickhouse_client Client)
+add_object_library(clickhouse_bridge Bridge)
 add_object_library(clickhouse_server Server)
 add_object_library(clickhouse_server_http Server/HTTP)
 add_object_library(clickhouse_formats Formats)
@@ -507,5 +508,10 @@ if (ENABLE_TESTS AND USE_GTEST)
         clickhouse_common_zookeeper
         string_utils)
 
+    # For __udivmodti4 referenced in Core/tests/gtest_DecimalFunctions.cpp
+    if (OS_DARWIN AND COMPILER_GCC)
+        target_link_libraries(unit_tests_dbms PRIVATE gcc)
+    endif ()
+
     add_check(unit_tests_dbms)
 endif ()
diff --git a/src/Client/Connection.h b/src/Client/Connection.h
index 7e3b9b7ab61..65ed956a60b 100644
--- a/src/Client/Connection.h
+++ b/src/Client/Connection.h
@@ -21,6 +21,7 @@
 #include <IO/ReadBufferFromPocoSocket.h>
 
 #include <Interpreters/TablesStatus.h>
+#include <Interpreters/Context_fwd.h>
 
 #include <Compression/ICompressionCodec.h>
 
@@ -52,8 +53,6 @@ class Connection;
 using ConnectionPtr = std::shared_ptr<Connection>;
 using Connections = std::vector<ConnectionPtr>;
 
-using Scalars = std::map<String, Block>;
-
 
 /// Packet that could be received from server.
 struct Packet
@@ -111,7 +110,7 @@ public:
         setDescription();
     }
 
-    virtual ~Connection() {}
+    virtual ~Connection() = default;
 
     /// Set throttler of network traffic. One throttler could be used for multiple connections to limit total traffic.
     void setThrottler(const ThrottlerPtr & throttler_)
diff --git a/src/Client/HedgedConnectionsFactory.cpp b/src/Client/HedgedConnectionsFactory.cpp
index 695b2e34fd6..b0c5a3d22f5 100644
--- a/src/Client/HedgedConnectionsFactory.cpp
+++ b/src/Client/HedgedConnectionsFactory.cpp
@@ -55,7 +55,7 @@ std::vector<Connection *> HedgedConnectionsFactory::getManyConnections(PoolMode
 {
     size_t min_entries = (settings && settings->skip_unavailable_shards) ? 0 : 1;
 
-    size_t max_entries;
+    size_t max_entries = 1;
     switch (pool_mode)
     {
         case PoolMode::GET_ALL:
diff --git a/src/Columns/ColumnAggregateFunction.cpp b/src/Columns/ColumnAggregateFunction.cpp
index df7b3cce729..8178802f3bd 100644
--- a/src/Columns/ColumnAggregateFunction.cpp
+++ b/src/Columns/ColumnAggregateFunction.cpp
@@ -162,7 +162,7 @@ MutableColumnPtr ColumnAggregateFunction::convertToValues(MutableColumnPtr colum
     return res;
 }
 
-MutableColumnPtr ColumnAggregateFunction::predictValues(const ColumnsWithTypeAndName & arguments, const Context & context) const
+MutableColumnPtr ColumnAggregateFunction::predictValues(const ColumnsWithTypeAndName & arguments, ContextPtr context) const
 {
     MutableColumnPtr res = func->getReturnTypeToPredict()->createColumn();
     res->reserve(data.size());
diff --git a/src/Columns/ColumnAggregateFunction.h b/src/Columns/ColumnAggregateFunction.h
index 5cb9aaa4ad5..8eb1a04b174 100644
--- a/src/Columns/ColumnAggregateFunction.h
+++ b/src/Columns/ColumnAggregateFunction.h
@@ -82,7 +82,7 @@ private:
     /// Name of the type to distinguish different aggregation states.
     String type_string;
 
-    ColumnAggregateFunction() {}
+    ColumnAggregateFunction() = default;
 
     /// Create a new column that has another column as a source.
     MutablePtr createView() const;
@@ -119,7 +119,7 @@ public:
     const char * getFamilyName() const override { return "AggregateFunction"; }
     TypeIndex getDataType() const override { return TypeIndex::AggregateFunction; }
 
-    MutableColumnPtr predictValues(const ColumnsWithTypeAndName & arguments, const Context & context) const;
+    MutableColumnPtr predictValues(const ColumnsWithTypeAndName & arguments, ContextPtr context) const;
 
     size_t size() const override
     {
diff --git a/src/Common/Arena.h b/src/Common/Arena.h
index 0f4f0420c38..4d14c15197d 100644
--- a/src/Common/Arena.h
+++ b/src/Common/Arena.h
@@ -128,7 +128,7 @@ private:
     template <size_t> friend class AlignedArenaAllocator;
 
 public:
-    Arena(size_t initial_size_ = 4096, size_t growth_factor_ = 2, size_t linear_growth_threshold_ = 128 * 1024 * 1024)
+    explicit Arena(size_t initial_size_ = 4096, size_t growth_factor_ = 2, size_t linear_growth_threshold_ = 128 * 1024 * 1024)
         : growth_factor(growth_factor_), linear_growth_threshold(linear_growth_threshold_),
         head(new MemoryChunk(initial_size_, nullptr)), size_in_bytes(head->size()),
         page_size(static_cast<size_t>(::getPageSize()))
@@ -160,7 +160,7 @@ public:
             void * head_pos = head->pos;
             size_t space = head->end - head->pos;
 
-            auto res = static_cast<char *>(std::align(alignment, size, head_pos, space));
+            auto * res = static_cast<char *>(std::align(alignment, size, head_pos, space));
             if (res)
             {
                 head->pos = static_cast<char *>(head_pos);
diff --git a/src/Common/Config/AbstractConfigurationComparison.cpp b/src/Common/Config/AbstractConfigurationComparison.cpp
index 59c0c895a89..eb677debb02 100644
--- a/src/Common/Config/AbstractConfigurationComparison.cpp
+++ b/src/Common/Config/AbstractConfigurationComparison.cpp
@@ -1,4 +1,5 @@
 #include <Common/Config/AbstractConfigurationComparison.h>
+#include <Common/getMultipleKeysFromConfig.h>
 
 #include <unordered_set>
 #include <common/StringRef.h>
@@ -31,6 +32,23 @@ bool isSameConfiguration(const Poco::Util::AbstractConfiguration & left, const P
     return isSameConfiguration(left, key, right, key);
 }
 
+bool isSameConfigurationWithMultipleKeys(const Poco::Util::AbstractConfiguration & left, const Poco::Util::AbstractConfiguration & right, const String & root, const String & name)
+{
+    if (&left == &right)
+        return true;
+
+    auto left_multiple_keys = getMultipleKeysFromConfig(left, root, name);
+    auto right_multiple_keys = getMultipleKeysFromConfig(right, root, name);
+    if (left_multiple_keys.size() != right_multiple_keys.size())
+        return false;
+
+    for (auto & key : left_multiple_keys)
+        if (!isSameConfiguration(left, right, concatKeyAndSubKey(root, key)))
+            return false;
+
+    return true;
+}
+
 bool isSameConfiguration(const Poco::Util::AbstractConfiguration & left, const String & left_key,
                          const Poco::Util::AbstractConfiguration & right, const String & right_key)
 {
diff --git a/src/Common/Config/AbstractConfigurationComparison.h b/src/Common/Config/AbstractConfigurationComparison.h
index 795fca2af8e..6e1d8a890bb 100644
--- a/src/Common/Config/AbstractConfigurationComparison.h
+++ b/src/Common/Config/AbstractConfigurationComparison.h
@@ -13,6 +13,17 @@ namespace DB
     bool isSameConfiguration(const Poco::Util::AbstractConfiguration & left,
                              const Poco::Util::AbstractConfiguration & right);
 
+    /// Config may have multiple keys with one name. For example:
+    /// <root>
+    ///     <some_key>...</some_key>
+    ///     <some_key>...</some_key>
+    /// </root>
+    /// Returns true if the specified subview of the two configurations contains
+    /// the same keys and values for each key with the given name.
+    bool isSameConfigurationWithMultipleKeys(const Poco::Util::AbstractConfiguration & left,
+                                             const Poco::Util::AbstractConfiguration & right,
+                                             const String & root, const String & name);
+
     /// Returns true if the specified subview of the two configurations contains the same keys and values.
     bool isSameConfiguration(const Poco::Util::AbstractConfiguration & left,
                              const Poco::Util::AbstractConfiguration & right,
diff --git a/src/Common/CurrentThread.h b/src/Common/CurrentThread.h
index 7ab57ea7fab..069f9cf2af7 100644
--- a/src/Common/CurrentThread.h
+++ b/src/Common/CurrentThread.h
@@ -1,11 +1,12 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
+#include <Common/ThreadStatus.h>
+#include <common/StringRef.h>
+
 #include <memory>
 #include <string>
 
-#include <common/StringRef.h>
-#include <Common/ThreadStatus.h>
-
 
 namespace ProfileEvents
 {
@@ -18,7 +19,6 @@ class MemoryTracker;
 namespace DB
 {
 
-class Context;
 class QueryStatus;
 struct Progress;
 class InternalTextLogsQueue;
@@ -87,7 +87,7 @@ public:
     /// Initializes query with current thread as master thread in constructor, and detaches it in destructor
     struct QueryScope
     {
-        explicit QueryScope(Context & query_context);
+        explicit QueryScope(ContextPtr query_context);
         ~QueryScope();
 
         void logPeakMemoryUsage();
@@ -99,7 +99,7 @@ private:
 
     /// Sets query_context for current thread group
     /// Can by used only through QueryScope
-    static void attachQueryContext(Context & query_context);
+    static void attachQueryContext(ContextPtr query_context);
 };
 
 }
diff --git a/src/Common/ErrorCodes.cpp b/src/Common/ErrorCodes.cpp
index 0f85ad5c792..ad0463db889 100644
--- a/src/Common/ErrorCodes.cpp
+++ b/src/Common/ErrorCodes.cpp
@@ -548,6 +548,7 @@
     M(578, INVALID_FORMAT_INSERT_QUERY_WITH_DATA) \
     M(579, INCORRECT_PART_TYPE) \
     M(580, CANNOT_SET_ROUNDING_MODE) \
+    M(581, TOO_LARGE_DISTRIBUTED_DEPTH) \
     \
     M(998, POSTGRESQL_CONNECTION_FAILURE) \
     M(999, KEEPER_EXCEPTION) \
@@ -590,7 +591,7 @@ namespace ErrorCodes
 
     void increment(ErrorCode error_code, bool remote, const std::string & message, const FramePointers & trace)
     {
-        if (error_code >= end())
+        if (error_code < 0 || error_code >= end())
         {
             /// For everything outside the range, use END.
             /// (end() is the pointer pass the end, while END is the last value that has an element in values array).
diff --git a/src/Common/FieldVisitors.h b/src/Common/FieldVisitors.h
index 954cd004e84..5adbf2b01ac 100644
--- a/src/Common/FieldVisitors.h
+++ b/src/Common/FieldVisitors.h
@@ -185,12 +185,20 @@ public:
                 /// Conversion of infinite values to integer is undefined.
                 throw Exception("Cannot convert infinite value to integer type", ErrorCodes::CANNOT_CONVERT_TYPE);
             }
+            else if (x > std::numeric_limits<T>::max() || x < std::numeric_limits<T>::lowest())
+            {
+                throw Exception("Cannot convert out of range floating point value to integer type", ErrorCodes::CANNOT_CONVERT_TYPE);
+            }
         }
 
         if constexpr (std::is_same_v<Decimal256, T>)
+        {
             return Int256(x);
+        }
         else
+        {
             return T(x);
+        }
     }
 
     T operator() (const UInt128 &) const
diff --git a/src/Common/HashTable/HashMap.h b/src/Common/HashTable/HashMap.h
index c3cd09eccb2..50324fe64c7 100644
--- a/src/Common/HashTable/HashMap.h
+++ b/src/Common/HashTable/HashMap.h
@@ -24,17 +24,26 @@ struct PairNoInit
 
     PairNoInit() {}
 
-    template <typename First_>
-    PairNoInit(First_ && first_, NoInitTag) : first(std::forward<First_>(first_))
+    template <typename FirstValue>
+    PairNoInit(FirstValue && first_, NoInitTag)
+        : first(std::forward<FirstValue>(first_))
     {
     }
 
-    template <typename First_, typename Second_>
-    PairNoInit(First_ && first_, Second_ && second_) : first(std::forward<First_>(first_)), second(std::forward<Second_>(second_))
+    template <typename FirstValue, typename SecondValue>
+    PairNoInit(FirstValue && first_, SecondValue && second_)
+        : first(std::forward<FirstValue>(first_))
+        , second(std::forward<SecondValue>(second_))
     {
     }
 };
 
+template <typename First, typename Second>
+PairNoInit<std::decay_t<First>, std::decay_t<Second>> makePairNoInit(First && first, Second && second)
+{
+    return PairNoInit<std::decay_t<First>, std::decay_t<Second>>(std::forward<First>(first), std::forward<Second>(second));
+}
+
 
 template <typename Key, typename TMapped, typename Hash, typename TState = HashTableNoState>
 struct HashMapCell
diff --git a/src/Common/ProfileEvents.cpp b/src/Common/ProfileEvents.cpp
index 35703790d82..d0876c5e69c 100644
--- a/src/Common/ProfileEvents.cpp
+++ b/src/Common/ProfileEvents.cpp
@@ -146,6 +146,8 @@
     M(StorageBufferPassedTimeMaxThreshold, "") \
     M(StorageBufferPassedRowsMaxThreshold, "") \
     M(StorageBufferPassedBytesMaxThreshold, "") \
+    M(StorageBufferLayerLockReadersWaitMilliseconds, "Time for waiting for Buffer layer during reading") \
+    M(StorageBufferLayerLockWritersWaitMilliseconds, "Time for waiting free Buffer layer to write to (can be used to tune Buffer layers)") \
     \
     M(DictCacheKeysRequested, "") \
     M(DictCacheKeysRequestedMiss, "") \
diff --git a/src/Common/StackTrace.h b/src/Common/StackTrace.h
index 35df77b6b8a..ef90a0d587d 100644
--- a/src/Common/StackTrace.h
+++ b/src/Common/StackTrace.h
@@ -11,7 +11,9 @@
 
 #ifdef __APPLE__
 // ucontext is not available without _XOPEN_SOURCE
-#   pragma clang diagnostic ignored "-Wreserved-id-macro"
+#   ifdef __clang__
+#       pragma clang diagnostic ignored "-Wreserved-id-macro"
+#   endif
 #   define _XOPEN_SOURCE 700
 #endif
 #include <ucontext.h>
diff --git a/src/Common/ThreadStatus.cpp b/src/Common/ThreadStatus.cpp
index 8c01ed2d46f..1493d30ea01 100644
--- a/src/Common/ThreadStatus.cpp
+++ b/src/Common/ThreadStatus.cpp
@@ -101,7 +101,8 @@ ThreadStatus::~ThreadStatus()
 
 #if !defined(ARCADIA_BUILD)
     /// It may cause segfault if query_context was destroyed, but was not detached
-    assert((!query_context && query_id.empty()) || (query_context && query_id == query_context->getCurrentQueryId()));
+    auto query_context_ptr = query_context.lock();
+    assert((!query_context_ptr && query_id.empty()) || (query_context_ptr && query_id == query_context_ptr->getCurrentQueryId()));
 #endif
 
     if (deleter)
diff --git a/src/Common/ThreadStatus.h b/src/Common/ThreadStatus.h
index dc5f09c5f3d..3b39e462fa6 100644
--- a/src/Common/ThreadStatus.h
+++ b/src/Common/ThreadStatus.h
@@ -1,20 +1,20 @@
 #pragma once
 
-#include <common/StringRef.h>
-#include <Common/ProfileEvents.h>
+#include <Core/SettingsEnums.h>
+#include <Interpreters/Context_fwd.h>
+#include <IO/Progress.h>
 #include <Common/MemoryTracker.h>
 #include <Common/OpenTelemetryTraceContext.h>
+#include <Common/ProfileEvents.h>
+#include <common/StringRef.h>
 
-#include <Core/SettingsEnums.h>
+#include <boost/noncopyable.hpp>
 
-#include <IO/Progress.h>
-
-#include <memory>
+#include <functional>
 #include <map>
+#include <memory>
 #include <mutex>
 #include <shared_mutex>
-#include <functional>
-#include <boost/noncopyable.hpp>
 
 
 namespace Poco
@@ -26,7 +26,6 @@ namespace Poco
 namespace DB
 {
 
-class Context;
 class QueryStatus;
 class ThreadStatus;
 class QueryProfilerReal;
@@ -58,8 +57,8 @@ public:
     ProfileEvents::Counters performance_counters{VariableContext::Process};
     MemoryTracker memory_tracker{VariableContext::Process};
 
-    Context * query_context = nullptr;
-    Context * global_context = nullptr;
+    ContextWeakPtr query_context;
+    ContextWeakPtr global_context;
 
     InternalTextLogsQueueWeakPtr logs_queue_ptr;
     std::function<void()> fatal_error_callback;
@@ -122,9 +121,9 @@ protected:
     std::atomic<int> thread_state{ThreadState::DetachedFromQuery};
 
     /// Is set once
-    Context * global_context = nullptr;
+    ContextWeakPtr global_context;
     /// Use it only from current thread
-    Context * query_context = nullptr;
+    ContextWeakPtr query_context;
 
     String query_id;
 
@@ -178,9 +177,9 @@ public:
         return query_id;
     }
 
-    const Context * getQueryContext() const
+    auto getQueryContext() const
     {
-        return query_context;
+        return query_context.lock();
     }
 
     /// Starts new query and create new thread group for it, current thread becomes master thread of the query
@@ -203,7 +202,7 @@ public:
 
     /// Sets query context for current master thread and its thread group
     /// NOTE: query_context have to be alive until detachQuery() is called
-    void attachQueryContext(Context & query_context);
+    void attachQueryContext(ContextPtr query_context);
 
     /// Update several ProfileEvents counters
     void updatePerformanceCounters();
diff --git a/src/Common/XDBCBridgeHelper.h b/src/Common/XDBCBridgeHelper.h
deleted file mode 100644
index 1e552157a56..00000000000
--- a/src/Common/XDBCBridgeHelper.h
+++ /dev/null
@@ -1,351 +0,0 @@
-#pragma once
-
-#include <IO/ReadHelpers.h>
-#include <IO/ReadWriteBufferFromHTTP.h>
-#include <Interpreters/Context.h>
-#include <Access/AccessType.h>
-#include <Parsers/IdentifierQuotingStyle.h>
-#include <Poco/File.h>
-#include <Poco/Logger.h>
-#include <Poco/Net/HTTPRequest.h>
-#include <Poco/Path.h>
-#include <Poco/URI.h>
-#include <Poco/Util/AbstractConfiguration.h>
-#include <Common/ShellCommand.h>
-#include <IO/ConnectionTimeoutsContext.h>
-#include <common/logger_useful.h>
-#include <ext/range.h>
-
-#if !defined(ARCADIA_BUILD)
-#    include <Common/config.h>
-#endif
-
-namespace DB
-{
-namespace ErrorCodes
-{
-    extern const int EXTERNAL_SERVER_IS_NOT_RESPONDING;
-    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
-}
-
-/**
- * Class for Helpers for Xdbc-bridges, provide utility methods, not main request
- */
-class IXDBCBridgeHelper
-{
-public:
-    static constexpr inline auto DEFAULT_FORMAT = "RowBinary";
-
-    virtual std::vector<std::pair<std::string, std::string>> getURLParams(const std::string & cols, UInt64 max_block_size) const = 0;
-    virtual void startBridgeSync() const = 0;
-    virtual Poco::URI getMainURI() const = 0;
-    virtual Poco::URI getColumnsInfoURI() const = 0;
-    virtual IdentifierQuotingStyle getIdentifierQuotingStyle() = 0;
-    virtual bool isSchemaAllowed() = 0;
-    virtual String getName() const = 0;
-
-    virtual ~IXDBCBridgeHelper() = default;
-};
-
-using BridgeHelperPtr = std::shared_ptr<IXDBCBridgeHelper>;
-
-template <typename BridgeHelperMixin>
-class XDBCBridgeHelper : public IXDBCBridgeHelper
-{
-private:
-    Poco::Timespan http_timeout;
-
-    std::string connection_string;
-
-    Poco::URI ping_url;
-
-    Poco::Logger * log = &Poco::Logger::get(BridgeHelperMixin::getName() + "BridgeHelper");
-
-    std::optional<IdentifierQuotingStyle> quote_style;
-    std::optional<bool> is_schema_allowed;
-
-protected:
-    auto getConnectionString() const
-    {
-        return connection_string;
-    }
-
-public:
-    using Configuration = Poco::Util::AbstractConfiguration;
-
-    const Context & context;
-    const Configuration & config;
-
-    static constexpr inline auto DEFAULT_HOST = "127.0.0.1";
-    static constexpr inline auto DEFAULT_PORT = BridgeHelperMixin::DEFAULT_PORT;
-    static constexpr inline auto PING_HANDLER = "/ping";
-    static constexpr inline auto MAIN_HANDLER = "/";
-    static constexpr inline auto COL_INFO_HANDLER = "/columns_info";
-    static constexpr inline auto IDENTIFIER_QUOTE_HANDLER = "/identifier_quote";
-    static constexpr inline auto SCHEMA_ALLOWED_HANDLER = "/schema_allowed";
-    static constexpr inline auto PING_OK_ANSWER = "Ok.";
-
-    XDBCBridgeHelper(const Context & global_context_, const Poco::Timespan & http_timeout_, const std::string & connection_string_)
-        : http_timeout(http_timeout_), connection_string(connection_string_), context(global_context_), config(context.getConfigRef())
-    {
-        size_t bridge_port = config.getUInt(BridgeHelperMixin::configPrefix() + ".port", DEFAULT_PORT);
-        std::string bridge_host = config.getString(BridgeHelperMixin::configPrefix() + ".host", DEFAULT_HOST);
-
-        ping_url.setHost(bridge_host);
-        ping_url.setPort(bridge_port);
-        ping_url.setScheme("http");
-        ping_url.setPath(PING_HANDLER);
-    }
-
-    String getName() const override
-    {
-        return BridgeHelperMixin::getName();
-    }
-
-    IdentifierQuotingStyle getIdentifierQuotingStyle() override
-    {
-        if (!quote_style.has_value())
-        {
-            startBridgeSync();
-
-            auto uri = createBaseURI();
-            uri.setPath(IDENTIFIER_QUOTE_HANDLER);
-            uri.addQueryParameter("connection_string", getConnectionString());
-
-            ReadWriteBufferFromHTTP buf(
-                uri, Poco::Net::HTTPRequest::HTTP_POST, {}, ConnectionTimeouts::getHTTPTimeouts(context));
-            std::string character;
-            readStringBinary(character, buf);
-            if (character.length() > 1)
-                throw Exception("Failed to parse quoting style from '" + character + "' for service " + BridgeHelperMixin::serviceAlias(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-            else if (character.length() == 0)
-                quote_style = IdentifierQuotingStyle::None;
-            else if (character[0] == '`')
-                quote_style = IdentifierQuotingStyle::Backticks;
-            else if (character[0] == '"')
-                quote_style = IdentifierQuotingStyle::DoubleQuotes;
-            else
-                throw Exception("Can not map quote identifier '" + character + "' to enum value", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-        }
-
-        return *quote_style;
-    }
-
-    bool isSchemaAllowed() override
-    {
-        if (!is_schema_allowed.has_value())
-        {
-            startBridgeSync();
-
-            auto uri = createBaseURI();
-            uri.setPath(SCHEMA_ALLOWED_HANDLER);
-            uri.addQueryParameter("connection_string", getConnectionString());
-
-            ReadWriteBufferFromHTTP buf(
-                uri, Poco::Net::HTTPRequest::HTTP_POST, {}, ConnectionTimeouts::getHTTPTimeouts(context));
-
-            bool res;
-            readBoolText(res, buf);
-            is_schema_allowed = res;
-        }
-
-        return *is_schema_allowed;
-    }
-
-    /**
-     * @todo leaky abstraction - used by external API's
-     */
-    std::vector<std::pair<std::string, std::string>> getURLParams(const std::string & cols, UInt64 max_block_size) const override
-    {
-        std::vector<std::pair<std::string, std::string>> result;
-
-        result.emplace_back("connection_string", connection_string); /// already validated
-        result.emplace_back("columns", cols);
-        result.emplace_back("max_block_size", std::to_string(max_block_size));
-
-        return result;
-    }
-
-    /**
-     * Performs spawn of external daemon
-     */
-    void startBridgeSync() const override
-    {
-        if (!checkBridgeIsRunning())
-        {
-            LOG_TRACE(log, "{} is not running, will try to start it", BridgeHelperMixin::serviceAlias());
-            startBridge();
-            bool started = false;
-
-            uint64_t milliseconds_to_wait = 10; /// Exponential backoff
-            uint64_t counter = 0;
-            while (milliseconds_to_wait < 10000)
-            {
-                ++counter;
-                LOG_TRACE(log, "Checking {} is running, try {}", BridgeHelperMixin::serviceAlias(), counter);
-                if (checkBridgeIsRunning())
-                {
-                    started = true;
-                    break;
-                }
-                std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds_to_wait));
-                milliseconds_to_wait *= 2;
-            }
-
-            if (!started)
-                throw Exception(BridgeHelperMixin::getName() + "BridgeHelper: " + BridgeHelperMixin::serviceAlias() + " is not responding",
-                    ErrorCodes::EXTERNAL_SERVER_IS_NOT_RESPONDING);
-        }
-    }
-
-    /**
-     * URI to fetch the data from external service
-     */
-    Poco::URI getMainURI() const override
-    {
-        auto uri = createBaseURI();
-        uri.setPath(MAIN_HANDLER);
-        return uri;
-    }
-
-    /**
-     * URI to retrieve column description from external service
-     */
-    Poco::URI getColumnsInfoURI() const override
-    {
-        auto uri = createBaseURI();
-        uri.setPath(COL_INFO_HANDLER);
-        return uri;
-    }
-
-protected:
-    Poco::URI createBaseURI() const
-    {
-        Poco::URI uri;
-        uri.setHost(ping_url.getHost());
-        uri.setPort(ping_url.getPort());
-        uri.setScheme("http");
-        return uri;
-    }
-
-private:
-    bool checkBridgeIsRunning() const
-    {
-        try
-        {
-            ReadWriteBufferFromHTTP buf(
-                ping_url, Poco::Net::HTTPRequest::HTTP_GET, {}, ConnectionTimeouts::getHTTPTimeouts(context));
-            return checkString(XDBCBridgeHelper::PING_OK_ANSWER, buf);
-        }
-        catch (...)
-        {
-            return false;
-        }
-    }
-
-    /* Contains logic for instantiation of the bridge instance */
-    void startBridge() const
-    {
-        auto cmd = BridgeHelperMixin::startBridge(config, log, http_timeout);
-        context.addXDBCBridgeCommand(std::move(cmd));
-    }
-};
-
-struct JDBCBridgeMixin
-{
-    static constexpr inline auto DEFAULT_PORT = 9019;
-    static const String configPrefix()
-    {
-        return "jdbc_bridge";
-    }
-    static const String serviceAlias()
-    {
-        return "clickhouse-jdbc-bridge";
-    }
-    static const String getName()
-    {
-        return "JDBC";
-    }
-    static AccessType getSourceAccessType()
-    {
-        return AccessType::JDBC;
-    }
-
-    static std::unique_ptr<ShellCommand> startBridge(const Poco::Util::AbstractConfiguration &, const Poco::Logger *, const Poco::Timespan &)
-    {
-        throw Exception("jdbc-bridge is not running. Please, start it manually", ErrorCodes::EXTERNAL_SERVER_IS_NOT_RESPONDING);
-    }
-};
-
-struct ODBCBridgeMixin
-{
-    static constexpr inline auto DEFAULT_PORT = 9018;
-
-    static const String configPrefix()
-    {
-        return "odbc_bridge";
-    }
-    static const String serviceAlias()
-    {
-        return "clickhouse-odbc-bridge";
-    }
-    static const String getName()
-    {
-        return "ODBC";
-    }
-    static AccessType getSourceAccessType()
-    {
-        return AccessType::ODBC;
-    }
-
-    static std::unique_ptr<ShellCommand> startBridge(
-        const Poco::Util::AbstractConfiguration & config, Poco::Logger * log, const Poco::Timespan & http_timeout)
-    {
-        /// Path to executable folder
-        Poco::Path path{config.getString("application.dir", "/usr/bin")};
-
-        std::vector<std::string> cmd_args;
-        path.setFileName("clickhouse-odbc-bridge");
-
-#if !CLICKHOUSE_SPLIT_BINARY
-        cmd_args.push_back("odbc-bridge");
-#endif
-
-        cmd_args.push_back("--http-port");
-        cmd_args.push_back(std::to_string(config.getUInt(configPrefix() + ".port", DEFAULT_PORT)));
-        cmd_args.push_back("--listen-host");
-        cmd_args.push_back(config.getString(configPrefix() + ".listen_host", XDBCBridgeHelper<ODBCBridgeMixin>::DEFAULT_HOST));
-        cmd_args.push_back("--http-timeout");
-        cmd_args.push_back(std::to_string(http_timeout.totalMicroseconds()));
-        if (config.has("logger." + configPrefix() + "_log"))
-        {
-            cmd_args.push_back("--log-path");
-            cmd_args.push_back(config.getString("logger." + configPrefix() + "_log"));
-        }
-        if (config.has("logger." + configPrefix() + "_errlog"))
-        {
-            cmd_args.push_back("--err-log-path");
-            cmd_args.push_back(config.getString("logger." + configPrefix() + "_errlog"));
-        }
-        if (config.has("logger." + configPrefix() + "_stdout"))
-        {
-            cmd_args.push_back("--stdout-path");
-            cmd_args.push_back(config.getString("logger." + configPrefix() + "_stdout"));
-        }
-        if (config.has("logger." + configPrefix() + "_stderr"))
-        {
-            cmd_args.push_back("--stderr-path");
-            cmd_args.push_back(config.getString("logger." + configPrefix() + "_stderr"));
-        }
-        if (config.has("logger." + configPrefix() + "_level"))
-        {
-            cmd_args.push_back("--log-level");
-            cmd_args.push_back(config.getString("logger." + configPrefix() + "_level"));
-        }
-
-        LOG_TRACE(log, "Starting {}", serviceAlias());
-
-        return ShellCommand::executeDirect(path.toString(), cmd_args, ShellCommandDestructorStrategy(true));
-    }
-};
-}
diff --git a/src/Common/ZooKeeper/ZooKeeper.cpp b/src/Common/ZooKeeper/ZooKeeper.cpp
index 330985e1599..9f59da233fc 100644
--- a/src/Common/ZooKeeper/ZooKeeper.cpp
+++ b/src/Common/ZooKeeper/ZooKeeper.cpp
@@ -243,6 +243,7 @@ Coordination::Error ZooKeeper::getChildrenImpl(const std::string & path, Strings
 
     auto callback = [&](const Coordination::ListResponse & response)
     {
+        SCOPE_EXIT(event.set());
         code = response.error;
         if (code == Coordination::Error::ZOK)
         {
@@ -250,7 +251,6 @@ Coordination::Error ZooKeeper::getChildrenImpl(const std::string & path, Strings
             if (stat)
                 *stat = response.stat;
         }
-        event.set();
     };
 
     impl->list(path, callback, watch_callback);
@@ -303,10 +303,10 @@ Coordination::Error ZooKeeper::createImpl(const std::string & path, const std::s
 
     auto callback = [&](const Coordination::CreateResponse & response)
     {
+        SCOPE_EXIT(event.set());
         code = response.error;
         if (code == Coordination::Error::ZOK)
             path_created = response.path_created;
-        event.set();
     };
 
     impl->create(path, data, mode & 1, mode & 2, {}, callback);  /// TODO better mode
@@ -371,9 +371,9 @@ Coordination::Error ZooKeeper::removeImpl(const std::string & path, int32_t vers
 
     auto callback = [&](const Coordination::RemoveResponse & response)
     {
+        SCOPE_EXIT(event.set());
         if (response.error != Coordination::Error::ZOK)
             code = response.error;
-        event.set();
     };
 
     impl->remove(path, version, callback);
@@ -404,10 +404,10 @@ Coordination::Error ZooKeeper::existsImpl(const std::string & path, Coordination
 
     auto callback = [&](const Coordination::ExistsResponse & response)
     {
+        SCOPE_EXIT(event.set());
         code = response.error;
         if (code == Coordination::Error::ZOK && stat)
             *stat = response.stat;
-        event.set();
     };
 
     impl->exists(path, callback, watch_callback);
@@ -436,6 +436,7 @@ Coordination::Error ZooKeeper::getImpl(const std::string & path, std::string & r
 
     auto callback = [&](const Coordination::GetResponse & response)
     {
+        SCOPE_EXIT(event.set());
         code = response.error;
         if (code == Coordination::Error::ZOK)
         {
@@ -443,7 +444,6 @@ Coordination::Error ZooKeeper::getImpl(const std::string & path, std::string & r
             if (stat)
                 *stat = response.stat;
         }
-        event.set();
     };
 
     impl->get(path, callback, watch_callback);
@@ -508,10 +508,10 @@ Coordination::Error ZooKeeper::setImpl(const std::string & path, const std::stri
 
     auto callback = [&](const Coordination::SetResponse & response)
     {
+        SCOPE_EXIT(event.set());
         code = response.error;
         if (code == Coordination::Error::ZOK && stat)
             *stat = response.stat;
-        event.set();
     };
 
     impl->set(path, data, version, callback);
@@ -558,9 +558,9 @@ Coordination::Error ZooKeeper::multiImpl(const Coordination::Requests & requests
 
     auto callback = [&](const Coordination::MultiResponse & response)
     {
+        SCOPE_EXIT(event.set());
         code = response.error;
         responses = response.responses;
-        event.set();
     };
 
     impl->multi(requests, callback);
diff --git a/src/Common/ZooKeeper/ZooKeeperImpl.cpp b/src/Common/ZooKeeper/ZooKeeperImpl.cpp
index 2314139af69..93ecaef8365 100644
--- a/src/Common/ZooKeeper/ZooKeeperImpl.cpp
+++ b/src/Common/ZooKeeper/ZooKeeperImpl.cpp
@@ -796,8 +796,17 @@ void ZooKeeper::receiveEvent()
         /// In case we cannot read the response, we should indicate it as the error of that type
         ///  when the user cannot assume whether the request was processed or not.
         response->error = Error::ZCONNECTIONLOSS;
-        if (request_info.callback)
-            request_info.callback(*response);
+
+        try
+        {
+            if (request_info.callback)
+                request_info.callback(*response);
+        }
+        catch (...)
+        {
+            /// Throw initial exception, not exception from callback.
+            tryLogCurrentException(__PRETTY_FUNCTION__);
+        }
 
         throw;
     }
diff --git a/src/Common/formatReadable.cpp b/src/Common/formatReadable.cpp
index fc5c6c19b50..fd8ff9abd86 100644
--- a/src/Common/formatReadable.cpp
+++ b/src/Common/formatReadable.cpp
@@ -13,7 +13,10 @@ namespace DB
     }
 }
 
-static void formatReadable(double size, DB::WriteBuffer & out, int precision, const char ** units, size_t units_size, double delimiter)
+// I wanted to make this ALWAYS_INLINE to prevent flappy performance tests,
+// but GCC complains it may not be inlined.
+static void formatReadable(double size, DB::WriteBuffer & out,
+    int precision, const char ** units, size_t units_size, double delimiter)
 {
     size_t i = 0;
     for (; i + 1 < units_size && fabs(size) >= delimiter; ++i)
diff --git a/src/Common/parseRemoteDescription.cpp b/src/Common/parseRemoteDescription.cpp
index cc89af26d99..6bb1186bfea 100644
--- a/src/Common/parseRemoteDescription.cpp
+++ b/src/Common/parseRemoteDescription.cpp
@@ -1,6 +1,9 @@
 #include "parseRemoteDescription.h"
 #include <Common/Exception.h>
 #include <IO/WriteHelpers.h>
+#include <IO/ReadHelpers.h>
+#include <common/logger_useful.h>
+
 
 namespace DB
 {
@@ -167,4 +170,27 @@ std::vector<String> parseRemoteDescription(const String & description, size_t l,
     return res;
 }
 
+
+std::vector<std::pair<String, uint16_t>> parseRemoteDescriptionForExternalDatabase(const String & description, size_t max_addresses, UInt16 default_port)
+{
+    auto addresses = parseRemoteDescription(description, 0, description.size(), '|', max_addresses);
+    std::vector<std::pair<String, uint16_t>> result;
+
+    for (const auto & address : addresses)
+    {
+        size_t colon = address.find(':');
+        if (colon == String::npos)
+        {
+            LOG_WARNING(&Poco::Logger::get("ParseRemoteDescription"), "Port is not found for host: {}. Using default port {}", default_port);
+            result.emplace_back(std::make_pair(address, default_port));
+        }
+        else
+        {
+            result.emplace_back(std::make_pair(address.substr(0, colon), DB::parseFromString<UInt16>(address.substr(colon + 1))));
+        }
+    }
+
+    return result;
+}
+
 }
diff --git a/src/Common/parseRemoteDescription.h b/src/Common/parseRemoteDescription.h
index 6ba0bb4737f..f691a57dc73 100644
--- a/src/Common/parseRemoteDescription.h
+++ b/src/Common/parseRemoteDescription.h
@@ -17,4 +17,7 @@ namespace DB
  */
 std::vector<String> parseRemoteDescription(const String & description, size_t l, size_t r, char separator, size_t max_addresses);
 
+/// Parse remote description for external database (MySQL or PostgreSQL).
+std::vector<std::pair<String, uint16_t>> parseRemoteDescriptionForExternalDatabase(const String & description, size_t max_addresses, UInt16 default_port);
+
 }
diff --git a/src/Common/tests/gtest_global_context.h b/src/Common/tests/gtest_global_context.h
index b6529f09b46..30ebf1dbca9 100644
--- a/src/Common/tests/gtest_global_context.h
+++ b/src/Common/tests/gtest_global_context.h
@@ -5,14 +5,14 @@
 struct ContextHolder
 {
     DB::SharedContextHolder shared_context;
-    DB::Context context;
+    DB::ContextPtr context;
 
     ContextHolder()
         : shared_context(DB::Context::createShared())
         , context(DB::Context::createGlobal(shared_context.get()))
     {
-        context.makeGlobalContext();
-        context.setPath("./");
+        context->makeGlobalContext();
+        context->setPath("./");
     }
 
     ContextHolder(ContextHolder &&) = default;
diff --git a/src/Coordination/Changelog.cpp b/src/Coordination/Changelog.cpp
index 227192fdf8a..7fc24de1cb9 100644
--- a/src/Coordination/Changelog.cpp
+++ b/src/Coordination/Changelog.cpp
@@ -44,8 +44,8 @@ ChangelogFileDescription getChangelogFileDescription(const std::string & path_st
 
     ChangelogFileDescription result;
     result.prefix = filename_parts[0];
-    result.from_log_index = parse<size_t>(filename_parts[1]);
-    result.to_log_index = parse<size_t>(filename_parts[2]);
+    result.from_log_index = parse<uint64_t>(filename_parts[1]);
+    result.to_log_index = parse<uint64_t>(filename_parts[2]);
     result.path = path_str;
     return result;
 }
@@ -73,7 +73,7 @@ Checksum computeRecordChecksum(const ChangelogRecord & record)
 class ChangelogWriter
 {
 public:
-    ChangelogWriter(const std::string & filepath_, WriteMode mode, size_t start_index_)
+    ChangelogWriter(const std::string & filepath_, WriteMode mode, uint64_t start_index_)
         : filepath(filepath_)
         , plain_buf(filepath, DBMS_DEFAULT_BUFFER_SIZE, mode == WriteMode::Rewrite ? -1 : (O_APPEND | O_CREAT | O_WRONLY))
         , start_index(start_index_)
@@ -115,22 +115,22 @@ public:
         plain_buf.sync();
     }
 
-    size_t getEntriesWritten() const
+    uint64_t getEntriesWritten() const
     {
         return entries_written;
     }
 
-    void setEntriesWritten(size_t entries_written_)
+    void setEntriesWritten(uint64_t entries_written_)
     {
         entries_written = entries_written_;
     }
 
-    size_t getStartIndex() const
+    uint64_t getStartIndex() const
     {
         return start_index;
     }
 
-    void setStartIndex(size_t start_index_)
+    void setStartIndex(uint64_t start_index_)
     {
         start_index = start_index_;
     }
@@ -138,14 +138,14 @@ public:
 private:
     std::string filepath;
     WriteBufferFromFile plain_buf;
-    size_t entries_written = 0;
-    size_t start_index;
+    uint64_t entries_written = 0;
+    uint64_t start_index;
 };
 
 struct ChangelogReadResult
 {
-    size_t entries_read;
-    size_t first_read_index;
+    uint64_t entries_read;
+    uint64_t first_read_index;
     off_t last_position;
     bool error;
 };
@@ -158,9 +158,9 @@ public:
         , read_buf(filepath)
     {}
 
-    ChangelogReadResult readChangelog(IndexToLogEntry & logs, size_t start_log_index, IndexToOffset & index_to_offset, Poco::Logger * log)
+    ChangelogReadResult readChangelog(IndexToLogEntry & logs, uint64_t start_log_index, IndexToOffset & index_to_offset, Poco::Logger * log)
     {
-        size_t previous_index = 0;
+        uint64_t previous_index = 0;
         ChangelogReadResult result{};
         try
         {
@@ -247,7 +247,7 @@ private:
     ReadBufferFromFile read_buf;
 };
 
-Changelog::Changelog(const std::string & changelogs_dir_, size_t rotate_interval_, Poco::Logger * log_)
+Changelog::Changelog(const std::string & changelogs_dir_, uint64_t rotate_interval_, Poco::Logger * log_)
     : changelogs_dir(changelogs_dir_)
     , rotate_interval(rotate_interval_)
     , log(log_)
@@ -263,15 +263,15 @@ Changelog::Changelog(const std::string & changelogs_dir_, size_t rotate_interval
     }
 }
 
-void Changelog::readChangelogAndInitWriter(size_t last_commited_log_index, size_t logs_to_keep)
+void Changelog::readChangelogAndInitWriter(uint64_t last_commited_log_index, uint64_t logs_to_keep)
 {
-    size_t total_read = 0;
-    size_t entries_in_last = 0;
-    size_t incomplete_log_index = 0;
+    uint64_t total_read = 0;
+    uint64_t entries_in_last = 0;
+    uint64_t incomplete_log_index = 0;
     ChangelogReadResult result{};
-    size_t first_read_index = 0;
+    uint64_t first_read_index = 0;
 
-    size_t start_to_read_from = last_commited_log_index;
+    uint64_t start_to_read_from = last_commited_log_index;
     if (start_to_read_from > logs_to_keep)
         start_to_read_from -= logs_to_keep;
     else
@@ -355,12 +355,8 @@ void Changelog::readChangelogAndInitWriter(size_t last_commited_log_index, size_
         rotate(start_index + total_read);
 }
 
-void Changelog::rotate(size_t new_start_log_index)
+void Changelog::rotate(uint64_t new_start_log_index)
 {
-    //// doesn't exist on init
-    if (current_writer)
-        current_writer->flush();
-
     ChangelogFileDescription new_description;
     new_description.prefix = DEFAULT_PREFIX;
     new_description.from_log_index = new_start_log_index;
@@ -373,7 +369,7 @@ void Changelog::rotate(size_t new_start_log_index)
     current_writer = std::make_unique<ChangelogWriter>(new_description.path, WriteMode::Rewrite, new_start_log_index);
 }
 
-ChangelogRecord Changelog::buildRecord(size_t index, const LogEntryPtr & log_entry)
+ChangelogRecord Changelog::buildRecord(uint64_t index, const LogEntryPtr & log_entry)
 {
     ChangelogRecord record;
     record.header.version = ChangelogVersion::V0;
@@ -391,7 +387,7 @@ ChangelogRecord Changelog::buildRecord(size_t index, const LogEntryPtr & log_ent
     return record;
 }
 
-void Changelog::appendEntry(size_t index, const LogEntryPtr & log_entry, bool force_sync)
+void Changelog::appendEntry(uint64_t index, const LogEntryPtr & log_entry, bool force_sync)
 {
     if (!current_writer)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "Changelog must be initialized before appending records");
@@ -409,7 +405,7 @@ void Changelog::appendEntry(size_t index, const LogEntryPtr & log_entry, bool fo
     logs[index] = makeClone(log_entry);
 }
 
-void Changelog::writeAt(size_t index, const LogEntryPtr & log_entry, bool force_sync)
+void Changelog::writeAt(uint64_t index, const LogEntryPtr & log_entry, bool force_sync)
 {
     if (index_to_start_pos.count(index) == 0)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot write at index {} because changelog doesn't contain it", index);
@@ -443,7 +439,7 @@ void Changelog::writeAt(size_t index, const LogEntryPtr & log_entry, bool force_
     }
 
     /// Remove redundant logs from memory
-    for (size_t i = index; ; ++i)
+    for (uint64_t i = index; ; ++i)
     {
         auto log_itr = logs.find(i);
         if (log_itr == logs.end())
@@ -458,7 +454,7 @@ void Changelog::writeAt(size_t index, const LogEntryPtr & log_entry, bool force_
     appendEntry(index, log_entry, force_sync);
 }
 
-void Changelog::compact(size_t up_to_log_index)
+void Changelog::compact(uint64_t up_to_log_index)
 {
     for (auto itr = existing_changelogs.begin(); itr != existing_changelogs.end();)
     {
@@ -480,9 +476,9 @@ void Changelog::compact(size_t up_to_log_index)
 
 LogEntryPtr Changelog::getLastEntry() const
 {
-    static LogEntryPtr fake_entry = nuraft::cs_new<nuraft::log_entry>(0, nuraft::buffer::alloc(sizeof(size_t)));
+    static LogEntryPtr fake_entry = nuraft::cs_new<nuraft::log_entry>(0, nuraft::buffer::alloc(sizeof(uint64_t)));
 
-    size_t next_index = getNextEntryIndex() - 1;
+    uint64_t next_index = getNextEntryIndex() - 1;
     auto entry = logs.find(next_index);
     if (entry == logs.end())
         return fake_entry;
@@ -490,13 +486,13 @@ LogEntryPtr Changelog::getLastEntry() const
     return entry->second;
 }
 
-LogEntriesPtr Changelog::getLogEntriesBetween(size_t start, size_t end)
+LogEntriesPtr Changelog::getLogEntriesBetween(uint64_t start, uint64_t end)
 {
     LogEntriesPtr ret = nuraft::cs_new<std::vector<nuraft::ptr<nuraft::log_entry>>>();
 
     ret->resize(end - start);
-    size_t result_pos = 0;
-    for (size_t i = start; i < end; ++i)
+    uint64_t result_pos = 0;
+    for (uint64_t i = start; i < end; ++i)
     {
         (*ret)[result_pos] = entryAt(i);
         result_pos++;
@@ -504,7 +500,7 @@ LogEntriesPtr Changelog::getLogEntriesBetween(size_t start, size_t end)
     return ret;
 }
 
-LogEntryPtr Changelog::entryAt(size_t index)
+LogEntryPtr Changelog::entryAt(uint64_t index)
 {
     nuraft::ptr<nuraft::log_entry> src = nullptr;
     auto entry = logs.find(index);
@@ -515,12 +511,12 @@ LogEntryPtr Changelog::entryAt(size_t index)
     return src;
 }
 
-nuraft::ptr<nuraft::buffer> Changelog::serializeEntriesToBuffer(size_t index, int32_t count)
+nuraft::ptr<nuraft::buffer> Changelog::serializeEntriesToBuffer(uint64_t index, int32_t count)
 {
     std::vector<nuraft::ptr<nuraft::buffer>> returned_logs;
 
-    size_t size_total = 0;
-    for (size_t i = index; i < index + count; ++i)
+    uint64_t size_total = 0;
+    for (uint64_t i = index; i < index + count; ++i)
     {
         auto entry = logs.find(i);
         if (entry == logs.end())
@@ -544,14 +540,14 @@ nuraft::ptr<nuraft::buffer> Changelog::serializeEntriesToBuffer(size_t index, in
     return buf_out;
 }
 
-void Changelog::applyEntriesFromBuffer(size_t index, nuraft::buffer & buffer, bool force_sync)
+void Changelog::applyEntriesFromBuffer(uint64_t index, nuraft::buffer & buffer, bool force_sync)
 {
     buffer.pos(0);
     int num_logs = buffer.get_int();
 
     for (int i = 0; i < num_logs; ++i)
     {
-        size_t cur_index = index + i;
+        uint64_t cur_index = index + i;
         int buf_size = buffer.get_int();
 
         nuraft::ptr<nuraft::buffer> buf_local = nuraft::buffer::alloc(buf_size);
diff --git a/src/Coordination/Changelog.h b/src/Coordination/Changelog.h
index 24b98d6b892..21d96cd1438 100644
--- a/src/Coordination/Changelog.h
+++ b/src/Coordination/Changelog.h
@@ -17,8 +17,8 @@ using LogEntries = std::vector<LogEntryPtr>;
 using LogEntriesPtr = nuraft::ptr<LogEntries>;
 using BufferPtr = nuraft::ptr<nuraft::buffer>;
 
-using IndexToOffset = std::unordered_map<size_t, off_t>;
-using IndexToLogEntry = std::unordered_map<size_t, LogEntryPtr>;
+using IndexToOffset = std::unordered_map<uint64_t, off_t>;
+using IndexToLogEntry = std::unordered_map<uint64_t, LogEntryPtr>;
 
 enum class ChangelogVersion : uint8_t
 {
@@ -30,10 +30,10 @@ static constexpr auto CURRENT_CHANGELOG_VERSION = ChangelogVersion::V0;
 struct ChangelogRecordHeader
 {
     ChangelogVersion version = CURRENT_CHANGELOG_VERSION;
-    size_t index; /// entry log number
-    size_t term;
+    uint64_t index; /// entry log number
+    uint64_t term;
     nuraft::log_val_type value_type;
-    size_t blob_size;
+    uint64_t blob_size;
 };
 
 /// Changelog record on disk
@@ -48,8 +48,8 @@ struct ChangelogRecord
 struct ChangelogFileDescription
 {
     std::string prefix;
-    size_t from_log_index;
-    size_t to_log_index;
+    uint64_t from_log_index;
+    uint64_t to_log_index;
 
     std::string path;
 };
@@ -63,27 +63,27 @@ class Changelog
 {
 
 public:
-    Changelog(const std::string & changelogs_dir_, size_t rotate_interval_, Poco::Logger * log_);
+    Changelog(const std::string & changelogs_dir_, uint64_t rotate_interval_, Poco::Logger * log_);
 
     /// Read changelog from files on changelogs_dir_ skipping all entries before from_log_index
     /// Truncate broken entries, remove files after broken entries.
-    void readChangelogAndInitWriter(size_t last_commited_log_index, size_t logs_to_keep);
+    void readChangelogAndInitWriter(uint64_t last_commited_log_index, uint64_t logs_to_keep);
 
     /// Add entry to log with index. Call fsync if force_sync true.
-    void appendEntry(size_t index, const LogEntryPtr & log_entry, bool force_sync);
+    void appendEntry(uint64_t index, const LogEntryPtr & log_entry, bool force_sync);
 
     /// Write entry at index and truncate all subsequent entries.
-    void writeAt(size_t index, const LogEntryPtr & log_entry, bool force_sync);
+    void writeAt(uint64_t index, const LogEntryPtr & log_entry, bool force_sync);
 
     /// Remove log files with to_log_index <= up_to_log_index.
-    void compact(size_t up_to_log_index);
+    void compact(uint64_t up_to_log_index);
 
-    size_t getNextEntryIndex() const
+    uint64_t getNextEntryIndex() const
     {
         return start_index + logs.size();
     }
 
-    size_t getStartIndex() const
+    uint64_t getStartIndex() const
     {
         return start_index;
     }
@@ -92,21 +92,21 @@ public:
     LogEntryPtr getLastEntry() const;
 
     /// Return log entries between [start, end)
-    LogEntriesPtr getLogEntriesBetween(size_t start_index, size_t end_index);
+    LogEntriesPtr getLogEntriesBetween(uint64_t start_index, uint64_t end_index);
 
     /// Return entry at position index
-    LogEntryPtr entryAt(size_t index);
+    LogEntryPtr entryAt(uint64_t index);
 
     /// Serialize entries from index into buffer
-    BufferPtr serializeEntriesToBuffer(size_t index, int32_t count);
+    BufferPtr serializeEntriesToBuffer(uint64_t index, int32_t count);
 
     /// Apply entries from buffer overriding existing entries
-    void applyEntriesFromBuffer(size_t index, nuraft::buffer & buffer, bool force_sync);
+    void applyEntriesFromBuffer(uint64_t index, nuraft::buffer & buffer, bool force_sync);
 
     /// Fsync log to disk
     void flush();
 
-    size_t size() const
+    uint64_t size() const
     {
         return logs.size();
     }
@@ -116,21 +116,21 @@ public:
 
 private:
     /// Pack log_entry into changelog record
-    static ChangelogRecord buildRecord(size_t index, const LogEntryPtr & log_entry);
+    static ChangelogRecord buildRecord(uint64_t index, const LogEntryPtr & log_entry);
 
     /// Starts new file [new_start_log_index, new_start_log_index + rotate_interval]
-    void rotate(size_t new_start_log_index);
+    void rotate(uint64_t new_start_log_index);
 
 private:
     const std::string changelogs_dir;
-    const size_t rotate_interval;
+    const uint64_t rotate_interval;
     Poco::Logger * log;
 
-    std::map<size_t, ChangelogFileDescription> existing_changelogs;
+    std::map<uint64_t, ChangelogFileDescription> existing_changelogs;
     std::unique_ptr<ChangelogWriter> current_writer;
     IndexToOffset index_to_start_pos;
     IndexToLogEntry logs;
-    size_t start_index = 0;
+    uint64_t start_index = 0;
 };
 
 }
diff --git a/src/Coordination/InMemoryLogStore.cpp b/src/Coordination/InMemoryLogStore.cpp
index 877c8a60a2a..b7bccdf588e 100644
--- a/src/Coordination/InMemoryLogStore.cpp
+++ b/src/Coordination/InMemoryLogStore.cpp
@@ -16,16 +16,16 @@ ptr<log_entry> makeClone(const ptr<log_entry> & entry)
 InMemoryLogStore::InMemoryLogStore()
     : start_idx(1)
 {
-    nuraft::ptr<nuraft::buffer> buf = nuraft::buffer::alloc(sizeof(size_t));
+    nuraft::ptr<nuraft::buffer> buf = nuraft::buffer::alloc(sizeof(uint64_t));
     logs[0] = nuraft::cs_new<nuraft::log_entry>(0, buf);
 }
 
-size_t InMemoryLogStore::start_index() const
+uint64_t InMemoryLogStore::start_index() const
 {
     return start_idx;
 }
 
-size_t InMemoryLogStore::next_slot() const
+uint64_t InMemoryLogStore::next_slot() const
 {
     std::lock_guard<std::mutex> l(logs_lock);
     // Exclude the dummy entry.
@@ -34,7 +34,7 @@ size_t InMemoryLogStore::next_slot() const
 
 nuraft::ptr<nuraft::log_entry> InMemoryLogStore::last_entry() const
 {
-    size_t next_idx = next_slot();
+    uint64_t next_idx = next_slot();
     std::lock_guard<std::mutex> lock(logs_lock);
     auto entry = logs.find(next_idx - 1);
     if (entry == logs.end())
@@ -43,17 +43,17 @@ nuraft::ptr<nuraft::log_entry> InMemoryLogStore::last_entry() const
     return makeClone(entry->second);
 }
 
-size_t InMemoryLogStore::append(nuraft::ptr<nuraft::log_entry> & entry)
+uint64_t InMemoryLogStore::append(nuraft::ptr<nuraft::log_entry> & entry)
 {
     ptr<log_entry> clone = makeClone(entry);
 
     std::lock_guard<std::mutex> l(logs_lock);
-    size_t idx = start_idx + logs.size() - 1;
+    uint64_t idx = start_idx + logs.size() - 1;
     logs[idx] = clone;
     return idx;
 }
 
-void InMemoryLogStore::write_at(size_t index, nuraft::ptr<nuraft::log_entry> & entry)
+void InMemoryLogStore::write_at(uint64_t index, nuraft::ptr<nuraft::log_entry> & entry)
 {
     nuraft::ptr<log_entry> clone = makeClone(entry);
 
@@ -65,14 +65,14 @@ void InMemoryLogStore::write_at(size_t index, nuraft::ptr<nuraft::log_entry> & e
     logs[index] = clone;
 }
 
-nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> InMemoryLogStore::log_entries(size_t start, size_t end)
+nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> InMemoryLogStore::log_entries(uint64_t start, uint64_t end)
 {
     nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> ret =
         nuraft::cs_new<std::vector<nuraft::ptr<nuraft::log_entry>>>();
 
     ret->resize(end - start);
-    size_t cc = 0;
-    for (size_t i = start; i < end; ++i)
+    uint64_t cc = 0;
+    for (uint64_t i = start; i < end; ++i)
     {
         nuraft::ptr<nuraft::log_entry> src = nullptr;
         {
@@ -90,7 +90,7 @@ nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> InMemoryLogStore::log_e
     return ret;
 }
 
-nuraft::ptr<nuraft::log_entry> InMemoryLogStore::entry_at(size_t index)
+nuraft::ptr<nuraft::log_entry> InMemoryLogStore::entry_at(uint64_t index)
 {
     nuraft::ptr<nuraft::log_entry> src = nullptr;
     {
@@ -103,9 +103,9 @@ nuraft::ptr<nuraft::log_entry> InMemoryLogStore::entry_at(size_t index)
     return makeClone(src);
 }
 
-size_t InMemoryLogStore::term_at(size_t index)
+uint64_t InMemoryLogStore::term_at(uint64_t index)
 {
-    size_t term = 0;
+    uint64_t term = 0;
     {
         std::lock_guard<std::mutex> l(logs_lock);
         auto entry = logs.find(index);
@@ -116,12 +116,12 @@ size_t InMemoryLogStore::term_at(size_t index)
     return term;
 }
 
-nuraft::ptr<nuraft::buffer> InMemoryLogStore::pack(size_t index, Int32 cnt)
+nuraft::ptr<nuraft::buffer> InMemoryLogStore::pack(uint64_t index, Int32 cnt)
 {
     std::vector<nuraft::ptr<nuraft::buffer>> returned_logs;
 
-    size_t size_total = 0;
-    for (size_t ii = index; ii < index + cnt; ++ii)
+    uint64_t uint64_total = 0;
+    for (uint64_t ii = index; ii < index + cnt; ++ii)
     {
         ptr<log_entry> le = nullptr;
         {
@@ -130,11 +130,11 @@ nuraft::ptr<nuraft::buffer> InMemoryLogStore::pack(size_t index, Int32 cnt)
         }
         assert(le.get());
         nuraft::ptr<nuraft::buffer> buf = le->serialize();
-        size_total += buf->size();
+        uint64_total += buf->size();
         returned_logs.push_back(buf);
     }
 
-    nuraft::ptr<buffer> buf_out = nuraft::buffer::alloc(sizeof(int32) + cnt * sizeof(int32) + size_total);
+    nuraft::ptr<buffer> buf_out = nuraft::buffer::alloc(sizeof(int32) + cnt * sizeof(int32) + uint64_total);
     buf_out->pos(0);
     buf_out->put(static_cast<Int32>(cnt));
 
@@ -147,14 +147,14 @@ nuraft::ptr<nuraft::buffer> InMemoryLogStore::pack(size_t index, Int32 cnt)
     return buf_out;
 }
 
-void InMemoryLogStore::apply_pack(size_t index, nuraft::buffer & pack)
+void InMemoryLogStore::apply_pack(uint64_t index, nuraft::buffer & pack)
 {
     pack.pos(0);
     Int32 num_logs = pack.get_int();
 
     for (Int32 i = 0; i < num_logs; ++i)
     {
-        size_t cur_idx = index + i;
+        uint64_t cur_idx = index + i;
         Int32 buf_size = pack.get_int();
 
         nuraft::ptr<nuraft::buffer> buf_local = nuraft::buffer::alloc(buf_size);
@@ -177,10 +177,10 @@ void InMemoryLogStore::apply_pack(size_t index, nuraft::buffer & pack)
     }
 }
 
-bool InMemoryLogStore::compact(size_t last_log_index)
+bool InMemoryLogStore::compact(uint64_t last_log_index)
 {
     std::lock_guard<std::mutex> l(logs_lock);
-    for (size_t ii = start_idx; ii <= last_log_index; ++ii)
+    for (uint64_t ii = start_idx; ii <= last_log_index; ++ii)
     {
         auto entry = logs.find(ii);
         if (entry != logs.end())
diff --git a/src/Coordination/InMemoryLogStore.h b/src/Coordination/InMemoryLogStore.h
index 425b056a81d..caa5e31698d 100644
--- a/src/Coordination/InMemoryLogStore.h
+++ b/src/Coordination/InMemoryLogStore.h
@@ -14,34 +14,34 @@ class InMemoryLogStore : public nuraft::log_store
 public:
     InMemoryLogStore();
 
-    size_t start_index() const override;
+    uint64_t start_index() const override;
 
-    size_t next_slot() const override;
+    uint64_t next_slot() const override;
 
     nuraft::ptr<nuraft::log_entry> last_entry() const override;
 
-    size_t append(nuraft::ptr<nuraft::log_entry> & entry) override;
+    uint64_t append(nuraft::ptr<nuraft::log_entry> & entry) override;
 
-    void write_at(size_t index, nuraft::ptr<nuraft::log_entry> & entry) override;
+    void write_at(uint64_t index, nuraft::ptr<nuraft::log_entry> & entry) override;
 
-    nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> log_entries(size_t start, size_t end) override;
+    nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> log_entries(uint64_t start, uint64_t end) override;
 
-    nuraft::ptr<nuraft::log_entry> entry_at(size_t index) override;
+    nuraft::ptr<nuraft::log_entry> entry_at(uint64_t index) override;
 
-    size_t term_at(size_t index) override;
+    uint64_t term_at(uint64_t index) override;
 
-    nuraft::ptr<nuraft::buffer> pack(size_t index, Int32 cnt) override;
+    nuraft::ptr<nuraft::buffer> pack(uint64_t index, Int32 cnt) override;
 
-    void apply_pack(size_t index, nuraft::buffer & pack) override;
+    void apply_pack(uint64_t index, nuraft::buffer & pack) override;
 
-    bool compact(size_t last_log_index) override;
+    bool compact(uint64_t last_log_index) override;
 
     bool flush() override { return true; }
 
 private:
-    std::map<size_t, nuraft::ptr<nuraft::log_entry>> logs;
+    std::map<uint64_t, nuraft::ptr<nuraft::log_entry>> logs;
     mutable std::mutex logs_lock;
-    std::atomic<size_t> start_idx;
+    std::atomic<uint64_t> start_idx;
 };
 
 }
diff --git a/src/Coordination/KeeperLogStore.cpp b/src/Coordination/KeeperLogStore.cpp
index 2b1306bffb9..f78d57ee1ce 100644
--- a/src/Coordination/KeeperLogStore.cpp
+++ b/src/Coordination/KeeperLogStore.cpp
@@ -3,26 +3,26 @@
 namespace DB
 {
 
-KeeperLogStore::KeeperLogStore(const std::string & changelogs_path, size_t rotate_interval_, bool force_sync_)
+KeeperLogStore::KeeperLogStore(const std::string & changelogs_path, uint64_t rotate_interval_, bool force_sync_)
     : log(&Poco::Logger::get("KeeperLogStore"))
     , changelog(changelogs_path, rotate_interval_, log)
     , force_sync(force_sync_)
 {
 }
 
-size_t KeeperLogStore::start_index() const
+uint64_t KeeperLogStore::start_index() const
 {
     std::lock_guard lock(changelog_lock);
     return changelog.getStartIndex();
 }
 
-void KeeperLogStore::init(size_t last_commited_log_index, size_t logs_to_keep)
+void KeeperLogStore::init(uint64_t last_commited_log_index, uint64_t logs_to_keep)
 {
     std::lock_guard lock(changelog_lock);
     changelog.readChangelogAndInitWriter(last_commited_log_index, logs_to_keep);
 }
 
-size_t KeeperLogStore::next_slot() const
+uint64_t KeeperLogStore::next_slot() const
 {
     std::lock_guard lock(changelog_lock);
     return changelog.getNextEntryIndex();
@@ -34,34 +34,34 @@ nuraft::ptr<nuraft::log_entry> KeeperLogStore::last_entry() const
     return changelog.getLastEntry();
 }
 
-size_t KeeperLogStore::append(nuraft::ptr<nuraft::log_entry> & entry)
+uint64_t KeeperLogStore::append(nuraft::ptr<nuraft::log_entry> & entry)
 {
     std::lock_guard lock(changelog_lock);
-    size_t idx = changelog.getNextEntryIndex();
+    uint64_t idx = changelog.getNextEntryIndex();
     changelog.appendEntry(idx, entry, force_sync);
     return idx;
 }
 
 
-void KeeperLogStore::write_at(size_t index, nuraft::ptr<nuraft::log_entry> & entry)
+void KeeperLogStore::write_at(uint64_t index, nuraft::ptr<nuraft::log_entry> & entry)
 {
     std::lock_guard lock(changelog_lock);
     changelog.writeAt(index, entry, force_sync);
 }
 
-nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> KeeperLogStore::log_entries(size_t start, size_t end)
+nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> KeeperLogStore::log_entries(uint64_t start, uint64_t end)
 {
     std::lock_guard lock(changelog_lock);
     return changelog.getLogEntriesBetween(start, end);
 }
 
-nuraft::ptr<nuraft::log_entry> KeeperLogStore::entry_at(size_t index)
+nuraft::ptr<nuraft::log_entry> KeeperLogStore::entry_at(uint64_t index)
 {
     std::lock_guard lock(changelog_lock);
     return changelog.entryAt(index);
 }
 
-size_t KeeperLogStore::term_at(size_t index)
+uint64_t KeeperLogStore::term_at(uint64_t index)
 {
     std::lock_guard lock(changelog_lock);
     auto entry = changelog.entryAt(index);
@@ -70,13 +70,13 @@ size_t KeeperLogStore::term_at(size_t index)
     return 0;
 }
 
-nuraft::ptr<nuraft::buffer> KeeperLogStore::pack(size_t index, int32_t cnt)
+nuraft::ptr<nuraft::buffer> KeeperLogStore::pack(uint64_t index, int32_t cnt)
 {
     std::lock_guard lock(changelog_lock);
     return changelog.serializeEntriesToBuffer(index, cnt);
 }
 
-bool KeeperLogStore::compact(size_t last_log_index)
+bool KeeperLogStore::compact(uint64_t last_log_index)
 {
     std::lock_guard lock(changelog_lock);
     changelog.compact(last_log_index);
@@ -90,13 +90,13 @@ bool KeeperLogStore::flush()
     return true;
 }
 
-void KeeperLogStore::apply_pack(size_t index, nuraft::buffer & pack)
+void KeeperLogStore::apply_pack(uint64_t index, nuraft::buffer & pack)
 {
     std::lock_guard lock(changelog_lock);
     changelog.applyEntriesFromBuffer(index, pack, force_sync);
 }
 
-size_t KeeperLogStore::size() const
+uint64_t KeeperLogStore::size() const
 {
     std::lock_guard lock(changelog_lock);
     return changelog.size();
diff --git a/src/Coordination/KeeperLogStore.h b/src/Coordination/KeeperLogStore.h
index c9c20e144ba..bc2ae719f0e 100644
--- a/src/Coordination/KeeperLogStore.h
+++ b/src/Coordination/KeeperLogStore.h
@@ -12,35 +12,35 @@ namespace DB
 class KeeperLogStore : public nuraft::log_store
 {
 public:
-    KeeperLogStore(const std::string & changelogs_path, size_t rotate_interval_, bool force_sync_);
+    KeeperLogStore(const std::string & changelogs_path, uint64_t rotate_interval_, bool force_sync_);
 
-    void init(size_t last_commited_log_index, size_t logs_to_keep);
+    void init(uint64_t last_commited_log_index, uint64_t logs_to_keep);
 
-    size_t start_index() const override;
+    uint64_t start_index() const override;
 
-    size_t next_slot() const override;
+    uint64_t next_slot() const override;
 
     nuraft::ptr<nuraft::log_entry> last_entry() const override;
 
-    size_t append(nuraft::ptr<nuraft::log_entry> & entry) override;
+    uint64_t append(nuraft::ptr<nuraft::log_entry> & entry) override;
 
-    void write_at(size_t index, nuraft::ptr<nuraft::log_entry> & entry) override;
+    void write_at(uint64_t index, nuraft::ptr<nuraft::log_entry> & entry) override;
 
-    nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> log_entries(size_t start, size_t end) override;
+    nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> log_entries(uint64_t start, uint64_t end) override;
 
-    nuraft::ptr<nuraft::log_entry> entry_at(size_t index) override;
+    nuraft::ptr<nuraft::log_entry> entry_at(uint64_t index) override;
 
-    size_t term_at(size_t index) override;
+    uint64_t term_at(uint64_t index) override;
 
-    nuraft::ptr<nuraft::buffer> pack(size_t index, int32_t cnt) override;
+    nuraft::ptr<nuraft::buffer> pack(uint64_t index, int32_t cnt) override;
 
-    void apply_pack(size_t index, nuraft::buffer & pack) override;
+    void apply_pack(uint64_t index, nuraft::buffer & pack) override;
 
-    bool compact(size_t last_log_index) override;
+    bool compact(uint64_t last_log_index) override;
 
     bool flush() override;
 
-    size_t size() const;
+    uint64_t size() const;
 
 private:
     mutable std::mutex changelog_lock;
diff --git a/src/Coordination/KeeperServer.cpp b/src/Coordination/KeeperServer.cpp
index c7446c296f0..7827a25afdd 100644
--- a/src/Coordination/KeeperServer.cpp
+++ b/src/Coordination/KeeperServer.cpp
@@ -1,4 +1,9 @@
 #include <Coordination/KeeperServer.h>
+
+#if !defined(ARCADIA_BUILD)
+#   include "config_core.h"
+#endif
+
 #include <Coordination/LoggerWrapper.h>
 #include <Coordination/KeeperStateMachine.h>
 #include <Coordination/KeeperStateManager.h>
@@ -9,6 +14,7 @@
 #include <chrono>
 #include <Common/ZooKeeper/ZooKeeperIO.h>
 #include <string>
+#include <Poco/Util/Application.h>
 
 namespace DB
 {
@@ -16,6 +22,42 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int RAFT_ERROR;
+    extern const int NO_ELEMENTS_IN_CONFIG;
+    extern const int SUPPORT_IS_DISABLED;
+}
+
+namespace
+{
+
+#if USE_SSL
+void setSSLParams(nuraft::asio_service::options & asio_opts)
+{
+    const Poco::Util::LayeredConfiguration & config = Poco::Util::Application::instance().config();
+    String certificate_file_property = "openSSL.server.certificateFile";
+    String private_key_file_property = "openSSL.server.privateKeyFile";
+    String root_ca_file_property = "openSSL.server.caConfig";
+
+    if (!config.has(certificate_file_property))
+        throw Exception("Server certificate file is not set.", ErrorCodes::NO_ELEMENTS_IN_CONFIG);
+
+    if (!config.has(private_key_file_property))
+        throw Exception("Server private key file is not set.", ErrorCodes::NO_ELEMENTS_IN_CONFIG);
+
+    asio_opts.enable_ssl_ = true;
+    asio_opts.server_cert_file_ = config.getString(certificate_file_property);
+    asio_opts.server_key_file_ = config.getString(private_key_file_property);
+
+    if (config.has(root_ca_file_property))
+        asio_opts.root_cert_file_ = config.getString(root_ca_file_property);
+
+    if (config.getBool("openSSL.server.loadDefaultCAFile", false))
+        asio_opts.load_default_ca_file_ = true;
+
+    if (config.getString("openSSL.server.verificationMode", "none") == "none")
+        asio_opts.skip_verification_ = true;
+}
+#endif
+
 }
 
 KeeperServer::KeeperServer(
@@ -32,14 +74,14 @@ KeeperServer::KeeperServer(
                         coordination_settings))
     , state_manager(nuraft::cs_new<KeeperStateManager>(server_id, "keeper_server", config, coordination_settings))
     , responses_queue(responses_queue_)
+    , log(&Poco::Logger::get("KeeperServer"))
 {
     if (coordination_settings->quorum_reads)
-        LOG_WARNING(&Poco::Logger::get("KeeperServer"), "Quorum reads enabled, Keeper will work slower.");
+        LOG_WARNING(log, "Quorum reads enabled, Keeper will work slower.");
 }
 
 void KeeperServer::startup()
 {
-
     state_machine->init();
 
     state_manager->loadLogStore(state_machine->last_commit_index() + 1, coordination_settings->reserved_log_items);
@@ -72,28 +114,99 @@ void KeeperServer::startup()
     params.return_method_ = nuraft::raft_params::blocking;
 
     nuraft::asio_service::options asio_opts{};
-    nuraft::raft_server::init_options init_options;
-    init_options.skip_initial_election_timeout_ = state_manager->shouldStartAsFollower();
-    init_options.raft_callback_ = [this] (nuraft::cb_func::Type type, nuraft::cb_func::Param * param)
+    if (state_manager->isSecure())
     {
-        return callbackFunc(type, param);
-    };
+#if USE_SSL
+        setSSLParams(asio_opts);
+#else
+        throw Exception{"SSL support for NuRaft is disabled because ClickHouse was built without SSL support.",
+                        ErrorCodes::SUPPORT_IS_DISABLED};
+#endif
+    }
 
-    raft_instance = launcher.init(
-        state_machine, state_manager, nuraft::cs_new<LoggerWrapper>("RaftInstance", coordination_settings->raft_logs_level), state_manager->getPort(),
-        asio_opts, params, init_options);
+    launchRaftServer(params, asio_opts);
 
     if (!raft_instance)
         throw Exception(ErrorCodes::RAFT_ERROR, "Cannot allocate RAFT instance");
 }
 
+void KeeperServer::launchRaftServer(
+    const nuraft::raft_params & params,
+    const nuraft::asio_service::options & asio_opts)
+{
+    nuraft::raft_server::init_options init_options;
+
+    init_options.skip_initial_election_timeout_ = state_manager->shouldStartAsFollower();
+    init_options.start_server_in_constructor_ = false;
+    init_options.raft_callback_ = [this] (nuraft::cb_func::Type type, nuraft::cb_func::Param * param)
+    {
+        return callbackFunc(type, param);
+    };
+
+    nuraft::ptr<nuraft::logger> logger = nuraft::cs_new<LoggerWrapper>("RaftInstance", coordination_settings->raft_logs_level);
+    asio_service = nuraft::cs_new<nuraft::asio_service>(asio_opts, logger);
+    asio_listener = asio_service->create_rpc_listener(state_manager->getPort(), logger);
+
+    if (!asio_listener)
+        return;
+
+    nuraft::ptr<nuraft::delayed_task_scheduler> scheduler = asio_service;
+    nuraft::ptr<nuraft::rpc_client_factory> rpc_cli_factory = asio_service;
+
+    nuraft::ptr<nuraft::state_mgr> casted_state_manager = state_manager;
+    nuraft::ptr<nuraft::state_machine> casted_state_machine = state_machine;
+
+    /// raft_server creates unique_ptr from it
+    nuraft::context * ctx = new nuraft::context(
+        casted_state_manager, casted_state_machine,
+        asio_listener, logger, rpc_cli_factory, scheduler, params);
+
+    raft_instance = nuraft::cs_new<nuraft::raft_server>(ctx, init_options);
+
+    raft_instance->start_server(init_options.skip_initial_election_timeout_);
+    asio_listener->listen(raft_instance);
+}
+
+void KeeperServer::shutdownRaftServer()
+{
+    size_t timeout = coordination_settings->shutdown_timeout.totalSeconds();
+
+    if (!raft_instance)
+    {
+        LOG_INFO(log, "RAFT doesn't start, shutdown not required");
+        return;
+    }
+
+    raft_instance->shutdown();
+    raft_instance.reset();
+
+    if (asio_listener)
+    {
+        asio_listener->stop();
+        asio_listener->shutdown();
+    }
+
+    if (asio_service)
+    {
+        asio_service->stop();
+        size_t count = 0;
+        while (asio_service->get_active_workers() != 0 && count < timeout * 100)
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            count++;
+        }
+    }
+
+    if (asio_service->get_active_workers() != 0)
+        LOG_WARNING(log, "Failed to shutdown RAFT server in {} seconds", timeout);
+}
+
+
 void KeeperServer::shutdown()
 {
     state_machine->shutdownStorage();
     state_manager->flushLogStore();
-    auto timeout = coordination_settings->shutdown_timeout.totalSeconds();
-    if (!launcher.shutdown(timeout))
-        LOG_WARNING(&Poco::Logger::get("KeeperServer"), "Failed to shutdown RAFT server in {} seconds", timeout);
+    shutdownRaftServer();
 }
 
 namespace
@@ -190,17 +303,17 @@ bool KeeperServer::isLeaderAlive() const
     return raft_instance->is_leader_alive();
 }
 
-nuraft::cb_func::ReturnCode KeeperServer::callbackFunc(nuraft::cb_func::Type type, nuraft::cb_func::Param * /* param */)
+nuraft::cb_func::ReturnCode KeeperServer::callbackFunc(nuraft::cb_func::Type type, nuraft::cb_func::Param * param)
 {
+    if (initialized_flag)
+        return nuraft::cb_func::ReturnCode::Ok;
+
     size_t last_commited = state_machine->last_commit_index();
     size_t next_index = state_manager->getLogStore()->next_slot();
     bool commited_store = false;
     if (next_index < last_commited || next_index - last_commited <= 1)
         commited_store = true;
 
-    if (initialized_flag)
-        return nuraft::cb_func::ReturnCode::Ok;
-
     auto set_initialized = [this] ()
     {
         std::unique_lock lock(initialized_mutex);
@@ -220,7 +333,7 @@ nuraft::cb_func::ReturnCode KeeperServer::callbackFunc(nuraft::cb_func::Type typ
         case nuraft::cb_func::BecomeFollower:
         case nuraft::cb_func::GotAppendEntryReqFromLeader:
         {
-            if (isLeaderAlive())
+            if (param->leaderId != -1)
             {
                 auto leader_index = raft_instance->get_leader_committed_log_idx();
                 auto our_index = raft_instance->get_committed_log_idx();
@@ -240,7 +353,7 @@ nuraft::cb_func::ReturnCode KeeperServer::callbackFunc(nuraft::cb_func::Type typ
         }
         case nuraft::cb_func::InitialBatchCommited:
         {
-            if (isLeader()) /// We have committed our log store and we are leader, ready to serve requests.
+            if (param->myId == param->leaderId) /// We have committed our log store and we are leader, ready to serve requests.
                 set_initialized();
             initial_batch_committed = true;
             return nuraft::cb_func::ReturnCode::Ok;
diff --git a/src/Coordination/KeeperServer.h b/src/Coordination/KeeperServer.h
index 9a0260cda94..5af948305ef 100644
--- a/src/Coordination/KeeperServer.h
+++ b/src/Coordination/KeeperServer.h
@@ -7,6 +7,7 @@
 #include <Coordination/KeeperStorage.h>
 #include <Coordination/CoordinationSettings.h>
 #include <unordered_map>
+#include <common/logger_useful.h>
 
 namespace DB
 {
@@ -22,9 +23,9 @@ private:
 
     nuraft::ptr<KeeperStateManager> state_manager;
 
-    nuraft::raft_launcher launcher;
-
     nuraft::ptr<nuraft::raft_server> raft_instance;
+    nuraft::ptr<nuraft::asio_service> asio_service;
+    nuraft::ptr<nuraft::rpc_listener> asio_listener;
 
     std::mutex append_entries_mutex;
 
@@ -36,8 +37,19 @@ private:
     std::atomic<bool> initial_batch_committed = false;
     std::atomic<size_t> active_session_id_requests = 0;
 
+    Poco::Logger * log;
+
     nuraft::cb_func::ReturnCode callbackFunc(nuraft::cb_func::Type type, nuraft::cb_func::Param * param);
 
+    /// Almost copy-paste from nuraft::launcher, but with separated server init and start
+    /// Allows to avoid race conditions.
+    void launchRaftServer(
+        const nuraft::raft_params & params,
+        const nuraft::asio_service::options & asio_opts);
+
+    void shutdownRaftServer();
+
+
 public:
     KeeperServer(
         int server_id_,
diff --git a/src/Coordination/KeeperSnapshotManager.cpp b/src/Coordination/KeeperSnapshotManager.cpp
index 70d540ca06b..3cfa07fb542 100644
--- a/src/Coordination/KeeperSnapshotManager.cpp
+++ b/src/Coordination/KeeperSnapshotManager.cpp
@@ -23,16 +23,16 @@ namespace ErrorCodes
 
 namespace
 {
-    size_t getSnapshotPathUpToLogIdx(const String & snapshot_path)
+    uint64_t getSnapshotPathUpToLogIdx(const String & snapshot_path)
     {
         std::filesystem::path path(snapshot_path);
         std::string filename = path.stem();
         Strings name_parts;
         splitInto<'_'>(name_parts, filename);
-        return parse<size_t>(name_parts[1]);
+        return parse<uint64_t>(name_parts[1]);
     }
 
-    std::string getSnapshotFileName(size_t up_to_log_idx)
+    std::string getSnapshotFileName(uint64_t up_to_log_idx)
     {
         return std::string{"snapshot_"} + std::to_string(up_to_log_idx) + ".bin";
     }
@@ -214,7 +214,7 @@ SnapshotMetadataPtr KeeperStorageSnapshot::deserialize(KeeperStorage & storage,
     return result;
 }
 
-KeeperStorageSnapshot::KeeperStorageSnapshot(KeeperStorage * storage_, size_t up_to_log_idx_)
+KeeperStorageSnapshot::KeeperStorageSnapshot(KeeperStorage * storage_, uint64_t up_to_log_idx_)
     : storage(storage_)
     , snapshot_meta(std::make_shared<SnapshotMetadata>(up_to_log_idx_, 0, std::make_shared<nuraft::cluster_config>()))
     , session_id(storage->session_id_counter)
@@ -266,7 +266,7 @@ KeeperSnapshotManager::KeeperSnapshotManager(const std::string & snapshots_path_
 }
 
 
-std::string KeeperSnapshotManager::serializeSnapshotBufferToDisk(nuraft::buffer & buffer, size_t up_to_log_idx)
+std::string KeeperSnapshotManager::serializeSnapshotBufferToDisk(nuraft::buffer & buffer, uint64_t up_to_log_idx)
 {
     ReadBufferFromNuraftBuffer reader(buffer);
 
@@ -307,7 +307,7 @@ nuraft::ptr<nuraft::buffer> KeeperSnapshotManager::deserializeLatestSnapshotBuff
     return nullptr;
 }
 
-nuraft::ptr<nuraft::buffer> KeeperSnapshotManager::deserializeSnapshotBufferFromDisk(size_t up_to_log_idx) const
+nuraft::ptr<nuraft::buffer> KeeperSnapshotManager::deserializeSnapshotBufferFromDisk(uint64_t up_to_log_idx) const
 {
     const std::string & snapshot_path = existing_snapshots.at(up_to_log_idx);
     WriteBufferFromNuraftBuffer writer;
@@ -352,7 +352,7 @@ void KeeperSnapshotManager::removeOutdatedSnapshotsIfNeeded()
         removeSnapshot(existing_snapshots.begin()->first);
 }
 
-void KeeperSnapshotManager::removeSnapshot(size_t log_idx)
+void KeeperSnapshotManager::removeSnapshot(uint64_t log_idx)
 {
     auto itr = existing_snapshots.find(log_idx);
     if (itr == existing_snapshots.end())
diff --git a/src/Coordination/KeeperSnapshotManager.h b/src/Coordination/KeeperSnapshotManager.h
index e53473d71c7..95d1ce831d4 100644
--- a/src/Coordination/KeeperSnapshotManager.h
+++ b/src/Coordination/KeeperSnapshotManager.h
@@ -18,7 +18,7 @@ enum SnapshotVersion : uint8_t
 struct KeeperStorageSnapshot
 {
 public:
-    KeeperStorageSnapshot(KeeperStorage * storage_, size_t up_to_log_idx_);
+    KeeperStorageSnapshot(KeeperStorage * storage_, uint64_t up_to_log_idx_);
 
     KeeperStorageSnapshot(KeeperStorage * storage_, const SnapshotMetadataPtr & snapshot_meta_);
     ~KeeperStorageSnapshot();
@@ -51,14 +51,14 @@ public:
     SnapshotMetaAndStorage restoreFromLatestSnapshot();
 
     static nuraft::ptr<nuraft::buffer> serializeSnapshotToBuffer(const KeeperStorageSnapshot & snapshot);
-    std::string serializeSnapshotBufferToDisk(nuraft::buffer & buffer, size_t up_to_log_idx);
+    std::string serializeSnapshotBufferToDisk(nuraft::buffer & buffer, uint64_t up_to_log_idx);
 
     SnapshotMetaAndStorage deserializeSnapshotFromBuffer(nuraft::ptr<nuraft::buffer> buffer) const;
 
-    nuraft::ptr<nuraft::buffer> deserializeSnapshotBufferFromDisk(size_t up_to_log_idx) const;
+    nuraft::ptr<nuraft::buffer> deserializeSnapshotBufferFromDisk(uint64_t up_to_log_idx) const;
     nuraft::ptr<nuraft::buffer> deserializeLatestSnapshotBufferFromDisk();
 
-    void removeSnapshot(size_t log_idx);
+    void removeSnapshot(uint64_t log_idx);
 
     size_t totalSnapshots() const
     {
@@ -76,7 +76,7 @@ private:
     void removeOutdatedSnapshotsIfNeeded();
     const std::string snapshots_path;
     const size_t snapshots_to_keep;
-    std::map<size_t, std::string> existing_snapshots;
+    std::map<uint64_t, std::string> existing_snapshots;
     size_t storage_tick_time;
 };
 
diff --git a/src/Coordination/KeeperStateMachine.cpp b/src/Coordination/KeeperStateMachine.cpp
index 227bb1aaa4e..c909cfc68e2 100644
--- a/src/Coordination/KeeperStateMachine.cpp
+++ b/src/Coordination/KeeperStateMachine.cpp
@@ -54,7 +54,7 @@ void KeeperStateMachine::init()
     bool has_snapshots = snapshot_manager.totalSnapshots() != 0;
     while (snapshot_manager.totalSnapshots() != 0)
     {
-        size_t latest_log_index = snapshot_manager.getLatestSnapshotIndex();
+        uint64_t latest_log_index = snapshot_manager.getLatestSnapshotIndex();
         LOG_DEBUG(log, "Trying to load state machine from snapshot up to log index {}", latest_log_index);
 
         try
@@ -88,7 +88,7 @@ void KeeperStateMachine::init()
         storage = std::make_unique<KeeperStorage>(coordination_settings->dead_session_check_period_ms.totalMilliseconds());
 }
 
-nuraft::ptr<nuraft::buffer> KeeperStateMachine::commit(const size_t log_idx, nuraft::buffer & data)
+nuraft::ptr<nuraft::buffer> KeeperStateMachine::commit(const uint64_t log_idx, nuraft::buffer & data)
 {
     if (data.size() == sizeof(int64_t))
     {
@@ -205,7 +205,7 @@ void KeeperStateMachine::create_snapshot(
 
 void KeeperStateMachine::save_logical_snp_obj(
     nuraft::snapshot & s,
-    size_t & obj_id,
+    uint64_t & obj_id,
     nuraft::buffer & data,
     bool /*is_first_obj*/,
     bool /*is_last_obj*/)
@@ -246,7 +246,7 @@ void KeeperStateMachine::save_logical_snp_obj(
 int KeeperStateMachine::read_logical_snp_obj(
     nuraft::snapshot & s,
     void* & /*user_snp_ctx*/,
-    ulong obj_id,
+    uint64_t obj_id,
     nuraft::ptr<nuraft::buffer> & data_out,
     bool & is_last_obj)
 {
diff --git a/src/Coordination/KeeperStateMachine.h b/src/Coordination/KeeperStateMachine.h
index aefdbe3f9f3..8712adaf4b1 100644
--- a/src/Coordination/KeeperStateMachine.h
+++ b/src/Coordination/KeeperStateMachine.h
@@ -20,13 +20,13 @@ public:
 
     void init();
 
-    nuraft::ptr<nuraft::buffer> pre_commit(const size_t /*log_idx*/, nuraft::buffer & /*data*/) override { return nullptr; }
+    nuraft::ptr<nuraft::buffer> pre_commit(const uint64_t /*log_idx*/, nuraft::buffer & /*data*/) override { return nullptr; }
 
-    nuraft::ptr<nuraft::buffer> commit(const size_t log_idx, nuraft::buffer & data) override;
+    nuraft::ptr<nuraft::buffer> commit(const uint64_t log_idx, nuraft::buffer & data) override;
 
-    void rollback(const size_t /*log_idx*/, nuraft::buffer & /*data*/) override {}
+    void rollback(const uint64_t /*log_idx*/, nuraft::buffer & /*data*/) override {}
 
-    size_t last_commit_index() override { return last_committed_idx; }
+    uint64_t last_commit_index() override { return last_committed_idx; }
 
     bool apply_snapshot(nuraft::snapshot & s) override;
 
@@ -38,7 +38,7 @@ public:
 
     void save_logical_snp_obj(
         nuraft::snapshot & s,
-        size_t & obj_id,
+        uint64_t & obj_id,
         nuraft::buffer & data,
         bool is_first_obj,
         bool is_last_obj) override;
@@ -46,7 +46,7 @@ public:
     int read_logical_snp_obj(
         nuraft::snapshot & s,
         void* & user_snp_ctx,
-        ulong obj_id,
+        uint64_t obj_id,
         nuraft::ptr<nuraft::buffer> & data_out,
         bool & is_last_obj) override;
 
@@ -82,7 +82,7 @@ private:
     std::mutex storage_lock;
 
     /// Last committed Raft log number.
-    std::atomic<size_t> last_committed_idx;
+    std::atomic<uint64_t> last_committed_idx;
     Poco::Logger * log;
 };
 
diff --git a/src/Coordination/KeeperStateManager.cpp b/src/Coordination/KeeperStateManager.cpp
index ad656cd1f95..e57ae7e7c19 100644
--- a/src/Coordination/KeeperStateManager.cpp
+++ b/src/Coordination/KeeperStateManager.cpp
@@ -12,6 +12,7 @@ namespace ErrorCodes
 KeeperStateManager::KeeperStateManager(int server_id_, const std::string & host, int port, const std::string & logs_path)
     : my_server_id(server_id_)
     , my_port(port)
+    , secure(false)
     , log_store(nuraft::cs_new<KeeperLogStore>(logs_path, 5000, false))
     , cluster_config(nuraft::cs_new<nuraft::cluster_config>())
 {
@@ -25,6 +26,7 @@ KeeperStateManager::KeeperStateManager(
     const Poco::Util::AbstractConfiguration & config,
     const CoordinationSettingsPtr & coordination_settings)
     : my_server_id(my_server_id_)
+    , secure(config.getBool(config_prefix + ".raft_configuration.secure", false))
     , log_store(nuraft::cs_new<KeeperLogStore>(
                     config.getString(config_prefix + ".log_storage_path", config.getString("path", DBMS_DEFAULT_PATH) + "coordination/logs"),
                     coordination_settings->rotate_log_storage_interval, coordination_settings->force_sync))
@@ -37,6 +39,9 @@ KeeperStateManager::KeeperStateManager(
 
     for (const auto & server_key : keys)
     {
+        if (!startsWith(server_key, "server"))
+            continue;
+
         std::string full_prefix = config_prefix + ".raft_configuration." + server_key;
         int server_id = config.getInt(full_prefix + ".id");
         std::string hostname = config.getString(full_prefix + ".hostname");
@@ -44,6 +49,7 @@ KeeperStateManager::KeeperStateManager(
         bool can_become_leader = config.getBool(full_prefix + ".can_become_leader", true);
         int32_t priority = config.getInt(full_prefix + ".priority", 1);
         bool start_as_follower = config.getBool(full_prefix + ".start_as_follower", false);
+
         if (start_as_follower)
             start_as_follower_servers.insert(server_id);
 
@@ -57,6 +63,7 @@ KeeperStateManager::KeeperStateManager(
 
         cluster_config->get_servers().push_back(peer_config);
     }
+
     if (!my_server_config)
         throw Exception(ErrorCodes::RAFT_ERROR, "Our server id {} not found in raft_configuration section", my_server_id);
 
@@ -64,7 +71,7 @@ KeeperStateManager::KeeperStateManager(
         throw Exception(ErrorCodes::RAFT_ERROR, "At least one of servers should be able to start as leader (without <start_as_follower>)");
 }
 
-void KeeperStateManager::loadLogStore(size_t last_commited_index, size_t logs_to_keep)
+void KeeperStateManager::loadLogStore(uint64_t last_commited_index, uint64_t logs_to_keep)
 {
     log_store->init(last_commited_index, logs_to_keep);
 }
diff --git a/src/Coordination/KeeperStateManager.h b/src/Coordination/KeeperStateManager.h
index f0575082b02..cb5181760cb 100644
--- a/src/Coordination/KeeperStateManager.h
+++ b/src/Coordination/KeeperStateManager.h
@@ -25,7 +25,7 @@ public:
         int port,
         const std::string & logs_path);
 
-    void loadLogStore(size_t last_commited_index, size_t logs_to_keep);
+    void loadLogStore(uint64_t last_commited_index, uint64_t logs_to_keep);
 
     void flushLogStore();
 
@@ -52,14 +52,20 @@ public:
         return start_as_follower_servers.count(my_server_id);
     }
 
+    bool isSecure() const
+    {
+        return secure;
+    }
+
     nuraft::ptr<KeeperLogStore> getLogStore() const { return log_store; }
 
-    size_t getTotalServers() const { return total_servers; }
+    uint64_t getTotalServers() const { return total_servers; }
 
 private:
     int my_server_id;
     int my_port;
-    size_t total_servers{0};
+    bool secure;
+    uint64_t total_servers{0};
     std::unordered_set<int> start_as_follower_servers;
     nuraft::ptr<KeeperLogStore> log_store;
     nuraft::ptr<nuraft::srv_config> my_server_config;
diff --git a/src/Coordination/SummingStateMachine.cpp b/src/Coordination/SummingStateMachine.cpp
index 0cb7a7da6c3..ae3d2b06d75 100644
--- a/src/Coordination/SummingStateMachine.cpp
+++ b/src/Coordination/SummingStateMachine.cpp
@@ -21,7 +21,7 @@ SummingStateMachine::SummingStateMachine()
 {
 }
 
-nuraft::ptr<nuraft::buffer> SummingStateMachine::commit(const size_t log_idx, nuraft::buffer & data)
+nuraft::ptr<nuraft::buffer> SummingStateMachine::commit(const uint64_t log_idx, nuraft::buffer & data)
 {
     int64_t value_to_add = deserializeValue(data);
 
@@ -84,7 +84,7 @@ void SummingStateMachine::createSnapshotInternal(nuraft::snapshot & s)
 
 void SummingStateMachine::save_logical_snp_obj(
     nuraft::snapshot & s,
-    size_t & obj_id,
+    uint64_t & obj_id,
     nuraft::buffer & data,
     bool /*is_first_obj*/,
     bool /*is_last_obj*/)
@@ -112,7 +112,7 @@ void SummingStateMachine::save_logical_snp_obj(
 int SummingStateMachine::read_logical_snp_obj(
     nuraft::snapshot & s,
     void* & /*user_snp_ctx*/,
-    size_t obj_id,
+    uint64_t obj_id,
     nuraft::ptr<nuraft::buffer> & data_out,
     bool & is_last_obj)
 {
@@ -142,7 +142,7 @@ int SummingStateMachine::read_logical_snp_obj(
     else
     {
         // Object ID > 0: second object, put actual value.
-        data_out = nuraft::buffer::alloc(sizeof(size_t));
+        data_out = nuraft::buffer::alloc(sizeof(uint64_t));
         nuraft::buffer_serializer bs(data_out);
         bs.put_u64(ctx->value);
         is_last_obj = true;
diff --git a/src/Coordination/SummingStateMachine.h b/src/Coordination/SummingStateMachine.h
index c8594ba7e8d..03572840739 100644
--- a/src/Coordination/SummingStateMachine.h
+++ b/src/Coordination/SummingStateMachine.h
@@ -15,13 +15,13 @@ class SummingStateMachine : public nuraft::state_machine
 public:
     SummingStateMachine();
 
-    nuraft::ptr<nuraft::buffer> pre_commit(const size_t /*log_idx*/, nuraft::buffer & /*data*/) override { return nullptr; }
+    nuraft::ptr<nuraft::buffer> pre_commit(const uint64_t /*log_idx*/, nuraft::buffer & /*data*/) override { return nullptr; }
 
-    nuraft::ptr<nuraft::buffer> commit(const size_t log_idx, nuraft::buffer & data) override;
+    nuraft::ptr<nuraft::buffer> commit(const uint64_t log_idx, nuraft::buffer & data) override;
 
-    void rollback(const size_t /*log_idx*/, nuraft::buffer & /*data*/) override {}
+    void rollback(const uint64_t /*log_idx*/, nuraft::buffer & /*data*/) override {}
 
-    size_t last_commit_index() override { return last_committed_idx; }
+    uint64_t last_commit_index() override { return last_committed_idx; }
 
     bool apply_snapshot(nuraft::snapshot & s) override;
 
@@ -33,7 +33,7 @@ public:
 
     void save_logical_snp_obj(
         nuraft::snapshot & s,
-        size_t & obj_id,
+        uint64_t & obj_id,
         nuraft::buffer & data,
         bool is_first_obj,
         bool is_last_obj) override;
@@ -41,7 +41,7 @@ public:
     int read_logical_snp_obj(
         nuraft::snapshot & s,
         void* & user_snp_ctx,
-        size_t obj_id,
+        uint64_t obj_id,
         nuraft::ptr<nuraft::buffer> & data_out,
         bool & is_last_obj) override;
 
diff --git a/src/Coordination/tests/gtest_for_build.cpp b/src/Coordination/tests/gtest_for_build.cpp
index 06e60e5592f..0e06af1a7f3 100644
--- a/src/Coordination/tests/gtest_for_build.cpp
+++ b/src/Coordination/tests/gtest_for_build.cpp
@@ -1085,7 +1085,7 @@ nuraft::ptr<nuraft::log_entry> getLogEntryFromZKRequest(size_t term, int64_t ses
     return nuraft::cs_new<nuraft::log_entry>(term, buffer);
 }
 
-void testLogAndStateMachine(Coordination::CoordinationSettingsPtr settings, size_t total_logs)
+void testLogAndStateMachine(Coordination::CoordinationSettingsPtr settings, uint64_t total_logs)
 {
     using namespace Coordination;
     using namespace DB;
diff --git a/src/Core/Block.h b/src/Core/Block.h
index 914d6b361b9..0cfd17b27dc 100644
--- a/src/Core/Block.h
+++ b/src/Core/Block.h
@@ -1,15 +1,15 @@
 #pragma once
 
-#include <vector>
-#include <list>
-#include <set>
-#include <map>
-#include <initializer_list>
-
 #include <Core/BlockInfo.h>
-#include <Core/NamesAndTypes.h>
 #include <Core/ColumnWithTypeAndName.h>
 #include <Core/ColumnsWithTypeAndName.h>
+#include <Core/NamesAndTypes.h>
+
+#include <initializer_list>
+#include <list>
+#include <map>
+#include <set>
+#include <vector>
 
 
 namespace DB
@@ -22,8 +22,6 @@ namespace DB
   * Allows to insert, remove columns in arbitrary position, to change order of columns.
   */
 
-class Context;
-
 class Block
 {
 private:
diff --git a/src/Core/BlockInfo.h b/src/Core/BlockInfo.h
index c8dd1576b22..125c90b1b23 100644
--- a/src/Core/BlockInfo.h
+++ b/src/Core/BlockInfo.h
@@ -1,9 +1,10 @@
 #pragma once
 
-#include <unordered_map>
-
 #include <common/types.h>
 
+#include <unordered_map>
+#include <vector>
+
 
 namespace DB
 {
diff --git a/src/Core/Defines.h b/src/Core/Defines.h
index 468c1187e91..e7c1c86a23e 100644
--- a/src/Core/Defines.h
+++ b/src/Core/Defines.h
@@ -81,8 +81,9 @@
 #define DBMS_MIN_REVISION_WITH_REFERER_IN_CLIENT_INFO 54447
 
 /// Version of ClickHouse TCP protocol. Increment it manually when you change the protocol.
-#define DBMS_TCP_PROTOCOL_VERSION 54447
+#define DBMS_TCP_PROTOCOL_VERSION 54448
 
+#define DBMS_MIN_PROTOCOL_VERSION_WITH_DISTRIBUTED_DEPTH 54448
 /// The boundary on which the blocks for asynchronous file operations should be aligned.
 #define DEFAULT_AIO_FILE_BLOCK_SIZE 4096
 
diff --git a/src/Core/ExternalTable.cpp b/src/Core/ExternalTable.cpp
index afc9fe00ef5..87945dd1ce6 100644
--- a/src/Core/ExternalTable.cpp
+++ b/src/Core/ExternalTable.cpp
@@ -31,11 +31,11 @@ namespace ErrorCodes
 }
 
 
-ExternalTableDataPtr BaseExternalTable::getData(const Context & context)
+ExternalTableDataPtr BaseExternalTable::getData(ContextPtr context)
 {
     initReadBuffer();
     initSampleBlock();
-    auto input = context.getInputFormat(format, *read_buffer, sample_block, DEFAULT_BLOCK_SIZE);
+    auto input = context->getInputFormat(format, *read_buffer, sample_block, DEFAULT_BLOCK_SIZE);
     auto stream = std::make_shared<AsynchronousBlockInputStream>(input);
 
     auto data = std::make_unique<ExternalTableData>();
@@ -127,7 +127,7 @@ ExternalTable::ExternalTable(const boost::program_options::variables_map & exter
 
 void ExternalTablesHandler::handlePart(const Poco::Net::MessageHeader & header, ReadBuffer & stream)
 {
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = getContext()->getSettingsRef();
 
     if (settings.http_max_multipart_form_data_size)
         read_buffer = std::make_unique<LimitReadBuffer>(
@@ -152,14 +152,14 @@ void ExternalTablesHandler::handlePart(const Poco::Net::MessageHeader & header,
     else
         throw Exception("Neither structure nor types have not been provided for external table " + name + ". Use fields " + name + "_structure or " + name + "_types to do so.", ErrorCodes::BAD_ARGUMENTS);
 
-    ExternalTableDataPtr data = getData(context);
+    ExternalTableDataPtr data = getData(getContext());
 
     /// Create table
     NamesAndTypesList columns = sample_block.getNamesAndTypesList();
-    auto temporary_table = TemporaryTableHolder(context, ColumnsDescription{columns}, {});
+    auto temporary_table = TemporaryTableHolder(getContext(), ColumnsDescription{columns}, {});
     auto storage = temporary_table.getTable();
-    context.addExternalTable(data->table_name, std::move(temporary_table));
-    BlockOutputStreamPtr output = storage->write(ASTPtr(), storage->getInMemoryMetadataPtr(), context);
+    getContext()->addExternalTable(data->table_name, std::move(temporary_table));
+    BlockOutputStreamPtr output = storage->write(ASTPtr(), storage->getInMemoryMetadataPtr(), getContext());
 
     /// Write data
     data->pipe->resize(1);
diff --git a/src/Core/ExternalTable.h b/src/Core/ExternalTable.h
index aa15846d48a..fcefa3d7fe3 100644
--- a/src/Core/ExternalTable.h
+++ b/src/Core/ExternalTable.h
@@ -2,6 +2,7 @@
 
 #include <Client/Connection.h>
 #include <Core/Block.h>
+#include <Interpreters/Context_fwd.h>
 #include <IO/ReadBuffer.h>
 #include <Server/HTTP/HTMLForm.h>
 
@@ -11,30 +12,21 @@
 #include <vector>
 
 
-namespace Poco
+namespace Poco::Net
 {
-    namespace Net
-    {
-        class NameValueCollection;
-        class MessageHeader;
-    }
+class NameValueCollection;
+class MessageHeader;
 }
 
-namespace boost
+namespace boost::program_options
 {
-    namespace program_options
-    {
-        class variables_map;
-    }
+class variables_map;
 }
 
 
 namespace DB
 {
 
-class Context;
-
-
 /// The base class containing the basic information about external table and
 /// basic functions for extracting this information from text fields.
 class BaseExternalTable
@@ -56,7 +48,7 @@ public:
     virtual void initReadBuffer() {}
 
     /// Get the table data - a pair (a stream with the contents of the table, the name of the table)
-    ExternalTableDataPtr getData(const Context & context);
+    ExternalTableDataPtr getData(ContextPtr context);
 
 protected:
     /// Clear all accumulated information
@@ -88,15 +80,14 @@ public:
 /// Parsing of external table used when sending tables via http
 /// The `handlePart` function will be called for each table passed,
 /// so it's also necessary to call `clean` at the end of the `handlePart`.
-class ExternalTablesHandler : public HTMLForm::PartHandler, BaseExternalTable
+class ExternalTablesHandler : public HTMLForm::PartHandler, BaseExternalTable, WithContext
 {
 public:
-    ExternalTablesHandler(Context & context_, const Poco::Net::NameValueCollection & params_) : context(context_), params(params_) {}
+    ExternalTablesHandler(ContextPtr context_, const Poco::Net::NameValueCollection & params_) : WithContext(context_), params(params_) {}
 
     void handlePart(const Poco::Net::MessageHeader & header, ReadBuffer & stream) override;
 
 private:
-    Context & context;
     const Poco::Net::NameValueCollection & params;
 };
 
diff --git a/src/Core/MySQL/Authentication.cpp b/src/Core/MySQL/Authentication.cpp
index e685ad0394d..b8dff9972c7 100644
--- a/src/Core/MySQL/Authentication.cpp
+++ b/src/Core/MySQL/Authentication.cpp
@@ -73,7 +73,7 @@ Native41::Native41(const String & password, const String & auth_plugin_data)
 }
 
 void Native41::authenticate(
-    const String & user_name, std::optional<String> auth_response, Context & context,
+    const String & user_name, std::optional<String> auth_response, ContextPtr context,
     std::shared_ptr<PacketEndpoint> packet_endpoint, bool, const Poco::Net::SocketAddress & address)
 {
     if (!auth_response)
@@ -86,15 +86,17 @@ void Native41::authenticate(
 
     if (auth_response->empty())
     {
-        context.setUser(user_name, "", address);
+        context->setUser(user_name, "", address);
         return;
     }
 
     if (auth_response->size() != Poco::SHA1Engine::DIGEST_SIZE)
-        throw Exception("Wrong size of auth response. Expected: " + std::to_string(Poco::SHA1Engine::DIGEST_SIZE) + " bytes, received: " + std::to_string(auth_response->size()) + " bytes.",
-                        ErrorCodes::UNKNOWN_EXCEPTION);
+        throw Exception(
+            "Wrong size of auth response. Expected: " + std::to_string(Poco::SHA1Engine::DIGEST_SIZE)
+                + " bytes, received: " + std::to_string(auth_response->size()) + " bytes.",
+            ErrorCodes::UNKNOWN_EXCEPTION);
 
-    auto user = context.getAccessControlManager().read<User>(user_name);
+    auto user = context->getAccessControlManager().read<User>(user_name);
 
     Poco::SHA1Engine::Digest double_sha1_value = user->authentication.getPasswordDoubleSHA1();
     assert(double_sha1_value.size() == Poco::SHA1Engine::DIGEST_SIZE);
@@ -109,7 +111,7 @@ void Native41::authenticate(
     {
         password_sha1[i] = digest[i] ^ static_cast<unsigned char>((*auth_response)[i]);
     }
-    context.setUser(user_name, password_sha1, address);
+    context->setUser(user_name, password_sha1, address);
 }
 
 #if USE_SSL
@@ -134,7 +136,7 @@ Sha256Password::Sha256Password(RSA & public_key_, RSA & private_key_, Poco::Logg
 }
 
 void Sha256Password::authenticate(
-    const String & user_name, std::optional<String> auth_response, Context & context,
+    const String & user_name, std::optional<String> auth_response, ContextPtr context,
     std::shared_ptr<PacketEndpoint> packet_endpoint, bool is_secure_connection, const Poco::Net::SocketAddress & address)
 {
     if (!auth_response)
@@ -229,7 +231,7 @@ void Sha256Password::authenticate(
         password.pop_back();
     }
 
-    context.setUser(user_name, password, address);
+    context->setUser(user_name, password, address);
 }
 
 #endif
diff --git a/src/Core/MySQL/Authentication.h b/src/Core/MySQL/Authentication.h
index e1b7c174139..5358e2da737 100644
--- a/src/Core/MySQL/Authentication.h
+++ b/src/Core/MySQL/Authentication.h
@@ -32,7 +32,7 @@ public:
     virtual String getAuthPluginData() = 0;
 
     virtual void authenticate(
-        const String & user_name, std::optional<String> auth_response, Context & context,
+        const String & user_name, std::optional<String> auth_response, ContextPtr context,
         std::shared_ptr<PacketEndpoint> packet_endpoint, bool is_secure_connection, const Poco::Net::SocketAddress & address) = 0;
 };
 
@@ -49,7 +49,7 @@ public:
     String getAuthPluginData() override { return scramble; }
 
     void authenticate(
-        const String & user_name, std::optional<String> auth_response, Context & context,
+        const String & user_name, std::optional<String> auth_response, ContextPtr context,
         std::shared_ptr<PacketEndpoint> packet_endpoint, bool /* is_secure_connection */, const Poco::Net::SocketAddress & address) override;
 
 private:
@@ -69,7 +69,7 @@ public:
     String getAuthPluginData() override { return scramble; }
 
     void authenticate(
-        const String & user_name, std::optional<String> auth_response, Context & context,
+        const String & user_name, std::optional<String> auth_response, ContextPtr context,
         std::shared_ptr<PacketEndpoint> packet_endpoint, bool is_secure_connection, const Poco::Net::SocketAddress & address) override;
 
 private:
diff --git a/src/Core/PostgreSQLProtocol.h b/src/Core/PostgreSQLProtocol.h
index 471811e969b..62b87e78642 100644
--- a/src/Core/PostgreSQLProtocol.h
+++ b/src/Core/PostgreSQLProtocol.h
@@ -797,15 +797,15 @@ namespace PGAuthentication
 class AuthenticationMethod
 {
 protected:
-    void setPassword(
+    static void setPassword(
         const String & user_name,
         const String & password,
-        Context & context,
+        ContextPtr context,
         Messaging::MessageTransport & mt,
         const Poco::Net::SocketAddress & address)
     {
         try {
-            context.setUser(user_name, password, address);
+            context->setUser(user_name, password, address);
         }
         catch (const Exception &)
         {
@@ -819,7 +819,7 @@ protected:
 public:
     virtual void authenticate(
         const String & user_name,
-        Context & context,
+        ContextPtr context,
         Messaging::MessageTransport & mt,
         const Poco::Net::SocketAddress & address) = 0;
 
@@ -833,7 +833,7 @@ class NoPasswordAuth : public AuthenticationMethod
 public:
     void authenticate(
         const String & /* user_name */,
-        Context & /* context */,
+        ContextPtr /* context */,
         Messaging::MessageTransport & /* mt */,
         const Poco::Net::SocketAddress & /* address */) override {}
 
@@ -848,7 +848,7 @@ class CleartextPasswordAuth : public AuthenticationMethod
 public:
     void authenticate(
         const String & user_name,
-        Context & context,
+        ContextPtr context,
         Messaging::MessageTransport & mt,
         const Poco::Net::SocketAddress & address) override
     {
@@ -891,11 +891,11 @@ public:
 
     void authenticate(
         const String & user_name,
-        Context & context,
+        ContextPtr context,
         Messaging::MessageTransport & mt,
         const Poco::Net::SocketAddress & address)
     {
-        auto user = context.getAccessControlManager().read<User>(user_name);
+        auto user = context->getAccessControlManager().read<User>(user_name);
         Authentication::Type user_auth_type = user->authentication.getType();
 
         if (type_to_method.find(user_auth_type) != type_to_method.end())
diff --git a/src/Core/Settings.h b/src/Core/Settings.h
index 045433dc895..d31073ae932 100644
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@@ -78,7 +78,7 @@ class IColumn;
     M(UInt64, background_buffer_flush_schedule_pool_size, 16, "Number of threads performing background flush for tables with Buffer engine. Only has meaning at server startup.", 0) \
     M(UInt64, background_pool_size, 16, "Number of threads performing background work for tables (for example, merging in merge tree). Only has meaning at server startup.", 0) \
     M(UInt64, background_move_pool_size, 8, "Number of threads performing background moves for tables. Only has meaning at server startup.", 0) \
-    M(UInt64, background_fetches_pool_size, 3, "Number of threads performing background fetches for replicated tables. Only has meaning at server startup.", 0) \
+    M(UInt64, background_fetches_pool_size, 8, "Number of threads performing background fetches for replicated tables. Only has meaning at server startup.", 0) \
     M(UInt64, background_schedule_pool_size, 16, "Number of threads performing background tasks for replicated tables, dns cache updates. Only has meaning at server startup.", 0) \
     M(UInt64, background_message_broker_schedule_pool_size, 16, "Number of threads performing background tasks for message streaming. Only has meaning at server startup.", 0) \
     M(UInt64, background_distributed_schedule_pool_size, 16, "Number of threads performing background tasks for distributed sends. Only has meaning at server startup.", 0) \
@@ -118,6 +118,7 @@ class IColumn;
     M(Bool, optimize_distributed_group_by_sharding_key, false, "Optimize GROUP BY sharding_key queries (by avoiding costly aggregation on the initiator server).", 0) \
     M(UInt64, optimize_skip_unused_shards_limit, 1000, "Limit for number of sharding key values, turns off optimize_skip_unused_shards if the limit is reached", 0) \
     M(Bool, optimize_skip_unused_shards, false, "Assumes that data is distributed by sharding_key. Optimization to skip unused shards if SELECT query filters by sharding_key.", 0) \
+    M(Bool, optimize_skip_unused_shards_rewrite_in, true, "Rewrite IN in query for remote shards to exclude values that does not belong to the shard (requires optimize_skip_unused_shards)", 0) \
     M(Bool, allow_nondeterministic_optimize_skip_unused_shards, false, "Allow non-deterministic functions (includes dictGet) in sharding_key for optimize_skip_unused_shards", 0) \
     M(UInt64, force_optimize_skip_unused_shards, 0, "Throw an exception if unused shards cannot be skipped (1 - throw only if the table has the sharding key, 2 - always throw.", 0) \
     M(UInt64, optimize_skip_unused_shards_nesting, 0, "Same as optimize_skip_unused_shards, but accept nesting level until which it will work.", 0) \
@@ -228,7 +229,7 @@ class IColumn;
     M(Seconds, http_connection_timeout, DEFAULT_HTTP_READ_BUFFER_CONNECTION_TIMEOUT, "HTTP connection timeout.", 0) \
     M(Seconds, http_send_timeout, DEFAULT_HTTP_READ_BUFFER_TIMEOUT, "HTTP send timeout", 0) \
     M(Seconds, http_receive_timeout, DEFAULT_HTTP_READ_BUFFER_TIMEOUT, "HTTP receive timeout", 0) \
-    M(UInt64, http_max_uri_size, 16384, "Maximum URI length of HTTP request", 0) \
+    M(UInt64, http_max_uri_size, 1048576, "Maximum URI length of HTTP request", 0) \
     M(Bool, optimize_throw_if_noop, false, "If setting is enabled and OPTIMIZE query didn't actually assign a merge then an explanatory exception is thrown", 0) \
     M(Bool, use_index_for_in_with_subqueries, true, "Try using an index if there is a subquery or a table expression on the right side of the IN operator.", 0) \
     M(Bool, joined_subquery_requires_alias, true, "Force joined subqueries and table functions to have aliases for correct name qualification.", 0) \
@@ -371,6 +372,8 @@ class IColumn;
     \
     M(UInt64, postgresql_connection_pool_size, 16, "Connection pool size for PostgreSQL table engine and database engine.", 0) \
     M(Int64, postgresql_connection_pool_wait_timeout, -1, "Connection pool push/pop timeout on empty pool for PostgreSQL table engine and database engine. By default it will block on empty pool.", 0) \
+    M(UInt64, glob_expansion_max_elements, 1000, "Maximum number of allowed addresses (For external storages, table functions, etc).", 0) \
+    M(UInt64, odbc_bridge_connection_pool_size, 16, "Connection pool size for each connection settings string in ODBC bridge.", 0) \
     \
     M(Seconds, distributed_replica_error_half_life, DBMS_CONNECTION_POOL_WITH_FAILOVER_DEFAULT_DECREASE_ERROR_PERIOD, "Time period reduces replica error counter by 2 times.", 0) \
     M(UInt64, distributed_replica_error_cap, DBMS_CONNECTION_POOL_WITH_FAILOVER_MAX_ERROR_COUNT, "Max number of errors per replica, prevents piling up an incredible amount of errors if replica was offline for some time and allows it to be reconsidered in a shorter amount of time.", 0) \
@@ -440,6 +443,7 @@ class IColumn;
     M(Bool, engine_file_truncate_on_insert, false, "Enables or disables truncate before insert in file engine tables", 0) \
     M(Bool, allow_experimental_database_replicated, false, "Allow to create databases with Replicated engine", 0) \
     M(UInt64, database_replicated_initial_query_timeout_sec, 300, "How long initial DDL query should wait for Replicated database to precess previous DDL queue entries", 0) \
+    M(UInt64, max_distributed_depth, 5, "Maximum distributed query depth", 0) \
     M(Bool, database_replicated_always_detach_permanently, false, "Execute DETACH TABLE as DETACH TABLE PERMANENTLY if database engine is Replicated", 0) \
     M(DistributedDDLOutputMode, distributed_ddl_output_mode, DistributedDDLOutputMode::THROW, "Format of distributed DDL query result", 0) \
     M(UInt64, distributed_ddl_entry_format_version, 1, "Version of DDL entry to write into ZooKeeper", 0) \
@@ -453,8 +457,13 @@ class IColumn;
     M(UnionMode, union_default_mode, UnionMode::Unspecified, "Set default Union Mode in SelectWithUnion query. Possible values: empty string, 'ALL', 'DISTINCT'. If empty, query without Union Mode will throw exception.", 0) \
     M(Bool, optimize_aggregators_of_group_by_keys, true, "Eliminates min/max/any/anyLast aggregators of GROUP BY keys in SELECT section", 0) \
     M(Bool, optimize_group_by_function_keys, true, "Eliminates functions of other keys in GROUP BY section", 0) \
+    \
+    M(Bool, query_plan_enable_optimizations, true, "Apply optimizations to query plan", 0) \
     M(UInt64, query_plan_max_optimizations_to_apply, 10000, "Limit the total number of optimizations applied to query plan. If zero, ignored. If limit reached, throw exception", 0) \
+    M(Bool, query_plan_filter_push_down, true, "Allow to push down filter by predicate query plan step", 0) \
+    \
     M(Bool, database_replicated_ddl_output, true, "Obsolete setting, does nothing. Will be removed after 2021-09-08", 0) \
+    M(HandleKafkaErrorMode, handle_kafka_error_mode, HandleKafkaErrorMode::DEFAULT, "How to handle errors for Kafka engine. Passible values: default, stream.", 0) \
 
 // End of COMMON_SETTINGS
 // Please add settings related to formats into the FORMAT_FACTORY_SETTINGS below.
diff --git a/src/Core/SettingsEnums.cpp b/src/Core/SettingsEnums.cpp
index 64ba51d1c68..26c2bd9b6af 100644
--- a/src/Core/SettingsEnums.cpp
+++ b/src/Core/SettingsEnums.cpp
@@ -108,4 +108,7 @@ IMPLEMENT_SETTING_ENUM(DistributedDDLOutputMode, ErrorCodes::BAD_ARGUMENTS,
      {"null_status_on_timeout", DistributedDDLOutputMode::NULL_STATUS_ON_TIMEOUT},
      {"never_throw", DistributedDDLOutputMode::NEVER_THROW}})
 
+IMPLEMENT_SETTING_ENUM(HandleKafkaErrorMode, ErrorCodes::BAD_ARGUMENTS,
+    {{"default",      HandleKafkaErrorMode::DEFAULT},
+     {"stream",       HandleKafkaErrorMode::STREAM}})
 }
diff --git a/src/Core/SettingsEnums.h b/src/Core/SettingsEnums.h
index 7615b185a61..f0dd10aacfb 100644
--- a/src/Core/SettingsEnums.h
+++ b/src/Core/SettingsEnums.h
@@ -138,7 +138,6 @@ enum class UnionMode
 
 DECLARE_SETTING_ENUM(UnionMode)
 
-
 enum class DistributedDDLOutputMode
 {
     NONE,
@@ -149,4 +148,13 @@ enum class DistributedDDLOutputMode
 
 DECLARE_SETTING_ENUM(DistributedDDLOutputMode)
 
+enum class HandleKafkaErrorMode
+{
+    DEFAULT = 0, // Ignore errors whit threshold.
+    STREAM, // Put errors to stream in the virtual column named ``_error.
+    /*FIXED_SYSTEM_TABLE, Put errors to in a fixed system table likey system.kafka_errors. This is not implemented now.  */
+    /*CUSTOM_SYSTEM_TABLE, Put errors to in a custom system table. This is not implemented now.  */
+};
+
+DECLARE_SETTING_ENUM(HandleKafkaErrorMode)
 }
diff --git a/src/DataStreams/AddingDefaultBlockOutputStream.cpp b/src/DataStreams/AddingDefaultBlockOutputStream.cpp
index f241d417205..f4d8f6954c1 100644
--- a/src/DataStreams/AddingDefaultBlockOutputStream.cpp
+++ b/src/DataStreams/AddingDefaultBlockOutputStream.cpp
@@ -10,7 +10,7 @@ AddingDefaultBlockOutputStream::AddingDefaultBlockOutputStream(
     const BlockOutputStreamPtr & output_,
     const Block & header_,
     const ColumnsDescription & columns_,
-    const Context & context_)
+    ContextPtr context_)
     : output(output_), header(header_)
 {
     auto dag = addMissingDefaults(header_, output->getHeader().getNamesAndTypesList(), columns_, context_);
diff --git a/src/DataStreams/AddingDefaultBlockOutputStream.h b/src/DataStreams/AddingDefaultBlockOutputStream.h
index 5fbbe2aed60..a8235d6623a 100644
--- a/src/DataStreams/AddingDefaultBlockOutputStream.h
+++ b/src/DataStreams/AddingDefaultBlockOutputStream.h
@@ -26,7 +26,7 @@ public:
         const BlockOutputStreamPtr & output_,
         const Block & header_,
         const ColumnsDescription & columns_,
-        const Context & context_);
+        ContextPtr context_);
 
     Block getHeader() const override { return header; }
     void write(const Block & block) override;
diff --git a/src/DataStreams/AddingDefaultsBlockInputStream.cpp b/src/DataStreams/AddingDefaultsBlockInputStream.cpp
index 81408b0aaa6..e3f0906cb03 100644
--- a/src/DataStreams/AddingDefaultsBlockInputStream.cpp
+++ b/src/DataStreams/AddingDefaultsBlockInputStream.cpp
@@ -130,7 +130,7 @@ static MutableColumnPtr mixColumns(const ColumnWithTypeAndName & col_read,
 AddingDefaultsBlockInputStream::AddingDefaultsBlockInputStream(
     const BlockInputStreamPtr & input,
     const ColumnsDescription & columns_,
-    const Context & context_)
+    ContextPtr context_)
     : columns(columns_)
     , column_defaults(columns.getDefaults())
     , context(context_)
diff --git a/src/DataStreams/AddingDefaultsBlockInputStream.h b/src/DataStreams/AddingDefaultsBlockInputStream.h
index b2efa5863ef..957f14caff3 100644
--- a/src/DataStreams/AddingDefaultsBlockInputStream.h
+++ b/src/DataStreams/AddingDefaultsBlockInputStream.h
@@ -7,8 +7,6 @@
 namespace DB
 {
 
-class Context;
-
 /// Adds defaults to columns using BlockDelayedDefaults bitmask attached to Block by child InputStream.
 class AddingDefaultsBlockInputStream : public IBlockInputStream
 {
@@ -16,7 +14,7 @@ public:
     AddingDefaultsBlockInputStream(
         const BlockInputStreamPtr & input,
         const ColumnsDescription & columns_,
-        const Context & context_);
+        ContextPtr context_);
 
     String getName() const override { return "AddingDefaults"; }
     Block getHeader() const override { return header; }
@@ -28,7 +26,7 @@ private:
     Block header;
     const ColumnsDescription columns;
     const ColumnDefaults column_defaults;
-    const Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/DataStreams/BlockIO.h b/src/DataStreams/BlockIO.h
index 91d7efac8d1..31a0e1020d2 100644
--- a/src/DataStreams/BlockIO.h
+++ b/src/DataStreams/BlockIO.h
@@ -50,7 +50,7 @@ struct BlockIO
         }
     }
 
-    void onException()
+    void onException() const
     {
         if (exception_callback)
             exception_callback();
diff --git a/src/DataStreams/CheckConstraintsBlockOutputStream.cpp b/src/DataStreams/CheckConstraintsBlockOutputStream.cpp
index 3b0b4db72f9..c4556162323 100644
--- a/src/DataStreams/CheckConstraintsBlockOutputStream.cpp
+++ b/src/DataStreams/CheckConstraintsBlockOutputStream.cpp
@@ -27,7 +27,7 @@ CheckConstraintsBlockOutputStream::CheckConstraintsBlockOutputStream(
     const BlockOutputStreamPtr & output_,
     const Block & header_,
     const ConstraintsDescription & constraints_,
-    const Context & context_)
+    ContextPtr context_)
     : table_id(table_id_),
     output(output_),
     header(header_),
diff --git a/src/DataStreams/CheckConstraintsBlockOutputStream.h b/src/DataStreams/CheckConstraintsBlockOutputStream.h
index a1be720f21e..0f115550eb8 100644
--- a/src/DataStreams/CheckConstraintsBlockOutputStream.h
+++ b/src/DataStreams/CheckConstraintsBlockOutputStream.h
@@ -20,7 +20,7 @@ public:
             const BlockOutputStreamPtr & output_,
             const Block & header_,
             const ConstraintsDescription & constraints_,
-            const Context & context_);
+            ContextPtr context_);
 
     Block getHeader() const override { return header; }
     void write(const Block & block) override;
diff --git a/src/DataStreams/IBlockInputStream.h b/src/DataStreams/IBlockInputStream.h
index 4e314ef2980..b077f87e8a8 100644
--- a/src/DataStreams/IBlockInputStream.h
+++ b/src/DataStreams/IBlockInputStream.h
@@ -2,9 +2,8 @@
 
 #include <Core/Block.h>
 #include <DataStreams/BlockStreamProfileInfo.h>
-#include <DataStreams/IBlockStream_fwd.h>
-#include <DataStreams/SizeLimits.h>
 #include <DataStreams/ExecutionSpeedLimits.h>
+#include <DataStreams/SizeLimits.h>
 #include <DataStreams/StreamLocalLimits.h>
 #include <IO/Progress.h>
 #include <Storages/TableLockHolder.h>
diff --git a/src/DataStreams/InputStreamFromASTInsertQuery.cpp b/src/DataStreams/InputStreamFromASTInsertQuery.cpp
index 70d69227ac0..0848d838276 100644
--- a/src/DataStreams/InputStreamFromASTInsertQuery.cpp
+++ b/src/DataStreams/InputStreamFromASTInsertQuery.cpp
@@ -24,7 +24,7 @@ InputStreamFromASTInsertQuery::InputStreamFromASTInsertQuery(
     const ASTPtr & ast,
     ReadBuffer * input_buffer_tail_part,
     const Block & header,
-    const Context & context,
+    ContextPtr context,
     const ASTPtr & input_function)
 {
     const auto * ast_insert_query = ast->as<ASTInsertQuery>();
@@ -58,9 +58,9 @@ InputStreamFromASTInsertQuery::InputStreamFromASTInsertQuery(
 
     input_buffer_contacenated = std::make_unique<ConcatReadBuffer>(buffers);
 
-    res_stream = context.getInputFormat(format, *input_buffer_contacenated, header, context.getSettings().max_insert_block_size);
+    res_stream = context->getInputFormat(format, *input_buffer_contacenated, header, context->getSettings().max_insert_block_size);
 
-    if (context.getSettingsRef().input_format_defaults_for_omitted_fields && ast_insert_query->table_id && !input_function)
+    if (context->getSettingsRef().input_format_defaults_for_omitted_fields && ast_insert_query->table_id && !input_function)
     {
         StoragePtr storage = DatabaseCatalog::instance().getTable(ast_insert_query->table_id, context);
         auto metadata_snapshot = storage->getInMemoryMetadataPtr();
diff --git a/src/DataStreams/InputStreamFromASTInsertQuery.h b/src/DataStreams/InputStreamFromASTInsertQuery.h
index d4c6443c77d..15b698a2d68 100644
--- a/src/DataStreams/InputStreamFromASTInsertQuery.h
+++ b/src/DataStreams/InputStreamFromASTInsertQuery.h
@@ -25,7 +25,7 @@ public:
         const ASTPtr & ast,
         ReadBuffer * input_buffer_tail_part,
         const Block & header,
-        const Context & context,
+        ContextPtr context,
         const ASTPtr & input_function);
 
     Block readImpl() override { return res_stream->read(); }
diff --git a/src/DataStreams/PostgreSQLBlockInputStream.cpp b/src/DataStreams/PostgreSQLBlockInputStream.cpp
index 478df9e2259..f4af15df011 100644
--- a/src/DataStreams/PostgreSQLBlockInputStream.cpp
+++ b/src/DataStreams/PostgreSQLBlockInputStream.cpp
@@ -28,7 +28,7 @@ namespace ErrorCodes
 }
 
 PostgreSQLBlockInputStream::PostgreSQLBlockInputStream(
-    PostgreSQLConnectionHolderPtr connection_,
+    postgres::ConnectionHolderPtr connection_,
     const std::string & query_str_,
     const Block & sample_block,
     const UInt64 max_block_size_)
@@ -120,8 +120,15 @@ void PostgreSQLBlockInputStream::insertValue(IColumn & column, std::string_view
     switch (type)
     {
         case ValueType::vtUInt8:
-            assert_cast<ColumnUInt8 &>(column).insertValue(pqxx::from_string<uint16_t>(value));
+        {
+            if (value == "t")
+                assert_cast<ColumnUInt8 &>(column).insertValue(1);
+            else if (value == "f")
+                assert_cast<ColumnUInt8 &>(column).insertValue(0);
+            else
+                assert_cast<ColumnUInt8 &>(column).insertValue(pqxx::from_string<uint16_t>(value));
             break;
+        }
         case ValueType::vtUInt16:
             assert_cast<ColumnUInt16 &>(column).insertValue(pqxx::from_string<uint16_t>(value));
             break;
diff --git a/src/DataStreams/PostgreSQLBlockInputStream.h b/src/DataStreams/PostgreSQLBlockInputStream.h
index 7795cc2d36a..b172cae5b62 100644
--- a/src/DataStreams/PostgreSQLBlockInputStream.h
+++ b/src/DataStreams/PostgreSQLBlockInputStream.h
@@ -19,7 +19,7 @@ class PostgreSQLBlockInputStream : public IBlockInputStream
 {
 public:
     PostgreSQLBlockInputStream(
-        PostgreSQLConnectionHolderPtr connection_,
+        postgres::ConnectionHolderPtr connection_,
         const std::string & query_str,
         const Block & sample_block,
         const UInt64 max_block_size_);
@@ -46,7 +46,7 @@ private:
     const UInt64 max_block_size;
     ExternalResultDescription description;
 
-    PostgreSQLConnectionHolderPtr connection;
+    postgres::ConnectionHolderPtr connection;
     std::unique_ptr<pqxx::read_transaction> tx;
     std::unique_ptr<pqxx::stream_from> stream;
 
diff --git a/src/DataStreams/PushingToViewsBlockOutputStream.cpp b/src/DataStreams/PushingToViewsBlockOutputStream.cpp
index 4d1990ffe18..56100205b0d 100644
--- a/src/DataStreams/PushingToViewsBlockOutputStream.cpp
+++ b/src/DataStreams/PushingToViewsBlockOutputStream.cpp
@@ -26,13 +26,13 @@ namespace DB
 PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
     const StoragePtr & storage_,
     const StorageMetadataPtr & metadata_snapshot_,
-    const Context & context_,
+    ContextPtr context_,
     const ASTPtr & query_ptr_,
     bool no_destination)
-    : storage(storage_)
+    : WithContext(context_)
+    , storage(storage_)
     , metadata_snapshot(metadata_snapshot_)
     , log(&Poco::Logger::get("PushingToViewsBlockOutputStream"))
-    , context(context_)
     , query_ptr(query_ptr_)
 {
     checkStackSize();
@@ -42,12 +42,12 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
       *  but it's clear that here is not the best place for this functionality.
       */
     addTableLock(
-        storage->lockForShare(context.getInitialQueryId(), context.getSettingsRef().lock_acquire_timeout));
+        storage->lockForShare(getContext()->getInitialQueryId(), getContext()->getSettingsRef().lock_acquire_timeout));
 
     /// If the "root" table deduplicates blocks, there are no need to make deduplication for children
     /// Moreover, deduplication for AggregatingMergeTree children could produce false positives due to low size of inserting blocks
     bool disable_deduplication_for_children = false;
-    if (!context.getSettingsRef().deduplicate_blocks_in_dependent_materialized_views)
+    if (!getContext()->getSettingsRef().deduplicate_blocks_in_dependent_materialized_views)
         disable_deduplication_for_children = !no_destination && storage->supportsDeduplication();
 
     auto table_id = storage->getStorageID();
@@ -56,8 +56,8 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
     /// We need special context for materialized views insertions
     if (!dependencies.empty())
     {
-        select_context = std::make_unique<Context>(context);
-        insert_context = std::make_unique<Context>(context);
+        select_context = Context::createCopy(context);
+        insert_context = Context::createCopy(context);
 
         const auto & insert_settings = insert_context->getSettingsRef();
 
@@ -74,7 +74,7 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
 
     for (const auto & database_table : dependencies)
     {
-        auto dependent_table = DatabaseCatalog::instance().getTable(database_table, context);
+        auto dependent_table = DatabaseCatalog::instance().getTable(database_table, getContext());
         auto dependent_metadata_snapshot = dependent_table->getInMemoryMetadataPtr();
 
         ASTPtr query;
@@ -83,7 +83,7 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
         if (auto * materialized_view = dynamic_cast<StorageMaterializedView *>(dependent_table.get()))
         {
             addTableLock(
-                materialized_view->lockForShare(context.getInitialQueryId(), context.getSettingsRef().lock_acquire_timeout));
+                materialized_view->lockForShare(getContext()->getInitialQueryId(), getContext()->getSettingsRef().lock_acquire_timeout));
 
             StoragePtr inner_table = materialized_view->getTargetTable();
             auto inner_table_id = inner_table->getStorageID();
@@ -94,7 +94,7 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
             insert->table_id = inner_table_id;
 
             /// Get list of columns we get from select query.
-            auto header = InterpreterSelectQuery(query, *select_context, SelectQueryOptions().analyze())
+            auto header = InterpreterSelectQuery(query, select_context, SelectQueryOptions().analyze())
                 .getSampleBlock();
 
             /// Insert only columns returned by select.
@@ -110,16 +110,16 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
             insert->columns = std::move(list);
 
             ASTPtr insert_query_ptr(insert.release());
-            InterpreterInsertQuery interpreter(insert_query_ptr, *insert_context);
+            InterpreterInsertQuery interpreter(insert_query_ptr, insert_context);
             BlockIO io = interpreter.execute();
             out = io.out;
         }
         else if (dynamic_cast<const StorageLiveView *>(dependent_table.get()))
             out = std::make_shared<PushingToViewsBlockOutputStream>(
-                dependent_table, dependent_metadata_snapshot, *insert_context, ASTPtr(), true);
+                dependent_table, dependent_metadata_snapshot, insert_context, ASTPtr(), true);
         else
             out = std::make_shared<PushingToViewsBlockOutputStream>(
-                dependent_table, dependent_metadata_snapshot, *insert_context, ASTPtr());
+                dependent_table, dependent_metadata_snapshot, insert_context, ASTPtr());
 
         views.emplace_back(ViewInfo{std::move(query), database_table, std::move(out), nullptr, 0 /* elapsed_ms */});
     }
@@ -127,7 +127,7 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
     /// Do not push to destination table if the flag is set
     if (!no_destination)
     {
-        output = storage->write(query_ptr, storage->getInMemoryMetadataPtr(), context);
+        output = storage->write(query_ptr, storage->getInMemoryMetadataPtr(), getContext());
         replicated_output = dynamic_cast<ReplicatedMergeTreeBlockOutputStream *>(output.get());
     }
 }
@@ -155,7 +155,7 @@ void PushingToViewsBlockOutputStream::write(const Block & block)
 
     if (auto * live_view = dynamic_cast<StorageLiveView *>(storage.get()))
     {
-        StorageLiveView::writeIntoLiveView(*live_view, block, context);
+        StorageLiveView::writeIntoLiveView(*live_view, block, getContext());
     }
     else
     {
@@ -166,11 +166,11 @@ void PushingToViewsBlockOutputStream::write(const Block & block)
     }
 
     /// Don't process materialized views if this block is duplicate
-    if (!context.getSettingsRef().deduplicate_blocks_in_dependent_materialized_views && replicated_output && replicated_output->lastBlockIsDuplicate())
+    if (!getContext()->getSettingsRef().deduplicate_blocks_in_dependent_materialized_views && replicated_output && replicated_output->lastBlockIsDuplicate())
         return;
 
     // Insert data into materialized views only after successful insert into main table
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = getContext()->getSettingsRef();
     if (settings.parallel_view_processing && views.size() > 1)
     {
         // Push to views concurrently if enabled and more than one view is attached
@@ -228,7 +228,7 @@ void PushingToViewsBlockOutputStream::writeSuffix()
 
     std::exception_ptr first_exception;
 
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = getContext()->getSettingsRef();
     bool parallel_processing = false;
 
     /// Run writeSuffix() for views in separate thread pool.
@@ -353,10 +353,9 @@ void PushingToViewsBlockOutputStream::process(const Block & block, ViewInfo & vi
             ///  but it will contain single block (that is INSERT-ed into main table).
             /// InterpreterSelectQuery will do processing of alias columns.
 
-            Context local_context = *select_context;
-            local_context.addViewSource(
-                StorageValues::create(
-                    storage->getStorageID(), metadata_snapshot->getColumns(), block, storage->getVirtuals()));
+            auto local_context = Context::createCopy(select_context);
+            local_context->addViewSource(
+                StorageValues::create(storage->getStorageID(), metadata_snapshot->getColumns(), block, storage->getVirtuals()));
             select.emplace(view.query, local_context, SelectQueryOptions());
             in = std::make_shared<MaterializingBlockInputStream>(select->execute().getInputStream());
 
@@ -364,7 +363,7 @@ void PushingToViewsBlockOutputStream::process(const Block & block, ViewInfo & vi
             /// even when only one block is inserted into the parent table (e.g. if the query is a GROUP BY
             /// and two-level aggregation is triggered).
             in = std::make_shared<SquashingBlockInputStream>(
-                    in, context.getSettingsRef().min_insert_block_size_rows, context.getSettingsRef().min_insert_block_size_bytes);
+                    in, getContext()->getSettingsRef().min_insert_block_size_rows, getContext()->getSettingsRef().min_insert_block_size_bytes);
             in = std::make_shared<ConvertingBlockInputStream>(in, view.out->getHeader(), ConvertingBlockInputStream::MatchColumnsMode::Name);
         }
         else
diff --git a/src/DataStreams/PushingToViewsBlockOutputStream.h b/src/DataStreams/PushingToViewsBlockOutputStream.h
index 6b32607b294..2ae941efc2e 100644
--- a/src/DataStreams/PushingToViewsBlockOutputStream.h
+++ b/src/DataStreams/PushingToViewsBlockOutputStream.h
@@ -1,9 +1,9 @@
 #pragma once
 
 #include <DataStreams/IBlockOutputStream.h>
-#include <Common/Stopwatch.h>
 #include <Parsers/IAST_fwd.h>
 #include <Storages/IStorage.h>
+#include <Common/Stopwatch.h>
 
 namespace Poco
 {
@@ -14,18 +14,16 @@ namespace DB
 {
 
 class ReplicatedMergeTreeBlockOutputStream;
-class Context;
-
 
 /** Writes data to the specified table and to all dependent materialized views.
   */
-class PushingToViewsBlockOutputStream : public IBlockOutputStream
+class PushingToViewsBlockOutputStream : public IBlockOutputStream, WithContext
 {
 public:
     PushingToViewsBlockOutputStream(
         const StoragePtr & storage_,
         const StorageMetadataPtr & metadata_snapshot_,
-        const Context & context_,
+        ContextPtr context_,
         const ASTPtr & query_ptr_,
         bool no_destination = false);
 
@@ -43,7 +41,6 @@ private:
     ReplicatedMergeTreeBlockOutputStream * replicated_output = nullptr;
     Poco::Logger * log;
 
-    const Context & context;
     ASTPtr query_ptr;
     Stopwatch main_watch;
 
@@ -57,8 +54,8 @@ private:
     };
 
     std::vector<ViewInfo> views;
-    std::unique_ptr<Context> select_context;
-    std::unique_ptr<Context> insert_context;
+    ContextPtr select_context;
+    ContextPtr insert_context;
 
     void process(const Block & block, ViewInfo & view);
 };
diff --git a/src/DataStreams/RemoteBlockInputStream.cpp b/src/DataStreams/RemoteBlockInputStream.cpp
index a62f7fca0b7..c633600d37f 100644
--- a/src/DataStreams/RemoteBlockInputStream.cpp
+++ b/src/DataStreams/RemoteBlockInputStream.cpp
@@ -6,7 +6,7 @@ namespace DB
 
 RemoteBlockInputStream::RemoteBlockInputStream(
         Connection & connection,
-        const String & query_, const Block & header_, const Context & context_,
+        const String & query_, const Block & header_, ContextPtr context_,
         const ThrottlerPtr & throttler, const Scalars & scalars_, const Tables & external_tables_, QueryProcessingStage::Enum stage_)
     : query_executor(connection, query_, header_, context_, throttler, scalars_, external_tables_, stage_)
 {
@@ -15,7 +15,7 @@ RemoteBlockInputStream::RemoteBlockInputStream(
 
 RemoteBlockInputStream::RemoteBlockInputStream(
         std::vector<IConnectionPool::Entry> && connections,
-        const String & query_, const Block & header_, const Context & context_,
+        const String & query_, const Block & header_, ContextPtr context_,
         const ThrottlerPtr & throttler, const Scalars & scalars_, const Tables & external_tables_, QueryProcessingStage::Enum stage_)
     : query_executor(std::move(connections), query_, header_, context_, throttler, scalars_, external_tables_, stage_)
 {
@@ -24,7 +24,7 @@ RemoteBlockInputStream::RemoteBlockInputStream(
 
 RemoteBlockInputStream::RemoteBlockInputStream(
         const ConnectionPoolWithFailoverPtr & pool,
-        const String & query_, const Block & header_, const Context & context_,
+        const String & query_, const Block & header_, ContextPtr context_,
         const ThrottlerPtr & throttler, const Scalars & scalars_, const Tables & external_tables_, QueryProcessingStage::Enum stage_)
     : query_executor(pool, query_, header_, context_, throttler, scalars_, external_tables_, stage_)
 {
diff --git a/src/DataStreams/RemoteBlockInputStream.h b/src/DataStreams/RemoteBlockInputStream.h
index 5ef05ee99eb..b0029da91bb 100644
--- a/src/DataStreams/RemoteBlockInputStream.h
+++ b/src/DataStreams/RemoteBlockInputStream.h
@@ -25,21 +25,21 @@ public:
     /// Takes already set connection.
     RemoteBlockInputStream(
             Connection & connection,
-            const String & query_, const Block & header_, const Context & context_,
+            const String & query_, const Block & header_, ContextPtr context_,
             const ThrottlerPtr & throttler = nullptr, const Scalars & scalars_ = Scalars(), const Tables & external_tables_ = Tables(),
             QueryProcessingStage::Enum stage_ = QueryProcessingStage::Complete);
 
     /// Accepts several connections already taken from pool.
     RemoteBlockInputStream(
             std::vector<IConnectionPool::Entry> && connections,
-            const String & query_, const Block & header_, const Context & context_,
+            const String & query_, const Block & header_, ContextPtr context_,
             const ThrottlerPtr & throttler = nullptr, const Scalars & scalars_ = Scalars(), const Tables & external_tables_ = Tables(),
             QueryProcessingStage::Enum stage_ = QueryProcessingStage::Complete);
 
     /// Takes a pool and gets one or several connections from it.
     RemoteBlockInputStream(
             const ConnectionPoolWithFailoverPtr & pool,
-            const String & query_, const Block & header_, const Context & context_,
+            const String & query_, const Block & header_, ContextPtr context_,
             const ThrottlerPtr & throttler = nullptr, const Scalars & scalars_ = Scalars(), const Tables & external_tables_ = Tables(),
             QueryProcessingStage::Enum stage_ = QueryProcessingStage::Complete);
 
diff --git a/src/DataStreams/RemoteQueryExecutor.cpp b/src/DataStreams/RemoteQueryExecutor.cpp
index 9cac638ceb5..4aa659854b9 100644
--- a/src/DataStreams/RemoteQueryExecutor.cpp
+++ b/src/DataStreams/RemoteQueryExecutor.cpp
@@ -28,41 +28,51 @@ namespace ErrorCodes
 
 RemoteQueryExecutor::RemoteQueryExecutor(
     Connection & connection,
-    const String & query_, const Block & header_, const Context & context_,
-    ThrottlerPtr throttler, const Scalars & scalars_, const Tables & external_tables_, QueryProcessingStage::Enum stage_)
-    : header(header_), query(query_), context(context_)
-    , scalars(scalars_), external_tables(external_tables_), stage(stage_)
+    const String & query_,
+    const Block & header_,
+    ContextPtr context_,
+    ThrottlerPtr throttler,
+    const Scalars & scalars_,
+    const Tables & external_tables_,
+    QueryProcessingStage::Enum stage_)
+    : header(header_), query(query_), context(context_), scalars(scalars_), external_tables(external_tables_), stage(stage_)
 {
     create_connections = [this, &connection, throttler]()
     {
-        return std::make_unique<MultiplexedConnections>(connection, context.getSettingsRef(), throttler);
+        return std::make_unique<MultiplexedConnections>(connection, context->getSettingsRef(), throttler);
     };
 }
 
 RemoteQueryExecutor::RemoteQueryExecutor(
     std::vector<IConnectionPool::Entry> && connections_,
-    const String & query_, const Block & header_, const Context & context_,
-    const ThrottlerPtr & throttler, const Scalars & scalars_, const Tables & external_tables_, QueryProcessingStage::Enum stage_)
-    : header(header_), query(query_), context(context_)
-    , scalars(scalars_), external_tables(external_tables_), stage(stage_)
+    const String & query_,
+    const Block & header_,
+    ContextPtr context_,
+    const ThrottlerPtr & throttler,
+    const Scalars & scalars_,
+    const Tables & external_tables_,
+    QueryProcessingStage::Enum stage_)
+    : header(header_), query(query_), context(context_), scalars(scalars_), external_tables(external_tables_), stage(stage_)
 {
-    create_connections = [this, connections_, throttler]() mutable
-    {
-        return std::make_unique<MultiplexedConnections>(
-                std::move(connections_), context.getSettingsRef(), throttler);
+    create_connections = [this, connections_, throttler]() mutable {
+        return std::make_unique<MultiplexedConnections>(std::move(connections_), context->getSettingsRef(), throttler);
     };
 }
 
 RemoteQueryExecutor::RemoteQueryExecutor(
     const ConnectionPoolWithFailoverPtr & pool,
-    const String & query_, const Block & header_, const Context & context_,
-    const ThrottlerPtr & throttler, const Scalars & scalars_, const Tables & external_tables_, QueryProcessingStage::Enum stage_)
-    : header(header_), query(query_), context(context_)
-    , scalars(scalars_), external_tables(external_tables_), stage(stage_)
+    const String & query_,
+    const Block & header_,
+    ContextPtr context_,
+    const ThrottlerPtr & throttler,
+    const Scalars & scalars_,
+    const Tables & external_tables_,
+    QueryProcessingStage::Enum stage_)
+    : header(header_), query(query_), context(context_), scalars(scalars_), external_tables(external_tables_), stage(stage_)
 {
     create_connections = [this, pool, throttler]()->std::unique_ptr<IConnections>
     {
-        const Settings & current_settings = context.getSettingsRef();
+        const Settings & current_settings = context->getSettingsRef();
         auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(current_settings);
 
 #if defined(OS_LINUX)
@@ -157,7 +167,7 @@ void RemoteQueryExecutor::sendQuery()
 
     connections = create_connections();
 
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = context->getSettingsRef();
     if (settings.skip_unavailable_shards && 0 == connections->size())
         return;
 
@@ -176,7 +186,7 @@ void RemoteQueryExecutor::sendQuery()
     was_cancelled = false;
 
     auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(settings);
-    ClientInfo modified_client_info = context.getClientInfo();
+    ClientInfo modified_client_info = context->getClientInfo();
     modified_client_info.query_kind = ClientInfo::QueryKind::SECONDARY_QUERY;
     if (CurrentThread::isInitialized())
     {
@@ -205,7 +215,7 @@ Block RemoteQueryExecutor::read()
     {
         sendQuery();
 
-        if (context.getSettingsRef().skip_unavailable_shards && (0 == connections->size()))
+        if (context->getSettingsRef().skip_unavailable_shards && (0 == connections->size()))
             return {};
     }
 
@@ -231,7 +241,7 @@ std::variant<Block, int> RemoteQueryExecutor::read(std::unique_ptr<ReadContext>
     {
         sendQuery();
 
-        if (context.getSettingsRef().skip_unavailable_shards && (0 == connections->size()))
+        if (context->getSettingsRef().skip_unavailable_shards && (0 == connections->size()))
             return Block();
     }
 
@@ -363,8 +373,8 @@ std::optional<Block> RemoteQueryExecutor::processPacket(Packet packet)
 
 bool RemoteQueryExecutor::setPartUUIDs(const std::vector<UUID> & uuids)
 {
-    Context & query_context = const_cast<Context &>(context).getQueryContext();
-    auto duplicates = query_context.getPartUUIDs()->add(uuids);
+    auto query_context = context->getQueryContext();
+    auto duplicates = query_context->getPartUUIDs()->add(uuids);
 
     if (!duplicates.empty())
     {
diff --git a/src/DataStreams/RemoteQueryExecutor.h b/src/DataStreams/RemoteQueryExecutor.h
index f55a023231b..45a633230b7 100644
--- a/src/DataStreams/RemoteQueryExecutor.h
+++ b/src/DataStreams/RemoteQueryExecutor.h
@@ -35,21 +35,21 @@ public:
     /// Takes already set connection.
     RemoteQueryExecutor(
         Connection & connection,
-        const String & query_, const Block & header_, const Context & context_,
+        const String & query_, const Block & header_, ContextPtr context_,
         ThrottlerPtr throttler_ = nullptr, const Scalars & scalars_ = Scalars(), const Tables & external_tables_ = Tables(),
         QueryProcessingStage::Enum stage_ = QueryProcessingStage::Complete);
 
     /// Accepts several connections already taken from pool.
     RemoteQueryExecutor(
         std::vector<IConnectionPool::Entry> && connections_,
-        const String & query_, const Block & header_, const Context & context_,
+        const String & query_, const Block & header_, ContextPtr context_,
         const ThrottlerPtr & throttler = nullptr, const Scalars & scalars_ = Scalars(), const Tables & external_tables_ = Tables(),
         QueryProcessingStage::Enum stage_ = QueryProcessingStage::Complete);
 
     /// Takes a pool and gets one or several connections from it.
     RemoteQueryExecutor(
         const ConnectionPoolWithFailoverPtr & pool,
-        const String & query_, const Block & header_, const Context & context_,
+        const String & query_, const Block & header_, ContextPtr context_,
         const ThrottlerPtr & throttler = nullptr, const Scalars & scalars_ = Scalars(), const Tables & external_tables_ = Tables(),
         QueryProcessingStage::Enum stage_ = QueryProcessingStage::Complete);
 
@@ -108,8 +108,8 @@ private:
     std::unique_ptr<IConnections> connections;
 
     const String query;
-    String query_id = "";
-    Context context;
+    String query_id;
+    ContextPtr context;
 
     ProgressCallback progress_callback;
     ProfileInfoCallback profile_info_callback;
diff --git a/src/DataStreams/TTLAggregationAlgorithm.cpp b/src/DataStreams/TTLAggregationAlgorithm.cpp
index ebe08159c55..9a1cf45772f 100644
--- a/src/DataStreams/TTLAggregationAlgorithm.cpp
+++ b/src/DataStreams/TTLAggregationAlgorithm.cpp
@@ -28,12 +28,12 @@ TTLAggregationAlgorithm::TTLAggregationAlgorithm(
                 descr.arguments.push_back(header.getPositionByName(name));
 
     columns_for_aggregator.resize(description.aggregate_descriptions.size());
-    const Settings & settings = storage_.global_context.getSettingsRef();
+    const Settings & settings = storage_.getContext()->getSettingsRef();
 
     Aggregator::Params params(header, keys, aggregates,
         false, settings.max_rows_to_group_by, settings.group_by_overflow_mode, 0, 0,
         settings.max_bytes_before_external_group_by, settings.empty_result_for_aggregation_by_empty_set,
-        storage_.global_context.getTemporaryVolume(), settings.max_threads, settings.min_free_disk_space_for_temporary_data);
+        storage_.getContext()->getTemporaryVolume(), settings.max_threads, settings.min_free_disk_space_for_temporary_data);
 
     aggregator = std::make_unique<Aggregator>(params);
 }
diff --git a/src/DataStreams/TTLBlockInputStream.cpp b/src/DataStreams/TTLBlockInputStream.cpp
index 4f141a03475..8b31da6d2f1 100644
--- a/src/DataStreams/TTLBlockInputStream.cpp
+++ b/src/DataStreams/TTLBlockInputStream.cpp
@@ -68,8 +68,9 @@ TTLBlockInputStream::TTLBlockInputStream(
                 auto default_ast = it->second.expression->clone();
                 default_ast = addTypeConversionToAST(std::move(default_ast), column.type->getName());
 
-                auto syntax_result = TreeRewriter(storage_.global_context).analyze(default_ast, metadata_snapshot_->getColumns().getAllPhysical());
-                default_expression = ExpressionAnalyzer{default_ast, syntax_result, storage_.global_context}.getActions(true);
+                auto syntax_result
+                    = TreeRewriter(storage_.getContext()).analyze(default_ast, metadata_snapshot_->getColumns().getAllPhysical());
+                default_expression = ExpressionAnalyzer{default_ast, syntax_result, storage_.getContext()}.getActions(true);
                 default_column_name = default_ast->getColumnName();
             }
 
diff --git a/src/DataTypes/DataTypeDecimalBase.cpp b/src/DataTypes/DataTypeDecimalBase.cpp
index 5f64fca6704..683710b8880 100644
--- a/src/DataTypes/DataTypeDecimalBase.cpp
+++ b/src/DataTypes/DataTypeDecimalBase.cpp
@@ -19,9 +19,14 @@ namespace ErrorCodes
 {
 }
 
-
-bool decimalCheckComparisonOverflow(const Context & context) { return context.getSettingsRef().decimal_check_overflow; }
-bool decimalCheckArithmeticOverflow(const Context & context) { return context.getSettingsRef().decimal_check_overflow; }
+bool decimalCheckComparisonOverflow(ContextPtr context)
+{
+    return context->getSettingsRef().decimal_check_overflow;
+}
+bool decimalCheckArithmeticOverflow(ContextPtr context)
+{
+    return context->getSettingsRef().decimal_check_overflow;
+}
 
 template <typename T>
 Field DataTypeDecimalBase<T>::getDefault() const
diff --git a/src/DataTypes/DataTypeDecimalBase.h b/src/DataTypes/DataTypeDecimalBase.h
index 85cb9fa8363..9e44310a0ff 100644
--- a/src/DataTypes/DataTypeDecimalBase.h
+++ b/src/DataTypes/DataTypeDecimalBase.h
@@ -1,11 +1,12 @@
 #pragma once
-#include <cmath>
 
 #include <Columns/ColumnDecimal.h>
 #include <Core/DecimalFunctions.h>
 #include <DataTypes/IDataType.h>
 #include <DataTypes/DataTypesNumber.h>
+#include <Interpreters/Context_fwd.h>
 
+#include <cmath>
 #include <type_traits>
 
 
@@ -17,9 +18,8 @@ namespace ErrorCodes
     extern const int ARGUMENT_OUT_OF_BOUND;
 }
 
-class Context;
-bool decimalCheckComparisonOverflow(const Context & context);
-bool decimalCheckArithmeticOverflow(const Context & context);
+bool decimalCheckComparisonOverflow(ContextPtr context);
+bool decimalCheckArithmeticOverflow(ContextPtr context);
 
 inline UInt32 leastDecimalPrecisionFor(TypeIndex int_type)
 {
diff --git a/src/DataTypes/DataTypeFactory.cpp b/src/DataTypes/DataTypeFactory.cpp
index eee3f22f9f1..c28de15565c 100644
--- a/src/DataTypes/DataTypeFactory.cpp
+++ b/src/DataTypes/DataTypeFactory.cpp
@@ -156,7 +156,7 @@ void DataTypeFactory::registerSimpleDataTypeCustom(const String &name, SimpleCre
 
 const DataTypeFactory::Value & DataTypeFactory::findCreatorByName(const String & family_name) const
 {
-    const Context * query_context = nullptr;
+    ContextPtr query_context;
     if (CurrentThread::isInitialized())
         query_context = CurrentThread::get().getQueryContext();
 
diff --git a/src/Databases/DatabaseAtomic.cpp b/src/Databases/DatabaseAtomic.cpp
index b4222a7e349..c9e533dfafb 100644
--- a/src/Databases/DatabaseAtomic.cpp
+++ b/src/Databases/DatabaseAtomic.cpp
@@ -35,10 +35,10 @@ public:
     UUID uuid() const override { return table()->getStorageID().uuid; }
 };
 
-DatabaseAtomic::DatabaseAtomic(String name_, String metadata_path_, UUID uuid, const String & logger_name, const Context & context_)
+DatabaseAtomic::DatabaseAtomic(String name_, String metadata_path_, UUID uuid, const String & logger_name, ContextPtr context_)
     : DatabaseOrdinary(name_, std::move(metadata_path_), "store/", logger_name, context_)
-    , path_to_table_symlinks(global_context.getPath() + "data/" + escapeForFileName(name_) + "/")
-    , path_to_metadata_symlink(global_context.getPath() + "metadata/" + escapeForFileName(name_))
+    , path_to_table_symlinks(getContext()->getPath() + "data/" + escapeForFileName(name_) + "/")
+    , path_to_metadata_symlink(getContext()->getPath() + "metadata/" + escapeForFileName(name_))
     , db_uuid(uuid)
 {
     assert(db_uuid != UUIDHelpers::Nil);
@@ -46,7 +46,7 @@ DatabaseAtomic::DatabaseAtomic(String name_, String metadata_path_, UUID uuid, c
     tryCreateMetadataSymlink();
 }
 
-DatabaseAtomic::DatabaseAtomic(String name_, String metadata_path_, UUID uuid, const Context & context_)
+DatabaseAtomic::DatabaseAtomic(String name_, String metadata_path_, UUID uuid, ContextPtr context_)
     : DatabaseAtomic(name_, std::move(metadata_path_), uuid, "DatabaseAtomic (" + name_ + ")", context_)
 {
 }
@@ -68,7 +68,7 @@ String DatabaseAtomic::getTableDataPath(const ASTCreateQuery & query) const
     return tmp;
 }
 
-void DatabaseAtomic::drop(const Context &)
+void DatabaseAtomic::drop(ContextPtr)
 {
     assert(tables.empty());
     try
@@ -106,13 +106,13 @@ StoragePtr DatabaseAtomic::detachTable(const String & name)
     return table;
 }
 
-void DatabaseAtomic::dropTable(const Context & context, const String & table_name, bool no_delay)
+void DatabaseAtomic::dropTable(ContextPtr local_context, const String & table_name, bool no_delay)
 {
-    if (auto * mv = dynamic_cast<StorageMaterializedView *>(tryGetTable(table_name, context).get()))
+    if (auto * mv = dynamic_cast<StorageMaterializedView *>(tryGetTable(table_name, local_context).get()))
     {
         /// Remove the inner table (if any) to avoid deadlock
         /// (due to attempt to execute DROP from the worker thread)
-        mv->dropInnerTable(no_delay, context);
+        mv->dropInnerTable(no_delay, local_context);
     }
 
     String table_metadata_path = getObjectMetadataPath(table_name);
@@ -122,8 +122,8 @@ void DatabaseAtomic::dropTable(const Context & context, const String & table_nam
         std::unique_lock lock(mutex);
         table = getTableUnlocked(table_name, lock);
         table_metadata_path_drop = DatabaseCatalog::instance().getPathForDroppedMetadata(table->getStorageID());
-        auto txn = context.getZooKeeperMetadataTransaction();
-        if (txn && !context.isInternalSubquery())
+        auto txn = local_context->getZooKeeperMetadataTransaction();
+        if (txn && !local_context->isInternalSubquery())
             txn->commit();      /// Commit point (a sort of) for Replicated database
 
         /// NOTE: replica will be lost if server crashes before the following rename
@@ -144,7 +144,7 @@ void DatabaseAtomic::dropTable(const Context & context, const String & table_nam
     DatabaseCatalog::instance().enqueueDroppedTableCleanup(table->getStorageID(), table, table_metadata_path_drop, no_delay);
 }
 
-void DatabaseAtomic::renameTable(const Context & context, const String & table_name, IDatabase & to_database,
+void DatabaseAtomic::renameTable(ContextPtr local_context, const String & table_name, IDatabase & to_database,
                                  const String & to_table_name, bool exchange, bool dictionary)
 {
     if (typeid(*this) != typeid(to_database))
@@ -152,7 +152,7 @@ void DatabaseAtomic::renameTable(const Context & context, const String & table_n
         if (!typeid_cast<DatabaseOrdinary *>(&to_database))
             throw Exception("Moving tables between databases of different engines is not supported", ErrorCodes::NOT_IMPLEMENTED);
         /// Allow moving tables between Atomic and Ordinary (with table lock)
-        DatabaseOnDisk::renameTable(context, table_name, to_database, to_table_name, exchange, dictionary);
+        DatabaseOnDisk::renameTable(local_context, table_name, to_database, to_table_name, exchange, dictionary);
         return;
     }
 
@@ -248,8 +248,8 @@ void DatabaseAtomic::renameTable(const Context & context, const String & table_n
     }
 
     /// Table renaming actually begins here
-    auto txn = context.getZooKeeperMetadataTransaction();
-    if (txn && !context.isInternalSubquery())
+    auto txn = local_context->getZooKeeperMetadataTransaction();
+    if (txn && !local_context->isInternalSubquery())
         txn->commit();     /// Commit point (a sort of) for Replicated database
 
     /// NOTE: replica will be lost if server crashes before the following rename
@@ -291,7 +291,7 @@ void DatabaseAtomic::renameTable(const Context & context, const String & table_n
 
 void DatabaseAtomic::commitCreateTable(const ASTCreateQuery & query, const StoragePtr & table,
                                        const String & table_metadata_tmp_path, const String & table_metadata_path,
-                                       const Context & query_context)
+                                       ContextPtr query_context)
 {
     DetachedTables not_in_use;
     auto table_data_path = getTableDataPath(query);
@@ -309,8 +309,8 @@ void DatabaseAtomic::commitCreateTable(const ASTCreateQuery & query, const Stora
         DatabaseCatalog::instance().addUUIDMapping(query.uuid);
         locked_uuid = true;
 
-        auto txn = query_context.getZooKeeperMetadataTransaction();
-        if (txn && !query_context.isInternalSubquery())
+        auto txn = query_context->getZooKeeperMetadataTransaction();
+        if (txn && !query_context->isInternalSubquery())
             txn->commit();     /// Commit point (a sort of) for Replicated database
 
         /// NOTE: replica will be lost if server crashes before the following renameNoReplace(...)
@@ -333,7 +333,7 @@ void DatabaseAtomic::commitCreateTable(const ASTCreateQuery & query, const Stora
 }
 
 void DatabaseAtomic::commitAlterTable(const StorageID & table_id, const String & table_metadata_tmp_path, const String & table_metadata_path,
-                                      const String & /*statement*/, const Context & query_context)
+                                      const String & /*statement*/, ContextPtr query_context)
 {
     bool check_file_exists = true;
     SCOPE_EXIT({ std::error_code code; if (check_file_exists) std::filesystem::remove(table_metadata_tmp_path, code); });
@@ -344,8 +344,8 @@ void DatabaseAtomic::commitAlterTable(const StorageID & table_id, const String &
     if (table_id.uuid != actual_table_id.uuid)
         throw Exception("Cannot alter table because it was renamed", ErrorCodes::CANNOT_ASSIGN_ALTER);
 
-    auto txn = query_context.getZooKeeperMetadataTransaction();
-    if (txn && !query_context.isInternalSubquery())
+    auto txn = query_context->getZooKeeperMetadataTransaction();
+    if (txn && !query_context->isInternalSubquery())
         txn->commit();      /// Commit point (a sort of) for Replicated database
 
     /// NOTE: replica will be lost if server crashes before the following rename
@@ -409,26 +409,27 @@ void DatabaseAtomic::assertCanBeDetached(bool cleanup)
                         "because some tables are still in use. Retry later.", ErrorCodes::DATABASE_NOT_EMPTY);
 }
 
-DatabaseTablesIteratorPtr DatabaseAtomic::getTablesIterator(const Context & context, const IDatabase::FilterByNameFunction & filter_by_table_name)
+DatabaseTablesIteratorPtr
+DatabaseAtomic::getTablesIterator(ContextPtr local_context, const IDatabase::FilterByNameFunction & filter_by_table_name)
 {
-    auto base_iter = DatabaseWithOwnTablesBase::getTablesIterator(context, filter_by_table_name);
+    auto base_iter = DatabaseWithOwnTablesBase::getTablesIterator(local_context, filter_by_table_name);
     return std::make_unique<AtomicDatabaseTablesSnapshotIterator>(std::move(typeid_cast<DatabaseTablesSnapshotIterator &>(*base_iter)));
 }
 
 UUID DatabaseAtomic::tryGetTableUUID(const String & table_name) const
 {
-    if (auto table = tryGetTable(table_name, global_context))
+    if (auto table = tryGetTable(table_name, getContext()))
         return table->getStorageID().uuid;
     return UUIDHelpers::Nil;
 }
 
-void DatabaseAtomic::loadStoredObjects(Context & context, bool has_force_restore_data_flag, bool force_attach)
+void DatabaseAtomic::loadStoredObjects(ContextPtr local_context, bool has_force_restore_data_flag, bool force_attach)
 {
     /// Recreate symlinks to table data dirs in case of force restore, because some of them may be broken
     if (has_force_restore_data_flag)
         Poco::File(path_to_table_symlinks).remove(true);
 
-    DatabaseOrdinary::loadStoredObjects(context, has_force_restore_data_flag, force_attach);
+    DatabaseOrdinary::loadStoredObjects(local_context, has_force_restore_data_flag, force_attach);
 
     if (has_force_restore_data_flag)
     {
@@ -449,7 +450,7 @@ void DatabaseAtomic::tryCreateSymlink(const String & table_name, const String &
     try
     {
         String link = path_to_table_symlinks + escapeForFileName(table_name);
-        Poco::File data = Poco::Path(global_context.getPath()).makeAbsolute().toString() + actual_data_path;
+        Poco::File data = Poco::Path(getContext()->getPath()).makeAbsolute().toString() + actual_data_path;
         if (!if_data_path_exist || data.exists())
             data.linkTo(link, Poco::File::LINK_SYMBOLIC);
     }
@@ -509,8 +510,8 @@ void DatabaseAtomic::renameDatabase(const String & new_name)
     }
 
     auto new_name_escaped = escapeForFileName(new_name);
-    auto old_database_metadata_path = global_context.getPath() + "metadata/" + escapeForFileName(getDatabaseName()) + ".sql";
-    auto new_database_metadata_path = global_context.getPath() + "metadata/" + new_name_escaped + ".sql";
+    auto old_database_metadata_path = getContext()->getPath() + "metadata/" + escapeForFileName(getDatabaseName()) + ".sql";
+    auto new_database_metadata_path = getContext()->getPath() + "metadata/" + new_name_escaped + ".sql";
     renameNoReplace(old_database_metadata_path, new_database_metadata_path);
 
     String old_path_to_table_symlinks;
@@ -535,9 +536,9 @@ void DatabaseAtomic::renameDatabase(const String & new_name)
             renameDictionaryInMemoryUnlocked(old_name, name);
         }
 
-        path_to_metadata_symlink = global_context.getPath() + "metadata/" + new_name_escaped;
+        path_to_metadata_symlink = getContext()->getPath() + "metadata/" + new_name_escaped;
         old_path_to_table_symlinks = path_to_table_symlinks;
-        path_to_table_symlinks = global_context.getPath() + "data/" + new_name_escaped + "/";
+        path_to_table_symlinks = getContext()->getPath() + "data/" + new_name_escaped + "/";
     }
 
     Poco::File(old_path_to_table_symlinks).renameTo(path_to_table_symlinks);
diff --git a/src/Databases/DatabaseAtomic.h b/src/Databases/DatabaseAtomic.h
index 09cdf269b35..d35495fc962 100644
--- a/src/Databases/DatabaseAtomic.h
+++ b/src/Databases/DatabaseAtomic.h
@@ -19,8 +19,8 @@ namespace DB
 class DatabaseAtomic : public DatabaseOrdinary
 {
 public:
-    DatabaseAtomic(String name_, String metadata_path_, UUID uuid, const String & logger_name, const Context & context_);
-    DatabaseAtomic(String name_, String metadata_path_, UUID uuid, const Context & context_);
+    DatabaseAtomic(String name_, String metadata_path_, UUID uuid, const String & logger_name, ContextPtr context_);
+    DatabaseAtomic(String name_, String metadata_path_, UUID uuid, ContextPtr context_);
 
     String getEngineName() const override { return "Atomic"; }
     UUID getUUID() const override { return db_uuid; }
@@ -28,14 +28,14 @@ public:
     void renameDatabase(const String & new_name) override;
 
     void renameTable(
-            const Context & context,
+            ContextPtr context,
             const String & table_name,
             IDatabase & to_database,
             const String & to_table_name,
             bool exchange,
             bool dictionary) override;
 
-    void dropTable(const Context & context, const String & table_name, bool no_delay) override;
+    void dropTable(ContextPtr context, const String & table_name, bool no_delay) override;
 
     void attachTable(const String & name, const StoragePtr & table, const String & relative_table_path) override;
     StoragePtr detachTable(const String & name) override;
@@ -43,11 +43,11 @@ public:
     String getTableDataPath(const String & table_name) const override;
     String getTableDataPath(const ASTCreateQuery & query) const override;
 
-    void drop(const Context & /*context*/) override;
+    void drop(ContextPtr /*context*/) override;
 
-    DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) override;
+    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name) override;
 
-    void loadStoredObjects(Context & context, bool has_force_restore_data_flag, bool force_attach) override;
+    void loadStoredObjects(ContextPtr context, bool has_force_restore_data_flag, bool force_attach) override;
 
     /// Atomic database cannot be detached if there is detached table which still in use
     void assertCanBeDetached(bool cleanup) override;
@@ -61,12 +61,12 @@ public:
     void setDetachedTableNotInUseForce(const UUID & uuid);
 
 protected:
-    void commitAlterTable(const StorageID & table_id, const String & table_metadata_tmp_path, const String & table_metadata_path, const String & statement, const Context & query_context) override;
+    void commitAlterTable(const StorageID & table_id, const String & table_metadata_tmp_path, const String & table_metadata_path, const String & statement, ContextPtr query_context) override;
     void commitCreateTable(const ASTCreateQuery & query, const StoragePtr & table,
-                           const String & table_metadata_tmp_path, const String & table_metadata_path, const Context & query_context) override;
+                           const String & table_metadata_tmp_path, const String & table_metadata_path, ContextPtr query_context) override;
 
     void assertDetachedTableNotInUse(const UUID & uuid);
-    typedef std::unordered_map<UUID, StoragePtr> DetachedTables;
+    using DetachedTables = std::unordered_map<UUID, StoragePtr>;
     [[nodiscard]] DetachedTables cleanupDetachedTables();
 
     void tryCreateMetadataSymlink();
@@ -74,7 +74,7 @@ protected:
     void renameDictionaryInMemoryUnlocked(const StorageID & old_name, const StorageID & new_name);
 
     //TODO store path in DatabaseWithOwnTables::tables
-    typedef std::unordered_map<String, String> NameToPathMap;
+    using NameToPathMap = std::unordered_map<String, String>;
     NameToPathMap table_name_to_path;
 
     DetachedTables detached_tables;
diff --git a/src/Databases/DatabaseDictionary.cpp b/src/Databases/DatabaseDictionary.cpp
index ff5510f0bf9..c00201145eb 100644
--- a/src/Databases/DatabaseDictionary.cpp
+++ b/src/Databases/DatabaseDictionary.cpp
@@ -44,17 +44,16 @@ namespace
     }
 }
 
-DatabaseDictionary::DatabaseDictionary(const String & name_, const Context & context_)
-    : IDatabase(name_)
+DatabaseDictionary::DatabaseDictionary(const String & name_, ContextPtr context_)
+    : IDatabase(name_), WithContext(context_->getGlobalContext())
     , log(&Poco::Logger::get("DatabaseDictionary(" + database_name + ")"))
-    , global_context(context_.getGlobalContext())
 {
 }
 
 Tables DatabaseDictionary::listTables(const FilterByNameFunction & filter_by_name)
 {
     Tables tables;
-    auto load_results = global_context.getExternalDictionariesLoader().getLoadResults(filter_by_name);
+    auto load_results = getContext()->getExternalDictionariesLoader().getLoadResults(filter_by_name);
     String db_name = getDatabaseName();
     for (auto & load_result : load_results)
     {
@@ -65,34 +64,34 @@ Tables DatabaseDictionary::listTables(const FilterByNameFunction & filter_by_nam
     return tables;
 }
 
-bool DatabaseDictionary::isTableExist(const String & table_name, const Context &) const
+bool DatabaseDictionary::isTableExist(const String & table_name, ContextPtr) const
 {
-    return global_context.getExternalDictionariesLoader().getCurrentStatus(table_name) != ExternalLoader::Status::NOT_EXIST;
+    return getContext()->getExternalDictionariesLoader().getCurrentStatus(table_name) != ExternalLoader::Status::NOT_EXIST;
 }
 
-StoragePtr DatabaseDictionary::tryGetTable(const String & table_name, const Context &) const
+StoragePtr DatabaseDictionary::tryGetTable(const String & table_name, ContextPtr) const
 {
-    auto load_result = global_context.getExternalDictionariesLoader().getLoadResult(table_name);
+    auto load_result = getContext()->getExternalDictionariesLoader().getLoadResult(table_name);
     return createStorageDictionary(getDatabaseName(), load_result);
 }
 
-DatabaseTablesIteratorPtr DatabaseDictionary::getTablesIterator(const Context &, const FilterByNameFunction & filter_by_table_name)
+DatabaseTablesIteratorPtr DatabaseDictionary::getTablesIterator(ContextPtr, const FilterByNameFunction & filter_by_table_name)
 {
     return std::make_unique<DatabaseTablesSnapshotIterator>(listTables(filter_by_table_name), getDatabaseName());
 }
 
 bool DatabaseDictionary::empty() const
 {
-    return !global_context.getExternalDictionariesLoader().hasObjects();
+    return !getContext()->getExternalDictionariesLoader().hasObjects();
 }
 
-ASTPtr DatabaseDictionary::getCreateTableQueryImpl(const String & table_name, const Context &, bool throw_on_error) const
+ASTPtr DatabaseDictionary::getCreateTableQueryImpl(const String & table_name, ContextPtr, bool throw_on_error) const
 {
     String query;
     {
         WriteBufferFromString buffer(query);
 
-        auto load_result = global_context.getExternalDictionariesLoader().getLoadResult(table_name);
+        auto load_result = getContext()->getExternalDictionariesLoader().getLoadResult(table_name);
         if (!load_result.config)
         {
             if (throw_on_error)
@@ -106,7 +105,7 @@ ASTPtr DatabaseDictionary::getCreateTableQueryImpl(const String & table_name, co
         buffer << ") Engine = Dictionary(" << backQuoteIfNeed(table_name) << ")";
     }
 
-    auto settings = global_context.getSettingsRef();
+    auto settings = getContext()->getSettingsRef();
     ParserCreateQuery parser;
     const char * pos = query.data();
     std::string error_message;
@@ -126,7 +125,7 @@ ASTPtr DatabaseDictionary::getCreateDatabaseQuery() const
         WriteBufferFromString buffer(query);
         buffer << "CREATE DATABASE " << backQuoteIfNeed(getDatabaseName()) << " ENGINE = Dictionary";
     }
-    auto settings = global_context.getSettingsRef();
+    auto settings = getContext()->getSettingsRef();
     ParserCreateQuery parser;
     return parseQuery(parser, query.data(), query.data() + query.size(), "", 0, settings.max_parser_depth);
 }
diff --git a/src/Databases/DatabaseDictionary.h b/src/Databases/DatabaseDictionary.h
index 2cfc6ef3285..06402a96381 100644
--- a/src/Databases/DatabaseDictionary.h
+++ b/src/Databases/DatabaseDictionary.h
@@ -1,11 +1,12 @@
 #pragma once
 
-#include <mutex>
-#include <unordered_set>
 #include <Databases/DatabasesCommon.h>
 #include <Databases/IDatabase.h>
 #include <Storages/IStorage_fwd.h>
 
+#include <mutex>
+#include <unordered_set>
+
 
 namespace Poco
 {
@@ -19,21 +20,21 @@ namespace DB
 /* Database to store StorageDictionary tables
  * automatically creates tables for all dictionaries
  */
-class DatabaseDictionary final : public IDatabase
+class DatabaseDictionary final : public IDatabase, WithContext
 {
 public:
-    DatabaseDictionary(const String & name_, const Context & context_);
+    DatabaseDictionary(const String & name_, ContextPtr context_);
 
     String getEngineName() const override
     {
         return "Dictionary";
     }
 
-    bool isTableExist(const String & table_name, const Context & context) const override;
+    bool isTableExist(const String & table_name, ContextPtr context) const override;
 
-    StoragePtr tryGetTable(const String & table_name, const Context & context) const override;
+    StoragePtr tryGetTable(const String & table_name, ContextPtr context) const override;
 
-    DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) override;
+    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name) override;
 
     bool empty() const override;
 
@@ -44,11 +45,10 @@ public:
     void shutdown() override;
 
 protected:
-    ASTPtr getCreateTableQueryImpl(const String & table_name, const Context & context, bool throw_on_error) const override;
+    ASTPtr getCreateTableQueryImpl(const String & table_name, ContextPtr context, bool throw_on_error) const override;
 
 private:
     Poco::Logger * log;
-    const Context & global_context;
 
     Tables listTables(const FilterByNameFunction & filter_by_name);
 };
diff --git a/src/Databases/DatabaseFactory.cpp b/src/Databases/DatabaseFactory.cpp
index 523ce7d925e..03c2849ac94 100644
--- a/src/Databases/DatabaseFactory.cpp
+++ b/src/Databases/DatabaseFactory.cpp
@@ -30,6 +30,7 @@
 #endif
 
 #if USE_MYSQL || USE_LIBPQXX
+#include <Common/parseRemoteDescription.h>
 #include <Interpreters/evaluateConstantExpression.h>
 #include <Common/parseAddress.h>
 #endif
@@ -50,7 +51,7 @@ namespace ErrorCodes
     extern const int CANNOT_CREATE_DATABASE;
 }
 
-DatabasePtr DatabaseFactory::get(const ASTCreateQuery & create, const String & metadata_path, Context & context)
+DatabasePtr DatabaseFactory::get(const ASTCreateQuery & create, const String & metadata_path, ContextPtr context)
 {
     bool created = false;
 
@@ -65,8 +66,8 @@ DatabasePtr DatabaseFactory::get(const ASTCreateQuery & create, const String & m
 
         DatabasePtr impl = getImpl(create, metadata_path, context);
 
-        if (impl && context.hasQueryContext() && context.getSettingsRef().log_queries)
-            context.getQueryContext().addQueryFactoriesInfo(Context::QueryLogFactories::Database, impl->getEngineName());
+        if (impl && context->hasQueryContext() && context->getSettingsRef().log_queries)
+            context->getQueryContext()->addQueryFactoriesInfo(Context::QueryLogFactories::Database, impl->getEngineName());
 
         return impl;
 
@@ -91,7 +92,7 @@ static inline ValueType safeGetLiteralValue(const ASTPtr &ast, const String &eng
     return ast->as<ASTLiteral>()->value.safeGet<ValueType>();
 }
 
-DatabasePtr DatabaseFactory::getImpl(const ASTCreateQuery & create, const String & metadata_path, Context & context)
+DatabasePtr DatabaseFactory::getImpl(const ASTCreateQuery & create, const String & metadata_path, ContextPtr context)
 {
     auto * engine_define = create.storage;
     const String & database_name = create.database;
@@ -133,19 +134,20 @@ DatabasePtr DatabaseFactory::getImpl(const ASTCreateQuery & create, const String
         ASTs & arguments = engine->arguments->children;
         arguments[1] = evaluateConstantExpressionOrIdentifierAsLiteral(arguments[1], context);
 
-        const auto & host_name_and_port = safeGetLiteralValue<String>(arguments[0], engine_name);
+        const auto & host_port = safeGetLiteralValue<String>(arguments[0], engine_name);
         const auto & mysql_database_name = safeGetLiteralValue<String>(arguments[1], engine_name);
         const auto & mysql_user_name = safeGetLiteralValue<String>(arguments[2], engine_name);
         const auto & mysql_user_password = safeGetLiteralValue<String>(arguments[3], engine_name);
 
         try
         {
-            const auto & [remote_host_name, remote_port] = parseAddress(host_name_and_port, 3306);
-            auto mysql_pool = mysqlxx::Pool(mysql_database_name, remote_host_name, mysql_user_name, mysql_user_password, remote_port);
-
             if (engine_name == "MySQL")
             {
                 auto mysql_database_settings = std::make_unique<ConnectionMySQLSettings>();
+                /// Split into replicas if needed.
+                size_t max_addresses = context->getSettingsRef().glob_expansion_max_elements;
+                auto addresses = parseRemoteDescriptionForExternalDatabase(host_port, max_addresses, 3306);
+                auto mysql_pool = mysqlxx::PoolWithFailover(mysql_database_name, addresses, mysql_user_name, mysql_user_password);
 
                 mysql_database_settings->loadFromQueryContext(context);
                 mysql_database_settings->loadFromQuery(*engine_define); /// higher priority
@@ -154,7 +156,10 @@ DatabasePtr DatabaseFactory::getImpl(const ASTCreateQuery & create, const String
                     context, database_name, metadata_path, engine_define, mysql_database_name, std::move(mysql_database_settings), std::move(mysql_pool));
             }
 
+            const auto & [remote_host_name, remote_port] = parseAddress(host_port, 3306);
             MySQLClient client(remote_host_name, remote_port, mysql_user_name, mysql_user_password);
+            auto mysql_pool = mysqlxx::Pool(mysql_database_name, remote_host_name, mysql_user_name, mysql_user_password);
+
 
             auto materialize_mode_settings = std::make_unique<MaterializeMySQLSettings>();
 
@@ -204,9 +209,9 @@ DatabasePtr DatabaseFactory::getImpl(const ASTCreateQuery & create, const String
         String shard_name = safeGetLiteralValue<String>(arguments[1], "Replicated");
         String replica_name  = safeGetLiteralValue<String>(arguments[2], "Replicated");
 
-        zookeeper_path = context.getMacros()->expand(zookeeper_path);
-        shard_name = context.getMacros()->expand(shard_name);
-        replica_name = context.getMacros()->expand(replica_name);
+        zookeeper_path = context->getMacros()->expand(zookeeper_path);
+        shard_name = context->getMacros()->expand(shard_name);
+        replica_name = context->getMacros()->expand(replica_name);
 
         DatabaseReplicatedSettings database_replicated_settings{};
         if (engine_define->settings)
@@ -243,15 +248,17 @@ DatabasePtr DatabaseFactory::getImpl(const ASTCreateQuery & create, const String
         if (engine->arguments->children.size() == 5)
             use_table_cache = safeGetLiteralValue<UInt64>(engine_args[4], engine_name);
 
-        auto parsed_host_port = parseAddress(host_port, 5432);
+        /// Split into replicas if needed.
+        size_t max_addresses = context->getSettingsRef().glob_expansion_max_elements;
+        auto addresses = parseRemoteDescriptionForExternalDatabase(host_port, max_addresses, 5432);
 
         /// no connection is made here
-        auto connection_pool = std::make_shared<PostgreSQLConnectionPool>(
+        auto connection_pool = std::make_shared<postgres::PoolWithFailover>(
             postgres_database_name,
-            parsed_host_port.first, parsed_host_port.second,
+            addresses,
             username, password,
-            context.getSettingsRef().postgresql_connection_pool_size,
-            context.getSettingsRef().postgresql_connection_pool_wait_timeout);
+            context->getSettingsRef().postgresql_connection_pool_size,
+            context->getSettingsRef().postgresql_connection_pool_wait_timeout);
 
         return std::make_shared<DatabasePostgreSQL>(
             context, metadata_path, engine_define, database_name, postgres_database_name, connection_pool, use_table_cache);
diff --git a/src/Databases/DatabaseFactory.h b/src/Databases/DatabaseFactory.h
index 88d33dc1cd5..8992ea27093 100644
--- a/src/Databases/DatabaseFactory.h
+++ b/src/Databases/DatabaseFactory.h
@@ -11,9 +11,9 @@ class ASTCreateQuery;
 class DatabaseFactory
 {
 public:
-    static DatabasePtr get(const ASTCreateQuery & create, const String & metadata_path, Context & context);
+    static DatabasePtr get(const ASTCreateQuery & create, const String & metadata_path, ContextPtr context);
 
-    static DatabasePtr getImpl(const ASTCreateQuery & create, const String & metadata_path, Context & context);
+    static DatabasePtr getImpl(const ASTCreateQuery & create, const String & metadata_path, ContextPtr context);
 };
 
 }
diff --git a/src/Databases/DatabaseLazy.cpp b/src/Databases/DatabaseLazy.cpp
index f297bf2c82f..d498cb96062 100644
--- a/src/Databases/DatabaseLazy.cpp
+++ b/src/Databases/DatabaseLazy.cpp
@@ -10,7 +10,7 @@
 #include <Storages/IStorage.h>
 
 #include <common/logger_useful.h>
-#include <ext/scope_guard.h>
+#include <ext/scope_guard_safe.h>
 #include <iomanip>
 #include <Poco/File.h>
 
@@ -27,7 +27,7 @@ namespace ErrorCodes
 }
 
 
-DatabaseLazy::DatabaseLazy(const String & name_, const String & metadata_path_, time_t expiration_time_, const Context & context_)
+DatabaseLazy::DatabaseLazy(const String & name_, const String & metadata_path_, time_t expiration_time_, ContextPtr context_)
     : DatabaseOnDisk(name_, metadata_path_, "data/" + escapeForFileName(name_) + "/", "DatabaseLazy (" + name_ + ")", context_)
     , expiration_time(expiration_time_)
 {
@@ -35,11 +35,11 @@ DatabaseLazy::DatabaseLazy(const String & name_, const String & metadata_path_,
 
 
 void DatabaseLazy::loadStoredObjects(
-    Context & context,
+    ContextPtr local_context,
     bool /* has_force_restore_data_flag */,
     bool /*force_attach*/)
 {
-    iterateMetadataFiles(context, [this](const String & file_name)
+    iterateMetadataFiles(local_context, [this](const String & file_name)
     {
         const std::string table_name = file_name.substr(0, file_name.size() - 4);
 
@@ -56,15 +56,15 @@ void DatabaseLazy::loadStoredObjects(
 
 
 void DatabaseLazy::createTable(
-    const Context & context,
+    ContextPtr local_context,
     const String & table_name,
     const StoragePtr & table,
     const ASTPtr & query)
 {
-    SCOPE_EXIT({ clearExpiredTables(); });
+    SCOPE_EXIT_MEMORY_SAFE({ clearExpiredTables(); });
     if (!endsWith(table->getName(), "Log"))
         throw Exception("Lazy engine can be used only with *Log tables.", ErrorCodes::UNSUPPORTED_METHOD);
-    DatabaseOnDisk::createTable(context, table_name, table, query);
+    DatabaseOnDisk::createTable(local_context, table_name, table, query);
 
     /// DatabaseOnDisk::createTable renames file, so we need to get new metadata_modification_time.
     std::lock_guard lock(mutex);
@@ -74,24 +74,24 @@ void DatabaseLazy::createTable(
 }
 
 void DatabaseLazy::dropTable(
-    const Context & context,
+    ContextPtr local_context,
     const String & table_name,
     bool no_delay)
 {
-    SCOPE_EXIT({ clearExpiredTables(); });
-    DatabaseOnDisk::dropTable(context, table_name, no_delay);
+    SCOPE_EXIT_MEMORY_SAFE({ clearExpiredTables(); });
+    DatabaseOnDisk::dropTable(local_context, table_name, no_delay);
 }
 
 void DatabaseLazy::renameTable(
-    const Context & context,
+    ContextPtr local_context,
     const String & table_name,
     IDatabase & to_database,
     const String & to_table_name,
     bool exchange,
     bool dictionary)
 {
-    SCOPE_EXIT({ clearExpiredTables(); });
-    DatabaseOnDisk::renameTable(context, table_name, to_database, to_table_name, exchange, dictionary);
+    SCOPE_EXIT_MEMORY_SAFE({ clearExpiredTables(); });
+    DatabaseOnDisk::renameTable(local_context, table_name, to_database, to_table_name, exchange, dictionary);
 }
 
 
@@ -105,7 +105,7 @@ time_t DatabaseLazy::getObjectMetadataModificationTime(const String & table_name
 }
 
 void DatabaseLazy::alterTable(
-    const Context & /* context */,
+    ContextPtr /* context */,
     const StorageID & /*table_id*/,
     const StorageInMemoryMetadata & /* metadata */)
 {
@@ -115,14 +115,14 @@ void DatabaseLazy::alterTable(
 
 bool DatabaseLazy::isTableExist(const String & table_name) const
 {
-    SCOPE_EXIT({ clearExpiredTables(); });
+    SCOPE_EXIT_MEMORY_SAFE({ clearExpiredTables(); });
     std::lock_guard lock(mutex);
     return tables_cache.find(table_name) != tables_cache.end();
 }
 
 StoragePtr DatabaseLazy::tryGetTable(const String & table_name) const
 {
-    SCOPE_EXIT({ clearExpiredTables(); });
+    SCOPE_EXIT_MEMORY_SAFE({ clearExpiredTables(); });
     {
         std::lock_guard lock(mutex);
         auto it = tables_cache.find(table_name);
@@ -142,7 +142,7 @@ StoragePtr DatabaseLazy::tryGetTable(const String & table_name) const
     return loadTable(table_name);
 }
 
-DatabaseTablesIteratorPtr DatabaseLazy::getTablesIterator(const Context &, const FilterByNameFunction & filter_by_table_name)
+DatabaseTablesIteratorPtr DatabaseLazy::getTablesIterator(ContextPtr, const FilterByNameFunction & filter_by_table_name)
 {
     std::lock_guard lock(mutex);
     Strings filtered_tables;
@@ -224,7 +224,7 @@ DatabaseLazy::~DatabaseLazy()
 
 StoragePtr DatabaseLazy::loadTable(const String & table_name) const
 {
-    SCOPE_EXIT({ clearExpiredTables(); });
+    SCOPE_EXIT_MEMORY_SAFE({ clearExpiredTables(); });
 
     LOG_DEBUG(log, "Load table {} to cache.", backQuote(table_name));
 
@@ -233,9 +233,9 @@ StoragePtr DatabaseLazy::loadTable(const String & table_name) const
     try
     {
         StoragePtr table;
-        Context context_copy(global_context); /// some tables can change context, but not LogTables
+        auto context_copy = Context::createCopy(context); /// some tables can change context, but not LogTables
 
-        auto ast = parseQueryFromMetadata(log, global_context, table_metadata_path, /*throw_on_error*/ true, /*remove_empty*/false);
+        auto ast = parseQueryFromMetadata(log, getContext(), table_metadata_path, /*throw_on_error*/ true, /*remove_empty*/false);
         if (ast)
         {
             const auto & ast_create = ast->as<const ASTCreateQuery &>();
diff --git a/src/Databases/DatabaseLazy.h b/src/Databases/DatabaseLazy.h
index 2d091297c91..99a71b342fa 100644
--- a/src/Databases/DatabaseLazy.h
+++ b/src/Databases/DatabaseLazy.h
@@ -18,7 +18,7 @@ class Context;
 class DatabaseLazy final : public DatabaseOnDisk
 {
 public:
-    DatabaseLazy(const String & name_, const String & metadata_path_, time_t expiration_time_, const Context & context_);
+    DatabaseLazy(const String & name_, const String & metadata_path_, time_t expiration_time_, ContextPtr context_);
 
     String getEngineName() const override { return "Lazy"; }
 
@@ -27,22 +27,22 @@ public:
     bool canContainDistributedTables() const override { return false; }
 
     void loadStoredObjects(
-        Context & context,
+        ContextPtr context,
         bool has_force_restore_data_flag, bool force_attach) override;
 
     void createTable(
-        const Context & context,
+        ContextPtr context,
         const String & table_name,
         const StoragePtr & table,
         const ASTPtr & query) override;
 
     void dropTable(
-        const Context & context,
+        ContextPtr context,
         const String & table_name,
         bool no_delay) override;
 
     void renameTable(
-        const Context & context,
+        ContextPtr context,
         const String & table_name,
         IDatabase & to_database,
         const String & to_table_name,
@@ -50,21 +50,21 @@ public:
         bool dictionary) override;
 
     void alterTable(
-        const Context & context,
+        ContextPtr context,
         const StorageID & table_id,
         const StorageInMemoryMetadata & metadata) override;
 
     time_t getObjectMetadataModificationTime(const String & table_name) const override;
 
-    bool isTableExist(const String & table_name, const Context &) const override { return isTableExist(table_name); }
+    bool isTableExist(const String & table_name, ContextPtr) const override { return isTableExist(table_name); }
     bool isTableExist(const String & table_name) const;
 
-    StoragePtr tryGetTable(const String & table_name, const Context &) const override { return tryGetTable(table_name); }
+    StoragePtr tryGetTable(const String & table_name, ContextPtr) const override { return tryGetTable(table_name); }
     StoragePtr tryGetTable(const String & table_name) const;
 
     bool empty() const override;
 
-    DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) override;
+    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name) override;
 
     void attachTable(const String & table_name, const StoragePtr & table, const String & relative_table_path) override;
 
diff --git a/src/Databases/DatabaseMemory.cpp b/src/Databases/DatabaseMemory.cpp
index 357acb32371..f21a145df55 100644
--- a/src/Databases/DatabaseMemory.cpp
+++ b/src/Databases/DatabaseMemory.cpp
@@ -16,13 +16,13 @@ namespace ErrorCodes
     extern const int UNKNOWN_TABLE;
 }
 
-DatabaseMemory::DatabaseMemory(const String & name_, const Context & context)
-    : DatabaseWithOwnTablesBase(name_, "DatabaseMemory(" + name_ + ")", context)
+DatabaseMemory::DatabaseMemory(const String & name_, ContextPtr context_)
+    : DatabaseWithOwnTablesBase(name_, "DatabaseMemory(" + name_ + ")", context_)
     , data_path("data/" + escapeForFileName(database_name) + "/")
 {}
 
 void DatabaseMemory::createTable(
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     const String & table_name,
     const StoragePtr & table,
     const ASTPtr & query)
@@ -33,7 +33,7 @@ void DatabaseMemory::createTable(
 }
 
 void DatabaseMemory::dropTable(
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     const String & table_name,
     bool /*no_delay*/)
 {
@@ -67,7 +67,7 @@ ASTPtr DatabaseMemory::getCreateDatabaseQuery() const
     return create_query;
 }
 
-ASTPtr DatabaseMemory::getCreateTableQueryImpl(const String & table_name, const Context &, bool throw_on_error) const
+ASTPtr DatabaseMemory::getCreateTableQueryImpl(const String & table_name, ContextPtr, bool throw_on_error) const
 {
     std::lock_guard lock{mutex};
     auto it = create_queries.find(table_name);
@@ -83,15 +83,15 @@ ASTPtr DatabaseMemory::getCreateTableQueryImpl(const String & table_name, const
 
 UUID DatabaseMemory::tryGetTableUUID(const String & table_name) const
 {
-    if (auto table = tryGetTable(table_name, global_context))
+    if (auto table = tryGetTable(table_name, getContext()))
         return table->getStorageID().uuid;
     return UUIDHelpers::Nil;
 }
 
-void DatabaseMemory::drop(const Context & context)
+void DatabaseMemory::drop(ContextPtr local_context)
 {
     /// Remove data on explicit DROP DATABASE
-    std::filesystem::remove_all(context.getPath() + data_path);
+    std::filesystem::remove_all(local_context->getPath() + data_path);
 }
 
 }
diff --git a/src/Databases/DatabaseMemory.h b/src/Databases/DatabaseMemory.h
index 40cc808e42b..8c9cf86ec19 100644
--- a/src/Databases/DatabaseMemory.h
+++ b/src/Databases/DatabaseMemory.h
@@ -19,22 +19,22 @@ namespace DB
 class DatabaseMemory final : public DatabaseWithOwnTablesBase
 {
 public:
-    DatabaseMemory(const String & name_, const Context & context);
+    DatabaseMemory(const String & name_, ContextPtr context);
 
     String getEngineName() const override { return "Memory"; }
 
     void createTable(
-        const Context & context,
+        ContextPtr context,
         const String & table_name,
         const StoragePtr & table,
         const ASTPtr & query) override;
 
     void dropTable(
-        const Context & context,
+        ContextPtr context,
         const String & table_name,
         bool no_delay) override;
 
-    ASTPtr getCreateTableQueryImpl(const String & name, const Context & context, bool throw_on_error) const override;
+    ASTPtr getCreateTableQueryImpl(const String & name, ContextPtr context, bool throw_on_error) const override;
     ASTPtr getCreateDatabaseQuery() const override;
 
     /// DatabaseMemory allows to create tables, which store data on disk.
@@ -46,7 +46,7 @@ public:
 
     UUID tryGetTableUUID(const String & table_name) const override;
 
-    void drop(const Context & context) override;
+    void drop(ContextPtr context) override;
 
 private:
     String data_path;
diff --git a/src/Databases/DatabaseOnDisk.cpp b/src/Databases/DatabaseOnDisk.cpp
index 79373128713..358f9030db5 100644
--- a/src/Databases/DatabaseOnDisk.cpp
+++ b/src/Databases/DatabaseOnDisk.cpp
@@ -46,7 +46,7 @@ std::pair<String, StoragePtr> createTableFromAST(
     ASTCreateQuery ast_create_query,
     const String & database_name,
     const String & table_data_path_relative,
-    Context & context,
+    ContextPtr context,
     bool has_force_restore_data_flag)
 {
     ast_create_query.attach = true;
@@ -79,7 +79,7 @@ std::pair<String, StoragePtr> createTableFromAST(
             ast_create_query,
             table_data_path_relative,
             context,
-            context.getGlobalContext(),
+            context->getGlobalContext(),
             columns,
             constraints,
             has_force_restore_data_flag)
@@ -188,23 +188,23 @@ DatabaseOnDisk::DatabaseOnDisk(
     const String & metadata_path_,
     const String & data_path_,
     const String & logger,
-    const Context & context)
-    : DatabaseWithOwnTablesBase(name, logger, context)
+    ContextPtr local_context)
+    : DatabaseWithOwnTablesBase(name, logger, local_context)
     , metadata_path(metadata_path_)
     , data_path(data_path_)
 {
-    Poco::File(context.getPath() + data_path).createDirectories();
+    Poco::File(local_context->getPath() + data_path).createDirectories();
     Poco::File(metadata_path).createDirectories();
 }
 
 
 void DatabaseOnDisk::createTable(
-    const Context & context,
+    ContextPtr local_context,
     const String & table_name,
     const StoragePtr & table,
     const ASTPtr & query)
 {
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = local_context->getSettingsRef();
     const auto & create = query->as<ASTCreateQuery &>();
     assert(table_name == create.table);
 
@@ -221,17 +221,19 @@ void DatabaseOnDisk::createTable(
     /// But there is protection from it - see using DDLGuard in InterpreterCreateQuery.
 
     if (isDictionaryExist(table_name))
-        throw Exception(ErrorCodes::DICTIONARY_ALREADY_EXISTS, "Dictionary {}.{} already exists", backQuote(getDatabaseName()), backQuote(table_name));
+        throw Exception(
+            ErrorCodes::DICTIONARY_ALREADY_EXISTS, "Dictionary {}.{} already exists", backQuote(getDatabaseName()), backQuote(table_name));
 
-    if (isTableExist(table_name, global_context))
-        throw Exception(ErrorCodes::TABLE_ALREADY_EXISTS, "Table {}.{} already exists", backQuote(getDatabaseName()), backQuote(table_name));
+    if (isTableExist(table_name, getContext()))
+        throw Exception(
+            ErrorCodes::TABLE_ALREADY_EXISTS, "Table {}.{} already exists", backQuote(getDatabaseName()), backQuote(table_name));
 
     String table_metadata_path = getObjectMetadataPath(table_name);
 
     if (create.attach_short_syntax)
     {
         /// Metadata already exists, table was detached
-        removeDetachedPermanentlyFlag(context, table_name, table_metadata_path, true);
+        removeDetachedPermanentlyFlag(local_context, table_name, table_metadata_path, true);
         attachTable(table_name, table, getTableDataPath(create));
         return;
     }
@@ -241,7 +243,7 @@ void DatabaseOnDisk::createTable(
 
     if (create.attach && Poco::File(table_metadata_path).exists())
     {
-        ASTPtr ast_detached = parseQueryFromMetadata(log, context, table_metadata_path);
+        ASTPtr ast_detached = parseQueryFromMetadata(log, local_context, table_metadata_path);
         auto & create_detached = ast_detached->as<ASTCreateQuery &>();
 
         // either both should be Nil, either values should be equal
@@ -268,14 +270,14 @@ void DatabaseOnDisk::createTable(
         out.close();
     }
 
-    commitCreateTable(create, table, table_metadata_tmp_path, table_metadata_path, context);
+    commitCreateTable(create, table, table_metadata_tmp_path, table_metadata_path, local_context);
 
-    removeDetachedPermanentlyFlag(context, table_name, table_metadata_path, false);
+    removeDetachedPermanentlyFlag(local_context, table_name, table_metadata_path, false);
 }
 
 /// If the table was detached permanently we will have a flag file with
 /// .sql.detached extension, is not needed anymore since we attached the table back
-void DatabaseOnDisk::removeDetachedPermanentlyFlag(const Context &, const String & table_name, const String & table_metadata_path, bool) const
+void DatabaseOnDisk::removeDetachedPermanentlyFlag(ContextPtr, const String & table_name, const String & table_metadata_path, bool) const
 {
     try
     {
@@ -293,7 +295,7 @@ void DatabaseOnDisk::removeDetachedPermanentlyFlag(const Context &, const String
 
 void DatabaseOnDisk::commitCreateTable(const ASTCreateQuery & query, const StoragePtr & table,
                                        const String & table_metadata_tmp_path, const String & table_metadata_path,
-                                       const Context & /*query_context*/)
+                                       ContextPtr /*query_context*/)
 {
     try
     {
@@ -311,7 +313,7 @@ void DatabaseOnDisk::commitCreateTable(const ASTCreateQuery & query, const Stora
     }
 }
 
-void DatabaseOnDisk::detachTablePermanently(const Context &, const String & table_name)
+void DatabaseOnDisk::detachTablePermanently(ContextPtr, const String & table_name)
 {
     auto table = detachTable(table_name);
 
@@ -327,7 +329,7 @@ void DatabaseOnDisk::detachTablePermanently(const Context &, const String & tabl
     }
 }
 
-void DatabaseOnDisk::dropTable(const Context & context, const String & table_name, bool /*no_delay*/)
+void DatabaseOnDisk::dropTable(ContextPtr local_context, const String & table_name, bool /*no_delay*/)
 {
     String table_metadata_path = getObjectMetadataPath(table_name);
     String table_metadata_path_drop = table_metadata_path + drop_suffix;
@@ -349,7 +351,7 @@ void DatabaseOnDisk::dropTable(const Context & context, const String & table_nam
         table->drop();
         table->is_dropped = true;
 
-        Poco::File table_data_dir{context.getPath() + table_data_path_relative};
+        Poco::File table_data_dir{local_context->getPath() + table_data_path_relative};
         if (table_data_dir.exists())
             table_data_dir.remove(true);
     }
@@ -387,7 +389,7 @@ void DatabaseOnDisk::checkMetadataFilenameAvailabilityUnlocked(const String & to
 }
 
 void DatabaseOnDisk::renameTable(
-        const Context & context,
+        ContextPtr local_context,
         const String & table_name,
         IDatabase & to_database,
         const String & to_table_name,
@@ -418,15 +420,16 @@ void DatabaseOnDisk::renameTable(
     String table_metadata_path;
     ASTPtr attach_query;
     /// DatabaseLazy::detachTable may return nullptr even if table exists, so we need tryGetTable for this case.
-    StoragePtr table = tryGetTable(table_name, global_context);
+    StoragePtr table = tryGetTable(table_name, getContext());
     detachTable(table_name);
     UUID prev_uuid = UUIDHelpers::Nil;
     try
     {
-        table_lock = table->lockExclusively(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+        table_lock = table->lockExclusively(
+            local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout);
 
         table_metadata_path = getObjectMetadataPath(table_name);
-        attach_query = parseQueryFromMetadata(log, context, table_metadata_path);
+        attach_query = parseQueryFromMetadata(log, local_context, table_metadata_path);
         auto & create = attach_query->as<ASTCreateQuery &>();
         create.database = to_database.getDatabaseName();
         create.table = to_table_name;
@@ -454,7 +457,7 @@ void DatabaseOnDisk::renameTable(
     }
 
     /// Now table data are moved to new database, so we must add metadata and attach table to new database
-    to_database.createTable(context, to_table_name, table, attach_query);
+    to_database.createTable(local_context, to_table_name, table, attach_query);
 
     Poco::File(table_metadata_path).remove();
 
@@ -473,10 +476,10 @@ void DatabaseOnDisk::renameTable(
 
 
 /// It returns create table statement (even if table is detached)
-ASTPtr DatabaseOnDisk::getCreateTableQueryImpl(const String & table_name, const Context &, bool throw_on_error) const
+ASTPtr DatabaseOnDisk::getCreateTableQueryImpl(const String & table_name, ContextPtr, bool throw_on_error) const
 {
     ASTPtr ast;
-    bool has_table = tryGetTable(table_name, global_context) != nullptr;
+    bool has_table = tryGetTable(table_name, getContext()) != nullptr;
     auto table_metadata_path = getObjectMetadataPath(table_name);
     try
     {
@@ -497,11 +500,11 @@ ASTPtr DatabaseOnDisk::getCreateDatabaseQuery() const
 {
     ASTPtr ast;
 
-    auto settings = global_context.getSettingsRef();
+    auto settings = getContext()->getSettingsRef();
     {
         std::lock_guard lock(mutex);
-        auto database_metadata_path = global_context.getPath() + "metadata/" + escapeForFileName(database_name) + ".sql";
-        ast = parseQueryFromMetadata(log, global_context, database_metadata_path, true);
+        auto database_metadata_path = getContext()->getPath() + "metadata/" + escapeForFileName(database_name) + ".sql";
+        ast = parseQueryFromMetadata(log, getContext(), database_metadata_path, true);
         auto & ast_create_query = ast->as<ASTCreateQuery &>();
         ast_create_query.attach = false;
         ast_create_query.database = database_name;
@@ -518,10 +521,10 @@ ASTPtr DatabaseOnDisk::getCreateDatabaseQuery() const
     return ast;
 }
 
-void DatabaseOnDisk::drop(const Context & context)
+void DatabaseOnDisk::drop(ContextPtr local_context)
 {
     assert(tables.empty());
-    Poco::File(context.getPath() + getDataPath()).remove(false);
+    Poco::File(local_context->getPath() + getDataPath()).remove(false);
     Poco::File(getMetadataPath()).remove(false);
 }
 
@@ -541,14 +544,14 @@ time_t DatabaseOnDisk::getObjectMetadataModificationTime(const String & object_n
         return static_cast<time_t>(0);
 }
 
-void DatabaseOnDisk::iterateMetadataFiles(const Context & context, const IteratingFunction & process_metadata_file) const
+void DatabaseOnDisk::iterateMetadataFiles(ContextPtr local_context, const IteratingFunction & process_metadata_file) const
 {
     auto process_tmp_drop_metadata_file = [&](const String & file_name)
     {
         assert(getUUID() == UUIDHelpers::Nil);
         static const char * tmp_drop_ext = ".sql.tmp_drop";
         const std::string object_name = file_name.substr(0, file_name.size() - strlen(tmp_drop_ext));
-        if (Poco::File(context.getPath() + getDataPath() + '/' + object_name).exists())
+        if (Poco::File(local_context->getPath() + getDataPath() + '/' + object_name).exists())
         {
             Poco::File(getMetadataPath() + file_name).renameTo(getMetadataPath() + object_name + ".sql");
             LOG_WARNING(log, "Object {} was not dropped previously and will be restored", backQuote(object_name));
@@ -615,7 +618,12 @@ void DatabaseOnDisk::iterateMetadataFiles(const Context & context, const Iterati
     pool.wait();
 }
 
-ASTPtr DatabaseOnDisk::parseQueryFromMetadata(Poco::Logger * logger, const Context & context, const String & metadata_file_path, bool throw_on_error /*= true*/, bool remove_empty /*= false*/)
+ASTPtr DatabaseOnDisk::parseQueryFromMetadata(
+    Poco::Logger * logger,
+    ContextPtr local_context,
+    const String & metadata_file_path,
+    bool throw_on_error /*= true*/,
+    bool remove_empty /*= false*/)
 {
     String query;
 
@@ -643,7 +651,7 @@ ASTPtr DatabaseOnDisk::parseQueryFromMetadata(Poco::Logger * logger, const Conte
         return nullptr;
     }
 
-    auto settings = context.getSettingsRef();
+    auto settings = local_context->getSettingsRef();
     ParserCreateQuery parser;
     const char * pos = query.data();
     std::string error_message;
@@ -662,7 +670,12 @@ ASTPtr DatabaseOnDisk::parseQueryFromMetadata(Poco::Logger * logger, const Conte
         table_name = unescapeForFileName(table_name);
 
         if (create.table != TABLE_WITH_UUID_NAME_PLACEHOLDER && logger)
-            LOG_WARNING(logger, "File {} contains both UUID and table name. Will use name `{}` instead of `{}`", metadata_file_path, table_name, create.table);
+            LOG_WARNING(
+                logger,
+                "File {} contains both UUID and table name. Will use name `{}` instead of `{}`",
+                metadata_file_path,
+                table_name,
+                create.table);
         create.table = table_name;
     }
 
@@ -671,7 +684,7 @@ ASTPtr DatabaseOnDisk::parseQueryFromMetadata(Poco::Logger * logger, const Conte
 
 ASTPtr DatabaseOnDisk::getCreateQueryFromMetadata(const String & database_metadata_path, bool throw_on_error) const
 {
-    ASTPtr ast = parseQueryFromMetadata(log, global_context, database_metadata_path, throw_on_error);
+    ASTPtr ast = parseQueryFromMetadata(log, getContext(), database_metadata_path, throw_on_error);
 
     if (ast)
     {
diff --git a/src/Databases/DatabaseOnDisk.h b/src/Databases/DatabaseOnDisk.h
index b96a24f3345..677465e306e 100644
--- a/src/Databases/DatabaseOnDisk.h
+++ b/src/Databases/DatabaseOnDisk.h
@@ -16,7 +16,7 @@ std::pair<String, StoragePtr> createTableFromAST(
     ASTCreateQuery ast_create_query,
     const String & database_name,
     const String & table_data_path_relative,
-    Context & context,
+    ContextPtr context,
     bool has_force_restore_data_flag);
 
 /** Get the string with the table definition based on the CREATE query.
@@ -33,23 +33,23 @@ void applyMetadataChangesToCreateQuery(const ASTPtr & query, const StorageInMemo
 class DatabaseOnDisk : public DatabaseWithOwnTablesBase
 {
 public:
-    DatabaseOnDisk(const String & name, const String & metadata_path_, const String & data_path_, const String & logger, const Context & context);
+    DatabaseOnDisk(const String & name, const String & metadata_path_, const String & data_path_, const String & logger, ContextPtr context);
 
     void createTable(
-        const Context & context,
+        ContextPtr context,
         const String & table_name,
         const StoragePtr & table,
         const ASTPtr & query) override;
 
-    void detachTablePermanently(const Context & context, const String & table_name) override;
+    void detachTablePermanently(ContextPtr context, const String & table_name) override;
 
     void dropTable(
-        const Context & context,
+        ContextPtr context,
         const String & table_name,
         bool no_delay) override;
 
     void renameTable(
-        const Context & context,
+        ContextPtr context,
         const String & table_name,
         IDatabase & to_database,
         const String & to_table_name,
@@ -58,7 +58,7 @@ public:
 
     ASTPtr getCreateDatabaseQuery() const override;
 
-    void drop(const Context & context) override;
+    void drop(ContextPtr context) override;
 
     String getObjectMetadataPath(const String & object_name) const override;
 
@@ -69,7 +69,7 @@ public:
     String getTableDataPath(const ASTCreateQuery & query) const override { return getTableDataPath(query.table); }
     String getMetadataPath() const override { return metadata_path; }
 
-    static ASTPtr parseQueryFromMetadata(Poco::Logger * log, const Context & context, const String & metadata_file_path, bool throw_on_error = true, bool remove_empty = false);
+    static ASTPtr parseQueryFromMetadata(Poco::Logger * log, ContextPtr context, const String & metadata_file_path, bool throw_on_error = true, bool remove_empty = false);
 
     /// will throw when the table we want to attach already exists (in active / detached / detached permanently form)
     void checkMetadataFilenameAvailability(const String & to_table_name) const;
@@ -82,19 +82,19 @@ protected:
 
     using IteratingFunction = std::function<void(const String &)>;
 
-    void iterateMetadataFiles(const Context & context, const IteratingFunction & process_metadata_file) const;
+    void iterateMetadataFiles(ContextPtr context, const IteratingFunction & process_metadata_file) const;
 
     ASTPtr getCreateTableQueryImpl(
         const String & table_name,
-        const Context & context,
+        ContextPtr context,
         bool throw_on_error) const override;
 
     ASTPtr getCreateQueryFromMetadata(const String & metadata_path, bool throw_on_error) const;
 
     virtual void commitCreateTable(const ASTCreateQuery & query, const StoragePtr & table,
-                                   const String & table_metadata_tmp_path, const String & table_metadata_path, const Context & query_context);
+                                   const String & table_metadata_tmp_path, const String & table_metadata_path, ContextPtr query_context);
 
-    virtual void removeDetachedPermanentlyFlag(const Context & context, const String & table_name, const String & table_metadata_path, bool attach) const;
+    virtual void removeDetachedPermanentlyFlag(ContextPtr context, const String & table_name, const String & table_metadata_path, bool attach) const;
 
     const String metadata_path;
     const String data_path;
diff --git a/src/Databases/DatabaseOrdinary.cpp b/src/Databases/DatabaseOrdinary.cpp
index a94668dacf7..840be0e006a 100644
--- a/src/Databases/DatabaseOrdinary.cpp
+++ b/src/Databases/DatabaseOrdinary.cpp
@@ -36,7 +36,7 @@ static constexpr size_t METADATA_FILE_BUFFER_SIZE = 32768;
 namespace
 {
     void tryAttachTable(
-        Context & context,
+        ContextPtr context,
         const ASTCreateQuery & query,
         DatabaseOrdinary & database,
         const String & database_name,
@@ -62,7 +62,7 @@ namespace
     }
 
 
-    void tryAttachDictionary(const ASTPtr & query, DatabaseOrdinary & database, const String & metadata_path, const Context & context)
+    void tryAttachDictionary(const ASTPtr & query, DatabaseOrdinary & database, const String & metadata_path, ContextPtr context)
     {
         auto & create_query = query->as<ASTCreateQuery &>();
         assert(create_query.is_dictionary);
@@ -94,18 +94,18 @@ namespace
 }
 
 
-DatabaseOrdinary::DatabaseOrdinary(const String & name_, const String & metadata_path_, const Context & context_)
+DatabaseOrdinary::DatabaseOrdinary(const String & name_, const String & metadata_path_, ContextPtr context_)
     : DatabaseOrdinary(name_, metadata_path_, "data/" + escapeForFileName(name_) + "/", "DatabaseOrdinary (" + name_ + ")", context_)
 {
 }
 
 DatabaseOrdinary::DatabaseOrdinary(
-    const String & name_, const String & metadata_path_, const String & data_path_, const String & logger, const Context & context_)
+    const String & name_, const String & metadata_path_, const String & data_path_, const String & logger, ContextPtr context_)
     : DatabaseWithDictionaries(name_, metadata_path_, data_path_, logger, context_)
 {
 }
 
-void DatabaseOrdinary::loadStoredObjects(Context & context, bool has_force_restore_data_flag, bool /*force_attach*/)
+void DatabaseOrdinary::loadStoredObjects(ContextPtr local_context, bool has_force_restore_data_flag, bool /*force_attach*/)
 {
     /** Tables load faster if they are loaded in sorted (by name) order.
       * Otherwise (for the ext4 filesystem), `DirectoryIterator` iterates through them in some order,
@@ -117,7 +117,8 @@ void DatabaseOrdinary::loadStoredObjects(Context & context, bool has_force_resto
 
     size_t total_dictionaries = 0;
 
-    auto process_metadata = [&context, &file_names, &total_dictionaries, &file_names_mutex, this](const String & file_name)
+    auto process_metadata = [context_weak = ContextWeakPtr(local_context), &file_names, &total_dictionaries, &file_names_mutex, this](
+                                const String & file_name)
     {
         fs::path path(getMetadataPath());
         fs::path file_path(file_name);
@@ -125,7 +126,7 @@ void DatabaseOrdinary::loadStoredObjects(Context & context, bool has_force_resto
 
         try
         {
-            auto ast = parseQueryFromMetadata(log, context, full_path.string(), /*throw_on_error*/ true, /*remove_empty*/ false);
+            auto ast = parseQueryFromMetadata(log, getContext(), full_path.string(), /*throw_on_error*/ true, /*remove_empty*/ false);
             if (ast)
             {
                 auto * create_query = ast->as<ASTCreateQuery>();
@@ -155,7 +156,7 @@ void DatabaseOrdinary::loadStoredObjects(Context & context, bool has_force_resto
         }
     };
 
-    iterateMetadataFiles(context, process_metadata);
+    iterateMetadataFiles(local_context, process_metadata);
 
     size_t total_tables = file_names.size() - total_dictionaries;
 
@@ -180,7 +181,7 @@ void DatabaseOrdinary::loadStoredObjects(Context & context, bool has_force_resto
         auto create_query = query->as<const ASTCreateQuery &>();
         if (create_query.is_dictionary)
         {
-            tryAttachDictionary(query, *this, getMetadataPath() + name, context);
+            tryAttachDictionary(query, *this, getMetadataPath() + name, local_context);
 
             /// Messages, so that it's not boring to wait for the server to load for a long time.
             logAboutProgress(log, ++dictionaries_processed, total_dictionaries, watch);
@@ -195,7 +196,7 @@ void DatabaseOrdinary::loadStoredObjects(Context & context, bool has_force_resto
             pool.scheduleOrThrowOnError([&]()
             {
                 tryAttachTable(
-                    context,
+                    local_context,
                     create_query,
                     *this,
                     database_name,
@@ -245,7 +246,7 @@ void DatabaseOrdinary::startupTables(ThreadPool & thread_pool)
     thread_pool.wait();
 }
 
-void DatabaseOrdinary::alterTable(const Context & context, const StorageID & table_id, const StorageInMemoryMetadata & metadata)
+void DatabaseOrdinary::alterTable(ContextPtr local_context, const StorageID & table_id, const StorageInMemoryMetadata & metadata)
 {
     String table_name = table_id.table_name;
     /// Read the definition of the table and replace the necessary parts with new ones.
@@ -265,7 +266,7 @@ void DatabaseOrdinary::alterTable(const Context & context, const StorageID & tab
         statement.data() + statement.size(),
         "in file " + table_metadata_path,
         0,
-        context.getSettingsRef().max_parser_depth);
+        local_context->getSettingsRef().max_parser_depth);
 
     applyMetadataChangesToCreateQuery(ast, metadata);
 
@@ -274,15 +275,15 @@ void DatabaseOrdinary::alterTable(const Context & context, const StorageID & tab
         WriteBufferFromFile out(table_metadata_tmp_path, statement.size(), O_WRONLY | O_CREAT | O_EXCL);
         writeString(statement, out);
         out.next();
-        if (context.getSettingsRef().fsync_metadata)
+        if (local_context->getSettingsRef().fsync_metadata)
             out.sync();
         out.close();
     }
 
-    commitAlterTable(table_id, table_metadata_tmp_path, table_metadata_path, statement, context);
+    commitAlterTable(table_id, table_metadata_tmp_path, table_metadata_path, statement, local_context);
 }
 
-void DatabaseOrdinary::commitAlterTable(const StorageID &, const String & table_metadata_tmp_path, const String & table_metadata_path, const String & /*statement*/, const Context & /*query_context*/)
+void DatabaseOrdinary::commitAlterTable(const StorageID &, const String & table_metadata_tmp_path, const String & table_metadata_path, const String & /*statement*/, ContextPtr /*query_context*/)
 {
     try
     {
diff --git a/src/Databases/DatabaseOrdinary.h b/src/Databases/DatabaseOrdinary.h
index c1ad32345f6..4cf58cef9f0 100644
--- a/src/Databases/DatabaseOrdinary.h
+++ b/src/Databases/DatabaseOrdinary.h
@@ -14,23 +14,26 @@ namespace DB
 class DatabaseOrdinary : public DatabaseWithDictionaries
 {
 public:
-    DatabaseOrdinary(const String & name_, const String & metadata_path_, const Context & context);
-    DatabaseOrdinary(const String & name_, const String & metadata_path_, const String & data_path_, const String & logger, const Context & context_);
+    DatabaseOrdinary(const String & name_, const String & metadata_path_, ContextPtr context);
+    DatabaseOrdinary(
+        const String & name_, const String & metadata_path_, const String & data_path_, const String & logger, ContextPtr context_);
 
     String getEngineName() const override { return "Ordinary"; }
 
-    void loadStoredObjects(
-        Context & context,
-        bool has_force_restore_data_flag,
-        bool force_attach) override;
+    void loadStoredObjects(ContextPtr context, bool has_force_restore_data_flag, bool force_attach) override;
 
     void alterTable(
-        const Context & context,
+        ContextPtr context,
         const StorageID & table_id,
         const StorageInMemoryMetadata & metadata) override;
 
 protected:
-    virtual void commitAlterTable(const StorageID & table_id, const String & table_metadata_tmp_path, const String & table_metadata_path, const String & statement, const Context & query_context);
+    virtual void commitAlterTable(
+        const StorageID & table_id,
+        const String & table_metadata_tmp_path,
+        const String & table_metadata_path,
+        const String & statement,
+        ContextPtr query_context);
 
     void startupTables(ThreadPool & thread_pool);
 };
diff --git a/src/Databases/DatabaseReplicated.cpp b/src/Databases/DatabaseReplicated.cpp
index 664452abe6f..46d67e275ba 100644
--- a/src/Databases/DatabaseReplicated.cpp
+++ b/src/Databases/DatabaseReplicated.cpp
@@ -47,12 +47,12 @@ static constexpr const char * BROKEN_TABLES_SUFFIX = "_broken_tables";
 
 zkutil::ZooKeeperPtr DatabaseReplicated::getZooKeeper() const
 {
-    return global_context.getZooKeeper();
+    return getContext()->getZooKeeper();
 }
 
-static inline String getHostID(const Context & global_context, const UUID & db_uuid)
+static inline String getHostID(ContextPtr global_context, const UUID & db_uuid)
 {
-    return Cluster::Address::toString(getFQDNOrHostName(), global_context.getTCPPort()) + ':' + toString(db_uuid);
+    return Cluster::Address::toString(getFQDNOrHostName(), global_context->getTCPPort()) + ':' + toString(db_uuid);
 }
 
 
@@ -66,7 +66,7 @@ DatabaseReplicated::DatabaseReplicated(
     const String & shard_name_,
     const String & replica_name_,
     DatabaseReplicatedSettings db_settings_,
-    const Context & context_)
+    ContextPtr context_)
     : DatabaseAtomic(name_, metadata_path_, uuid, "DatabaseReplicated (" + name_ + ")", context_)
     , zookeeper_path(zookeeper_path_)
     , shard_name(shard_name_)
@@ -126,7 +126,7 @@ ClusterPtr DatabaseReplicated::getClusterImpl() const
     Strings hosts;
     Strings host_ids;
 
-    auto zookeeper = global_context.getZooKeeper();
+    auto zookeeper = getContext()->getZooKeeper();
     constexpr int max_retries = 10;
     int iteration = 0;
     bool success = false;
@@ -189,22 +189,22 @@ ClusterPtr DatabaseReplicated::getClusterImpl() const
 
     String username = db_settings.cluster_username;
     String password = db_settings.cluster_password;
-    UInt16 default_port = global_context.getTCPPort();
+    UInt16 default_port = getContext()->getTCPPort();
     bool secure = db_settings.cluster_secure_connection;
 
-    return std::make_shared<Cluster>(global_context.getSettingsRef(), shards, username, password, default_port, false, secure);
+    return std::make_shared<Cluster>(getContext()->getSettingsRef(), shards, username, password, default_port, false, secure);
 }
 
 void DatabaseReplicated::tryConnectToZooKeeperAndInitDatabase(bool force_attach)
 {
     try
     {
-        if (!global_context.hasZooKeeper())
+        if (!getContext()->hasZooKeeper())
         {
             throw Exception("Can't create replicated database without ZooKeeper", ErrorCodes::NO_ZOOKEEPER);
         }
 
-        auto current_zookeeper = global_context.getZooKeeper();
+        auto current_zookeeper = getContext()->getZooKeeper();
 
         if (!current_zookeeper->exists(zookeeper_path))
         {
@@ -217,7 +217,7 @@ void DatabaseReplicated::tryConnectToZooKeeperAndInitDatabase(bool force_attach)
         String replica_host_id;
         if (current_zookeeper->tryGet(replica_path, replica_host_id))
         {
-            String host_id = getHostID(global_context, db_uuid);
+            String host_id = getHostID(getContext(), db_uuid);
             if (replica_host_id != host_id)
                 throw Exception(ErrorCodes::REPLICA_IS_ALREADY_EXIST,
                                 "Replica {} of shard {} of replicated database at {} already exists. Replica host ID: '{}', current host ID: '{}'",
@@ -291,7 +291,7 @@ void DatabaseReplicated::createEmptyLogEntry(Coordination::Requests & ops, const
 void DatabaseReplicated::createReplicaNodesInZooKeeper(const zkutil::ZooKeeperPtr & current_zookeeper)
 {
     /// Write host name to replica_path, it will protect from multiple replicas with the same name
-    auto host_id = getHostID(global_context, db_uuid);
+    auto host_id = getHostID(getContext(), db_uuid);
 
     Coordination::Requests ops;
     ops.emplace_back(zkutil::makeCreateRequest(replica_path, host_id, zkutil::CreateMode::Persistent));
@@ -300,17 +300,17 @@ void DatabaseReplicated::createReplicaNodesInZooKeeper(const zkutil::ZooKeeperPt
     current_zookeeper->multi(ops);
 }
 
-void DatabaseReplicated::loadStoredObjects(Context & context, bool has_force_restore_data_flag, bool force_attach)
+void DatabaseReplicated::loadStoredObjects(ContextPtr local_context, bool has_force_restore_data_flag, bool force_attach)
 {
     tryConnectToZooKeeperAndInitDatabase(force_attach);
 
-    DatabaseAtomic::loadStoredObjects(context, has_force_restore_data_flag, force_attach);
+    DatabaseAtomic::loadStoredObjects(local_context, has_force_restore_data_flag, force_attach);
 
-    ddl_worker = std::make_unique<DatabaseReplicatedDDLWorker>(this, global_context);
+    ddl_worker = std::make_unique<DatabaseReplicatedDDLWorker>(this, getContext());
     ddl_worker->startup();
 }
 
-void DatabaseReplicated::checkQueryValid(const ASTPtr & query, const Context & query_context) const
+void DatabaseReplicated::checkQueryValid(const ASTPtr & query, ContextPtr query_context) const
 {
     /// Replicas will set correct name of current database in query context (database name can be different on replicas)
     if (auto * ddl_query = dynamic_cast<ASTQueryWithTableAndOutput *>(query.get()))
@@ -343,12 +343,12 @@ void DatabaseReplicated::checkQueryValid(const ASTPtr & query, const Context & q
 
             Macros::MacroExpansionInfo info;
             info.table_id = {getDatabaseName(), create->table, create->uuid};
-            query_context.getMacros()->expand(maybe_path, info);
+            query_context->getMacros()->expand(maybe_path, info);
             bool maybe_shard_macros = info.expanded_other;
             info.expanded_other = false;
-            query_context.getMacros()->expand(maybe_replica, info);
+            query_context->getMacros()->expand(maybe_replica, info);
             bool maybe_replica_macros = info.expanded_other;
-            bool enable_functional_tests_helper = global_context.getConfigRef().has("_functional_tests_helper_database_replicated_replace_args_macros");
+            bool enable_functional_tests_helper = getContext()->getConfigRef().has("_functional_tests_helper_database_replicated_replace_args_macros");
 
             if (!enable_functional_tests_helper)
                 LOG_WARNING(log, "It's not recommended to explicitly specify zookeeper_path and replica_name in ReplicatedMergeTree arguments");
@@ -383,7 +383,7 @@ void DatabaseReplicated::checkQueryValid(const ASTPtr & query, const Context & q
 
     if (auto * query_drop = query->as<ASTDropQuery>())
     {
-        if (query_drop->kind == ASTDropQuery::Kind::Detach && query_context.getSettingsRef().database_replicated_always_detach_permanently)
+        if (query_drop->kind == ASTDropQuery::Kind::Detach && query_context->getSettingsRef().database_replicated_always_detach_permanently)
             query_drop->permanently = true;
         if (query_drop->kind == ASTDropQuery::Kind::Detach && !query_drop->permanently)
             throw Exception(ErrorCodes::INCORRECT_QUERY, "DETACH TABLE is not allowed for Replicated databases. "
@@ -392,12 +392,12 @@ void DatabaseReplicated::checkQueryValid(const ASTPtr & query, const Context & q
     }
 }
 
-BlockIO DatabaseReplicated::tryEnqueueReplicatedDDL(const ASTPtr & query, const Context & query_context)
+BlockIO DatabaseReplicated::tryEnqueueReplicatedDDL(const ASTPtr & query, ContextPtr query_context)
 {
     if (is_readonly)
         throw Exception(ErrorCodes::NO_ZOOKEEPER, "Database is in readonly mode, because it cannot connect to ZooKeeper");
 
-    if (query_context.getClientInfo().query_kind != ClientInfo::QueryKind::INITIAL_QUERY)
+    if (query_context->getClientInfo().query_kind != ClientInfo::QueryKind::INITIAL_QUERY)
         throw Exception(ErrorCodes::INCORRECT_QUERY, "It's not initial query. ON CLUSTER is not allowed for Replicated database.");
 
     checkQueryValid(query, query_context);
@@ -413,15 +413,15 @@ BlockIO DatabaseReplicated::tryEnqueueReplicatedDDL(const ASTPtr & query, const
     return getDistributedDDLStatus(node_path, entry, query_context, hosts_to_wait);
 }
 
-static UUID getTableUUIDIfReplicated(const String & metadata, const Context & context)
+static UUID getTableUUIDIfReplicated(const String & metadata, ContextPtr context)
 {
     bool looks_like_replicated = metadata.find("ReplicatedMergeTree") != std::string::npos;
     if (!looks_like_replicated)
         return UUIDHelpers::Nil;
 
     ParserCreateQuery parser;
-    auto size = context.getSettingsRef().max_query_size;
-    auto depth = context.getSettingsRef().max_parser_depth;
+    auto size = context->getSettingsRef().max_query_size;
+    auto depth = context->getSettingsRef().max_parser_depth;
     ASTPtr query = parseQuery(parser, metadata, size, depth);
     const ASTCreateQuery & create = query->as<const ASTCreateQuery &>();
     if (!create.storage || !create.storage->engine)
@@ -457,7 +457,7 @@ void DatabaseReplicated::recoverLostReplica(const ZooKeeperPtr & current_zookeep
     std::unordered_map<UUID, String> zk_replicated_id_to_name;
     for (const auto & zk_table : table_name_to_metadata)
     {
-        UUID zk_replicated_id = getTableUUIDIfReplicated(zk_table.second, global_context);
+        UUID zk_replicated_id = getTableUUIDIfReplicated(zk_table.second, getContext());
         if (zk_replicated_id != UUIDHelpers::Nil)
             zk_replicated_id_to_name.emplace(zk_replicated_id, zk_table.first);
     }
@@ -467,7 +467,8 @@ void DatabaseReplicated::recoverLostReplica(const ZooKeeperPtr & current_zookeep
     std::vector<std::pair<String, String>> replicated_tables_to_rename;
     size_t total_tables = 0;
     std::vector<UUID> replicated_ids;
-    for (auto existing_tables_it = getTablesIterator(global_context, {}); existing_tables_it->isValid(); existing_tables_it->next(), ++total_tables)
+    for (auto existing_tables_it = getTablesIterator(getContext(), {}); existing_tables_it->isValid();
+         existing_tables_it->next(), ++total_tables)
     {
         String name = existing_tables_it->name();
         UUID local_replicated_id = UUIDHelpers::Nil;
@@ -506,7 +507,7 @@ void DatabaseReplicated::recoverLostReplica(const ZooKeeperPtr & current_zookeep
         /// We use Ordinary engine for destination database, because it's the only way to discard table UUID
         /// and make possible creation of new table with the same UUID.
         String query = fmt::format("CREATE DATABASE IF NOT EXISTS {} ENGINE=Ordinary", backQuoteIfNeed(to_db_name));
-        Context query_context = global_context;
+        auto query_context = Context::createCopy(getContext());
         executeQuery(query, query_context, true);
     }
 
@@ -519,12 +520,12 @@ void DatabaseReplicated::recoverLostReplica(const ZooKeeperPtr & current_zookeep
         if (getDatabaseName() != db_name)
             throw Exception(ErrorCodes::UNKNOWN_DATABASE, "Database was renamed, will retry");
 
-        auto table = tryGetTable(table_name, global_context);
+        auto table = tryGetTable(table_name, getContext());
         if (isDictionaryExist(table_name))
         {
             /// We can safely drop any dictionaries because they do not store data
             LOG_DEBUG(log, "Will DROP DICTIONARY {}", backQuoteIfNeed(table_name));
-            DatabaseAtomic::removeDictionary(global_context, table_name);
+            DatabaseAtomic::removeDictionary(getContext(), table_name);
             ++dropped_dicts;
         }
         else if (!table->storesDataOnDisk())
@@ -532,7 +533,7 @@ void DatabaseReplicated::recoverLostReplica(const ZooKeeperPtr & current_zookeep
             LOG_DEBUG(log, "Will DROP TABLE {}, because it does not store data on disk and can be safely dropped", backQuoteIfNeed(table_name));
             dropped_tables.push_back(tryGetTableUUID(table_name));
             table->shutdown();
-            DatabaseAtomic::dropTable(global_context, table_name, true);
+            DatabaseAtomic::dropTable(getContext(), table_name, true);
         }
         else
         {
@@ -542,7 +543,7 @@ void DatabaseReplicated::recoverLostReplica(const ZooKeeperPtr & current_zookeep
             assert(db_name < to_db_name);
             DDLGuardPtr to_table_guard = DatabaseCatalog::instance().getDDLGuard(to_db_name, to_name);
             auto to_db_ptr = DatabaseCatalog::instance().getDatabase(to_db_name);
-            DatabaseAtomic::renameTable(global_context, table_name, *to_db_ptr, to_name, false, false);
+            DatabaseAtomic::renameTable(getContext(), table_name, *to_db_ptr, to_name, false, false);
             ++moved_tables;
         }
     }
@@ -561,7 +562,7 @@ void DatabaseReplicated::recoverLostReplica(const ZooKeeperPtr & current_zookeep
         /// TODO Maybe we should do it in two steps: rename all tables to temporary names and then rename them to actual names?
         DDLGuardPtr table_guard = DatabaseCatalog::instance().getDDLGuard(db_name, std::min(from, to));
         DDLGuardPtr to_table_guard = DatabaseCatalog::instance().getDDLGuard(db_name, std::max(from, to));
-        DatabaseAtomic::renameTable(global_context, from, *this, to, false, false);
+        DatabaseAtomic::renameTable(getContext(), from, *this, to, false, false);
     }
 
     for (const auto & id : dropped_tables)
@@ -569,7 +570,7 @@ void DatabaseReplicated::recoverLostReplica(const ZooKeeperPtr & current_zookeep
 
     for (const auto & name_and_meta : table_name_to_metadata)
     {
-        if (isTableExist(name_and_meta.first, global_context))
+        if (isTableExist(name_and_meta.first, getContext()))
         {
             assert(name_and_meta.second == readMetadataFile(name_and_meta.first));
             continue;
@@ -577,11 +578,11 @@ void DatabaseReplicated::recoverLostReplica(const ZooKeeperPtr & current_zookeep
 
         auto query_ast = parseQueryFromMetadataInZooKeeper(name_and_meta.first, name_and_meta.second);
 
-        Context query_context = global_context;
-        query_context.makeQueryContext();
-        query_context.getClientInfo().query_kind = ClientInfo::QueryKind::SECONDARY_QUERY;
-        query_context.setCurrentDatabase(database_name);
-        query_context.setCurrentQueryId(""); // generate random query_id
+        auto query_context = Context::createCopy(getContext());
+        query_context->makeQueryContext();
+        query_context->getClientInfo().query_kind = ClientInfo::QueryKind::SECONDARY_QUERY;
+        query_context->setCurrentDatabase(database_name);
+        query_context->setCurrentQueryId(""); // generate random query_id
 
         LOG_INFO(log, "Executing {}", serializeAST(*query_ast));
         InterpreterCreateQuery(query_ast, query_context).execute();
@@ -643,7 +644,7 @@ ASTPtr DatabaseReplicated::parseQueryFromMetadataInZooKeeper(const String & node
 {
     ParserCreateQuery parser;
     String description = "in ZooKeeper " + zookeeper_path + "/metadata/" + node_name;
-    auto ast = parseQuery(parser, query, description, 0, global_context.getSettingsRef().max_parser_depth);
+    auto ast = parseQuery(parser, query, description, 0, getContext()->getSettingsRef().max_parser_depth);
 
     auto & create = ast->as<ASTCreateQuery &>();
     if (create.uuid == UUIDHelpers::Nil || create.table != TABLE_WITH_UUID_NAME_PLACEHOLDER || !create.database.empty())
@@ -658,7 +659,7 @@ ASTPtr DatabaseReplicated::parseQueryFromMetadataInZooKeeper(const String & node
     return ast;
 }
 
-void DatabaseReplicated::drop(const Context & context_)
+void DatabaseReplicated::drop(ContextPtr context_)
 {
     auto current_zookeeper = getZooKeeper();
     Coordination::Requests ops;
@@ -691,22 +692,22 @@ void DatabaseReplicated::shutdown()
 }
 
 
-void DatabaseReplicated::dropTable(const Context & context, const String & table_name, bool no_delay)
+void DatabaseReplicated::dropTable(ContextPtr local_context, const String & table_name, bool no_delay)
 {
-    auto txn = context.getZooKeeperMetadataTransaction();
+    auto txn = local_context->getZooKeeperMetadataTransaction();
     assert(!ddl_worker->isCurrentlyActive() || txn || startsWith(table_name, ".inner_id."));
     if (txn && txn->isInitialQuery())
     {
         String metadata_zk_path = zookeeper_path + "/metadata/" + escapeForFileName(table_name);
         txn->addOp(zkutil::makeRemoveRequest(metadata_zk_path, -1));
     }
-    DatabaseAtomic::dropTable(context, table_name, no_delay);
+    DatabaseAtomic::dropTable(local_context, table_name, no_delay);
 }
 
-void DatabaseReplicated::renameTable(const Context & context, const String & table_name, IDatabase & to_database,
+void DatabaseReplicated::renameTable(ContextPtr local_context, const String & table_name, IDatabase & to_database,
                                      const String & to_table_name, bool exchange, bool dictionary)
 {
-    auto txn = context.getZooKeeperMetadataTransaction();
+    auto txn = local_context->getZooKeeperMetadataTransaction();
     assert(txn);
 
     if (txn->isInitialQuery())
@@ -715,9 +716,9 @@ void DatabaseReplicated::renameTable(const Context & context, const String & tab
             throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Moving tables between databases is not supported for Replicated engine");
         if (table_name == to_table_name)
             throw Exception(ErrorCodes::INCORRECT_QUERY, "Cannot rename table to itself");
-        if (!isTableExist(table_name, context))
+        if (!isTableExist(table_name, local_context))
             throw Exception(ErrorCodes::UNKNOWN_TABLE, "Table {} does not exist", table_name);
-        if (exchange && !to_database.isTableExist(to_table_name, context))
+        if (exchange && !to_database.isTableExist(to_table_name, local_context))
             throw Exception(ErrorCodes::UNKNOWN_TABLE, "Table {} does not exist", to_table_name);
 
         String statement = readMetadataFile(table_name);
@@ -733,14 +734,14 @@ void DatabaseReplicated::renameTable(const Context & context, const String & tab
         txn->addOp(zkutil::makeCreateRequest(metadata_zk_path_to, statement, zkutil::CreateMode::Persistent));
     }
 
-    DatabaseAtomic::renameTable(context, table_name, to_database, to_table_name, exchange, dictionary);
+    DatabaseAtomic::renameTable(local_context, table_name, to_database, to_table_name, exchange, dictionary);
 }
 
 void DatabaseReplicated::commitCreateTable(const ASTCreateQuery & query, const StoragePtr & table,
                        const String & table_metadata_tmp_path, const String & table_metadata_path,
-                       const Context & query_context)
+                       ContextPtr query_context)
 {
-    auto txn = query_context.getZooKeeperMetadataTransaction();
+    auto txn = query_context->getZooKeeperMetadataTransaction();
     assert(!ddl_worker->isCurrentlyActive() || txn);
     if (txn && txn->isInitialQuery())
     {
@@ -754,9 +755,9 @@ void DatabaseReplicated::commitCreateTable(const ASTCreateQuery & query, const S
 
 void DatabaseReplicated::commitAlterTable(const StorageID & table_id,
                                           const String & table_metadata_tmp_path, const String & table_metadata_path,
-                                          const String & statement, const Context & query_context)
+                                          const String & statement, ContextPtr query_context)
 {
-    auto txn = query_context.getZooKeeperMetadataTransaction();
+    auto txn = query_context->getZooKeeperMetadataTransaction();
     if (txn && txn->isInitialQuery())
     {
         String metadata_zk_path = zookeeper_path + "/metadata/" + escapeForFileName(table_id.table_name);
@@ -765,11 +766,11 @@ void DatabaseReplicated::commitAlterTable(const StorageID & table_id,
     DatabaseAtomic::commitAlterTable(table_id, table_metadata_tmp_path, table_metadata_path, statement, query_context);
 }
 
-void DatabaseReplicated::createDictionary(const Context & context,
+void DatabaseReplicated::createDictionary(ContextPtr local_context,
                                           const String & dictionary_name,
                                           const ASTPtr & query)
 {
-    auto txn = context.getZooKeeperMetadataTransaction();
+    auto txn = local_context->getZooKeeperMetadataTransaction();
     assert(!ddl_worker->isCurrentlyActive() || txn);
     if (txn && txn->isInitialQuery())
     {
@@ -777,24 +778,24 @@ void DatabaseReplicated::createDictionary(const Context & context,
         String statement = getObjectDefinitionFromCreateQuery(query->clone());
         txn->addOp(zkutil::makeCreateRequest(metadata_zk_path, statement, zkutil::CreateMode::Persistent));
     }
-    DatabaseAtomic::createDictionary(context, dictionary_name, query);
+    DatabaseAtomic::createDictionary(local_context, dictionary_name, query);
 }
 
-void DatabaseReplicated::removeDictionary(const Context & context, const String & dictionary_name)
+void DatabaseReplicated::removeDictionary(ContextPtr local_context, const String & dictionary_name)
 {
-    auto txn = context.getZooKeeperMetadataTransaction();
+    auto txn = local_context->getZooKeeperMetadataTransaction();
     assert(!ddl_worker->isCurrentlyActive() || txn);
     if (txn && txn->isInitialQuery())
     {
         String metadata_zk_path = zookeeper_path + "/metadata/" + escapeForFileName(dictionary_name);
         txn->addOp(zkutil::makeRemoveRequest(metadata_zk_path, -1));
     }
-    DatabaseAtomic::removeDictionary(context, dictionary_name);
+    DatabaseAtomic::removeDictionary(local_context, dictionary_name);
 }
 
-void DatabaseReplicated::detachTablePermanently(const Context & context, const String & table_name)
+void DatabaseReplicated::detachTablePermanently(ContextPtr local_context, const String & table_name)
 {
-    auto txn = context.getZooKeeperMetadataTransaction();
+    auto txn = local_context->getZooKeeperMetadataTransaction();
     assert(!ddl_worker->isCurrentlyActive() || txn);
     if (txn && txn->isInitialQuery())
     {
@@ -803,12 +804,12 @@ void DatabaseReplicated::detachTablePermanently(const Context & context, const S
         String metadata_zk_path = zookeeper_path + "/metadata/" + escapeForFileName(table_name);
         txn->addOp(zkutil::makeRemoveRequest(metadata_zk_path, -1));
     }
-    DatabaseAtomic::detachTablePermanently(context, table_name);
+    DatabaseAtomic::detachTablePermanently(local_context, table_name);
 }
 
-void DatabaseReplicated::removeDetachedPermanentlyFlag(const Context & context, const String & table_name, const String & table_metadata_path, bool attach) const
+void DatabaseReplicated::removeDetachedPermanentlyFlag(ContextPtr local_context, const String & table_name, const String & table_metadata_path, bool attach) const
 {
-    auto txn = context.getZooKeeperMetadataTransaction();
+    auto txn = local_context->getZooKeeperMetadataTransaction();
     assert(!ddl_worker->isCurrentlyActive() || txn);
     if (txn && txn->isInitialQuery() && attach)
     {
@@ -816,7 +817,7 @@ void DatabaseReplicated::removeDetachedPermanentlyFlag(const Context & context,
         String statement = readMetadataFile(table_name);
         txn->addOp(zkutil::makeCreateRequest(metadata_zk_path, statement, zkutil::CreateMode::Persistent));
     }
-    DatabaseAtomic::removeDetachedPermanentlyFlag(context, table_name, table_metadata_path, attach);
+    DatabaseAtomic::removeDetachedPermanentlyFlag(local_context, table_name, table_metadata_path, attach);
 }
 
 
diff --git a/src/Databases/DatabaseReplicated.h b/src/Databases/DatabaseReplicated.h
index 46bcdc71ef1..5220535f095 100644
--- a/src/Databases/DatabaseReplicated.h
+++ b/src/Databases/DatabaseReplicated.h
@@ -24,32 +24,32 @@ public:
     DatabaseReplicated(const String & name_, const String & metadata_path_, UUID uuid,
                        const String & zookeeper_path_, const String & shard_name_, const String & replica_name_,
                        DatabaseReplicatedSettings db_settings_,
-                       const Context & context);
+                       ContextPtr context);
 
     ~DatabaseReplicated() override;
 
     String getEngineName() const override { return "Replicated"; }
 
     /// If current query is initial, then the following methods add metadata updating ZooKeeper operations to current ZooKeeperMetadataTransaction.
-    void dropTable(const Context &, const String & table_name, bool no_delay) override;
-    void renameTable(const Context & context, const String & table_name, IDatabase & to_database,
+    void dropTable(ContextPtr, const String & table_name, bool no_delay) override;
+    void renameTable(ContextPtr context, const String & table_name, IDatabase & to_database,
                      const String & to_table_name, bool exchange, bool dictionary) override;
     void commitCreateTable(const ASTCreateQuery & query, const StoragePtr & table,
                            const String & table_metadata_tmp_path, const String & table_metadata_path,
-                           const Context & query_context) override;
+                           ContextPtr query_context) override;
     void commitAlterTable(const StorageID & table_id,
                           const String & table_metadata_tmp_path, const String & table_metadata_path,
-                          const String & statement, const Context & query_context) override;
-    void createDictionary(const Context & context,
+                          const String & statement, ContextPtr query_context) override;
+    void createDictionary(ContextPtr context,
                           const String & dictionary_name,
                           const ASTPtr & query) override;
-    void removeDictionary(const Context & context, const String & dictionary_name) override;
-    void detachTablePermanently(const Context & context, const String & table_name) override;
-    void removeDetachedPermanentlyFlag(const Context & context, const String & table_name, const String & table_metadata_path, bool attach) const override;
+    void removeDictionary(ContextPtr context, const String & dictionary_name) override;
+    void detachTablePermanently(ContextPtr context, const String & table_name) override;
+    void removeDetachedPermanentlyFlag(ContextPtr context, const String & table_name, const String & table_metadata_path, bool attach) const override;
 
     /// Try to execute DLL query on current host as initial query. If query is succeed,
     /// then it will be executed on all replicas.
-    BlockIO tryEnqueueReplicatedDDL(const ASTPtr & query, const Context & query_context);
+    BlockIO tryEnqueueReplicatedDDL(const ASTPtr & query, ContextPtr query_context);
 
     void stopReplication();
 
@@ -59,9 +59,9 @@ public:
     /// Returns cluster consisting of database replicas
     ClusterPtr getCluster() const;
 
-    void drop(const Context & /*context*/) override;
+    void drop(ContextPtr /*context*/) override;
 
-    void loadStoredObjects(Context & context, bool has_force_restore_data_flag, bool force_attach) override;
+    void loadStoredObjects(ContextPtr context, bool has_force_restore_data_flag, bool force_attach) override;
     void shutdown() override;
 
     friend struct DatabaseReplicatedTask;
@@ -71,7 +71,7 @@ private:
     bool createDatabaseNodesInZooKeeper(const ZooKeeperPtr & current_zookeeper);
     void createReplicaNodesInZooKeeper(const ZooKeeperPtr & current_zookeeper);
 
-    void checkQueryValid(const ASTPtr & query, const Context & query_context) const;
+    void checkQueryValid(const ASTPtr & query, ContextPtr query_context) const;
 
     void recoverLostReplica(const ZooKeeperPtr & current_zookeeper, UInt32 our_log_ptr, UInt32 max_log_ptr);
     std::map<String, String> tryGetConsistentMetadataSnapshot(const ZooKeeperPtr & zookeeper, UInt32 & max_log_ptr);
diff --git a/src/Databases/DatabaseReplicatedWorker.cpp b/src/Databases/DatabaseReplicatedWorker.cpp
index 63f4d89b216..9ae4d026bf0 100644
--- a/src/Databases/DatabaseReplicatedWorker.cpp
+++ b/src/Databases/DatabaseReplicatedWorker.cpp
@@ -13,7 +13,7 @@ namespace ErrorCodes
     extern const int UNFINISHED;
 }
 
-DatabaseReplicatedDDLWorker::DatabaseReplicatedDDLWorker(DatabaseReplicated * db, const Context & context_)
+DatabaseReplicatedDDLWorker::DatabaseReplicatedDDLWorker(DatabaseReplicated * db, ContextPtr context_)
     : DDLWorker(/* pool_size */ 1, db->zookeeper_path + "/log", context_, nullptr, {}, fmt::format("DDLWorker({})", db->getDatabaseName()))
     , database(db)
 {
@@ -91,7 +91,7 @@ String DatabaseReplicatedDDLWorker::enqueueQuery(DDLLogEntry & entry)
     return node_path;
 }
 
-String DatabaseReplicatedDDLWorker::tryEnqueueAndExecuteEntry(DDLLogEntry & entry, const Context & query_context)
+String DatabaseReplicatedDDLWorker::tryEnqueueAndExecuteEntry(DDLLogEntry & entry, ContextPtr query_context)
 {
     /// NOTE Possibly it would be better to execute initial query on the most up-to-date node,
     /// but it requires more complex logic around /try node.
@@ -115,7 +115,7 @@ String DatabaseReplicatedDDLWorker::tryEnqueueAndExecuteEntry(DDLLogEntry & entr
     task->is_initial_query = true;
 
     LOG_DEBUG(log, "Waiting for worker thread to process all entries before {}", entry_name);
-    UInt64 timeout = query_context.getSettingsRef().database_replicated_initial_query_timeout_sec;
+    UInt64 timeout = query_context->getSettingsRef().database_replicated_initial_query_timeout_sec;
     {
         std::unique_lock lock{mutex};
         bool processed = wait_current_task_change.wait_for(lock, std::chrono::seconds(timeout), [&]()
diff --git a/src/Databases/DatabaseReplicatedWorker.h b/src/Databases/DatabaseReplicatedWorker.h
index 3a45817c755..16ad100b81a 100644
--- a/src/Databases/DatabaseReplicatedWorker.h
+++ b/src/Databases/DatabaseReplicatedWorker.h
@@ -21,11 +21,11 @@ class DatabaseReplicated;
 class DatabaseReplicatedDDLWorker : public DDLWorker
 {
 public:
-    DatabaseReplicatedDDLWorker(DatabaseReplicated * db, const Context & context_);
+    DatabaseReplicatedDDLWorker(DatabaseReplicated * db, ContextPtr context_);
 
     String enqueueQuery(DDLLogEntry & entry) override;
 
-    String tryEnqueueAndExecuteEntry(DDLLogEntry & entry, const Context & query_context);
+    String tryEnqueueAndExecuteEntry(DDLLogEntry & entry, ContextPtr query_context);
 
     void shutdown() override;
 
diff --git a/src/Databases/DatabaseWithDictionaries.cpp b/src/Databases/DatabaseWithDictionaries.cpp
index 55b04f27c58..5180b251a5f 100644
--- a/src/Databases/DatabaseWithDictionaries.cpp
+++ b/src/Databases/DatabaseWithDictionaries.cpp
@@ -125,9 +125,9 @@ void DatabaseWithDictionaries::detachDictionaryImpl(const String & dictionary_na
         detachTable(dictionary_name);
 }
 
-void DatabaseWithDictionaries::createDictionary(const Context & context, const String & dictionary_name, const ASTPtr & query)
+void DatabaseWithDictionaries::createDictionary(ContextPtr local_context, const String & dictionary_name, const ASTPtr & query)
 {
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = local_context->getSettingsRef();
 
     /** The code is based on the assumption that all threads share the same order of operations:
       * - create the .sql.tmp file;
@@ -151,7 +151,7 @@ void DatabaseWithDictionaries::createDictionary(const Context & context, const S
         throw Exception(ErrorCodes::DICTIONARY_ALREADY_EXISTS,
                         "Dictionary {} already exists.", dict_id.getFullNameNotQuoted());
 
-    if (isTableExist(dictionary_name, global_context))
+    if (isTableExist(dictionary_name, getContext()))
         throw Exception(ErrorCodes::TABLE_ALREADY_EXISTS, "Table {} already exists.", dict_id.getFullTableName());
 
     String dictionary_metadata_path = getObjectMetadataPath(dictionary_name);
@@ -177,9 +177,9 @@ void DatabaseWithDictionaries::createDictionary(const Context & context, const S
     /// Add a temporary repository containing the dictionary.
     /// We need this temp repository to try loading the dictionary before actually attaching it to the database.
     auto temp_repository = external_loader.addConfigRepository(std::make_unique<ExternalLoaderTempConfigRepository>(
-        getDatabaseName(), dictionary_metadata_tmp_path, getDictionaryConfigurationFromAST(query->as<const ASTCreateQuery &>(), context)));
+        getDatabaseName(), dictionary_metadata_tmp_path, getDictionaryConfigurationFromAST(query->as<const ASTCreateQuery &>(), local_context)));
 
-    bool lazy_load = context.getConfigRef().getBool("dictionaries_lazy_load", true);
+    bool lazy_load = local_context->getConfigRef().getBool("dictionaries_lazy_load", true);
     if (!lazy_load)
     {
         /// load() is called here to force loading the dictionary, wait until the loading is finished,
@@ -187,15 +187,15 @@ void DatabaseWithDictionaries::createDictionary(const Context & context, const S
         external_loader.load(dict_id.getInternalDictionaryName());
     }
 
-    auto config = getDictionaryConfigurationFromAST(query->as<const ASTCreateQuery &>(), context);
+    auto config = getDictionaryConfigurationFromAST(query->as<const ASTCreateQuery &>(), local_context);
     attachDictionary(dictionary_name, DictionaryAttachInfo{query, config, time(nullptr)});
     SCOPE_EXIT({
         if (!succeeded)
             detachDictionary(dictionary_name);
     });
 
-    auto txn = context.getZooKeeperMetadataTransaction();
-    if (txn && !context.isInternalSubquery())
+    auto txn = local_context->getZooKeeperMetadataTransaction();
+    if (txn && !local_context->isInternalSubquery())
         txn->commit();      /// Commit point (a sort of) for Replicated database
 
     /// If it was ATTACH query and file with dictionary metadata already exist
@@ -210,7 +210,7 @@ void DatabaseWithDictionaries::createDictionary(const Context & context, const S
     succeeded = true;
 }
 
-void DatabaseWithDictionaries::removeDictionary(const Context & context, const String & dictionary_name)
+void DatabaseWithDictionaries::removeDictionary(ContextPtr local_context, const String & dictionary_name)
 {
     DictionaryAttachInfo attach_info;
     detachDictionaryImpl(dictionary_name, attach_info);
@@ -219,8 +219,8 @@ void DatabaseWithDictionaries::removeDictionary(const Context & context, const S
     {
         String dictionary_metadata_path = getObjectMetadataPath(dictionary_name);
 
-        auto txn = context.getZooKeeperMetadataTransaction();
-        if (txn && !context.isInternalSubquery())
+        auto txn = local_context->getZooKeeperMetadataTransaction();
+        if (txn && !local_context->isInternalSubquery())
             txn->commit();      /// Commit point (a sort of) for Replicated database
 
         Poco::File(dictionary_metadata_path).remove();
@@ -335,7 +335,7 @@ void DatabaseWithDictionaries::reloadDictionaryConfig(const String & full_name)
     /// Ensure that this database is attached to ExternalLoader as a config repository.
     if (!database_as_config_repo_for_external_loader.load())
     {
-        auto repository = std::make_unique<ExternalLoaderDatabaseConfigRepository>(*this, global_context);
+        auto repository = std::make_unique<ExternalLoaderDatabaseConfigRepository>(*this, getContext());
         auto remove_repository_callback = external_loader.addConfigRepository(std::move(repository));
         database_as_config_repo_for_external_loader = boost::make_shared<ext::scope_guard>(std::move(remove_repository_callback));
     }
@@ -359,9 +359,9 @@ void DatabaseWithDictionaries::shutdown()
 
 
 DatabaseWithDictionaries::DatabaseWithDictionaries(
-    const String & name, const String & metadata_path_, const String & data_path_, const String & logger, const Context & context)
-    : DatabaseOnDisk(name, metadata_path_, data_path_, logger, context)
-    , external_loader(context.getExternalDictionariesLoader())
+    const String & name, const String & metadata_path_, const String & data_path_, const String & logger, ContextPtr context_)
+    : DatabaseOnDisk(name, metadata_path_, data_path_, logger, context_)
+    , external_loader(context_->getExternalDictionariesLoader())
 {
 }
 
diff --git a/src/Databases/DatabaseWithDictionaries.h b/src/Databases/DatabaseWithDictionaries.h
index d69289d7456..d10908c7c06 100644
--- a/src/Databases/DatabaseWithDictionaries.h
+++ b/src/Databases/DatabaseWithDictionaries.h
@@ -17,11 +17,11 @@ public:
 
     void detachDictionary(const String & dictionary_name) override;
 
-    void createDictionary(const Context & context,
+    void createDictionary(ContextPtr context,
                           const String & dictionary_name,
                           const ASTPtr & query) override;
 
-    void removeDictionary(const Context & context, const String & dictionary_name) override;
+    void removeDictionary(ContextPtr context, const String & dictionary_name) override;
 
     bool isDictionaryExist(const String & dictionary_name) const override;
 
@@ -38,7 +38,7 @@ public:
     ~DatabaseWithDictionaries() override;
 
 protected:
-    DatabaseWithDictionaries(const String & name, const String & metadata_path_, const String & data_path_, const String & logger, const Context & context);
+    DatabaseWithDictionaries(const String & name, const String & metadata_path_, const String & data_path_, const String & logger, ContextPtr context);
 
     ASTPtr getCreateDictionaryQueryImpl(const String & dictionary_name, bool throw_on_error) const override;
 
diff --git a/src/Databases/DatabasesCommon.cpp b/src/Databases/DatabasesCommon.cpp
index 2d3d206162b..9329b0a4210 100644
--- a/src/Databases/DatabasesCommon.cpp
+++ b/src/Databases/DatabasesCommon.cpp
@@ -20,18 +20,18 @@ namespace ErrorCodes
     extern const int UNKNOWN_DATABASE;
 }
 
-DatabaseWithOwnTablesBase::DatabaseWithOwnTablesBase(const String & name_, const String & logger, const Context & context)
-        : IDatabase(name_), log(&Poco::Logger::get(logger)), global_context(context.getGlobalContext())
+DatabaseWithOwnTablesBase::DatabaseWithOwnTablesBase(const String & name_, const String & logger, ContextPtr context_)
+        : IDatabase(name_), WithContext(context_->getGlobalContext()), log(&Poco::Logger::get(logger))
 {
 }
 
-bool DatabaseWithOwnTablesBase::isTableExist(const String & table_name, const Context &) const
+bool DatabaseWithOwnTablesBase::isTableExist(const String & table_name, ContextPtr) const
 {
     std::lock_guard lock(mutex);
     return tables.find(table_name) != tables.end();
 }
 
-StoragePtr DatabaseWithOwnTablesBase::tryGetTable(const String & table_name, const Context &) const
+StoragePtr DatabaseWithOwnTablesBase::tryGetTable(const String & table_name, ContextPtr) const
 {
     std::lock_guard lock(mutex);
     auto it = tables.find(table_name);
@@ -40,7 +40,7 @@ StoragePtr DatabaseWithOwnTablesBase::tryGetTable(const String & table_name, con
     return {};
 }
 
-DatabaseTablesIteratorPtr DatabaseWithOwnTablesBase::getTablesIterator(const Context &, const FilterByNameFunction & filter_by_table_name)
+DatabaseTablesIteratorPtr DatabaseWithOwnTablesBase::getTablesIterator(ContextPtr, const FilterByNameFunction & filter_by_table_name)
 {
     std::lock_guard lock(mutex);
     if (!filter_by_table_name)
diff --git a/src/Databases/DatabasesCommon.h b/src/Databases/DatabasesCommon.h
index 5e1e555a524..da1bd6c1852 100644
--- a/src/Databases/DatabasesCommon.h
+++ b/src/Databases/DatabasesCommon.h
@@ -16,12 +16,12 @@ namespace DB
 class Context;
 
 /// A base class for databases that manage their own list of tables.
-class DatabaseWithOwnTablesBase : public IDatabase
+class DatabaseWithOwnTablesBase : public IDatabase, protected WithContext
 {
 public:
-    bool isTableExist(const String & table_name, const Context & context) const override;
+    bool isTableExist(const String & table_name, ContextPtr context) const override;
 
-    StoragePtr tryGetTable(const String & table_name, const Context & context) const override;
+    StoragePtr tryGetTable(const String & table_name, ContextPtr context) const override;
 
     bool empty() const override;
 
@@ -29,7 +29,7 @@ public:
 
     StoragePtr detachTable(const String & table_name) override;
 
-    DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) override;
+    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name) override;
 
     void shutdown() override;
 
@@ -38,9 +38,8 @@ public:
 protected:
     Tables tables;
     Poco::Logger * log;
-    const Context & global_context;
 
-    DatabaseWithOwnTablesBase(const String & name_, const String & logger, const Context & context);
+    DatabaseWithOwnTablesBase(const String & name_, const String & logger, ContextPtr context);
 
     void attachTableUnlocked(const String & table_name, const StoragePtr & table, std::unique_lock<std::mutex> & lock);
     StoragePtr detachTableUnlocked(const String & table_name, std::unique_lock<std::mutex> & lock);
diff --git a/src/Databases/IDatabase.h b/src/Databases/IDatabase.h
index 3a196f827b7..6cd0e468709 100644
--- a/src/Databases/IDatabase.h
+++ b/src/Databases/IDatabase.h
@@ -10,6 +10,7 @@
 
 #include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/copy.hpp>
+
 #include <ctime>
 #include <functional>
 #include <memory>
@@ -18,7 +19,6 @@
 namespace DB
 {
 
-class Context;
 struct Settings;
 struct ConstraintsDescription;
 struct IndicesDescription;
@@ -153,10 +153,10 @@ public:
 
     /// Load a set of existing tables.
     /// You can call only once, right after the object is created.
-    virtual void loadStoredObjects(Context & /*context*/, bool /*has_force_restore_data_flag*/, bool /*force_attach*/ = false) {}
+    virtual void loadStoredObjects(ContextPtr /*context*/, bool /*has_force_restore_data_flag*/, bool /*force_attach*/ = false) {}
 
     /// Check the existence of the table.
-    virtual bool isTableExist(const String & name, const Context & context) const = 0;
+    virtual bool isTableExist(const String & name, ContextPtr context) const = 0;
 
     /// Check the existence of the dictionary
     virtual bool isDictionaryExist(const String & /*name*/) const
@@ -165,7 +165,7 @@ public:
     }
 
     /// Get the table for work. Return nullptr if there is no table.
-    virtual StoragePtr tryGetTable(const String & name, const Context & context) const = 0;
+    virtual StoragePtr tryGetTable(const String & name, ContextPtr context) const = 0;
 
     virtual UUID tryGetTableUUID(const String & /*table_name*/) const { return UUIDHelpers::Nil; }
 
@@ -173,7 +173,7 @@ public:
 
     /// Get an iterator that allows you to pass through all the tables.
     /// It is possible to have "hidden" tables that are not visible when passing through, but are visible if you get them by name using the functions above.
-    virtual DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name = {}) = 0;
+    virtual DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name = {}) = 0;
 
     /// Get an iterator to pass through all the dictionaries.
     virtual DatabaseDictionariesIteratorPtr getDictionariesIterator([[maybe_unused]] const FilterByNameFunction & filter_by_dictionary_name = {})
@@ -186,7 +186,7 @@ public:
 
     /// Add the table to the database. Record its presence in the metadata.
     virtual void createTable(
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         const String & /*name*/,
         const StoragePtr & /*table*/,
         const ASTPtr & /*query*/)
@@ -196,7 +196,7 @@ public:
 
     /// Add the dictionary to the database. Record its presence in the metadata.
     virtual void createDictionary(
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         const String & /*dictionary_name*/,
         const ASTPtr & /*query*/)
     {
@@ -205,7 +205,7 @@ public:
 
     /// Delete the table from the database, drop table and delete the metadata.
     virtual void dropTable(
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         const String & /*name*/,
         [[maybe_unused]] bool no_delay = false)
     {
@@ -214,7 +214,7 @@ public:
 
     /// Delete the dictionary from the database. Delete the metadata.
     virtual void removeDictionary(
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         const String & /*dictionary_name*/)
     {
         throw Exception("There is no DROP DICTIONARY query for Database" + getEngineName(), ErrorCodes::NOT_IMPLEMENTED);
@@ -249,14 +249,14 @@ public:
 
     /// Forget about the table without deleting it's data, but rename metadata file to prevent reloading it
     /// with next restart. The database may not support this method.
-    virtual void detachTablePermanently(const Context & /*context*/, const String & /*name*/)
+    virtual void detachTablePermanently(ContextPtr /*context*/, const String & /*name*/)
     {
         throw Exception("There is no DETACH TABLE PERMANENTLY query for Database" + getEngineName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
     /// Rename the table and possibly move the table to another database.
     virtual void renameTable(
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         const String & /*name*/,
         IDatabase & /*to_database*/,
         const String & /*to_name*/,
@@ -271,7 +271,7 @@ public:
     /// Change the table structure in metadata.
     /// You must call under the alter_lock of the corresponding table . If engine_modifier is empty, then engine does not change.
     virtual void alterTable(
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         const StorageID & /*table_id*/,
         const StorageInMemoryMetadata & /*metadata*/)
     {
@@ -285,12 +285,12 @@ public:
     }
 
     /// Get the CREATE TABLE query for the table. It can also provide information for detached tables for which there is metadata.
-    ASTPtr tryGetCreateTableQuery(const String & name, const Context & context) const noexcept
+    ASTPtr tryGetCreateTableQuery(const String & name, ContextPtr context) const noexcept
     {
         return getCreateTableQueryImpl(name, context, false);
     }
 
-    ASTPtr getCreateTableQuery(const String & name, const Context & context) const
+    ASTPtr getCreateTableQuery(const String & name, ContextPtr context) const
     {
         return getCreateTableQueryImpl(name, context, true);
     }
@@ -351,12 +351,12 @@ public:
     virtual void shutdown() = 0;
 
     /// Delete data and metadata stored inside the database, if exists.
-    virtual void drop(const Context & /*context*/) {}
+    virtual void drop(ContextPtr /*context*/) {}
 
-    virtual ~IDatabase() {}
+    virtual ~IDatabase() = default;
 
 protected:
-    virtual ASTPtr getCreateTableQueryImpl(const String & /*name*/, const Context & /*context*/, bool throw_on_error) const
+    virtual ASTPtr getCreateTableQueryImpl(const String & /*name*/, ContextPtr /*context*/, bool throw_on_error) const
     {
         if (throw_on_error)
             throw Exception("There is no SHOW CREATE TABLE query for Database" + getEngineName(), ErrorCodes::CANNOT_GET_CREATE_TABLE_QUERY);
diff --git a/src/Databases/MySQL/ConnectionMySQLSettings.cpp b/src/Databases/MySQL/ConnectionMySQLSettings.cpp
index fa92e793225..1026d14018b 100644
--- a/src/Databases/MySQL/ConnectionMySQLSettings.cpp
+++ b/src/Databases/MySQL/ConnectionMySQLSettings.cpp
@@ -50,12 +50,12 @@ void ConnectionMySQLSettings::loadFromQuery(ASTStorage & storage_def)
 #undef ADD_IF_ABSENT
 }
 
-void ConnectionMySQLSettings::loadFromQueryContext(const Context & context)
+void ConnectionMySQLSettings::loadFromQueryContext(ContextPtr context)
 {
-    if (!context.hasQueryContext())
+    if (!context->hasQueryContext())
         return;
 
-    const Settings & settings = context.getQueryContext().getSettingsRef();
+    const Settings & settings = context->getQueryContext()->getSettingsRef();
 
     if (settings.mysql_datatypes_support_level.value != mysql_datatypes_support_level.value)
         set("mysql_datatypes_support_level", settings.mysql_datatypes_support_level.toString());
diff --git a/src/Databases/MySQL/ConnectionMySQLSettings.h b/src/Databases/MySQL/ConnectionMySQLSettings.h
index ce2773307c5..f05985a0cda 100644
--- a/src/Databases/MySQL/ConnectionMySQLSettings.h
+++ b/src/Databases/MySQL/ConnectionMySQLSettings.h
@@ -1,13 +1,13 @@
 #pragma once
 
-#include <Core/Defines.h>
 #include <Core/BaseSettings.h>
+#include <Core/Defines.h>
 #include <Core/SettingsEnums.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
 
-class Context;
 class ASTStorage;
 
 #define LIST_OF_CONNECTION_MYSQL_SETTINGS(M) \
@@ -27,7 +27,7 @@ struct ConnectionMySQLSettings : public BaseSettings<ConnectionMySQLSettingsTrai
 {
     void loadFromQuery(ASTStorage & storage_def);
 
-    void loadFromQueryContext(const Context & context);
+    void loadFromQueryContext(ContextPtr context);
 };
 
 }
diff --git a/src/Databases/MySQL/DatabaseConnectionMySQL.cpp b/src/Databases/MySQL/DatabaseConnectionMySQL.cpp
index eeea12ae8f3..9615aa85e05 100644
--- a/src/Databases/MySQL/DatabaseConnectionMySQL.cpp
+++ b/src/Databases/MySQL/DatabaseConnectionMySQL.cpp
@@ -45,10 +45,16 @@ constexpr static const auto suffix = ".remove_flag";
 static constexpr const std::chrono::seconds cleaner_sleep_time{30};
 static const std::chrono::seconds lock_acquire_timeout{10};
 
-DatabaseConnectionMySQL::DatabaseConnectionMySQL(const Context & context, const String & database_name_, const String & metadata_path_,
-    const ASTStorage * database_engine_define_, const String & database_name_in_mysql_, std::unique_ptr<ConnectionMySQLSettings> settings_, mysqlxx::Pool && pool)
+DatabaseConnectionMySQL::DatabaseConnectionMySQL(
+    ContextPtr context_,
+    const String & database_name_,
+    const String & metadata_path_,
+    const ASTStorage * database_engine_define_,
+    const String & database_name_in_mysql_,
+    std::unique_ptr<ConnectionMySQLSettings> settings_,
+    mysqlxx::PoolWithFailover && pool)
     : IDatabase(database_name_)
-    , global_context(context.getGlobalContext())
+    , WithContext(context_->getGlobalContext())
     , metadata_path(metadata_path_)
     , database_engine_define(database_engine_define_->clone())
     , database_name_in_mysql(database_name_in_mysql_)
@@ -63,7 +69,7 @@ bool DatabaseConnectionMySQL::empty() const
 {
     std::lock_guard<std::mutex> lock(mutex);
 
-    fetchTablesIntoLocalCache(global_context);
+    fetchTablesIntoLocalCache(getContext());
 
     if (local_tables_cache.empty())
         return true;
@@ -75,12 +81,12 @@ bool DatabaseConnectionMySQL::empty() const
     return true;
 }
 
-DatabaseTablesIteratorPtr DatabaseConnectionMySQL::getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name)
+DatabaseTablesIteratorPtr DatabaseConnectionMySQL::getTablesIterator(ContextPtr local_context, const FilterByNameFunction & filter_by_table_name)
 {
     Tables tables;
     std::lock_guard<std::mutex> lock(mutex);
 
-    fetchTablesIntoLocalCache(context);
+    fetchTablesIntoLocalCache(local_context);
 
     for (const auto & [table_name, modify_time_and_storage] : local_tables_cache)
         if (!remove_or_detach_tables.count(table_name) && (!filter_by_table_name || filter_by_table_name(table_name)))
@@ -89,16 +95,16 @@ DatabaseTablesIteratorPtr DatabaseConnectionMySQL::getTablesIterator(const Conte
     return std::make_unique<DatabaseTablesSnapshotIterator>(tables, database_name);
 }
 
-bool DatabaseConnectionMySQL::isTableExist(const String & name, const Context & context) const
+bool DatabaseConnectionMySQL::isTableExist(const String & name, ContextPtr local_context) const
 {
-    return bool(tryGetTable(name, context));
+    return bool(tryGetTable(name, local_context));
 }
 
-StoragePtr DatabaseConnectionMySQL::tryGetTable(const String & mysql_table_name, const Context & context) const
+StoragePtr DatabaseConnectionMySQL::tryGetTable(const String & mysql_table_name, ContextPtr local_context) const
 {
     std::lock_guard<std::mutex> lock(mutex);
 
-    fetchTablesIntoLocalCache(context);
+    fetchTablesIntoLocalCache(local_context);
 
     if (!remove_or_detach_tables.count(mysql_table_name) && local_tables_cache.find(mysql_table_name) != local_tables_cache.end())
         return local_tables_cache[mysql_table_name].second;
@@ -153,11 +159,11 @@ static ASTPtr getCreateQueryFromStorage(const StoragePtr & storage, const ASTPtr
     return create_table_query;
 }
 
-ASTPtr DatabaseConnectionMySQL::getCreateTableQueryImpl(const String & table_name, const Context & context, bool throw_on_error) const
+ASTPtr DatabaseConnectionMySQL::getCreateTableQueryImpl(const String & table_name, ContextPtr local_context, bool throw_on_error) const
 {
     std::lock_guard<std::mutex> lock(mutex);
 
-    fetchTablesIntoLocalCache(context);
+    fetchTablesIntoLocalCache(local_context);
 
     if (local_tables_cache.find(table_name) == local_tables_cache.end())
     {
@@ -174,7 +180,7 @@ time_t DatabaseConnectionMySQL::getObjectMetadataModificationTime(const String &
 {
     std::lock_guard<std::mutex> lock(mutex);
 
-    fetchTablesIntoLocalCache(global_context);
+    fetchTablesIntoLocalCache(getContext());
 
     if (local_tables_cache.find(table_name) == local_tables_cache.end())
         throw Exception("MySQL table " + database_name_in_mysql + "." + table_name + " doesn't exist.", ErrorCodes::UNKNOWN_TABLE);
@@ -190,12 +196,12 @@ ASTPtr DatabaseConnectionMySQL::getCreateDatabaseQuery() const
     return create_query;
 }
 
-void DatabaseConnectionMySQL::fetchTablesIntoLocalCache(const Context & context) const
+void DatabaseConnectionMySQL::fetchTablesIntoLocalCache(ContextPtr local_context) const
 {
     const auto & tables_with_modification_time = fetchTablesWithModificationTime();
 
     destroyLocalCacheExtraTables(tables_with_modification_time);
-    fetchLatestTablesStructureIntoCache(tables_with_modification_time, context);
+    fetchLatestTablesStructureIntoCache(tables_with_modification_time, local_context);
 }
 
 void DatabaseConnectionMySQL::destroyLocalCacheExtraTables(const std::map<String, UInt64> & tables_with_modification_time) const
@@ -212,7 +218,8 @@ void DatabaseConnectionMySQL::destroyLocalCacheExtraTables(const std::map<String
     }
 }
 
-void DatabaseConnectionMySQL::fetchLatestTablesStructureIntoCache(const std::map<String, UInt64> &tables_modification_time, const Context & context) const
+void DatabaseConnectionMySQL::fetchLatestTablesStructureIntoCache(
+    const std::map<String, UInt64> & tables_modification_time, ContextPtr local_context) const
 {
     std::vector<String> wait_update_tables_name;
     for (const auto & table_modification_time : tables_modification_time)
@@ -224,7 +231,7 @@ void DatabaseConnectionMySQL::fetchLatestTablesStructureIntoCache(const std::map
             wait_update_tables_name.emplace_back(table_modification_time.first);
     }
 
-    std::map<String, NamesAndTypesList> tables_and_columns = fetchTablesColumnsList(wait_update_tables_name, context);
+    std::map<String, NamesAndTypesList> tables_and_columns = fetchTablesColumnsList(wait_update_tables_name, local_context);
 
     for (const auto & table_and_columns : tables_and_columns)
     {
@@ -241,7 +248,7 @@ void DatabaseConnectionMySQL::fetchLatestTablesStructureIntoCache(const std::map
 
         local_tables_cache[table_name] = std::make_pair(table_modification_time, StorageMySQL::create(
             StorageID(database_name, table_name), std::move(mysql_pool), database_name_in_mysql, table_name,
-            false, "", ColumnsDescription{columns_name_and_type}, ConstraintsDescription{}, global_context));
+            false, "", ColumnsDescription{columns_name_and_type}, ConstraintsDescription{}, getContext()));
     }
 }
 
@@ -276,9 +283,10 @@ std::map<String, UInt64> DatabaseConnectionMySQL::fetchTablesWithModificationTim
     return tables_with_modification_time;
 }
 
-std::map<String, NamesAndTypesList> DatabaseConnectionMySQL::fetchTablesColumnsList(const std::vector<String> & tables_name, const Context & context) const
+std::map<String, NamesAndTypesList>
+DatabaseConnectionMySQL::fetchTablesColumnsList(const std::vector<String> & tables_name, ContextPtr local_context) const
 {
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = local_context->getSettingsRef();
 
     return DB::fetchTablesColumnsList(
             mysql_pool,
@@ -303,7 +311,7 @@ void DatabaseConnectionMySQL::shutdown()
     local_tables_cache.clear();
 }
 
-void DatabaseConnectionMySQL::drop(const Context & /*context*/)
+void DatabaseConnectionMySQL::drop(ContextPtr /*context*/)
 {
     Poco::File(getMetadataPath()).remove(true);
 }
@@ -378,7 +386,7 @@ String DatabaseConnectionMySQL::getMetadataPath() const
     return metadata_path;
 }
 
-void DatabaseConnectionMySQL::loadStoredObjects(Context &, bool, bool /*force_attach*/)
+void DatabaseConnectionMySQL::loadStoredObjects(ContextPtr, bool, bool /*force_attach*/)
 {
 
     std::lock_guard<std::mutex> lock{mutex};
@@ -395,7 +403,7 @@ void DatabaseConnectionMySQL::loadStoredObjects(Context &, bool, bool /*force_at
     }
 }
 
-void DatabaseConnectionMySQL::detachTablePermanently(const Context &, const String & table_name)
+void DatabaseConnectionMySQL::detachTablePermanently(ContextPtr, const String & table_name)
 {
     std::lock_guard<std::mutex> lock{mutex};
 
@@ -429,9 +437,9 @@ void DatabaseConnectionMySQL::detachTablePermanently(const Context &, const Stri
     table_iter->second.second->is_dropped = true;
 }
 
-void DatabaseConnectionMySQL::dropTable(const Context & context, const String & table_name, bool /*no_delay*/)
+void DatabaseConnectionMySQL::dropTable(ContextPtr local_context, const String & table_name, bool /*no_delay*/)
 {
-    detachTablePermanently(context, table_name);
+    detachTablePermanently(local_context, table_name);
 }
 
 DatabaseConnectionMySQL::~DatabaseConnectionMySQL()
@@ -456,7 +464,7 @@ DatabaseConnectionMySQL::~DatabaseConnectionMySQL()
     }
 }
 
-void DatabaseConnectionMySQL::createTable(const Context &, const String & table_name, const StoragePtr & storage, const ASTPtr & create_query)
+void DatabaseConnectionMySQL::createTable(ContextPtr, const String & table_name, const StoragePtr & storage, const ASTPtr & create_query)
 {
     const auto & create = create_query->as<ASTCreateQuery>();
 
@@ -467,7 +475,7 @@ void DatabaseConnectionMySQL::createTable(const Context &, const String & table_
     /// XXX: hack
     /// In order to prevent users from broken the table structure by executing attach table database_name.table_name (...)
     /// we should compare the old and new create_query to make them completely consistent
-    const auto & origin_create_query = getCreateTableQuery(table_name, global_context);
+    const auto & origin_create_query = getCreateTableQuery(table_name, getContext());
     origin_create_query->as<ASTCreateQuery>()->attach = true;
 
     if (queryToString(origin_create_query) != queryToString(create_query))
diff --git a/src/Databases/MySQL/DatabaseConnectionMySQL.h b/src/Databases/MySQL/DatabaseConnectionMySQL.h
index d0a5c041d7b..a626924d6dd 100644
--- a/src/Databases/MySQL/DatabaseConnectionMySQL.h
+++ b/src/Databases/MySQL/DatabaseConnectionMySQL.h
@@ -10,6 +10,7 @@
 #include <Databases/DatabasesCommon.h>
 #include <Databases/MySQL/ConnectionMySQLSettings.h>
 #include <Parsers/ASTCreateQuery.h>
+#include <mysqlxx/PoolWithFailover.h>
 
 #include <atomic>
 #include <condition_variable>
@@ -30,15 +31,19 @@ enum class MySQLDataTypesSupport;
  *  It doesn't make any manipulations with filesystem.
  *  All tables are created by calling code after real-time pull-out structure from remote MySQL
  */
-class DatabaseConnectionMySQL final : public IDatabase
+class DatabaseConnectionMySQL final : public IDatabase, WithContext
 {
 public:
     ~DatabaseConnectionMySQL() override;
 
     DatabaseConnectionMySQL(
-        const Context & context, const String & database_name, const String & metadata_path,
-        const ASTStorage * database_engine_define, const String & database_name_in_mysql, std::unique_ptr<ConnectionMySQLSettings> settings_,
-        mysqlxx::Pool && pool);
+        ContextPtr context,
+        const String & database_name,
+        const String & metadata_path,
+        const ASTStorage * database_engine_define,
+        const String & database_name_in_mysql,
+        std::unique_ptr<ConnectionMySQLSettings> settings_,
+        mysqlxx::PoolWithFailover && pool);
 
     String getEngineName() const override { return "MySQL"; }
 
@@ -50,39 +55,38 @@ public:
 
     bool empty() const override;
 
-    DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) override;
+    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name) override;
 
     ASTPtr getCreateDatabaseQuery() const override;
 
-    bool isTableExist(const String & name, const Context & context) const override;
+    bool isTableExist(const String & name, ContextPtr context) const override;
 
-    StoragePtr tryGetTable(const String & name, const Context & context) const override;
+    StoragePtr tryGetTable(const String & name, ContextPtr context) const override;
 
     time_t getObjectMetadataModificationTime(const String & name) const override;
 
     void shutdown() override;
 
-    void drop(const Context & /*context*/) override;
+    void drop(ContextPtr /*context*/) override;
 
     String getMetadataPath() const override;
 
-    void createTable(const Context &, const String & table_name, const StoragePtr & storage, const ASTPtr & create_query) override;
+    void createTable(ContextPtr, const String & table_name, const StoragePtr & storage, const ASTPtr & create_query) override;
 
-    void loadStoredObjects(Context &, bool, bool force_attach) override;
+    void loadStoredObjects(ContextPtr, bool, bool force_attach) override;
 
     StoragePtr detachTable(const String & table_name) override;
 
-    void detachTablePermanently(const Context & context, const String & table_name) override;
+    void detachTablePermanently(ContextPtr context, const String & table_name) override;
 
-    void dropTable(const Context & context, const String & table_name, bool no_delay) override;
+    void dropTable(ContextPtr context, const String & table_name, bool no_delay) override;
 
     void attachTable(const String & table_name, const StoragePtr & storage, const String & relative_table_path) override;
 
 protected:
-    ASTPtr getCreateTableQueryImpl(const String & name, const Context & context, bool throw_on_error) const override;
+    ASTPtr getCreateTableQueryImpl(const String & name, ContextPtr context, bool throw_on_error) const override;
 
 private:
-    const Context & global_context;
     String metadata_path;
     ASTPtr database_engine_define;
     String database_name_in_mysql;
@@ -91,7 +95,7 @@ private:
     std::atomic<bool> quit{false};
     std::condition_variable cond;
 
-    using MySQLPool = mysqlxx::Pool;
+    using MySQLPool = mysqlxx::PoolWithFailover;
     using ModifyTimeAndStorage = std::pair<UInt64, StoragePtr>;
 
     mutable MySQLPool mysql_pool;
@@ -102,15 +106,15 @@ private:
 
     void cleanOutdatedTables();
 
-    void fetchTablesIntoLocalCache(const Context & context) const;
+    void fetchTablesIntoLocalCache(ContextPtr context) const;
 
     std::map<String, UInt64> fetchTablesWithModificationTime() const;
 
-    std::map<String, NamesAndTypesList> fetchTablesColumnsList(const std::vector<String> & tables_name, const Context & context) const;
+    std::map<String, NamesAndTypesList> fetchTablesColumnsList(const std::vector<String> & tables_name, ContextPtr context) const;
 
     void destroyLocalCacheExtraTables(const std::map<String, UInt64> & tables_with_modification_time) const;
 
-    void fetchLatestTablesStructureIntoCache(const std::map<String, UInt64> & tables_modification_time, const Context & context) const;
+    void fetchLatestTablesStructureIntoCache(const std::map<String, UInt64> & tables_modification_time, ContextPtr context) const;
 
     ThreadFromGlobalPool thread;
 };
diff --git a/src/Databases/MySQL/DatabaseMaterializeMySQL.cpp b/src/Databases/MySQL/DatabaseMaterializeMySQL.cpp
index 8edeabee004..62a66b22c93 100644
--- a/src/Databases/MySQL/DatabaseMaterializeMySQL.cpp
+++ b/src/Databases/MySQL/DatabaseMaterializeMySQL.cpp
@@ -26,27 +26,40 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
-template<>
+template <>
 DatabaseMaterializeMySQL<DatabaseOrdinary>::DatabaseMaterializeMySQL(
-    const Context & context, const String & database_name_, const String & metadata_path_, UUID /*uuid*/,
-    const String & mysql_database_name_, mysqlxx::Pool && pool_, MySQLClient && client_, std::unique_ptr<MaterializeMySQLSettings> settings_)
-    : DatabaseOrdinary(database_name_
-                      , metadata_path_
-                      , "data/" + escapeForFileName(database_name_) + "/"
-                      , "DatabaseMaterializeMySQL<Ordinary> (" + database_name_ + ")", context
-                      )
+    ContextPtr context_,
+    const String & database_name_,
+    const String & metadata_path_,
+    UUID /*uuid*/,
+    const String & mysql_database_name_,
+    mysqlxx::Pool && pool_,
+    MySQLClient && client_,
+    std::unique_ptr<MaterializeMySQLSettings> settings_)
+    : DatabaseOrdinary(
+        database_name_,
+        metadata_path_,
+        "data/" + escapeForFileName(database_name_) + "/",
+        "DatabaseMaterializeMySQL<Ordinary> (" + database_name_ + ")",
+        context_)
     , settings(std::move(settings_))
-    , materialize_thread(context, database_name_, mysql_database_name_, std::move(pool_), std::move(client_), settings.get())
+    , materialize_thread(context_, database_name_, mysql_database_name_, std::move(pool_), std::move(client_), settings.get())
 {
 }
 
-template<>
+template <>
 DatabaseMaterializeMySQL<DatabaseAtomic>::DatabaseMaterializeMySQL(
-    const Context & context, const String & database_name_, const String & metadata_path_, UUID uuid,
-    const String & mysql_database_name_, mysqlxx::Pool && pool_, MySQLClient && client_, std::unique_ptr<MaterializeMySQLSettings> settings_)
-    : DatabaseAtomic(database_name_, metadata_path_, uuid, "DatabaseMaterializeMySQL<Atomic> (" + database_name_ + ")", context)
+    ContextPtr context_,
+    const String & database_name_,
+    const String & metadata_path_,
+    UUID uuid,
+    const String & mysql_database_name_,
+    mysqlxx::Pool && pool_,
+    MySQLClient && client_,
+    std::unique_ptr<MaterializeMySQLSettings> settings_)
+    : DatabaseAtomic(database_name_, metadata_path_, uuid, "DatabaseMaterializeMySQL<Atomic> (" + database_name_ + ")", context_)
     , settings(std::move(settings_))
-    , materialize_thread(context, database_name_, mysql_database_name_, std::move(pool_), std::move(client_), settings.get())
+    , materialize_thread(context_, database_name_, mysql_database_name_, std::move(pool_), std::move(client_), settings.get())
 {
 }
 
@@ -79,9 +92,9 @@ void DatabaseMaterializeMySQL<Base>::setException(const std::exception_ptr & exc
 }
 
 template<typename Base>
-void DatabaseMaterializeMySQL<Base>::loadStoredObjects(Context & context, bool has_force_restore_data_flag, bool force_attach)
+void DatabaseMaterializeMySQL<Base>::loadStoredObjects(ContextPtr context_, bool has_force_restore_data_flag, bool force_attach)
 {
-    Base::loadStoredObjects(context, has_force_restore_data_flag, force_attach);
+    Base::loadStoredObjects(context_, has_force_restore_data_flag, force_attach);
     if (!force_attach)
         materialize_thread.assertMySQLAvailable();
 
@@ -90,17 +103,17 @@ void DatabaseMaterializeMySQL<Base>::loadStoredObjects(Context & context, bool h
 }
 
 template<typename Base>
-void DatabaseMaterializeMySQL<Base>::createTable(const Context & context, const String & name, const StoragePtr & table, const ASTPtr & query)
+void DatabaseMaterializeMySQL<Base>::createTable(ContextPtr context_, const String & name, const StoragePtr & table, const ASTPtr & query)
 {
     assertCalledFromSyncThreadOrDrop("create table");
-    Base::createTable(context, name, table, query);
+    Base::createTable(context_, name, table, query);
 }
 
 template<typename Base>
-void DatabaseMaterializeMySQL<Base>::dropTable(const Context & context, const String & name, bool no_delay)
+void DatabaseMaterializeMySQL<Base>::dropTable(ContextPtr context_, const String & name, bool no_delay)
 {
     assertCalledFromSyncThreadOrDrop("drop table");
-    Base::dropTable(context, name, no_delay);
+    Base::dropTable(context_, name, no_delay);
 }
 
 template<typename Base>
@@ -118,7 +131,7 @@ StoragePtr DatabaseMaterializeMySQL<Base>::detachTable(const String & name)
 }
 
 template<typename Base>
-void DatabaseMaterializeMySQL<Base>::renameTable(const Context & context, const String & name, IDatabase & to_database, const String & to_name, bool exchange, bool dictionary)
+void DatabaseMaterializeMySQL<Base>::renameTable(ContextPtr context_, const String & name, IDatabase & to_database, const String & to_name, bool exchange, bool dictionary)
 {
     assertCalledFromSyncThreadOrDrop("rename table");
 
@@ -131,18 +144,18 @@ void DatabaseMaterializeMySQL<Base>::renameTable(const Context & context, const
     if (to_database.getDatabaseName() != Base::getDatabaseName())
         throw Exception("Cannot rename with other database for MaterializeMySQL database.", ErrorCodes::NOT_IMPLEMENTED);
 
-    Base::renameTable(context, name, *this, to_name, exchange, dictionary);
+    Base::renameTable(context_, name, *this, to_name, exchange, dictionary);
 }
 
 template<typename Base>
-void DatabaseMaterializeMySQL<Base>::alterTable(const Context & context, const StorageID & table_id, const StorageInMemoryMetadata & metadata)
+void DatabaseMaterializeMySQL<Base>::alterTable(ContextPtr context_, const StorageID & table_id, const StorageInMemoryMetadata & metadata)
 {
     assertCalledFromSyncThreadOrDrop("alter table");
-    Base::alterTable(context, table_id, metadata);
+    Base::alterTable(context_, table_id, metadata);
 }
 
 template<typename Base>
-void DatabaseMaterializeMySQL<Base>::drop(const Context & context)
+void DatabaseMaterializeMySQL<Base>::drop(ContextPtr context_)
 {
     /// Remove metadata info
     Poco::File metadata(Base::getMetadataPath() + "/.metadata");
@@ -150,15 +163,15 @@ void DatabaseMaterializeMySQL<Base>::drop(const Context & context)
     if (metadata.exists())
         metadata.remove(false);
 
-    Base::drop(context);
+    Base::drop(context_);
 }
 
 template<typename Base>
-StoragePtr DatabaseMaterializeMySQL<Base>::tryGetTable(const String & name, const Context & context) const
+StoragePtr DatabaseMaterializeMySQL<Base>::tryGetTable(const String & name, ContextPtr context_) const
 {
     if (!MaterializeMySQLSyncThread::isMySQLSyncThread())
     {
-        StoragePtr nested_storage = Base::tryGetTable(name, context);
+        StoragePtr nested_storage = Base::tryGetTable(name, context_);
 
         if (!nested_storage)
             return {};
@@ -166,19 +179,20 @@ StoragePtr DatabaseMaterializeMySQL<Base>::tryGetTable(const String & name, cons
         return std::make_shared<StorageMaterializeMySQL>(std::move(nested_storage), this);
     }
 
-    return Base::tryGetTable(name, context);
+    return Base::tryGetTable(name, context_);
 }
 
-template<typename Base>
-DatabaseTablesIteratorPtr DatabaseMaterializeMySQL<Base>::getTablesIterator(const Context & context, const DatabaseOnDisk::FilterByNameFunction & filter_by_table_name)
+template <typename Base>
+DatabaseTablesIteratorPtr
+DatabaseMaterializeMySQL<Base>::getTablesIterator(ContextPtr context_, const DatabaseOnDisk::FilterByNameFunction & filter_by_table_name)
 {
     if (!MaterializeMySQLSyncThread::isMySQLSyncThread())
     {
-        DatabaseTablesIteratorPtr iterator = Base::getTablesIterator(context, filter_by_table_name);
+        DatabaseTablesIteratorPtr iterator = Base::getTablesIterator(context_, filter_by_table_name);
         return std::make_unique<DatabaseMaterializeTablesIterator>(std::move(iterator), this);
     }
 
-    return Base::getTablesIterator(context, filter_by_table_name);
+    return Base::getTablesIterator(context_, filter_by_table_name);
 }
 
 template<typename Base>
diff --git a/src/Databases/MySQL/DatabaseMaterializeMySQL.h b/src/Databases/MySQL/DatabaseMaterializeMySQL.h
index e1229269a33..cd9fe640239 100644
--- a/src/Databases/MySQL/DatabaseMaterializeMySQL.h
+++ b/src/Databases/MySQL/DatabaseMaterializeMySQL.h
@@ -23,7 +23,7 @@ class DatabaseMaterializeMySQL : public Base
 public:
 
     DatabaseMaterializeMySQL(
-        const Context & context, const String & database_name_, const String & metadata_path_, UUID uuid,
+        ContextPtr context, const String & database_name_, const String & metadata_path_, UUID uuid,
         const String & mysql_database_name_, mysqlxx::Pool && pool_,
         MySQLClient && client_, std::unique_ptr<MaterializeMySQLSettings> settings_);
 
@@ -43,25 +43,25 @@ protected:
 public:
     String getEngineName() const override { return "MaterializeMySQL"; }
 
-    void loadStoredObjects(Context & context, bool has_force_restore_data_flag, bool force_attach) override;
+    void loadStoredObjects(ContextPtr context_, bool has_force_restore_data_flag, bool force_attach) override;
 
-    void createTable(const Context & context, const String & name, const StoragePtr & table, const ASTPtr & query) override;
+    void createTable(ContextPtr context_, const String & name, const StoragePtr & table, const ASTPtr & query) override;
 
-    void dropTable(const Context & context, const String & name, bool no_delay) override;
+    void dropTable(ContextPtr context_, const String & name, bool no_delay) override;
 
     void attachTable(const String & name, const StoragePtr & table, const String & relative_table_path) override;
 
     StoragePtr detachTable(const String & name) override;
 
-    void renameTable(const Context & context, const String & name, IDatabase & to_database, const String & to_name, bool exchange, bool dictionary) override;
+    void renameTable(ContextPtr context_, const String & name, IDatabase & to_database, const String & to_name, bool exchange, bool dictionary) override;
 
-    void alterTable(const Context & context, const StorageID & table_id, const StorageInMemoryMetadata & metadata) override;
+    void alterTable(ContextPtr context_, const StorageID & table_id, const StorageInMemoryMetadata & metadata) override;
 
-    void drop(const Context & context) override;
+    void drop(ContextPtr context_) override;
 
-    StoragePtr tryGetTable(const String & name, const Context & context) const override;
+    StoragePtr tryGetTable(const String & name, ContextPtr context_) const override;
 
-    DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const DatabaseOnDisk::FilterByNameFunction & filter_by_table_name) override;
+    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context_, const DatabaseOnDisk::FilterByNameFunction & filter_by_table_name) override;
 
     void assertCalledFromSyncThreadOrDrop(const char * method) const;
 
diff --git a/src/Databases/MySQL/FetchTablesColumnsList.cpp b/src/Databases/MySQL/FetchTablesColumnsList.cpp
index 3e25c703a1d..6344553ba69 100644
--- a/src/Databases/MySQL/FetchTablesColumnsList.cpp
+++ b/src/Databases/MySQL/FetchTablesColumnsList.cpp
@@ -41,7 +41,7 @@ namespace DB
 {
 
 std::map<String, NamesAndTypesList> fetchTablesColumnsList(
-        mysqlxx::Pool & pool,
+        mysqlxx::PoolWithFailover & pool,
         const String & database_name,
         const std::vector<String> & tables_name,
         bool external_table_functions_use_nulls,
diff --git a/src/Databases/MySQL/FetchTablesColumnsList.h b/src/Databases/MySQL/FetchTablesColumnsList.h
index 52191c2ecb8..d609f4896e7 100644
--- a/src/Databases/MySQL/FetchTablesColumnsList.h
+++ b/src/Databases/MySQL/FetchTablesColumnsList.h
@@ -3,7 +3,7 @@
 #include "config_core.h"
 #if USE_MYSQL
 
-#include <mysqlxx/Pool.h>
+#include <mysqlxx/PoolWithFailover.h>
 
 #include <common/types.h>
 #include <Core/MultiEnum.h>
@@ -17,7 +17,7 @@ namespace DB
 {
 
 std::map<String, NamesAndTypesList> fetchTablesColumnsList(
-        mysqlxx::Pool & pool,
+        mysqlxx::PoolWithFailover & pool,
         const String & database_name,
         const std::vector<String> & tables_name,
         bool external_table_functions_use_nulls,
diff --git a/src/Databases/MySQL/MaterializeMySQLSyncThread.cpp b/src/Databases/MySQL/MaterializeMySQLSyncThread.cpp
index 8d1c1e109ac..b8e135eef32 100644
--- a/src/Databases/MySQL/MaterializeMySQLSyncThread.cpp
+++ b/src/Databases/MySQL/MaterializeMySQLSyncThread.cpp
@@ -41,30 +41,30 @@ namespace ErrorCodes
 
 static constexpr auto MYSQL_BACKGROUND_THREAD_NAME = "MySQLDBSync";
 
-static Context createQueryContext(const Context & global_context)
+static ContextPtr createQueryContext(ContextPtr context)
 {
-    Settings new_query_settings = global_context.getSettings();
+    Settings new_query_settings = context->getSettings();
     new_query_settings.insert_allow_materialized_columns = true;
 
     /// To avoid call AST::format
     /// TODO: We need to implement the format function for MySQLAST
     new_query_settings.enable_global_with_statement = false;
 
-    Context query_context(global_context);
-    query_context.setSettings(new_query_settings);
+    auto query_context = Context::createCopy(context);
+    query_context->setSettings(new_query_settings);
     CurrentThread::QueryScope query_scope(query_context);
 
-    query_context.getClientInfo().query_kind = ClientInfo::QueryKind::SECONDARY_QUERY;
-    query_context.setCurrentQueryId(""); // generate random query_id
+    query_context->getClientInfo().query_kind = ClientInfo::QueryKind::SECONDARY_QUERY;
+    query_context->setCurrentQueryId(""); // generate random query_id
     return query_context;
 }
 
-static BlockIO tryToExecuteQuery(const String & query_to_execute, Context & query_context, const String & database, const String & comment)
+static BlockIO tryToExecuteQuery(const String & query_to_execute, ContextPtr query_context, const String & database, const String & comment)
 {
     try
     {
         if (!database.empty())
-            query_context.setCurrentDatabase(database);
+            query_context->setCurrentDatabase(database);
 
         return executeQuery("/*" + comment + "*/ " + query_to_execute, query_context, true);
     }
@@ -143,10 +143,19 @@ static void checkMySQLVariables(const mysqlxx::Pool::Entry & connection)
 }
 
 MaterializeMySQLSyncThread::MaterializeMySQLSyncThread(
-    const Context & context, const String & database_name_, const String & mysql_database_name_,
-    mysqlxx::Pool && pool_, MySQLClient && client_, MaterializeMySQLSettings * settings_)
-    : log(&Poco::Logger::get("MaterializeMySQLSyncThread")), global_context(context.getGlobalContext()), database_name(database_name_)
-    , mysql_database_name(mysql_database_name_), pool(std::move(pool_)), client(std::move(client_)), settings(settings_)
+    ContextPtr context_,
+    const String & database_name_,
+    const String & mysql_database_name_,
+    mysqlxx::Pool && pool_,
+    MySQLClient && client_,
+    MaterializeMySQLSettings * settings_)
+    : WithContext(context_->getGlobalContext())
+    , log(&Poco::Logger::get("MaterializeMySQLSyncThread"))
+    , database_name(database_name_)
+    , mysql_database_name(mysql_database_name_)
+    , pool(std::move(pool_))
+    , client(std::move(client_))
+    , settings(settings_)
 {
     query_prefix = "EXTERNAL DDL FROM MySQL(" + backQuoteIfNeed(database_name) + ", " + backQuoteIfNeed(mysql_database_name) + ") ";
 }
@@ -248,7 +257,7 @@ void MaterializeMySQLSyncThread::assertMySQLAvailable()
     }
 }
 
-static inline void cleanOutdatedTables(const String & database_name, const Context & context)
+static inline void cleanOutdatedTables(const String & database_name, ContextPtr context)
 {
     String cleaning_table_name;
     try
@@ -258,7 +267,7 @@ static inline void cleanOutdatedTables(const String & database_name, const Conte
 
         for (auto iterator = clean_database->getTablesIterator(context); iterator->isValid(); iterator->next())
         {
-            Context query_context = createQueryContext(context);
+            auto query_context = createQueryContext(context);
             String comment = "Materialize MySQL step 1: execute MySQL DDL for dump data";
             cleaning_table_name = backQuoteIfNeed(database_name) + "." + backQuoteIfNeed(iterator->name());
             tryToExecuteQuery(" DROP TABLE " + cleaning_table_name, query_context, database_name, comment);
@@ -271,7 +280,8 @@ static inline void cleanOutdatedTables(const String & database_name, const Conte
     }
 }
 
-static inline BlockOutputStreamPtr getTableOutput(const String & database_name, const String & table_name, Context & query_context, bool insert_materialized = false)
+static inline BlockOutputStreamPtr
+getTableOutput(const String & database_name, const String & table_name, ContextPtr query_context, bool insert_materialized = false)
 {
     const StoragePtr & storage = DatabaseCatalog::instance().getTable(StorageID(database_name, table_name), query_context);
 
@@ -303,7 +313,7 @@ static inline BlockOutputStreamPtr getTableOutput(const String & database_name,
 static inline void dumpDataForTables(
     mysqlxx::Pool::Entry & connection, const std::unordered_map<String, String> & need_dumping_tables,
     const String & query_prefix, const String & database_name, const String & mysql_database_name,
-    const Context & context, const std::function<bool()> & is_cancelled)
+    ContextPtr context, const std::function<bool()> & is_cancelled)
 {
     auto iterator = need_dumping_tables.begin();
     for (; iterator != need_dumping_tables.end() && !is_cancelled(); ++iterator)
@@ -311,7 +321,7 @@ static inline void dumpDataForTables(
         try
         {
             const auto & table_name = iterator->first;
-            Context query_context = createQueryContext(context);
+            auto query_context = createQueryContext(context);
             String comment = "Materialize MySQL step 1: execute MySQL DDL for dump data";
             tryToExecuteQuery(query_prefix + " " + iterator->second, query_context, database_name, comment); /// create table.
 
@@ -376,8 +386,12 @@ bool MaterializeMySQLSyncThread::prepareSynchronized(MaterializeMetadata & metad
 
                 metadata.transaction(position, [&]()
                 {
-                    cleanOutdatedTables(database_name, global_context);
-                    dumpDataForTables(connection, need_dumping_tables, query_prefix, database_name, mysql_database_name, global_context, [this] { return isCancelled(); });
+                    cleanOutdatedTables(database_name, getContext());
+                    dumpDataForTables(
+                        connection, need_dumping_tables, query_prefix, database_name, mysql_database_name, getContext(), [this]
+                        {
+                            return isCancelled();
+                        });
                 });
 
                 const auto & position_message = [&]()
@@ -431,7 +445,7 @@ void MaterializeMySQLSyncThread::flushBuffersData(Buffers & buffers, Materialize
     if (buffers.data.empty())
         return;
 
-    metadata.transaction(client.getPosition(), [&]() { buffers.commit(global_context); });
+    metadata.transaction(client.getPosition(), [&]() { buffers.commit(getContext()); });
 
     const auto & position_message = [&]()
     {
@@ -664,21 +678,21 @@ void MaterializeMySQLSyncThread::onEvent(Buffers & buffers, const BinlogEventPtr
     if (receive_event->type() == MYSQL_WRITE_ROWS_EVENT)
     {
         WriteRowsEvent & write_rows_event = static_cast<WriteRowsEvent &>(*receive_event);
-        Buffers::BufferAndSortingColumnsPtr buffer = buffers.getTableDataBuffer(write_rows_event.table, global_context);
+        Buffers::BufferAndSortingColumnsPtr buffer = buffers.getTableDataBuffer(write_rows_event.table, getContext());
         size_t bytes = onWriteOrDeleteData<1>(write_rows_event.rows, buffer->first, ++metadata.data_version);
         buffers.add(buffer->first.rows(), buffer->first.bytes(), write_rows_event.rows.size(), bytes);
     }
     else if (receive_event->type() == MYSQL_UPDATE_ROWS_EVENT)
     {
         UpdateRowsEvent & update_rows_event = static_cast<UpdateRowsEvent &>(*receive_event);
-        Buffers::BufferAndSortingColumnsPtr buffer = buffers.getTableDataBuffer(update_rows_event.table, global_context);
+        Buffers::BufferAndSortingColumnsPtr buffer = buffers.getTableDataBuffer(update_rows_event.table, getContext());
         size_t bytes = onUpdateData(update_rows_event.rows, buffer->first, ++metadata.data_version, buffer->second);
         buffers.add(buffer->first.rows(), buffer->first.bytes(), update_rows_event.rows.size(), bytes);
     }
     else if (receive_event->type() == MYSQL_DELETE_ROWS_EVENT)
     {
         DeleteRowsEvent & delete_rows_event = static_cast<DeleteRowsEvent &>(*receive_event);
-        Buffers::BufferAndSortingColumnsPtr buffer = buffers.getTableDataBuffer(delete_rows_event.table, global_context);
+        Buffers::BufferAndSortingColumnsPtr buffer = buffers.getTableDataBuffer(delete_rows_event.table, getContext());
         size_t bytes = onWriteOrDeleteData<-1>(delete_rows_event.rows, buffer->first, ++metadata.data_version);
         buffers.add(buffer->first.rows(), buffer->first.bytes(), delete_rows_event.rows.size(), bytes);
     }
@@ -687,7 +701,7 @@ void MaterializeMySQLSyncThread::onEvent(Buffers & buffers, const BinlogEventPtr
         QueryEvent & query_event = static_cast<QueryEvent &>(*receive_event);
         Position position_before_ddl;
         position_before_ddl.update(metadata.binlog_position, metadata.binlog_file, metadata.executed_gtid_set);
-        metadata.transaction(position_before_ddl, [&]() { buffers.commit(global_context); });
+        metadata.transaction(position_before_ddl, [&]() { buffers.commit(getContext()); });
         metadata.transaction(client.getPosition(),[&](){ executeDDLAtomic(query_event); });
     }
     else
@@ -718,7 +732,7 @@ void MaterializeMySQLSyncThread::executeDDLAtomic(const QueryEvent & query_event
 {
     try
     {
-        Context query_context = createQueryContext(global_context);
+        auto query_context = createQueryContext(getContext());
         String comment = "Materialize MySQL step 2: execute MySQL DDL for sync data";
         String event_database = query_event.schema == mysql_database_name ? database_name : "";
         tryToExecuteQuery(query_prefix + query_event.query, query_context, event_database, comment);
@@ -761,13 +775,13 @@ bool MaterializeMySQLSyncThread::Buffers::checkThresholds(size_t check_block_row
         || total_blocks_bytes >= check_total_bytes;
 }
 
-void MaterializeMySQLSyncThread::Buffers::commit(const Context & context)
+void MaterializeMySQLSyncThread::Buffers::commit(ContextPtr context)
 {
     try
     {
         for (auto & table_name_and_buffer : data)
         {
-            Context query_context = createQueryContext(context);
+            auto query_context = createQueryContext(context);
             OneBlockInputStream input(table_name_and_buffer.second->first);
             BlockOutputStreamPtr out = getTableOutput(database, table_name_and_buffer.first, query_context, true);
             copyData(input, *out);
@@ -787,7 +801,7 @@ void MaterializeMySQLSyncThread::Buffers::commit(const Context & context)
 }
 
 MaterializeMySQLSyncThread::Buffers::BufferAndSortingColumnsPtr MaterializeMySQLSyncThread::Buffers::getTableDataBuffer(
-    const String & table_name, const Context & context)
+    const String & table_name, ContextPtr context)
 {
     const auto & iterator = data.find(table_name);
     if (iterator == data.end())
diff --git a/src/Databases/MySQL/MaterializeMySQLSyncThread.h b/src/Databases/MySQL/MaterializeMySQLSyncThread.h
index 54a6cbbdda2..03958fe10cc 100644
--- a/src/Databases/MySQL/MaterializeMySQLSyncThread.h
+++ b/src/Databases/MySQL/MaterializeMySQLSyncThread.h
@@ -36,14 +36,18 @@ namespace DB
  *  real-time pull incremental data:
  *      We will pull the binlog event of MySQL to parse and execute when the full data synchronization is completed.
  */
-class MaterializeMySQLSyncThread
+class MaterializeMySQLSyncThread : WithContext
 {
 public:
     ~MaterializeMySQLSyncThread();
 
     MaterializeMySQLSyncThread(
-        const Context & context, const String & database_name_, const String & mysql_database_name_
-        , mysqlxx::Pool && pool_, MySQLClient && client_, MaterializeMySQLSettings * settings_);
+        ContextPtr context,
+        const String & database_name_,
+        const String & mysql_database_name_,
+        mysqlxx::Pool && pool_,
+        MySQLClient && client_,
+        MaterializeMySQLSettings * settings_);
 
     void stopSynchronization();
 
@@ -55,7 +59,6 @@ public:
 
 private:
     Poco::Logger * log;
-    const Context & global_context;
 
     String database_name;
     String mysql_database_name;
@@ -90,13 +93,13 @@ private:
 
         Buffers(const String & database_) : database(database_) {}
 
-        void commit(const Context & context);
+        void commit(ContextPtr context);
 
         void add(size_t block_rows, size_t block_bytes, size_t written_rows, size_t written_bytes);
 
         bool checkThresholds(size_t check_block_rows, size_t check_block_bytes, size_t check_total_rows, size_t check_total_bytes) const;
 
-        BufferAndSortingColumnsPtr getTableDataBuffer(const String & table, const Context & context);
+        BufferAndSortingColumnsPtr getTableDataBuffer(const String & table, ContextPtr context);
     };
 
     void synchronization();
diff --git a/src/Databases/PostgreSQL/DatabasePostgreSQL.cpp b/src/Databases/PostgreSQL/DatabasePostgreSQL.cpp
index 229c338d765..e12d7f975ce 100644
--- a/src/Databases/PostgreSQL/DatabasePostgreSQL.cpp
+++ b/src/Databases/PostgreSQL/DatabasePostgreSQL.cpp
@@ -35,22 +35,22 @@ static const auto suffix = ".removed";
 static const auto cleaner_reschedule_ms = 60000;
 
 DatabasePostgreSQL::DatabasePostgreSQL(
-        const Context & context,
+        ContextPtr context_,
         const String & metadata_path_,
         const ASTStorage * database_engine_define_,
         const String & dbname_,
         const String & postgres_dbname,
-        PostgreSQLConnectionPoolPtr connection_pool_,
+        postgres::PoolWithFailoverPtr connection_pool_,
         const bool cache_tables_)
     : IDatabase(dbname_)
-    , global_context(context.getGlobalContext())
+    , WithContext(context_->getGlobalContext())
     , metadata_path(metadata_path_)
     , database_engine_define(database_engine_define_->clone())
     , dbname(postgres_dbname)
     , connection_pool(std::move(connection_pool_))
     , cache_tables(cache_tables_)
 {
-    cleaner_task = context.getSchedulePool().createTask("PostgreSQLCleanerTask", [this]{ removeOutdatedTables(); });
+    cleaner_task = getContext()->getSchedulePool().createTask("PostgreSQLCleanerTask", [this]{ removeOutdatedTables(); });
     cleaner_task->deactivate();
 }
 
@@ -69,8 +69,7 @@ bool DatabasePostgreSQL::empty() const
 }
 
 
-DatabaseTablesIteratorPtr DatabasePostgreSQL::getTablesIterator(
-        const Context & context, const FilterByNameFunction & /* filter_by_table_name */)
+DatabaseTablesIteratorPtr DatabasePostgreSQL::getTablesIterator(ContextPtr local_context, const FilterByNameFunction & /* filter_by_table_name */)
 {
     std::lock_guard<std::mutex> lock(mutex);
 
@@ -79,7 +78,7 @@ DatabaseTablesIteratorPtr DatabasePostgreSQL::getTablesIterator(
 
     for (const auto & table_name : table_names)
         if (!detached_or_dropped.count(table_name))
-            tables[table_name] = fetchTable(table_name, context, true);
+            tables[table_name] = fetchTable(table_name, local_context, true);
 
     return std::make_unique<DatabaseTablesSnapshotIterator>(tables, database_name);
 }
@@ -135,7 +134,7 @@ bool DatabasePostgreSQL::checkPostgresTable(const String & table_name) const
 }
 
 
-bool DatabasePostgreSQL::isTableExist(const String & table_name, const Context & /* context */) const
+bool DatabasePostgreSQL::isTableExist(const String & table_name, ContextPtr /* context */) const
 {
     std::lock_guard<std::mutex> lock(mutex);
 
@@ -146,33 +145,33 @@ bool DatabasePostgreSQL::isTableExist(const String & table_name, const Context &
 }
 
 
-StoragePtr DatabasePostgreSQL::tryGetTable(const String & table_name, const Context & context) const
+StoragePtr DatabasePostgreSQL::tryGetTable(const String & table_name, ContextPtr local_context) const
 {
     std::lock_guard<std::mutex> lock(mutex);
 
     if (!detached_or_dropped.count(table_name))
-        return fetchTable(table_name, context, false);
+        return fetchTable(table_name, local_context, false);
 
     return StoragePtr{};
 }
 
 
-StoragePtr DatabasePostgreSQL::fetchTable(const String & table_name, const Context & context, const bool table_checked) const
+StoragePtr DatabasePostgreSQL::fetchTable(const String & table_name, ContextPtr local_context, const bool table_checked) const
 {
     if (!cache_tables || !cached_tables.count(table_name))
     {
         if (!table_checked && !checkPostgresTable(table_name))
             return StoragePtr{};
 
-        auto use_nulls = context.getSettingsRef().external_table_functions_use_nulls;
+        auto use_nulls = local_context->getSettingsRef().external_table_functions_use_nulls;
         auto columns = fetchPostgreSQLTableStructure(connection_pool->get(), doubleQuoteString(table_name), use_nulls);
 
         if (!columns)
             return StoragePtr{};
 
         auto storage = StoragePostgreSQL::create(
-                StorageID(database_name, table_name), table_name, std::make_shared<PostgreSQLConnectionPool>(*connection_pool),
-                ColumnsDescription{*columns}, ConstraintsDescription{}, context);
+                StorageID(database_name, table_name), *connection_pool, table_name,
+                ColumnsDescription{*columns}, ConstraintsDescription{}, local_context);
 
         if (cache_tables)
             cached_tables[table_name] = storage;
@@ -232,7 +231,7 @@ StoragePtr DatabasePostgreSQL::detachTable(const String & table_name)
 }
 
 
-void DatabasePostgreSQL::createTable(const Context &, const String & table_name, const StoragePtr & storage, const ASTPtr & create_query)
+void DatabasePostgreSQL::createTable(ContextPtr, const String & table_name, const StoragePtr & storage, const ASTPtr & create_query)
 {
     const auto & create = create_query->as<ASTCreateQuery>();
 
@@ -243,7 +242,7 @@ void DatabasePostgreSQL::createTable(const Context &, const String & table_name,
 }
 
 
-void DatabasePostgreSQL::dropTable(const Context &, const String & table_name, bool /* no_delay */)
+void DatabasePostgreSQL::dropTable(ContextPtr, const String & table_name, bool /* no_delay */)
 {
     std::lock_guard<std::mutex> lock{mutex};
 
@@ -271,13 +270,13 @@ void DatabasePostgreSQL::dropTable(const Context &, const String & table_name, b
 }
 
 
-void DatabasePostgreSQL::drop(const Context & /*context*/)
+void DatabasePostgreSQL::drop(ContextPtr /*context*/)
 {
     Poco::File(getMetadataPath()).remove(true);
 }
 
 
-void DatabasePostgreSQL::loadStoredObjects(Context & /* context */, bool, bool /*force_attach*/)
+void DatabasePostgreSQL::loadStoredObjects(ContextPtr /* context */, bool, bool /*force_attach*/)
 {
     {
         std::lock_guard<std::mutex> lock{mutex};
@@ -349,9 +348,9 @@ ASTPtr DatabasePostgreSQL::getCreateDatabaseQuery() const
 }
 
 
-ASTPtr DatabasePostgreSQL::getCreateTableQueryImpl(const String & table_name, const Context & context, bool throw_on_error) const
+ASTPtr DatabasePostgreSQL::getCreateTableQueryImpl(const String & table_name, ContextPtr local_context, bool throw_on_error) const
 {
-    auto storage = fetchTable(table_name, context, false);
+    auto storage = fetchTable(table_name, local_context, false);
     if (!storage)
     {
         if (throw_on_error)
diff --git a/src/Databases/PostgreSQL/DatabasePostgreSQL.h b/src/Databases/PostgreSQL/DatabasePostgreSQL.h
index 7be34df2123..3505c38e499 100644
--- a/src/Databases/PostgreSQL/DatabasePostgreSQL.h
+++ b/src/Databases/PostgreSQL/DatabasePostgreSQL.h
@@ -9,14 +9,13 @@
 #include <Databases/DatabasesCommon.h>
 #include <Core/BackgroundSchedulePool.h>
 #include <Parsers/ASTCreateQuery.h>
+#include <Storages/PostgreSQL/PostgreSQLPoolWithFailover.h>
 
 
 namespace DB
 {
 
 class Context;
-class PostgreSQLConnectionPool;
-using PostgreSQLConnectionPoolPtr = std::shared_ptr<PostgreSQLConnectionPool>;
 
 
 /** Real-time access to table list and table structure from remote PostgreSQL.
@@ -24,18 +23,18 @@ using PostgreSQLConnectionPoolPtr = std::shared_ptr<PostgreSQLConnectionPool>;
  *  If `cache_tables` == 1 (default: 0) table structure is cached and not checked for being modififed,
  *  but it will be updated during detach->attach.
  */
-class DatabasePostgreSQL final : public IDatabase
+class DatabasePostgreSQL final : public IDatabase, WithContext
 {
 
 public:
     DatabasePostgreSQL(
-        const Context & context,
+        ContextPtr context,
         const String & metadata_path_,
         const ASTStorage * database_engine_define,
         const String & dbname_,
         const String & postgres_dbname,
-        PostgreSQLConnectionPoolPtr connection_pool_,
-        const bool cache_tables_);
+        postgres::PoolWithFailoverPtr connection_pool_,
+        bool cache_tables_);
 
     String getEngineName() const override { return "PostgreSQL"; }
     String getMetadataPath() const override { return metadata_path; }
@@ -48,31 +47,30 @@ public:
 
     bool empty() const override;
 
-    void loadStoredObjects(Context &, bool, bool force_attach) override;
+    void loadStoredObjects(ContextPtr, bool, bool force_attach) override;
 
-    DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) override;
+    DatabaseTablesIteratorPtr getTablesIterator(ContextPtr context, const FilterByNameFunction & filter_by_table_name) override;
 
-    bool isTableExist(const String & name, const Context & context) const override;
-    StoragePtr tryGetTable(const String & name, const Context & context) const override;
+    bool isTableExist(const String & name, ContextPtr context) const override;
+    StoragePtr tryGetTable(const String & name, ContextPtr context) const override;
 
-    void createTable(const Context &, const String & table_name, const StoragePtr & storage, const ASTPtr & create_query) override;
-    void dropTable(const Context &, const String & table_name, bool no_delay) override;
+    void createTable(ContextPtr, const String & table_name, const StoragePtr & storage, const ASTPtr & create_query) override;
+    void dropTable(ContextPtr, const String & table_name, bool no_delay) override;
 
     void attachTable(const String & table_name, const StoragePtr & storage, const String & relative_table_path) override;
     StoragePtr detachTable(const String & table_name) override;
 
-    void drop(const Context & /*context*/) override;
+    void drop(ContextPtr /*context*/) override;
     void shutdown() override;
 
 protected:
-    ASTPtr getCreateTableQueryImpl(const String & table_name, const Context & context, bool throw_on_error) const override;
+    ASTPtr getCreateTableQueryImpl(const String & table_name, ContextPtr context, bool throw_on_error) const override;
 
 private:
-    const Context & global_context;
     String metadata_path;
     ASTPtr database_engine_define;
     String dbname;
-    PostgreSQLConnectionPoolPtr connection_pool;
+    postgres::PoolWithFailoverPtr connection_pool;
     const bool cache_tables;
 
     mutable Tables cached_tables;
@@ -81,7 +79,7 @@ private:
 
     bool checkPostgresTable(const String & table_name) const;
     std::unordered_set<std::string> fetchTablesList() const;
-    StoragePtr fetchTable(const String & table_name, const Context & context, const bool table_checked) const;
+    StoragePtr fetchTable(const String & table_name, ContextPtr context, bool table_checked) const;
     void removeOutdatedTables();
     ASTPtr getColumnDeclaration(const DataTypePtr & data_type) const;
 };
diff --git a/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp b/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp
index 4887b47d98a..066090d02d6 100644
--- a/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp
+++ b/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp
@@ -40,6 +40,8 @@ static DataTypePtr convertPostgreSQLDataType(std::string & type, bool is_nullabl
         res = std::make_shared<DataTypeInt32>();
     else if (type == "bigint")
         res = std::make_shared<DataTypeInt64>();
+    else if (type == "boolean")
+        res = std::make_shared<DataTypeUInt8>();
     else if (type == "real")
         res = std::make_shared<DataTypeFloat32>();
     else if (type == "double precision")
@@ -94,7 +96,7 @@ static DataTypePtr convertPostgreSQLDataType(std::string & type, bool is_nullabl
 
 
 std::shared_ptr<NamesAndTypesList> fetchPostgreSQLTableStructure(
-    PostgreSQLConnectionHolderPtr connection, const String & postgres_table_name, bool use_nulls)
+    postgres::ConnectionHolderPtr connection, const String & postgres_table_name, bool use_nulls)
 {
     auto columns = NamesAndTypesList();
 
diff --git a/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.h b/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.h
index 96305349062..f40929aa91d 100644
--- a/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.h
+++ b/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.h
@@ -12,7 +12,7 @@ namespace DB
 {
 
 std::shared_ptr<NamesAndTypesList> fetchPostgreSQLTableStructure(
-    PostgreSQLConnectionHolderPtr connection, const String & postgres_table_name, bool use_nulls);
+    postgres::ConnectionHolderPtr connection, const String & postgres_table_name, bool use_nulls);
 
 }
 
diff --git a/src/Dictionaries/CacheDictionary.cpp b/src/Dictionaries/CacheDictionary.cpp
index 535e862af40..b1b8ebed5bd 100644
--- a/src/Dictionaries/CacheDictionary.cpp
+++ b/src/Dictionaries/CacheDictionary.cpp
@@ -70,7 +70,7 @@ CacheDictionary<dictionary_key_type>::CacheDictionary(
     , rnd_engine(randomSeed())
 {
     if (!source_ptr->supportsSelectiveLoad())
-        throw Exception{full_name + ": source cannot be used with CacheDictionary", ErrorCodes::UNSUPPORTED_METHOD};
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "{}: source cannot be used with CacheDictionary", full_name);
 }
 
 template <DictionaryKeyType dictionary_key_type>
@@ -133,7 +133,7 @@ ColumnPtr CacheDictionary<dictionary_key_type>::getColumn(
 template <DictionaryKeyType dictionary_key_type>
 Columns CacheDictionary<dictionary_key_type>::getColumns(
     const Strings & attribute_names,
-    const DataTypes &,
+    const DataTypes & result_types,
     const Columns & key_columns,
     const DataTypes & key_types,
     const Columns & default_values_columns) const
@@ -159,7 +159,7 @@ Columns CacheDictionary<dictionary_key_type>::getColumns(
     DictionaryKeysExtractor<dictionary_key_type> extractor(key_columns, arena_holder.getComplexKeyArena());
     auto keys = extractor.extractAllKeys();
 
-    DictionaryStorageFetchRequest request(dict_struct, attribute_names, default_values_columns);
+    DictionaryStorageFetchRequest request(dict_struct, attribute_names, result_types, default_values_columns);
 
     FetchResult result_of_fetch_from_storage;
 
@@ -277,7 +277,7 @@ ColumnUInt8::Ptr CacheDictionary<dictionary_key_type>::hasKeys(const Columns & k
     const auto keys = extractor.extractAllKeys();
 
     /// We make empty request just to fetch if keys exists
-    DictionaryStorageFetchRequest request(dict_struct, {}, {});
+    DictionaryStorageFetchRequest request(dict_struct, {}, {}, {});
 
     FetchResult result_of_fetch_from_storage;
 
diff --git a/src/Dictionaries/CacheDictionaryStorage.h b/src/Dictionaries/CacheDictionaryStorage.h
index 98031801b11..720800e6357 100644
--- a/src/Dictionaries/CacheDictionaryStorage.h
+++ b/src/Dictionaries/CacheDictionaryStorage.h
@@ -77,7 +77,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::simple)
             return fetchColumnsForKeysImpl<SimpleKeysStorageFetchResult>(keys, fetch_request);
         else
-            throw Exception("Method fetchColumnsForKeys is not supported for complex key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method fetchColumnsForKeys is not supported for complex key storage");
     }
 
     void insertColumnsForKeys(const PaddedPODArray<UInt64> & keys, Columns columns) override
@@ -85,7 +85,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::simple)
             insertColumnsForKeysImpl(keys, columns);
         else
-            throw Exception("Method insertColumnsForKeys is not supported for complex key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method insertColumnsForKeys is not supported for complex key storage");
     }
 
     void insertDefaultKeys(const PaddedPODArray<UInt64> & keys) override
@@ -93,7 +93,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::simple)
             insertDefaultKeysImpl(keys);
         else
-            throw Exception("Method insertDefaultKeysImpl is not supported for complex key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method insertDefaultKeysImpl is not supported for complex key storage");
     }
 
     PaddedPODArray<UInt64> getCachedSimpleKeys() const override
@@ -101,7 +101,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::simple)
             return getCachedKeysImpl();
         else
-            throw Exception("Method getCachedSimpleKeys is not supported for complex key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method getCachedSimpleKeys is not supported for complex key storage");
     }
 
     bool supportsComplexKeys() const override { return dictionary_key_type == DictionaryKeyType::complex; }
@@ -113,7 +113,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::complex)
             return fetchColumnsForKeysImpl<ComplexKeysStorageFetchResult>(keys, column_fetch_requests);
         else
-            throw Exception("Method fetchColumnsForKeys is not supported for simple key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method fetchColumnsForKeys is not supported for simple key storage");
     }
 
     void insertColumnsForKeys(const PaddedPODArray<StringRef> & keys, Columns columns) override
@@ -121,7 +121,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::complex)
             insertColumnsForKeysImpl(keys, columns);
         else
-            throw Exception("Method insertColumnsForKeys is not supported for simple key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method insertColumnsForKeys is not supported for simple key storage");
     }
 
     void insertDefaultKeys(const PaddedPODArray<StringRef> & keys) override
@@ -129,7 +129,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::complex)
             insertDefaultKeysImpl(keys);
         else
-            throw Exception("Method insertDefaultKeysImpl is not supported for simple key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method insertDefaultKeysImpl is not supported for simple key storage");
     }
 
     PaddedPODArray<StringRef> getCachedComplexKeys() const override
@@ -137,7 +137,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::complex)
             return getCachedKeysImpl();
         else
-            throw Exception("Method getCachedComplexKeys is not supported for simple key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method getCachedComplexKeys is not supported for simple key storage");
     }
 
     size_t getSize() const override { return size; }
@@ -601,6 +601,7 @@ private:
             PaddedPODArray<Decimal32>,
             PaddedPODArray<Decimal64>,
             PaddedPODArray<Decimal128>,
+            PaddedPODArray<Decimal256>,
             PaddedPODArray<Float32>,
             PaddedPODArray<Float64>,
             PaddedPODArray<StringRef>,
diff --git a/src/Dictionaries/CacheDictionaryUpdateQueue.cpp b/src/Dictionaries/CacheDictionaryUpdateQueue.cpp
index eca833f62da..310abed822f 100644
--- a/src/Dictionaries/CacheDictionaryUpdateQueue.cpp
+++ b/src/Dictionaries/CacheDictionaryUpdateQueue.cpp
@@ -49,11 +49,10 @@ template <DictionaryKeyType dictionary_key_type>
 void CacheDictionaryUpdateQueue<dictionary_key_type>::tryPushToUpdateQueueOrThrow(CacheDictionaryUpdateUnitPtr<dictionary_key_type> & update_unit_ptr)
 {
     if (finished)
-        throw Exception{"CacheDictionaryUpdateQueue finished", ErrorCodes::UNSUPPORTED_METHOD};
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "CacheDictionaryUpdateQueue finished");
 
     if (!update_queue.tryPush(update_unit_ptr, configuration.update_queue_push_timeout_milliseconds))
-        throw DB::Exception(
-            ErrorCodes::CACHE_DICTIONARY_UPDATE_FAIL,
+        throw DB::Exception(ErrorCodes::CACHE_DICTIONARY_UPDATE_FAIL,
             "Cannot push to internal update queue in dictionary {}. "
             "Timelimit of {} ms. exceeded. Current queue size is {}",
             dictionary_name_for_logs,
@@ -65,7 +64,7 @@ template <DictionaryKeyType dictionary_key_type>
 void CacheDictionaryUpdateQueue<dictionary_key_type>::waitForCurrentUpdateFinish(CacheDictionaryUpdateUnitPtr<dictionary_key_type> & update_unit_ptr) const
 {
     if (finished)
-        throw Exception{"CacheDictionaryUpdateQueue finished", ErrorCodes::UNSUPPORTED_METHOD};
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "CacheDictionaryUpdateQueue finished");
 
     std::unique_lock<std::mutex> update_lock(update_mutex);
 
diff --git a/src/Dictionaries/CassandraBlockInputStream.cpp b/src/Dictionaries/CassandraBlockInputStream.cpp
index 721cb44a82e..4e71c212451 100644
--- a/src/Dictionaries/CassandraBlockInputStream.cpp
+++ b/src/Dictionaries/CassandraBlockInputStream.cpp
@@ -142,7 +142,7 @@ void CassandraBlockInputStream::insertValue(IColumn & column, ValueType type, co
             break;
         }
         default:
-            throw Exception("Unknown type : " + std::to_string(static_cast<int>(type)), ErrorCodes::UNKNOWN_TYPE);
+            throw Exception(ErrorCodes::UNKNOWN_TYPE, "Unknown type : {}", std::to_string(static_cast<int>(type)));
     }
 }
 
@@ -256,7 +256,7 @@ void CassandraBlockInputStream::assertTypes(const CassResultPtr & result)
                 expected_text = "uuid";
                 break;
             default:
-                throw Exception("Unknown type : " + std::to_string(static_cast<int>(description.types[i].first)), ErrorCodes::UNKNOWN_TYPE);
+                throw Exception(ErrorCodes::UNKNOWN_TYPE, "Unknown type : {}", std::to_string(static_cast<int>(description.types[i].first)));
         }
 
         CassValueType got = cass_result_column_type(result, i);
@@ -267,8 +267,10 @@ void CassandraBlockInputStream::assertTypes(const CassResultPtr & result)
                 continue;
 
             const auto & column_name = description.sample_block.getColumnsWithTypeAndName()[i].name;
-            throw Exception("Type mismatch for column " + column_name + ": expected Cassandra type " + expected_text,
-                            ErrorCodes::TYPE_MISMATCH);
+            throw Exception(ErrorCodes::TYPE_MISMATCH,
+                "Type mismatch for column {} : expected Cassandra type {}",
+                column_name,
+                expected_text);
         }
     }
 
diff --git a/src/Dictionaries/CassandraDictionarySource.cpp b/src/Dictionaries/CassandraDictionarySource.cpp
index 643e9af54b8..b4f7f3221bc 100644
--- a/src/Dictionaries/CassandraDictionarySource.cpp
+++ b/src/Dictionaries/CassandraDictionarySource.cpp
@@ -17,7 +17,7 @@ void registerDictionarySourceCassandra(DictionarySourceFactory & factory)
                                    [[maybe_unused]] const Poco::Util::AbstractConfiguration & config,
                                    [[maybe_unused]] const std::string & config_prefix,
                                    [[maybe_unused]] Block & sample_block,
-                                                    const Context & /* context */,
+                                                    ContextPtr /* context */,
                                                     const std::string & /* default_database */,
                                                     bool /*check_config*/) -> DictionarySourcePtr
     {
@@ -25,8 +25,8 @@ void registerDictionarySourceCassandra(DictionarySourceFactory & factory)
     setupCassandraDriverLibraryLogging(CASS_LOG_INFO);
     return std::make_unique<CassandraDictionarySource>(dict_struct, config, config_prefix + ".cassandra", sample_block);
 #else
-    throw Exception{"Dictionary source of type `cassandra` is disabled because ClickHouse was built without cassandra support.",
-                    ErrorCodes::SUPPORT_IS_DISABLED};
+    throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
+        "Dictionary source of type `cassandra` is disabled because ClickHouse was built without cassandra support.");
 #endif
     };
     factory.registerSource("cassandra", create_table_source);
@@ -90,7 +90,7 @@ void CassandraSettings::setConsistency(const String & config_str)
     else if (config_str == "LocalSerial")
         consistency = CASS_CONSISTENCY_LOCAL_SERIAL;
     else    /// CASS_CONSISTENCY_ANY is only valid for writes
-        throw Exception("Unsupported consistency level: " + config_str, ErrorCodes::INVALID_CONFIG_PARAMETER);
+        throw Exception(ErrorCodes::INVALID_CONFIG_PARAMETER, "Unsupported consistency level: {}", config_str);
 }
 
 static const size_t max_block_size = 8192;
@@ -156,7 +156,7 @@ BlockInputStreamPtr CassandraDictionarySource::loadIds(const std::vector<UInt64>
 BlockInputStreamPtr CassandraDictionarySource::loadKeys(const Columns & key_columns, const std::vector<size_t> & requested_rows)
 {
     if (requested_rows.empty())
-        throw Exception("No rows requested", ErrorCodes::LOGICAL_ERROR);
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "No rows requested");
 
     /// TODO is there a better way to load data by complex keys?
     std::unordered_map<UInt64, std::vector<size_t>> partitions;
@@ -185,7 +185,7 @@ BlockInputStreamPtr CassandraDictionarySource::loadKeys(const Columns & key_colu
 
 BlockInputStreamPtr CassandraDictionarySource::loadUpdatedAll()
 {
-    throw Exception("Method loadUpdatedAll is unsupported for CassandraDictionarySource", ErrorCodes::NOT_IMPLEMENTED);
+    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method loadUpdatedAll is unsupported for CassandraDictionarySource");
 }
 
 CassSessionShared CassandraDictionarySource::getSession()
diff --git a/src/Dictionaries/CassandraHelpers.cpp b/src/Dictionaries/CassandraHelpers.cpp
index 6de80a455c7..81f7d6d9a63 100644
--- a/src/Dictionaries/CassandraHelpers.cpp
+++ b/src/Dictionaries/CassandraHelpers.cpp
@@ -16,8 +16,10 @@ extern const int CASSANDRA_INTERNAL_ERROR;
 void cassandraCheck(CassError code)
 {
     if (code != CASS_OK)
-        throw Exception("Cassandra driver error " + std::to_string(code) + ": " + cass_error_desc(code),
-                        ErrorCodes::CASSANDRA_INTERNAL_ERROR);
+        throw Exception(ErrorCodes::CASSANDRA_INTERNAL_ERROR,
+            "Cassandra driver error {}: {}",
+            std::to_string(code),
+            cass_error_desc(code));
 }
 
 
@@ -31,8 +33,12 @@ void cassandraWaitAndCheck(CassFuturePtr & future)
     const char * message;
     size_t message_len;
     cass_future_error_message(future, &message, & message_len);
-    std::string full_message = "Cassandra driver error " + std::to_string(code) + ": " + cass_error_desc(code) + ": " + message;
-    throw Exception(full_message, ErrorCodes::CASSANDRA_INTERNAL_ERROR);
+
+    throw Exception(ErrorCodes::CASSANDRA_INTERNAL_ERROR,
+        "Cassandra driver error {}: {}: {}",
+        std::to_string(code),
+        cass_error_desc(code),
+        message);
 }
 
 static std::once_flag setup_logging_flag;
diff --git a/src/Dictionaries/ClickHouseDictionarySource.cpp b/src/Dictionaries/ClickHouseDictionarySource.cpp
index d89271932eb..fdb0d76a8d7 100644
--- a/src/Dictionaries/ClickHouseDictionarySource.cpp
+++ b/src/Dictionaries/ClickHouseDictionarySource.cpp
@@ -27,9 +27,9 @@ namespace
 {
     constexpr size_t MAX_CONNECTIONS = 16;
 
-    inline UInt16 getPortFromContext(const Context & context, bool secure)
+    inline UInt16 getPortFromContext(ContextPtr context, bool secure)
     {
-        return secure ? context.getTCPPortSecure().value_or(0) : context.getTCPPort();
+        return secure ? context->getTCPPortSecure().value_or(0) : context->getTCPPort();
     }
 
     ConnectionPoolWithFailoverPtr createPool(const ClickHouseDictionarySource::Configuration & configuration)
@@ -60,19 +60,19 @@ ClickHouseDictionarySource::ClickHouseDictionarySource(
     const DictionaryStructure & dict_struct_,
     const Configuration & configuration_,
     const Block & sample_block_,
-    const Context & context_)
+    ContextPtr context_)
     : update_time{std::chrono::system_clock::from_time_t(0)}
     , dict_struct{dict_struct_}
     , configuration{configuration_}
     , query_builder{dict_struct, configuration.db, "", configuration.table, configuration.where, IdentifierQuotingStyle::Backticks}
     , sample_block{sample_block_}
-    , context{context_}
+    , context(Context::createCopy(context_))
     , pool{createPool(configuration)}
     , load_all_query{query_builder.composeLoadAllQuery()}
 {
     /// Query context is needed because some code in executeQuery function may assume it exists.
     /// Current example is Context::getSampleBlockCache from InterpreterSelectWithUnionQuery::getSampleBlock.
-    context.makeQueryContext();
+    context->makeQueryContext();
 }
 
 ClickHouseDictionarySource::ClickHouseDictionarySource(const ClickHouseDictionarySource & other)
@@ -82,11 +82,11 @@ ClickHouseDictionarySource::ClickHouseDictionarySource(const ClickHouseDictionar
     , invalidate_query_response{other.invalidate_query_response}
     , query_builder{dict_struct, configuration.db, "", configuration.table, configuration.where, IdentifierQuotingStyle::Backticks}
     , sample_block{other.sample_block}
-    , context{other.context}
+    , context(Context::createCopy(other.context))
     , pool{createPool(configuration)}
     , load_all_query{other.load_all_query}
 {
-    context.makeQueryContext();
+    context->makeQueryContext();
 }
 
 std::string ClickHouseDictionarySource::getUpdateFieldAndDate()
@@ -172,7 +172,7 @@ std::string ClickHouseDictionarySource::doInvalidateQuery(const std::string & re
     LOG_TRACE(log, "Performing invalidate query");
     if (configuration.is_local)
     {
-        Context query_context = context;
+        auto query_context = Context::createCopy(context);
         auto input_block = executeQuery(request, query_context, true).getInputStream();
         return readInvalidateQuery(*input_block);
     }
@@ -191,12 +191,12 @@ void registerDictionarySourceClickHouse(DictionarySourceFactory & factory)
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
-                                 const Context & context,
+                                 ContextPtr context,
                                  const std::string & default_database [[maybe_unused]],
                                  bool /* check_config */) -> DictionarySourcePtr
     {
         bool secure = config.getBool(config_prefix + ".secure", false);
-        Context context_copy = context;
+        auto context_copy = Context::createCopy(context);
 
         UInt16 default_port = getPortFromContext(context_copy, secure);
 
@@ -221,7 +221,7 @@ void registerDictionarySourceClickHouse(DictionarySourceFactory & factory)
         /// We should set user info even for the case when the dictionary is loaded in-process (without TCP communication).
         if (configuration.is_local)
         {
-            context_copy.setUser(configuration.user, configuration.password, Poco::Net::SocketAddress("127.0.0.1", 0));
+            context_copy->setUser(configuration.user, configuration.password, Poco::Net::SocketAddress("127.0.0.1", 0));
             context_copy = copyContextAndApplySettings(config_prefix, context_copy, config);
         }
 
diff --git a/src/Dictionaries/ClickHouseDictionarySource.h b/src/Dictionaries/ClickHouseDictionarySource.h
index ac615848b49..21c290ab23b 100644
--- a/src/Dictionaries/ClickHouseDictionarySource.h
+++ b/src/Dictionaries/ClickHouseDictionarySource.h
@@ -37,7 +37,7 @@ public:
         const DictionaryStructure & dict_struct_,
         const Configuration & configuration_,
         const Block & sample_block_,
-        const Context & context);
+        ContextPtr context);
 
     /// copy-constructor is provided in order to support cloneability
     ClickHouseDictionarySource(const ClickHouseDictionarySource & other);
@@ -77,7 +77,7 @@ private:
     mutable std::string invalidate_query_response;
     ExternalQueryBuilder query_builder;
     Block sample_block;
-    Context context;
+    ContextPtr context;
     ConnectionPoolWithFailoverPtr pool;
     const std::string load_all_query;
     Poco::Logger * log = &Poco::Logger::get("ClickHouseDictionarySource");
diff --git a/src/Dictionaries/DictionaryFactory.cpp b/src/Dictionaries/DictionaryFactory.cpp
index 0ab7d199186..413bbd4f967 100644
--- a/src/Dictionaries/DictionaryFactory.cpp
+++ b/src/Dictionaries/DictionaryFactory.cpp
@@ -20,7 +20,7 @@ namespace ErrorCodes
 void DictionaryFactory::registerLayout(const std::string & layout_type, Creator create_layout, bool is_complex)
 {
     if (!registered_layouts.emplace(layout_type, std::move(create_layout)).second)
-        throw Exception("DictionaryFactory: the layout name '" + layout_type + "' is not unique", ErrorCodes::LOGICAL_ERROR);
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "DictionaryFactory: the layout name '{}' is not unique", layout_type);
 
     layout_complexity[layout_type] = is_complex;
 
@@ -31,15 +31,16 @@ DictionaryPtr DictionaryFactory::create(
     const std::string & name,
     const Poco::Util::AbstractConfiguration & config,
     const std::string & config_prefix,
-    const Context & context,
+    ContextPtr context,
     bool check_source_config) const
 {
     Poco::Util::AbstractConfiguration::Keys keys;
     const auto & layout_prefix = config_prefix + ".layout";
     config.keys(layout_prefix, keys);
     if (keys.size() != 1)
-        throw Exception{name + ": element dictionary.layout should have exactly one child element",
-                        ErrorCodes::EXCESSIVE_ELEMENT_IN_CONFIG};
+        throw Exception(ErrorCodes::EXCESSIVE_ELEMENT_IN_CONFIG,
+            "{}: element dictionary.layout should have exactly one child element",
+            name);
 
     const DictionaryStructure dict_struct{config, config_prefix};
 
@@ -47,8 +48,8 @@ DictionaryPtr DictionaryFactory::create(
         name, config, config_prefix + ".source", dict_struct, context, config.getString(config_prefix + ".database", ""), check_source_config);
     LOG_TRACE(&Poco::Logger::get("DictionaryFactory"), "Created dictionary source '{}' for dictionary '{}'", source_ptr->toString(), name);
 
-    if (context.hasQueryContext() && context.getSettingsRef().log_queries)
-        context.getQueryContext().addQueryFactoriesInfo(Context::QueryLogFactories::Dictionary, name);
+    if (context->hasQueryContext() && context->getSettingsRef().log_queries)
+        context->getQueryContext()->addQueryFactoriesInfo(Context::QueryLogFactories::Dictionary, name);
 
     const auto & layout_type = keys.front();
 
@@ -61,10 +62,13 @@ DictionaryPtr DictionaryFactory::create(
         }
     }
 
-    throw Exception{name + ": unknown dictionary layout type: " + layout_type, ErrorCodes::UNKNOWN_ELEMENT_IN_CONFIG};
+    throw Exception(ErrorCodes::UNKNOWN_ELEMENT_IN_CONFIG,
+        "{}: unknown dictionary layout type: {}",
+        name,
+        layout_type);
 }
 
-DictionaryPtr DictionaryFactory::create(const std::string & name, const ASTCreateQuery & ast, const Context & context) const
+DictionaryPtr DictionaryFactory::create(const std::string & name, const ASTCreateQuery & ast, ContextPtr context) const
 {
     auto configuration = getDictionaryConfigurationFromAST(ast, context);
     return DictionaryFactory::create(name, *configuration, "dictionary", context, true);
@@ -77,7 +81,9 @@ bool DictionaryFactory::isComplex(const std::string & layout_type) const
     if (found != layout_complexity.end())
         return found->second;
 
-    throw Exception{"Unknown dictionary layout type: " + layout_type, ErrorCodes::UNKNOWN_ELEMENT_IN_CONFIG};
+    throw Exception(ErrorCodes::UNKNOWN_ELEMENT_IN_CONFIG,
+        "Unknown dictionary layout type: {}",
+        layout_type);
 }
 
 
diff --git a/src/Dictionaries/DictionaryFactory.h b/src/Dictionaries/DictionaryFactory.h
index 3d3f793e2b2..b869550a9af 100644
--- a/src/Dictionaries/DictionaryFactory.h
+++ b/src/Dictionaries/DictionaryFactory.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
 #include "IDictionary.h"
 #include "registerDictionaries.h"
 #include <Parsers/ASTCreateQuery.h>
@@ -21,8 +22,6 @@ class Logger;
 namespace DB
 {
 
-class Context;
-
 /** Create dictionary according to its layout.
   */
 class DictionaryFactory : private boost::noncopyable
@@ -37,13 +36,13 @@ public:
         const std::string & name,
         const Poco::Util::AbstractConfiguration & config,
         const std::string & config_prefix,
-        const Context & context,
+        ContextPtr context,
         bool check_source_config = false) const;
 
     /// Create dictionary from DDL-query
     DictionaryPtr create(const std::string & name,
         const ASTCreateQuery & ast,
-        const Context & context) const;
+        ContextPtr context) const;
 
     using Creator = std::function<DictionaryPtr(
         const std::string & name,
diff --git a/src/Dictionaries/DictionaryHelpers.h b/src/Dictionaries/DictionaryHelpers.h
index 3e7063bb9ef..e4406c9a22b 100644
--- a/src/Dictionaries/DictionaryHelpers.h
+++ b/src/Dictionaries/DictionaryHelpers.h
@@ -1,11 +1,14 @@
 #pragma once
 
 #include <Common/Arena.h>
+#include <Common/HashTable/HashMap.h>
 #include <Columns/IColumn.h>
 #include <Columns/ColumnDecimal.h>
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnVector.h>
+#include <DataStreams/IBlockInputStream.h>
 #include <DataTypes/DataTypesDecimal.h>
+#include <Core/Block.h>
 #include <Dictionaries/IDictionary.h>
 #include <Dictionaries/DictionaryStructure.h>
 
@@ -60,7 +63,11 @@ private:
 class DictionaryStorageFetchRequest
 {
 public:
-    DictionaryStorageFetchRequest(const DictionaryStructure & structure, const Strings & attributes_names_to_fetch, Columns attributes_default_values_columns)
+    DictionaryStorageFetchRequest(
+        const DictionaryStructure & structure,
+        const Strings & attributes_names_to_fetch,
+        DataTypes attributes_to_fetch_result_types,
+        Columns attributes_default_values_columns)
         : attributes_to_fetch_names_set(attributes_names_to_fetch.begin(), attributes_names_to_fetch.end())
         , attributes_to_fetch_filter(structure.attributes.size(), false)
     {
@@ -73,7 +80,7 @@ public:
         dictionary_attributes_types.reserve(attributes_size);
         attributes_default_value_providers.reserve(attributes_to_fetch_names_set.size());
 
-        size_t default_values_column_index = 0;
+        size_t attributes_to_fetch_index = 0;
         for (size_t i = 0; i < attributes_size; ++i)
         {
             const auto & dictionary_attribute = structure.attributes[i];
@@ -84,8 +91,16 @@ public:
             if (attributes_to_fetch_names_set.find(name) != attributes_to_fetch_names_set.end())
             {
                 attributes_to_fetch_filter[i] = true;
-                attributes_default_value_providers.emplace_back(dictionary_attribute.null_value, attributes_default_values_columns[default_values_column_index]);
-                ++default_values_column_index;
+                auto & attribute_to_fetch_result_type = attributes_to_fetch_result_types[attributes_to_fetch_index];
+
+                if (!attribute_to_fetch_result_type->equals(*type))
+                    throw Exception(ErrorCodes::TYPE_MISMATCH,
+                    "Attribute type does not match, expected ({}), found ({})",
+                    attribute_to_fetch_result_type->getName(),
+                    type->getName());
+
+                attributes_default_value_providers.emplace_back(dictionary_attribute.null_value, attributes_default_values_columns[attributes_to_fetch_index]);
+                ++attributes_to_fetch_index;
             }
             else
                 attributes_default_value_providers.emplace_back(dictionary_attribute.null_value);
@@ -236,7 +251,7 @@ public:
         else if constexpr (IsNumber<DictionaryAttributeType>)
             return ColumnType::create(size);
         else
-            throw Exception{"Unsupported attribute type.", ErrorCodes::TYPE_MISMATCH};
+            throw Exception(ErrorCodes::TYPE_MISMATCH, "Unsupported attribute type.");
     }
 };
 
@@ -273,7 +288,7 @@ public:
                 use_default_value_from_column = false;
             }
             else
-                throw Exception{"Type of default column is not the same as dictionary attribute type.", ErrorCodes::TYPE_MISMATCH};
+                throw Exception(ErrorCodes::TYPE_MISMATCH, "Type of default column is not the same as dictionary attribute type.");
         }
     }
 
@@ -416,6 +431,105 @@ private:
     Arena * complex_key_arena;
 };
 
+/** Merge block with blocks from stream. If there are duplicate keys in block they are filtered out.
+  * In result block_to_update will be merged with blocks from stream.
+  * Note: readPrefix readImpl readSuffix will be called on stream object during function execution.
+  */
+template <DictionaryKeyType dictionary_key_type>
+void mergeBlockWithStream(
+    size_t key_column_size [[maybe_unused]],
+    Block & block_to_update [[maybe_unused]],
+    BlockInputStreamPtr & stream [[maybe_unused]])
+{
+    using KeyType = std::conditional_t<dictionary_key_type == DictionaryKeyType::simple, UInt64, StringRef>;
+    static_assert(dictionary_key_type != DictionaryKeyType::range, "Range key type is not supported by updatePreviousyLoadedBlockWithStream");
+
+    Columns saved_block_key_columns;
+    saved_block_key_columns.reserve(key_column_size);
+
+    /// Split into keys columns and attribute columns
+    for (size_t i = 0; i < key_column_size; ++i)
+        saved_block_key_columns.emplace_back(block_to_update.safeGetByPosition(i).column);
+
+    DictionaryKeysArenaHolder<dictionary_key_type> arena_holder;
+    DictionaryKeysExtractor<dictionary_key_type> saved_keys_extractor(saved_block_key_columns, arena_holder.getComplexKeyArena());
+    auto saved_keys_extracted_from_block = saved_keys_extractor.extractAllKeys();
+
+    IColumn::Filter filter(saved_keys_extracted_from_block.size(), true);
+
+    HashMap<KeyType, size_t> saved_key_to_index;
+    saved_key_to_index.reserve(saved_keys_extracted_from_block.size());
+
+    size_t indexes_to_remove_count = 0;
+
+    for (size_t i = 0; i < saved_keys_extracted_from_block.size(); ++i)
+    {
+        auto saved_key = saved_keys_extracted_from_block[i];
+        auto [it, was_inserted] = saved_key_to_index.insert(makePairNoInit(saved_key, i));
+
+        if (!was_inserted)
+        {
+            size_t index_to_remove = it->getMapped();
+            filter[index_to_remove] = false;
+            it->getMapped() = i;
+            ++indexes_to_remove_count;
+        }
+    }
+
+    auto result_fetched_columns = block_to_update.cloneEmptyColumns();
+
+    stream->readPrefix();
+
+    while (Block block = stream->read())
+    {
+        Columns block_key_columns;
+        block_key_columns.reserve(key_column_size);
+
+        /// Split into keys columns and attribute columns
+        for (size_t i = 0; i < key_column_size; ++i)
+            block_key_columns.emplace_back(block.safeGetByPosition(i).column);
+
+        DictionaryKeysExtractor<dictionary_key_type> update_keys_extractor(block_key_columns, arena_holder.getComplexKeyArena());
+        PaddedPODArray<KeyType> update_keys = update_keys_extractor.extractAllKeys();
+
+        for (auto update_key : update_keys)
+        {
+            const auto * it = saved_key_to_index.find(update_key);
+            if (it != nullptr)
+            {
+                size_t index_to_filter = it->getMapped();
+                filter[index_to_filter] = false;
+                ++indexes_to_remove_count;
+            }
+        }
+
+        size_t rows = block.rows();
+
+        for (size_t column_index = 0; column_index < block.columns(); ++column_index)
+        {
+            const auto update_column = block.safeGetByPosition(column_index).column;
+            MutableColumnPtr & result_fetched_column = result_fetched_columns[column_index];
+
+            result_fetched_column->insertRangeFrom(*update_column, 0, rows);
+        }
+    }
+
+    stream->readSuffix();
+
+    size_t result_fetched_rows = result_fetched_columns.front()->size();
+    size_t filter_hint = filter.size() - indexes_to_remove_count;
+
+    for (size_t column_index = 0; column_index < block_to_update.columns(); ++column_index)
+    {
+        auto & column = block_to_update.getByPosition(column_index).column;
+        column = column->filter(filter, filter_hint);
+
+        MutableColumnPtr mutable_column = column->assumeMutable();
+        const IColumn & fetched_column = *result_fetched_columns[column_index];
+        mutable_column->insertRangeFrom(fetched_column, 0, result_fetched_rows);
+    }
+}
+
 /**
  * Returns ColumnVector data as PaddedPodArray.
 
@@ -434,10 +548,10 @@ static const PaddedPODArray<T> & getColumnVectorData(
 
     if (!vector_col)
     {
-        throw Exception{ErrorCodes::TYPE_MISMATCH,
+        throw Exception(ErrorCodes::TYPE_MISMATCH,
             "{}: type mismatch: column has wrong type expected {}",
             dictionary->getDictionaryID().getNameForLogs(),
-            TypeName<T>::get()};
+            TypeName<T>::get());
     }
 
     if (is_const_column)
diff --git a/src/Dictionaries/DictionarySourceFactory.cpp b/src/Dictionaries/DictionarySourceFactory.cpp
index af3552364ba..50ba6405074 100644
--- a/src/Dictionaries/DictionarySourceFactory.cpp
+++ b/src/Dictionaries/DictionarySourceFactory.cpp
@@ -71,7 +71,7 @@ DictionarySourceFactory::DictionarySourceFactory() : log(&Poco::Logger::get("Dic
 void DictionarySourceFactory::registerSource(const std::string & source_type, Creator create_source)
 {
     if (!registered_sources.emplace(source_type, std::move(create_source)).second)
-        throw Exception("DictionarySourceFactory: the source name '" + source_type + "' is not unique", ErrorCodes::LOGICAL_ERROR);
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "DictionarySourceFactory: the source name '{}' is not unique", source_type);
 }
 
 DictionarySourcePtr DictionarySourceFactory::create(
@@ -79,7 +79,7 @@ DictionarySourcePtr DictionarySourceFactory::create(
     const Poco::Util::AbstractConfiguration & config,
     const std::string & config_prefix,
     const DictionaryStructure & dict_struct,
-    const Context & context,
+    ContextPtr context,
     const std::string & default_database,
     bool check_config) const
 {
@@ -87,8 +87,9 @@ DictionarySourcePtr DictionarySourceFactory::create(
     config.keys(config_prefix, keys);
 
     if (keys.empty() || keys.size() > 2)
-        throw Exception{name + ": element dictionary.source should have one or two child elements",
-                        ErrorCodes::EXCESSIVE_ELEMENT_IN_CONFIG};
+        throw Exception(ErrorCodes::EXCESSIVE_ELEMENT_IN_CONFIG,
+            "{}: element dictionary.source should have one or two child elements",
+            name);
 
     const std::string & source_type = keys.front() == "settings" ? keys.back() : keys.front();
 
@@ -100,7 +101,10 @@ DictionarySourcePtr DictionarySourceFactory::create(
         return create_source(dict_struct, config, config_prefix, sample_block, context, default_database, check_config);
     }
 
-    throw Exception{name + ": unknown dictionary source type: " + source_type, ErrorCodes::UNKNOWN_ELEMENT_IN_CONFIG};
+    throw Exception(ErrorCodes::UNKNOWN_ELEMENT_IN_CONFIG,
+        "{}: unknown dictionary source type: {}",
+        name,
+        source_type);
 }
 
 DictionarySourceFactory & DictionarySourceFactory::instance()
diff --git a/src/Dictionaries/DictionarySourceFactory.h b/src/Dictionaries/DictionarySourceFactory.h
index 1406660dfb4..bb583927ac4 100644
--- a/src/Dictionaries/DictionarySourceFactory.h
+++ b/src/Dictionaries/DictionarySourceFactory.h
@@ -2,6 +2,7 @@
 
 #include "IDictionarySource.h"
 #include <Core/Block.h>
+#include <Interpreters/Context_fwd.h>
 
 #include <unordered_map>
 
@@ -17,7 +18,7 @@ class Logger;
 
 namespace DB
 {
-class Context;
+
 struct DictionaryStructure;
 
 /// creates IDictionarySource instance from config and DictionaryStructure
@@ -34,7 +35,7 @@ public:
         const Poco::Util::AbstractConfiguration & config,
         const std::string & config_prefix,
         Block & sample_block,
-        const Context & context,
+        ContextPtr context,
         const std::string & default_database,
         bool check_config)>;
 
@@ -47,7 +48,7 @@ public:
         const Poco::Util::AbstractConfiguration & config,
         const std::string & config_prefix,
         const DictionaryStructure & dict_struct,
-        const Context & context,
+        ContextPtr context,
         const std::string & default_database,
         bool check_config) const;
 
diff --git a/src/Dictionaries/DictionarySourceHelpers.cpp b/src/Dictionaries/DictionarySourceHelpers.cpp
index 64527a78e8e..e175c6c3eae 100644
--- a/src/Dictionaries/DictionarySourceHelpers.cpp
+++ b/src/Dictionaries/DictionarySourceHelpers.cpp
@@ -67,12 +67,12 @@ Block blockForKeys(
     return block;
 }
 
-Context copyContextAndApplySettings(
+ContextPtr copyContextAndApplySettings(
     const std::string & config_prefix,
-    const Context & context,
+    ContextPtr context,
     const Poco::Util::AbstractConfiguration & config)
 {
-    Context local_context(context);
+    auto local_context = Context::createCopy(context);
     if (config.has(config_prefix + ".settings"))
     {
         const auto prefix = config_prefix + ".settings";
@@ -88,7 +88,7 @@ Context copyContextAndApplySettings(
             changes.emplace_back(key, value);
         }
 
-        local_context.applySettingsChanges(changes);
+        local_context->applySettingsChanges(changes);
     }
     return local_context;
 }
@@ -125,9 +125,8 @@ Block BlockInputStreamWithAdditionalColumns::readImpl()
         auto cut_block = block_to_add.cloneWithCutColumns(current_range_index, block_rows);
 
         if (cut_block.rows() != block_rows)
-            throw Exception(
-                "Number of rows in block to add after cut must equal to number of rows in block from inner stream",
-                ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
+            throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH,
+                "Number of rows in block to add after cut must equal to number of rows in block from inner stream");
 
         for (Int64 i = static_cast<Int64>(cut_block.columns() - 1); i >= 0; --i)
             block.insert(0, cut_block.getByPosition(i));
diff --git a/src/Dictionaries/DictionarySourceHelpers.h b/src/Dictionaries/DictionarySourceHelpers.h
index b429136a981..1febf921e07 100644
--- a/src/Dictionaries/DictionarySourceHelpers.h
+++ b/src/Dictionaries/DictionarySourceHelpers.h
@@ -9,6 +9,7 @@
 #include <DataStreams/IBlockInputStream.h>
 #include <Columns/IColumn.h>
 #include <Core/Block.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
@@ -17,7 +18,6 @@ class IBlockOutputStream;
 using BlockOutputStreamPtr = std::shared_ptr<IBlockOutputStream>;
 
 struct DictionaryStructure;
-class Context;
 
 /// Write keys to block output stream.
 
@@ -37,14 +37,14 @@ Block blockForKeys(
     const std::vector<size_t> & requested_rows);
 
 /// Used for applying settings to copied context in some register[...]Source functions
-Context copyContextAndApplySettings(
+ContextPtr copyContextAndApplySettings(
     const std::string & config_prefix,
-    const Context & context,
+    ContextPtr context,
     const Poco::Util::AbstractConfiguration & config);
 
 void applySettingsToContext(
     const std::string & config_prefix,
-    Context & context,
+    ContextPtr context,
     const Poco::Util::AbstractConfiguration & config);
 
 /** A stream, adds additional columns to each block that it will read from inner stream.
diff --git a/src/Dictionaries/DictionaryStructure.cpp b/src/Dictionaries/DictionaryStructure.cpp
index 806ee0b80e0..dd53e31041b 100644
--- a/src/Dictionaries/DictionaryStructure.cpp
+++ b/src/Dictionaries/DictionaryStructure.cpp
@@ -33,7 +33,7 @@ namespace
         const auto expression = config.getString(config_prefix + ".expression", "");
 
         if (name.empty() && !expression.empty())
-            throw Exception{"Element " + config_prefix + ".name is empty", ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Element {}.name is empty");
 
         const auto type_name = config.getString(config_prefix + ".type", default_type);
         return DictionaryTypedSpecialAttribute{std::move(name), std::move(expression), DataTypeFactory::instance().get(type_name)};
@@ -65,6 +65,7 @@ AttributeUnderlyingType getAttributeUnderlyingType(const DataTypePtr & type)
         case TypeIndex::Decimal32:      return AttributeUnderlyingType::utDecimal32;
         case TypeIndex::Decimal64:      return AttributeUnderlyingType::utDecimal64;
         case TypeIndex::Decimal128:     return AttributeUnderlyingType::utDecimal128;
+        case TypeIndex::Decimal256:     return AttributeUnderlyingType::utDecimal256;
 
         case TypeIndex::Date:           return AttributeUnderlyingType::utUInt16;
         case TypeIndex::DateTime:       return AttributeUnderlyingType::utUInt32;
@@ -81,11 +82,11 @@ AttributeUnderlyingType getAttributeUnderlyingType(const DataTypePtr & type)
         default: break;
     }
 
-    throw Exception{"Unknown type for dictionary" + type->getName(), ErrorCodes::UNKNOWN_TYPE};
+    throw Exception(ErrorCodes::UNKNOWN_TYPE, "Unknown type {} for dictionary attribute", type->getName());
 }
 
 
-std::string toString(const AttributeUnderlyingType type)
+std::string toString(AttributeUnderlyingType type)
 {
     switch (type)
     {
@@ -117,11 +118,13 @@ std::string toString(const AttributeUnderlyingType type)
             return "Decimal64";
         case AttributeUnderlyingType::utDecimal128:
             return "Decimal128";
+        case AttributeUnderlyingType::utDecimal256:
+            return "Decimal256";
         case AttributeUnderlyingType::utString:
             return "String";
     }
 
-    throw Exception{"Unknown attribute_type " + toString(static_cast<int>(type)), ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+    throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Unknown dictionary attribute type {}", toString(static_cast<int>(type)));
 }
 
 
@@ -129,7 +132,7 @@ DictionarySpecialAttribute::DictionarySpecialAttribute(const Poco::Util::Abstrac
     : name{config.getString(config_prefix + ".name", "")}, expression{config.getString(config_prefix + ".expression", "")}
 {
     if (name.empty() && !expression.empty())
-        throw Exception{"Element " + config_prefix + ".name is empty", ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Element {}.name is empty", config_prefix);
 }
 
 
@@ -141,7 +144,7 @@ DictionaryStructure::DictionaryStructure(const Poco::Util::AbstractConfiguration
     const auto has_key = config.has(structure_prefix + ".key");
 
     if (has_key && has_id)
-        throw Exception{"Only one of 'id' and 'key' should be specified", ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Only one of 'id' and 'key' should be specified");
 
     if (has_id)
         id.emplace(config, structure_prefix + ".id");
@@ -149,15 +152,15 @@ DictionaryStructure::DictionaryStructure(const Poco::Util::AbstractConfiguration
     {
         key.emplace(getAttributes(config, structure_prefix + ".key", true));
         if (key->empty())
-            throw Exception{"Empty 'key' supplied", ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Empty 'key' supplied");
     }
     else
-        throw Exception{"Dictionary structure should specify either 'id' or 'key'", ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Dictionary structure should specify either 'id' or 'key'");
 
     if (id)
     {
         if (id->name.empty())
-            throw Exception{"'id' cannot be empty", ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "'id' cannot be empty");
 
         const char * range_default_type = "Date";
         if (config.has(structure_prefix + ".range_min"))
@@ -168,28 +171,27 @@ DictionaryStructure::DictionaryStructure(const Poco::Util::AbstractConfiguration
 
         if (range_min.has_value() != range_max.has_value())
         {
-            throw Exception{"Dictionary structure should have both 'range_min' and 'range_max' either specified or not.",
-                            ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                "Dictionary structure should have both 'range_min' and 'range_max' either specified or not.");
         }
 
         if (range_min && range_max && !range_min->type->equals(*range_max->type))
         {
-            throw Exception{"Dictionary structure 'range_min' and 'range_max' should have same type, "
-                            "'range_min' type: "
-                                + range_min->type->getName()
-                                + ", "
-                                  "'range_max' type: "
-                                + range_max->type->getName(),
-                            ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                "Dictionary structure 'range_min' and 'range_max' should have same type, "
+                "'range_min' type: {},"
+                "'range_max' type: {}",
+                range_min->type->getName(),
+                range_max->type->getName());
         }
 
         if (range_min)
         {
             if (!range_min->type->isValueRepresentedByInteger())
-                throw Exception{"Dictionary structure type of 'range_min' and 'range_max' should be an integer, Date, DateTime, or Enum."
-                                " Actual 'range_min' and 'range_max' type is "
-                                    + range_min->type->getName(),
-                                ErrorCodes::BAD_ARGUMENTS};
+                throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                    "Dictionary structure type of 'range_min' and 'range_max' should be an integer, Date, DateTime, or Enum."
+                    " Actual 'range_min' and 'range_max' type is {}",
+                    range_min->type->getName());
         }
 
         if (!id->expression.empty() || (range_min && !range_min->expression.empty()) || (range_max && !range_max->expression.empty()))
@@ -208,8 +210,9 @@ DictionaryStructure::DictionaryStructure(const Poco::Util::AbstractConfiguration
         {
             if (id && attribute.underlying_type != AttributeUnderlyingType::utUInt64)
                 throw Exception(ErrorCodes::TYPE_MISMATCH,
-                    "Hierarchical attribute type for dictionary with simple key must be UInt64. Actual ({})",
+                    "Hierarchical attribute type for dictionary with simple key must be UInt64. Actual {}",
                     toString(attribute.underlying_type));
+
             else if (key)
                 throw Exception(ErrorCodes::BAD_ARGUMENTS, "Dictionary with complex key does not support hierarchy");
 
@@ -218,7 +221,7 @@ DictionaryStructure::DictionaryStructure(const Poco::Util::AbstractConfiguration
     }
 
     if (attributes.empty())
-        throw Exception{"Dictionary has no attributes defined", ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Dictionary has no attributes defined");
 
     if (config.getBool(config_prefix + ".layout.ip_trie.access_to_key_from_attributes", false))
         access_to_key_from_attributes = true;
@@ -228,7 +231,7 @@ DictionaryStructure::DictionaryStructure(const Poco::Util::AbstractConfiguration
 void DictionaryStructure::validateKeyTypes(const DataTypes & key_types) const
 {
     if (key_types.size() != key->size())
-        throw Exception{"Key structure does not match, expected " + getKeyDescription(), ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Key structure does not match, expected {}", getKeyDescription());
 
     for (const auto i : ext::range(0, key_types.size()))
     {
@@ -236,9 +239,11 @@ void DictionaryStructure::validateKeyTypes(const DataTypes & key_types) const
         const auto & actual_type = key_types[i];
 
         if (!areTypesEqual(expected_type, actual_type))
-            throw Exception{"Key type at position " + std::to_string(i) + " does not match, expected " + expected_type->getName() + ", found "
-                    + actual_type->getName(),
-                ErrorCodes::TYPE_MISMATCH};
+            throw Exception(ErrorCodes::TYPE_MISMATCH,
+            "Key type at position {} does not match, expected {}, found {}",
+            std::to_string(i),
+            expected_type->getName(),
+            actual_type->getName());
     }
 }
 
@@ -249,13 +254,13 @@ const DictionaryAttribute & DictionaryStructure::getAttribute(const std::string
     if (it == attribute_name_to_index.end())
     {
         if (!access_to_key_from_attributes)
-            throw Exception{"No such attribute '" + attribute_name + "'", ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "No such attribute '{}'", attribute_name);
 
         for (const auto & key_attribute : *key)
             if (key_attribute.name == attribute_name)
                 return key_attribute;
 
-        throw Exception{"No such attribute '" + attribute_name + "' in keys", ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "No such attribute '{}' in keys", attribute_name);
     }
 
     size_t attribute_index = it->second;
@@ -267,8 +272,10 @@ const DictionaryAttribute & DictionaryStructure::getAttribute(const std::string
     const auto & attribute = getAttribute(attribute_name);
 
     if (!areTypesEqual(attribute.type, type))
-        throw Exception{"Attribute type does not match, expected " + attribute.type->getName() + ", found " + type->getName(),
-            ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH,
+            "Attribute type does not match, expected {}, found {}",
+            attribute.type->getName(),
+            type->getName());
 
     return attribute;
 }
@@ -343,11 +350,10 @@ static void checkAttributeKeys(const Poco::Util::AbstractConfiguration::Keys & k
     for (const auto & key : keys)
     {
         if (valid_keys.find(key) == valid_keys.end())
-            throw Exception{"Unknown key '" + key + "' inside attribute section", ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unknown key '{}' inside attribute section", key);
     }
 }
 
-
 std::vector<DictionaryAttribute> DictionaryStructure::getAttributes(
     const Poco::Util::AbstractConfiguration & config,
     const std::string & config_prefix,
@@ -388,8 +394,7 @@ std::vector<DictionaryAttribute> DictionaryStructure::getAttributes(
         bool inserted = insert_result.second;
 
         if (!inserted)
-            throw Exception(
-                ErrorCodes::BAD_ARGUMENTS,
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
                 "Dictionary attributes names must be unique. Attribute name ({}) is not unique",
                 name);
 
@@ -442,13 +447,13 @@ std::vector<DictionaryAttribute> DictionaryStructure::getAttributes(
         const auto injective = config.getBool(prefix + "injective", false);
         const auto is_object_id = config.getBool(prefix + "is_object_id", false);
         if (name.empty())
-            throw Exception{"Properties 'name' and 'type' of an attribute cannot be empty", ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Properties 'name' and 'type' of an attribute cannot be empty");
 
         if (has_hierarchy && !hierarchy_allowed)
-            throw Exception{"Hierarchy not allowed in '" + prefix, ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Hierarchy not allowed in '{}'", prefix);
 
         if (has_hierarchy && hierarchical)
-            throw Exception{"Only one hierarchical attribute supported", ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Only one hierarchical attribute supported");
 
         has_hierarchy = has_hierarchy || hierarchical;
 
diff --git a/src/Dictionaries/DictionaryStructure.h b/src/Dictionaries/DictionaryStructure.h
index 4f03b4ff09e..ce5dd3dd422 100644
--- a/src/Dictionaries/DictionaryStructure.h
+++ b/src/Dictionaries/DictionaryStructure.h
@@ -32,13 +32,14 @@ enum class AttributeUnderlyingType
     utDecimal32,
     utDecimal64,
     utDecimal128,
+    utDecimal256,
     utString
 };
 
 
 AttributeUnderlyingType getAttributeUnderlyingType(const std::string & type);
 
-std::string toString(const AttributeUnderlyingType type);
+std::string toString(AttributeUnderlyingType type);
 
 /// Min and max lifetimes for a dictionary or it's entry
 using DictionaryLifetime = ExternalLoadableLifetime;
@@ -125,6 +126,9 @@ void callOnDictionaryAttributeType(AttributeUnderlyingType type, F&& func)
         case AttributeUnderlyingType::utDecimal128:
             func(DictionaryAttributeType<Decimal128>());
             break;
+        case AttributeUnderlyingType::utDecimal256:
+            func(DictionaryAttributeType<Decimal256>());
+            break;
     }
 };
 
diff --git a/src/Dictionaries/DirectDictionary.cpp b/src/Dictionaries/DirectDictionary.cpp
index 96ef259106a..0a3e685df1a 100644
--- a/src/Dictionaries/DirectDictionary.cpp
+++ b/src/Dictionaries/DirectDictionary.cpp
@@ -27,16 +27,16 @@ DirectDictionary<dictionary_key_type>::DirectDictionary(
     , source_ptr{std::move(source_ptr_)}
 {
     if (!source_ptr->supportsSelectiveLoad())
-        throw Exception{full_name + ": source cannot be used with DirectDictionary", ErrorCodes::UNSUPPORTED_METHOD};
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "{}: source cannot be used with DirectDictionary", full_name);
 }
 
 template <DictionaryKeyType dictionary_key_type>
-ColumnPtr DirectDictionary<dictionary_key_type>::getColumn(
-        const std::string & attribute_name,
-        const DataTypePtr & result_type,
-        const Columns & key_columns,
-        const DataTypes & key_types [[maybe_unused]],
-        const ColumnPtr & default_values_column) const
+Columns DirectDictionary<dictionary_key_type>::getColumns(
+    const Strings & attribute_names,
+    const DataTypes & result_types,
+    const Columns & key_columns,
+    const DataTypes & key_types [[maybe_unused]],
+    const Columns & default_values_columns) const
 {
     if constexpr (dictionary_key_type == DictionaryKeyType::complex)
         dict_struct.validateKeyTypes(key_types);
@@ -45,16 +45,14 @@ ColumnPtr DirectDictionary<dictionary_key_type>::getColumn(
     DictionaryKeysExtractor<dictionary_key_type> extractor(key_columns, arena_holder.getComplexKeyArena());
     const auto requested_keys = extractor.extractAllKeys();
 
-    const DictionaryAttribute & attribute = dict_struct.getAttribute(attribute_name, result_type);
-    DefaultValueProvider default_value_provider(attribute.null_value, default_values_column);
+    DictionaryStorageFetchRequest request(dict_struct, attribute_names, result_types, default_values_columns);
 
     HashMap<KeyType, size_t> key_to_fetched_index;
     key_to_fetched_index.reserve(requested_keys.size());
 
-    auto fetched_from_storage = attribute.type->createColumn();
+    auto fetched_columns_from_storage = request.makeAttributesResultColumns();
 
     size_t fetched_key_index = 0;
-    size_t requested_attribute_index = dict_struct.attribute_name_to_index.find(attribute_name)->second;
 
     Columns block_key_columns;
     size_t dictionary_keys_size = dict_struct.getKeysNames().size();
@@ -73,8 +71,14 @@ ColumnPtr DirectDictionary<dictionary_key_type>::getColumn(
         DictionaryKeysExtractor<dictionary_key_type> block_keys_extractor(block_key_columns, arena_holder.getComplexKeyArena());
         auto block_keys = block_keys_extractor.extractAllKeys();
 
-        const auto & block_column = block.safeGetByPosition(dictionary_keys_size + requested_attribute_index).column;
-        fetched_from_storage->insertRangeFrom(*block_column, 0, block_keys.size());
+        for (size_t attribute_index = 0; attribute_index < request.attributesSize(); ++attribute_index)
+        {
+            if (!request.shouldFillResultColumnWithIndex(attribute_index))
+                continue;
+
+            const auto & block_column = block.safeGetByPosition(dictionary_keys_size + attribute_index).column;
+            fetched_columns_from_storage[attribute_index]->insertRangeFrom(*block_column, 0, block_keys.size());
+        }
 
         for (size_t block_key_index = 0; block_key_index < block_keys.size(); ++block_key_index)
         {
@@ -92,29 +96,54 @@ ColumnPtr DirectDictionary<dictionary_key_type>::getColumn(
 
     size_t requested_keys_size = requested_keys.size();
 
-    auto result = fetched_from_storage->cloneEmpty();
-    result->reserve(requested_keys_size);
+    auto result_columns = request.makeAttributesResultColumns();
 
-    for (size_t requested_key_index = 0; requested_key_index < requested_keys_size; ++requested_key_index)
+    for (size_t attribute_index = 0; attribute_index < result_columns.size(); ++attribute_index)
     {
-        const auto requested_key = requested_keys[requested_key_index];
-        const auto * it = key_to_fetched_index.find(requested_key);
+        if (!request.shouldFillResultColumnWithIndex(attribute_index))
+            continue;
 
-        if (it)
-            fetched_from_storage->get(it->getMapped(), value_to_insert);
-        else
-            value_to_insert = default_value_provider.getDefaultValue(requested_key_index);
+        auto & result_column = result_columns[attribute_index];
 
-        result->insert(value_to_insert);
+        const auto & fetched_column_from_storage = fetched_columns_from_storage[attribute_index];
+        const auto & default_value_provider = request.defaultValueProviderAtIndex(attribute_index);
+
+        result_column->reserve(requested_keys_size);
+
+        for (size_t requested_key_index = 0; requested_key_index < requested_keys_size; ++requested_key_index)
+        {
+            const auto requested_key = requested_keys[requested_key_index];
+            const auto * it = key_to_fetched_index.find(requested_key);
+
+            if (it)
+                fetched_column_from_storage->get(it->getMapped(), value_to_insert);
+            else
+                value_to_insert = default_value_provider.getDefaultValue(requested_key_index);
+
+            result_column->insert(value_to_insert);
+        }
     }
 
     query_count.fetch_add(requested_keys_size, std::memory_order_relaxed);
 
-    return result;
+    return request.filterRequestedColumns(result_columns);
 }
 
 template <DictionaryKeyType dictionary_key_type>
-ColumnUInt8::Ptr DirectDictionary<dictionary_key_type>::hasKeys(const Columns & key_columns, const DataTypes & key_types [[maybe_unused]]) const
+ColumnPtr DirectDictionary<dictionary_key_type>::getColumn(
+    const std::string & attribute_name,
+    const DataTypePtr & result_type,
+    const Columns & key_columns,
+    const DataTypes & key_types,
+    const ColumnPtr & default_values_column) const
+{
+    return getColumns({ attribute_name }, { result_type }, key_columns, key_types, { default_values_column }).front();
+}
+
+template <DictionaryKeyType dictionary_key_type>
+ColumnUInt8::Ptr DirectDictionary<dictionary_key_type>::hasKeys(
+    const Columns & key_columns,
+    const DataTypes & key_types [[maybe_unused]]) const
 {
     if constexpr (dictionary_key_type == DictionaryKeyType::complex)
         dict_struct.validateKeyTypes(key_types);
@@ -261,20 +290,20 @@ namespace
         {
             if (dict_struct.key)
                 throw Exception(ErrorCodes::UNSUPPORTED_METHOD,
-                    "'key' is not supported for dictionary of layout '({})'",
+                    "'key' is not supported for dictionary of layout '{}'",
                     layout_name);
         }
         else
         {
             if (dict_struct.id)
                 throw Exception(ErrorCodes::UNSUPPORTED_METHOD,
-                    "'id' is not supported for dictionary of layout '({})'",
+                    "'id' is not supported for dictionary of layout '{}'",
                     layout_name);
         }
 
         if (dict_struct.range_min || dict_struct.range_max)
             throw Exception(ErrorCodes::BAD_ARGUMENTS,
-                "({}): elements .structure.range_min and .structure.range_max should be defined only " \
+                "{}: elements .structure.range_min and .structure.range_max should be defined only "
                 "for a dictionary of layout 'range_hashed'",
                 full_name);
 
@@ -282,7 +311,7 @@ namespace
 
         if (config.has(config_prefix + ".lifetime.min") || config.has(config_prefix + ".lifetime.max"))
             throw Exception(ErrorCodes::BAD_ARGUMENTS,
-                "'lifetime' parameter is redundant for the dictionary' of layout '({})'",
+                "'lifetime' parameter is redundant for the dictionary' of layout '{}'",
                 layout_name);
 
         return std::make_unique<DirectDictionary<dictionary_key_type>>(dict_id, dict_struct, std::move(source_ptr));
diff --git a/src/Dictionaries/DirectDictionary.h b/src/Dictionaries/DirectDictionary.h
index 6bca6ac6a18..e547e10433c 100644
--- a/src/Dictionaries/DirectDictionary.h
+++ b/src/Dictionaries/DirectDictionary.h
@@ -66,6 +66,13 @@ public:
 
     DictionaryKeyType getKeyType() const override { return dictionary_key_type; }
 
+    Columns getColumns(
+        const Strings & attribute_names,
+        const DataTypes & result_types,
+        const Columns & key_columns,
+        const DataTypes & key_types,
+        const Columns & default_values_columns) const override;
+
     ColumnPtr getColumn(
         const std::string& attribute_name,
         const DataTypePtr & result_type,
diff --git a/src/Dictionaries/ExecutableDictionarySource.cpp b/src/Dictionaries/ExecutableDictionarySource.cpp
index 8066de41b20..13feab2071a 100644
--- a/src/Dictionaries/ExecutableDictionarySource.cpp
+++ b/src/Dictionaries/ExecutableDictionarySource.cpp
@@ -62,7 +62,7 @@ ExecutableDictionarySource::ExecutableDictionarySource(
     const Poco::Util::AbstractConfiguration & config,
     const std::string & config_prefix,
     Block & sample_block_,
-    const Context & context_)
+    ContextPtr context_)
     : log(&Poco::Logger::get("ExecutableDictionarySource"))
     , dict_struct{dict_struct_}
     , implicit_key{config.getBool(config_prefix + ".implicit_key", false)}
@@ -97,25 +97,25 @@ ExecutableDictionarySource::ExecutableDictionarySource(const ExecutableDictionar
     , update_field{other.update_field}
     , format{other.format}
     , sample_block{other.sample_block}
-    , context(other.context)
+    , context(Context::createCopy(other.context))
 {
 }
 
 BlockInputStreamPtr ExecutableDictionarySource::loadAll()
 {
     if (implicit_key)
-        throw Exception("ExecutableDictionarySource with implicit_key does not support loadAll method", ErrorCodes::UNSUPPORTED_METHOD);
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "ExecutableDictionarySource with implicit_key does not support loadAll method");
 
     LOG_TRACE(log, "loadAll {}", toString());
     auto process = ShellCommand::execute(command);
-    auto input_stream = context.getInputFormat(format, process->out, sample_block, max_block_size);
+    auto input_stream = context->getInputFormat(format, process->out, sample_block, max_block_size);
     return std::make_shared<ShellCommandOwningBlockInputStream>(log, input_stream, std::move(process));
 }
 
 BlockInputStreamPtr ExecutableDictionarySource::loadUpdatedAll()
 {
     if (implicit_key)
-        throw Exception("ExecutableDictionarySource with implicit_key does not support loadUpdatedAll method", ErrorCodes::UNSUPPORTED_METHOD);
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "ExecutableDictionarySource with implicit_key does not support loadUpdatedAll method");
 
     time_t new_update_time = time(nullptr);
     SCOPE_EXIT(update_time = new_update_time);
@@ -126,7 +126,7 @@ BlockInputStreamPtr ExecutableDictionarySource::loadUpdatedAll()
 
     LOG_TRACE(log, "loadUpdatedAll {}", command_with_update_field);
     auto process = ShellCommand::execute(command_with_update_field);
-    auto input_stream = context.getInputFormat(format, process->out, sample_block, max_block_size);
+    auto input_stream = context->getInputFormat(format, process->out, sample_block, max_block_size);
     return std::make_shared<ShellCommandOwningBlockInputStream>(log, input_stream, std::move(process));
 }
 
@@ -139,7 +139,7 @@ namespace
     {
     public:
         BlockInputStreamWithBackgroundThread(
-            const Context & context,
+            ContextPtr context,
             const std::string & format,
             const Block & sample_block,
             const std::string & command_str,
@@ -150,7 +150,7 @@ namespace
             send_data(std::move(send_data_)),
             thread([this] { send_data(command->in); })
         {
-            stream = context.getInputFormat(format, command->out, sample_block, max_block_size);
+            stream = context->getInputFormat(format, command->out, sample_block, max_block_size);
         }
 
         ~BlockInputStreamWithBackgroundThread() override
@@ -222,7 +222,7 @@ BlockInputStreamPtr ExecutableDictionarySource::getStreamForBlock(const Block &
         context, format, sample_block, command, log,
         [block, this](WriteBufferFromFile & out) mutable
         {
-            auto output_stream = context.getOutputStream(format, out, block.cloneEmpty());
+            auto output_stream = context->getOutputStream(format, out, block.cloneEmpty());
             formatBlock(output_stream, block);
             out.close();
         });
@@ -264,7 +264,7 @@ void registerDictionarySourceExecutable(DictionarySourceFactory & factory)
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
-                                 const Context & context,
+                                 ContextPtr context,
                                  const std::string & /* default_database */,
                                  bool check_config) -> DictionarySourcePtr
     {
@@ -277,7 +277,7 @@ void registerDictionarySourceExecutable(DictionarySourceFactory & factory)
         if (check_config)
             throw Exception(ErrorCodes::DICTIONARY_ACCESS_DENIED, "Dictionaries with executable dictionary source are not allowed to be created from DDL query");
 
-        Context context_local_copy = copyContextAndApplySettings(config_prefix, context, config);
+        auto context_local_copy = copyContextAndApplySettings(config_prefix, context, config);
 
         return std::make_unique<ExecutableDictionarySource>(
             dict_struct, config, config_prefix + ".executable",
diff --git a/src/Dictionaries/ExecutableDictionarySource.h b/src/Dictionaries/ExecutableDictionarySource.h
index 9dc152bf580..878cb086873 100644
--- a/src/Dictionaries/ExecutableDictionarySource.h
+++ b/src/Dictionaries/ExecutableDictionarySource.h
@@ -20,7 +20,7 @@ public:
         const Poco::Util::AbstractConfiguration & config,
         const std::string & config_prefix,
         Block & sample_block_,
-        const Context & context_);
+        ContextPtr context_);
 
     ExecutableDictionarySource(const ExecutableDictionarySource & other);
     ExecutableDictionarySource & operator=(const ExecutableDictionarySource &) = delete;
@@ -58,7 +58,7 @@ private:
     const std::string update_field;
     const std::string format;
     Block sample_block;
-    Context context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Dictionaries/ExecutablePoolDictionarySource.cpp b/src/Dictionaries/ExecutablePoolDictionarySource.cpp
index 0c9ca4ce714..e920b8392d6 100644
--- a/src/Dictionaries/ExecutablePoolDictionarySource.cpp
+++ b/src/Dictionaries/ExecutablePoolDictionarySource.cpp
@@ -32,7 +32,7 @@ ExecutablePoolDictionarySource::ExecutablePoolDictionarySource(
     const DictionaryStructure & dict_struct_,
     const Configuration & configuration_,
     Block & sample_block_,
-    const Context & context_)
+    ContextPtr context_)
     : log(&Poco::Logger::get("ExecutablePoolDictionarySource"))
     , dict_struct{dict_struct_}
     , configuration{configuration_}
@@ -63,19 +63,19 @@ ExecutablePoolDictionarySource::ExecutablePoolDictionarySource(const ExecutableP
     , dict_struct{other.dict_struct}
     , configuration{other.configuration}
     , sample_block{other.sample_block}
-    , context{other.context}
+    , context{Context::createCopy(other.context)}
     , process_pool{std::make_shared<ProcessPool>(configuration.pool_size)}
 {
 }
 
 BlockInputStreamPtr ExecutablePoolDictionarySource::loadAll()
 {
-    throw Exception("ExecutablePoolDictionarySource with implicit_key does not support loadAll method", ErrorCodes::UNSUPPORTED_METHOD);
+    throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "ExecutablePoolDictionarySource with implicit_key does not support loadAll method");
 }
 
 BlockInputStreamPtr ExecutablePoolDictionarySource::loadUpdatedAll()
 {
-    throw Exception("ExecutablePoolDictionarySource with implicit_key does not support loadAll method", ErrorCodes::UNSUPPORTED_METHOD);
+    throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "ExecutablePoolDictionarySource with implicit_key does not support loadAll method");
 }
 
 namespace
@@ -226,13 +226,13 @@ BlockInputStreamPtr ExecutablePoolDictionarySource::getStreamForBlock(const Bloc
             configuration.max_command_execution_time);
 
     size_t rows_to_read = block.rows();
-    auto read_stream = context.getInputFormat(configuration.format, process->out, sample_block, rows_to_read);
+    auto read_stream = context->getInputFormat(configuration.format, process->out, sample_block, rows_to_read);
 
     auto stream = std::make_unique<PoolBlockInputStreamWithBackgroundThread>(
         process_pool, std::move(process), std::move(read_stream), rows_to_read, log,
         [block, this](WriteBufferFromFile & out) mutable
         {
-            auto output_stream = context.getOutputStream(configuration.format, out, block.cloneEmpty());
+            auto output_stream = context->getOutputStream(configuration.format, out, block.cloneEmpty());
             formatBlock(output_stream, block);
         });
 
@@ -273,7 +273,7 @@ void registerDictionarySourceExecutablePool(DictionarySourceFactory & factory)
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
-                                 const Context & context,
+                                 ContextPtr context,
                                  const std::string & /* default_database */,
                                  bool check_config) -> DictionarySourcePtr
     {
@@ -286,20 +286,20 @@ void registerDictionarySourceExecutablePool(DictionarySourceFactory & factory)
         if (check_config)
             throw Exception(ErrorCodes::DICTIONARY_ACCESS_DENIED, "Dictionaries with executable pool dictionary source are not allowed to be created from DDL query");
 
-        Context context_local_copy = copyContextAndApplySettings(config_prefix, context, config);
+        auto context_local_copy = copyContextAndApplySettings(config_prefix, context, config);
 
         /** Currently parallel parsing input format cannot read exactly max_block_size rows from input,
          *  so it will be blocked on ReadBufferFromFileDescriptor because this file descriptor represent pipe that does not have eof.
          */
-        auto settings_no_parallel_parsing = context_local_copy.getSettings();
+        auto settings_no_parallel_parsing = context_local_copy->getSettings();
         settings_no_parallel_parsing.input_format_parallel_parsing = false;
-        context_local_copy.setSettings(settings_no_parallel_parsing);
+        context_local_copy->setSettings(settings_no_parallel_parsing);
 
         String configuration_config_prefix = config_prefix + ".executable_pool";
 
         size_t max_command_execution_time = config.getUInt64(configuration_config_prefix + ".max_command_execution_time", 10);
 
-        size_t max_execution_time_seconds = static_cast<size_t>(context.getSettings().max_execution_time.totalSeconds());
+        size_t max_execution_time_seconds = static_cast<size_t>(context->getSettings().max_execution_time.totalSeconds());
         if (max_execution_time_seconds != 0 && max_command_execution_time > max_execution_time_seconds)
             max_command_execution_time = max_execution_time_seconds;
 
diff --git a/src/Dictionaries/ExecutablePoolDictionarySource.h b/src/Dictionaries/ExecutablePoolDictionarySource.h
index da75881b799..7f24e56257a 100644
--- a/src/Dictionaries/ExecutablePoolDictionarySource.h
+++ b/src/Dictionaries/ExecutablePoolDictionarySource.h
@@ -41,7 +41,7 @@ public:
         const DictionaryStructure & dict_struct_,
         const Configuration & configuration_,
         Block & sample_block_,
-        const Context & context_);
+        ContextPtr context_);
 
     ExecutablePoolDictionarySource(const ExecutablePoolDictionarySource & other);
     ExecutablePoolDictionarySource & operator=(const ExecutablePoolDictionarySource &) = delete;
@@ -77,7 +77,7 @@ private:
     const Configuration configuration;
 
     Block sample_block;
-    Context context;
+    ContextPtr context;
     std::shared_ptr<ProcessPool> process_pool;
 };
 
diff --git a/src/Dictionaries/ExternalQueryBuilder.cpp b/src/Dictionaries/ExternalQueryBuilder.cpp
index 454c918fd1f..8c6e9f60afb 100644
--- a/src/Dictionaries/ExternalQueryBuilder.cpp
+++ b/src/Dictionaries/ExternalQueryBuilder.cpp
@@ -173,7 +173,7 @@ std::string ExternalQueryBuilder::composeUpdateQuery(const std::string & update_
 std::string ExternalQueryBuilder::composeLoadIdsQuery(const std::vector<UInt64> & ids)
 {
     if (!dict_struct.id)
-        throw Exception{"Simple key required for method", ErrorCodes::UNSUPPORTED_METHOD};
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "Simple key required for method");
 
     WriteBufferFromOwnString out;
     writeString("SELECT ", out);
@@ -244,10 +244,10 @@ std::string ExternalQueryBuilder::composeLoadKeysQuery(
     const Columns & key_columns, const std::vector<size_t> & requested_rows, LoadKeysMethod method, size_t partition_key_prefix)
 {
     if (!dict_struct.key)
-        throw Exception{"Composite key required for method", ErrorCodes::UNSUPPORTED_METHOD};
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "Composite key required for method");
 
     if (key_columns.size() != dict_struct.key->size())
-        throw Exception{"The size of key_columns does not equal to the size of dictionary key", ErrorCodes::LOGICAL_ERROR};
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "The size of key_columns does not equal to the size of dictionary key");
 
     WriteBufferFromOwnString out;
     writeString("SELECT ", out);
@@ -386,7 +386,7 @@ void ExternalQueryBuilder::composeInWithTuples(const Columns & key_columns, cons
 void ExternalQueryBuilder::composeKeyTupleDefinition(WriteBuffer & out, size_t beg, size_t end) const
 {
     if (!dict_struct.key)
-        throw Exception{"Composite key required for method", ErrorCodes::UNSUPPORTED_METHOD};
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "Composite key required for method");
 
     writeChar('(', out);
 
diff --git a/src/Dictionaries/FileDictionarySource.cpp b/src/Dictionaries/FileDictionarySource.cpp
index addc2adef02..378c6f11857 100644
--- a/src/Dictionaries/FileDictionarySource.cpp
+++ b/src/Dictionaries/FileDictionarySource.cpp
@@ -1,8 +1,11 @@
 #include "FileDictionarySource.h"
+
+#include <Poco/File.h>
+#include <filesystem>
+
 #include <DataStreams/OwningBlockInputStream.h>
 #include <IO/ReadBufferFromFile.h>
 #include <Interpreters/Context.h>
-#include <Poco/File.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <common/logger_useful.h>
 #include "DictionarySourceFactory.h"
@@ -10,7 +13,6 @@
 #include "registerDictionaries.h"
 #include "DictionarySourceHelpers.h"
 
-
 namespace DB
 {
 static const UInt64 max_block_size = 8192;
@@ -24,7 +26,7 @@ namespace ErrorCodes
 
 FileDictionarySource::FileDictionarySource(
     const std::string & filepath_, const std::string & format_,
-    Block & sample_block_, const Context & context_, bool check_config)
+    Block & sample_block_, ContextPtr context_, bool check_config)
     : filepath{filepath_}
     , format{format_}
     , sample_block{sample_block_}
@@ -32,9 +34,19 @@ FileDictionarySource::FileDictionarySource(
 {
     if (check_config)
     {
-        const String user_files_path = context.getUserFilesPath();
-        if (!startsWith(filepath, user_files_path))
-            throw Exception(ErrorCodes::PATH_ACCESS_DENIED, "File path {} is not inside {}", filepath, user_files_path);
+        auto source_file_path = std::filesystem::path(filepath);
+        auto source_file_absolute_path = std::filesystem::canonical(source_file_path);
+
+        String user_files_path_string_value = context->getUserFilesPath();
+        auto user_files_path = std::filesystem::path(user_files_path_string_value);
+        auto user_files_absolute_path = std::filesystem::canonical(user_files_path);
+
+        auto [_, user_files_absolute_path_mismatch_it] = std::mismatch(source_file_absolute_path.begin(), source_file_absolute_path.end(), user_files_absolute_path.begin(), user_files_absolute_path.end());
+
+        bool user_files_absolute_path_include_source_file_absolute_path = user_files_absolute_path_mismatch_it == user_files_absolute_path.end();
+
+        if (!user_files_absolute_path_include_source_file_absolute_path)
+            throw Exception(ErrorCodes::PATH_ACCESS_DENIED, "File path {} is not inside {}", filepath, user_files_path_string_value);
     }
 }
 
@@ -43,7 +55,7 @@ FileDictionarySource::FileDictionarySource(const FileDictionarySource & other)
     : filepath{other.filepath}
     , format{other.format}
     , sample_block{other.sample_block}
-    , context(other.context)
+    , context(Context::createCopy(other.context))
     , last_modification{other.last_modification}
 {
 }
@@ -53,7 +65,7 @@ BlockInputStreamPtr FileDictionarySource::loadAll()
 {
     LOG_TRACE(&Poco::Logger::get("FileDictionary"), "loadAll {}", toString());
     auto in_ptr = std::make_unique<ReadBufferFromFile>(filepath);
-    auto stream = context.getInputFormat(format, *in_ptr, sample_block, max_block_size);
+    auto stream = context->getInputFormat(format, *in_ptr, sample_block, max_block_size);
     last_modification = getLastModification();
 
     return std::make_shared<OwningBlockInputStream<ReadBuffer>>(stream, std::move(in_ptr));
@@ -77,17 +89,17 @@ void registerDictionarySourceFile(DictionarySourceFactory & factory)
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
-                                 const Context & context,
+                                 ContextPtr context,
                                  const std::string & /* default_database */,
                                  bool check_config) -> DictionarySourcePtr
     {
         if (dict_struct.has_expressions)
-            throw Exception{"Dictionary source of type `file` does not support attribute expressions", ErrorCodes::LOGICAL_ERROR};
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Dictionary source of type `file` does not support attribute expressions");
 
         const auto filepath = config.getString(config_prefix + ".file.path");
         const auto format = config.getString(config_prefix + ".file.format");
 
-        Context context_local_copy = copyContextAndApplySettings(config_prefix, context, config);
+        auto context_local_copy = copyContextAndApplySettings(config_prefix, context, config);
 
         return std::make_unique<FileDictionarySource>(filepath, format, sample_block, context_local_copy, check_config);
     };
diff --git a/src/Dictionaries/FileDictionarySource.h b/src/Dictionaries/FileDictionarySource.h
index fa47b280911..6559503cccd 100644
--- a/src/Dictionaries/FileDictionarySource.h
+++ b/src/Dictionaries/FileDictionarySource.h
@@ -17,7 +17,7 @@ class FileDictionarySource final : public IDictionarySource
 {
 public:
     FileDictionarySource(const std::string & filepath_, const std::string & format_,
-        Block & sample_block_, const Context & context_, bool check_config);
+        Block & sample_block_, ContextPtr context_, bool check_config);
 
     FileDictionarySource(const FileDictionarySource & other);
 
@@ -25,17 +25,17 @@ public:
 
     BlockInputStreamPtr loadUpdatedAll() override
     {
-        throw Exception{"Method loadUpdatedAll is unsupported for FileDictionarySource", ErrorCodes::NOT_IMPLEMENTED};
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method loadUpdatedAll is unsupported for FileDictionarySource");
     }
 
     BlockInputStreamPtr loadIds(const std::vector<UInt64> & /*ids*/) override
     {
-        throw Exception{"Method loadIds is unsupported for FileDictionarySource", ErrorCodes::NOT_IMPLEMENTED};
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method loadIds is unsupported for FileDictionarySource");
     }
 
     BlockInputStreamPtr loadKeys(const Columns & /*key_columns*/, const std::vector<size_t> & /*requested_rows*/) override
     {
-        throw Exception{"Method loadKeys is unsupported for FileDictionarySource", ErrorCodes::NOT_IMPLEMENTED};
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method loadKeys is unsupported for FileDictionarySource");
     }
 
     bool isModified() const override
@@ -61,7 +61,7 @@ private:
     const std::string filepath;
     const std::string format;
     Block sample_block;
-    const Context context;
+    ContextPtr context;
     Poco::Timestamp last_modification;
 };
 
diff --git a/src/Dictionaries/FlatDictionary.cpp b/src/Dictionaries/FlatDictionary.cpp
index 2d8d208d76b..1540a3a876b 100644
--- a/src/Dictionaries/FlatDictionary.cpp
+++ b/src/Dictionaries/FlatDictionary.cpp
@@ -2,6 +2,7 @@
 
 #include <Core/Defines.h>
 #include <Common/HashTable/HashMap.h>
+#include <Common/HashTable/HashSet.h>
 
 #include <DataTypes/DataTypesDecimal.h>
 #include <IO/WriteHelpers.h>
@@ -23,23 +24,20 @@ namespace ErrorCodes
     extern const int UNSUPPORTED_METHOD;
 }
 
-static const auto initial_array_size = 1024;
-static const auto max_array_size = 500000;
-
 FlatDictionary::FlatDictionary(
     const StorageID & dict_id_,
     const DictionaryStructure & dict_struct_,
     DictionarySourcePtr source_ptr_,
     const DictionaryLifetime dict_lifetime_,
-    bool require_nonempty_,
-    BlockPtr saved_block_)
+    Configuration configuration_,
+    BlockPtr previously_loaded_block_)
     : IDictionary(dict_id_)
     , dict_struct(dict_struct_)
     , source_ptr{std::move(source_ptr_)}
     , dict_lifetime(dict_lifetime_)
-    , require_nonempty(require_nonempty_)
-    , loaded_ids(initial_array_size, false)
-    , saved_block{std::move(saved_block_)}
+    , configuration(configuration_)
+    , loaded_keys(configuration.initial_array_size, false)
+    , previously_loaded_block(std::move(previously_loaded_block_))
 {
     createAttributes();
     loadData();
@@ -126,20 +124,19 @@ ColumnPtr FlatDictionary::getColumn(
 ColumnUInt8::Ptr FlatDictionary::hasKeys(const Columns & key_columns, const DataTypes &) const
 {
     PaddedPODArray<UInt64> backup_storage;
-    const auto& ids = getColumnVectorData(this, key_columns.front(), backup_storage);
+    const auto & keys = getColumnVectorData(this, key_columns.front(), backup_storage);
+    size_t keys_size = keys.size();
 
-    auto result = ColumnUInt8::create(ext::size(ids));
-    auto& out = result->getData();
+    auto result = ColumnUInt8::create(keys_size);
+    auto & out = result->getData();
 
-    const auto ids_count = ext::size(ids);
-
-    for (const auto i : ext::range(0, ids_count))
+    for (size_t key_index = 0; key_index < keys_size; ++key_index)
     {
-        const auto id = ids[i];
-        out[i] = id < loaded_ids.size() && loaded_ids[id];
+        const auto key = keys[key_index];
+        out[key_index] = key < loaded_keys.size() && loaded_keys[key];
     }
 
-    query_count.fetch_add(ids_count, std::memory_order_relaxed);
+    query_count.fetch_add(keys_size, std::memory_order_relaxed);
 
     return result;
 }
@@ -153,22 +150,14 @@ ColumnPtr FlatDictionary::getHierarchy(ColumnPtr key_column, const DataTypePtr &
     const auto & hierarchical_attribute = attributes[hierarchical_attribute_index];
 
     const UInt64 null_value = std::get<UInt64>(hierarchical_attribute.null_values);
-    const ContainerType<UInt64> & parent_keys = std::get<ContainerType<UInt64>>(hierarchical_attribute.arrays);
+    const ContainerType<UInt64> & parent_keys = std::get<ContainerType<UInt64>>(hierarchical_attribute.container);
 
-    auto is_key_valid_func = [&, this](auto & key)
-    {
-        return key < loaded_ids.size() && loaded_ids[key];
-    };
+    auto is_key_valid_func = [&, this](auto & key) { return key < loaded_keys.size() && loaded_keys[key]; };
 
     auto get_parent_key_func = [&, this](auto & hierarchy_key)
     {
-        std::optional<UInt64> result;
-
-        if (hierarchy_key >= loaded_ids.size() || !loaded_ids[hierarchy_key])
-            return result;
-
-        result = parent_keys[hierarchy_key];
-
+        bool is_key_valid = hierarchy_key < loaded_keys.size() && loaded_keys[hierarchy_key];
+        std::optional<UInt64> result = is_key_valid ? std::make_optional(parent_keys[hierarchy_key]) : std::nullopt;
         return result;
     };
 
@@ -194,22 +183,14 @@ ColumnUInt8::Ptr FlatDictionary::isInHierarchy(
     const auto & hierarchical_attribute = attributes[hierarchical_attribute_index];
 
     const UInt64 null_value = std::get<UInt64>(hierarchical_attribute.null_values);
-    const ContainerType<UInt64> & parent_keys = std::get<ContainerType<UInt64>>(hierarchical_attribute.arrays);
+    const ContainerType<UInt64> & parent_keys = std::get<ContainerType<UInt64>>(hierarchical_attribute.container);
 
-    auto is_key_valid_func = [&, this](auto & key)
-    {
-        return key < loaded_ids.size() && loaded_ids[key];
-    };
+    auto is_key_valid_func = [&, this](auto & key) { return key < loaded_keys.size() && loaded_keys[key]; };
 
     auto get_parent_key_func = [&, this](auto & hierarchy_key)
     {
-        std::optional<UInt64> result;
-
-        if (hierarchy_key >= loaded_ids.size() || !loaded_ids[hierarchy_key])
-            return result;
-
-        result = parent_keys[hierarchy_key];
-
+        bool is_key_valid = hierarchy_key < loaded_keys.size() && loaded_keys[hierarchy_key];
+        std::optional<UInt64> result = is_key_valid ? std::make_optional(parent_keys[hierarchy_key]) : std::nullopt;
         return result;
     };
 
@@ -230,7 +211,7 @@ ColumnPtr FlatDictionary::getDescendants(
 
     size_t hierarchical_attribute_index = *dict_struct.hierarchical_attribute_index;
     const auto & hierarchical_attribute = attributes[hierarchical_attribute_index];
-    const ContainerType<UInt64> & parent_keys = std::get<ContainerType<UInt64>>(hierarchical_attribute.arrays);
+    const ContainerType<UInt64> & parent_keys = std::get<ContainerType<UInt64>>(hierarchical_attribute.container);
 
     HashMap<UInt64, PaddedPODArray<UInt64>> parent_to_child;
 
@@ -238,7 +219,7 @@ ColumnPtr FlatDictionary::getDescendants(
     {
         auto parent_key = parent_keys[i];
 
-        if (loaded_ids[i])
+        if (loaded_keys[i])
             parent_to_child[parent_key].emplace_back(static_cast<UInt64>(i));
     }
 
@@ -260,22 +241,39 @@ void FlatDictionary::createAttributes()
 
 void FlatDictionary::blockToAttributes(const Block & block)
 {
-    const IColumn & id_column = *block.safeGetByPosition(0).column;
-    element_count += id_column.size();
+    const auto keys_column = block.safeGetByPosition(0).column;
 
-    for (const size_t attribute_idx : ext::range(0, attributes.size()))
+    DictionaryKeysArenaHolder<DictionaryKeyType::simple> arena_holder;
+    DictionaryKeysExtractor<DictionaryKeyType::simple> keys_extractor({ keys_column }, arena_holder.getComplexKeyArena());
+    auto keys = keys_extractor.extractAllKeys();
+
+    HashSet<UInt64> already_processed_keys;
+
+    size_t key_offset = 1;
+    for (size_t attribute_index = 0; attribute_index < attributes.size(); ++attribute_index)
     {
-        const IColumn & attribute_column = *block.safeGetByPosition(attribute_idx + 1).column;
-        Attribute & attribute = attributes[attribute_idx];
+        const IColumn & attribute_column = *block.safeGetByPosition(attribute_index + key_offset).column;
+        Attribute & attribute = attributes[attribute_index];
 
-        for (const auto row_idx : ext::range(0, id_column.size()))
-            setAttributeValue(attribute, id_column[row_idx].get<UInt64>(), attribute_column[row_idx]);
+        for (size_t i = 0; i < keys.size(); ++i)
+        {
+            auto key = keys[i];
+
+            if (already_processed_keys.find(key) != nullptr)
+                continue;
+            already_processed_keys.insert(key);
+
+            setAttributeValue(attribute, key, attribute_column[i]);
+            ++element_count;
+        }
+
+        already_processed_keys.clear();
     }
 }
 
 void FlatDictionary::updateData()
 {
-    if (!saved_block || saved_block->rows() == 0)
+    if (!previously_loaded_block || previously_loaded_block->rows() == 0)
     {
         auto stream = source_ptr->loadUpdatedAll();
         stream->readPrefix();
@@ -283,12 +281,13 @@ void FlatDictionary::updateData()
         while (const auto block = stream->read())
         {
             /// We are using this to keep saved data if input stream consists of multiple blocks
-            if (!saved_block)
-                saved_block = std::make_shared<DB::Block>(block.cloneEmpty());
-            for (const auto attribute_idx : ext::range(0, attributes.size() + 1))
+            if (!previously_loaded_block)
+                previously_loaded_block = std::make_shared<DB::Block>(block.cloneEmpty());
+
+            for (size_t column_index = 0; column_index < block.columns(); ++column_index)
             {
-                const IColumn & update_column = *block.getByPosition(attribute_idx).column.get();
-                MutableColumnPtr saved_column = saved_block->getByPosition(attribute_idx).column->assumeMutable();
+                const IColumn & update_column = *block.getByPosition(column_index).column.get();
+                MutableColumnPtr saved_column = previously_loaded_block->getByPosition(column_index).column->assumeMutable();
                 saved_column->insertRangeFrom(update_column, 0, update_column.size());
             }
         }
@@ -297,51 +296,14 @@ void FlatDictionary::updateData()
     else
     {
         auto stream = source_ptr->loadUpdatedAll();
-        stream->readPrefix();
-
-        while (Block block = stream->read())
-        {
-            const auto & saved_id_column = *saved_block->safeGetByPosition(0).column;
-            const auto & update_id_column = *block.safeGetByPosition(0).column;
-
-            std::unordered_map<UInt64, std::vector<size_t>> update_ids;
-            for (size_t row = 0; row < update_id_column.size(); ++row)
-            {
-                const auto id = update_id_column.get64(row);
-                update_ids[id].push_back(row);
-            }
-
-            const size_t saved_rows = saved_id_column.size();
-            IColumn::Filter filter(saved_rows);
-            std::unordered_map<UInt64, std::vector<size_t>>::iterator it;
-
-            for (size_t row = 0; row < saved_id_column.size(); ++row)
-            {
-                auto id = saved_id_column.get64(row);
-                it = update_ids.find(id);
-
-                if (it != update_ids.end())
-                    filter[row] = 0;
-                else
-                    filter[row] = 1;
-            }
-
-            auto block_columns = block.mutateColumns();
-            for (const auto attribute_idx : ext::range(0, attributes.size() + 1))
-            {
-                auto & column = saved_block->safeGetByPosition(attribute_idx).column;
-                const auto & filtered_column = column->filter(filter, -1);
-
-                block_columns[attribute_idx]->insertRangeFrom(*filtered_column.get(), 0, filtered_column->size());
-            }
-
-            saved_block->setColumns(std::move(block_columns));
-        }
-        stream->readSuffix();
+        mergeBlockWithStream<DictionaryKeyType::simple>(
+            dict_struct.getKeysSize(),
+            *previously_loaded_block,
+            stream);
     }
 
-    if (saved_block)
-        blockToAttributes(*saved_block.get());
+    if (previously_loaded_block)
+        blockToAttributes(*previously_loaded_block.get());
 }
 
 void FlatDictionary::loadData()
@@ -359,26 +321,8 @@ void FlatDictionary::loadData()
     else
         updateData();
 
-    if (require_nonempty && 0 == element_count)
-        throw Exception{full_name + ": dictionary source is empty and 'require_nonempty' property is set.", ErrorCodes::DICTIONARY_IS_EMPTY};
-}
-
-
-template <typename T>
-void FlatDictionary::addAttributeSize(const Attribute & attribute)
-{
-    const auto & array_ref = std::get<ContainerType<T>>(attribute.arrays);
-    bytes_allocated += sizeof(PaddedPODArray<T>) + array_ref.allocated_bytes();
-    bucket_count = array_ref.capacity();
-}
-
-template <>
-void FlatDictionary::addAttributeSize<String>(const Attribute & attribute)
-{
-    const auto & array_ref = std::get<ContainerType<StringRef>>(attribute.arrays);
-    bytes_allocated += sizeof(PaddedPODArray<StringRef>) + array_ref.allocated_bytes();
-    bytes_allocated += sizeof(Arena) + attribute.string_arena->size();
-    bucket_count = array_ref.capacity();
+    if (configuration.require_nonempty && 0 == element_count)
+        throw Exception(ErrorCodes::DICTIONARY_IS_EMPTY, "{}: dictionary source is empty and 'require_nonempty' property is set.", full_name);
 }
 
 void FlatDictionary::calculateBytesAllocated()
@@ -391,102 +335,108 @@ void FlatDictionary::calculateBytesAllocated()
         {
             using Type = std::decay_t<decltype(dictionary_attribute_type)>;
             using AttributeType = typename Type::AttributeType;
+            using ValueType = DictionaryValueType<AttributeType>;
 
-            addAttributeSize<AttributeType>(attribute);
+            const auto & container = std::get<ContainerType<ValueType>>(attribute.container);
+            bytes_allocated += sizeof(PaddedPODArray<ValueType>) + container.allocated_bytes();
+            bucket_count = container.capacity();
+
+            if constexpr (std::is_same_v<ValueType, StringRef>)
+                bytes_allocated += sizeof(Arena) + attribute.string_arena->size();
         };
 
         callOnDictionaryAttributeType(attribute.type, type_call);
     }
 }
 
-
-template <typename T>
-void FlatDictionary::createAttributeImpl(Attribute & attribute, const Field & null_value)
+FlatDictionary::Attribute FlatDictionary::createAttribute(const DictionaryAttribute & dictionary_attribute, const Field & null_value)
 {
-    attribute.null_values = T(null_value.get<T>());
-    const auto & null_value_ref = std::get<T>(attribute.null_values);
-    attribute.arrays.emplace<ContainerType<T>>(initial_array_size, null_value_ref);
-}
+    auto nullable_set = dictionary_attribute.is_nullable ? std::make_optional<NullableSet>() : std::optional<NullableSet>{};
+    Attribute attribute{dictionary_attribute.underlying_type, std::move(nullable_set), {}, {}, {}};
 
-template <>
-void FlatDictionary::createAttributeImpl<String>(Attribute & attribute, const Field & null_value)
-{
-    attribute.string_arena = std::make_unique<Arena>();
-    const String & string = null_value.get<String>();
-    const char * string_in_arena = attribute.string_arena->insert(string.data(), string.size());
-    attribute.null_values.emplace<StringRef>(string_in_arena, string.size());
-    attribute.arrays.emplace<ContainerType<StringRef>>(initial_array_size, StringRef(string_in_arena, string.size()));
-}
-
-FlatDictionary::Attribute FlatDictionary::createAttribute(const DictionaryAttribute& attribute, const Field & null_value)
-{
-    auto nullable_set = attribute.is_nullable ? std::make_optional<NullableSet>() : std::optional<NullableSet>{};
-    Attribute attr{attribute.underlying_type, std::move(nullable_set), {}, {}, {}};
-
-    auto type_call = [&](const auto &dictionary_attribute_type)
+    auto type_call = [&](const auto & dictionary_attribute_type)
     {
         using Type = std::decay_t<decltype(dictionary_attribute_type)>;
         using AttributeType = typename Type::AttributeType;
+        using ValueType = DictionaryValueType<AttributeType>;
 
-        createAttributeImpl<AttributeType>(attr, null_value);
+        if constexpr (std::is_same_v<ValueType, StringRef>)
+        {
+            attribute.string_arena = std::make_unique<Arena>();
+            const String & string = null_value.get<String>();
+            const char * string_in_arena = attribute.string_arena->insert(string.data(), string.size());
+            attribute.null_values.emplace<StringRef>(string_in_arena, string.size());
+        }
+        else
+            attribute.null_values = ValueType(null_value.get<NearestFieldType<ValueType>>());
+
+        const auto & null_value_ref = std::get<ValueType>(attribute.null_values);
+        attribute.container.emplace<ContainerType<ValueType>>(configuration.initial_array_size, null_value_ref);
     };
 
-    callOnDictionaryAttributeType(attribute.underlying_type, type_call);
+    callOnDictionaryAttributeType(dictionary_attribute.underlying_type, type_call);
 
-    return attr;
+    return attribute;
 }
 
-
 template <typename AttributeType, typename OutputType, typename ValueSetter, typename DefaultValueExtractor>
 void FlatDictionary::getItemsImpl(
     const Attribute & attribute,
-    const PaddedPODArray<UInt64> & ids,
+    const PaddedPODArray<UInt64> & keys,
     ValueSetter && set_value,
     DefaultValueExtractor & default_value_extractor) const
 {
-    const auto & attr = std::get<ContainerType<AttributeType>>(attribute.arrays);
-    const auto rows = ext::size(ids);
+    const auto & container = std::get<ContainerType<AttributeType>>(attribute.container);
+    const auto rows = keys.size();
 
-    for (const auto row : ext::range(0, rows))
+    for (size_t row = 0; row < rows; ++row)
     {
-        const auto id = ids[row];
-        set_value(row, id < ext::size(attr) && loaded_ids[id] ? static_cast<OutputType>(attr[id]) : default_value_extractor[row]);
+        const auto key = keys[row];
+
+        if (key < loaded_keys.size() && loaded_keys[key])
+            set_value(row, static_cast<OutputType>(container[key]));
+        else
+            set_value(row, default_value_extractor[row]);
     }
 
     query_count.fetch_add(rows, std::memory_order_relaxed);
 }
 
 template <typename T>
-void FlatDictionary::resize(Attribute & attribute, const UInt64 id)
+void FlatDictionary::resize(Attribute & attribute, UInt64 key)
 {
-    if (id >= max_array_size)
-        throw Exception{full_name + ": identifier should be less than " + toString(max_array_size), ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+    if (key >= configuration.max_array_size)
+        throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND,
+            "{}: identifier should be less than {}",
+            full_name,
+            toString(configuration.max_array_size));
 
-    auto & array = std::get<ContainerType<T>>(attribute.arrays);
-    if (id >= array.size())
+    auto & container = std::get<ContainerType<T>>(attribute.container);
+
+    if (key >= container.size())
     {
-        const size_t elements_count = id + 1; //id=0 -> elements_count=1
-        loaded_ids.resize(elements_count, false);
-        array.resize_fill(elements_count, std::get<T>(attribute.null_values));
+        const size_t elements_count = key + 1; //id=0 -> elements_count=1
+        loaded_keys.resize(elements_count, false);
+        container.resize_fill(elements_count, std::get<T>(attribute.null_values));
     }
 }
 
 template <typename T>
-void FlatDictionary::setAttributeValueImpl(Attribute & attribute, const UInt64 id, const T & value)
+void FlatDictionary::setAttributeValueImpl(Attribute & attribute, UInt64 key, const T & value)
 {
-    auto & array = std::get<ContainerType<T>>(attribute.arrays);
-    array[id] = value;
-    loaded_ids[id] = true;
+    auto & array = std::get<ContainerType<T>>(attribute.container);
+    array[key] = value;
+    loaded_keys[key] = true;
 }
 
 template <>
-void FlatDictionary::setAttributeValueImpl<String>(Attribute & attribute, const UInt64 id, const String & value)
+void FlatDictionary::setAttributeValueImpl<String>(Attribute & attribute, UInt64 key, const String & value)
 {
     const auto * string_in_arena = attribute.string_arena->insert(value.data(), value.size());
-    setAttributeValueImpl(attribute, id, StringRef{string_in_arena, value.size()});
+    setAttributeValueImpl(attribute, key, StringRef{string_in_arena, value.size()});
 }
 
-void FlatDictionary::setAttributeValue(Attribute & attribute, const UInt64 id, const Field & value)
+void FlatDictionary::setAttributeValue(Attribute & attribute, const UInt64 key, const Field & value)
 {
     auto type_call = [&](const auto &dictionary_attribute_type)
     {
@@ -494,44 +444,36 @@ void FlatDictionary::setAttributeValue(Attribute & attribute, const UInt64 id, c
         using AttributeType = typename Type::AttributeType;
         using ResizeType = std::conditional_t<std::is_same_v<AttributeType, String>, StringRef, AttributeType>;
 
-        resize<ResizeType>(attribute, id);
+        resize<ResizeType>(attribute, key);
 
         if (attribute.nullable_set)
         {
             if (value.isNull())
             {
-                attribute.nullable_set->insert(id);
-                loaded_ids[id] = true;
+                attribute.nullable_set->insert(key);
+                loaded_keys[key] = true;
                 return;
             }
-            else
-            {
-                attribute.nullable_set->erase(id);
-            }
         }
 
-        setAttributeValueImpl<AttributeType>(attribute, id, value.get<AttributeType>());
+        setAttributeValueImpl<AttributeType>(attribute, key, value.get<AttributeType>());
     };
 
     callOnDictionaryAttributeType(attribute.type, type_call);
 }
 
-PaddedPODArray<UInt64> FlatDictionary::getIds() const
-{
-    const auto ids_count = ext::size(loaded_ids);
-
-    PaddedPODArray<UInt64> ids;
-    ids.reserve(ids_count);
-
-    for (auto idx : ext::range(0, ids_count))
-        if (loaded_ids[idx])
-            ids.push_back(idx);
-    return ids;
-}
-
 BlockInputStreamPtr FlatDictionary::getBlockInputStream(const Names & column_names, size_t max_block_size) const
 {
-    return std::make_shared<DictionaryBlockInputStream>(shared_from_this(), max_block_size, getIds(), column_names);
+    const auto keys_count = loaded_keys.size();
+
+    PaddedPODArray<UInt64> keys;
+    keys.reserve(keys_count);
+
+    for (size_t key_index = 0; key_index < keys_count; ++key_index)
+        if (loaded_keys[key_index])
+            keys.push_back(key_index);
+
+    return std::make_shared<DictionaryBlockInputStream>(shared_from_this(), max_block_size, std::move(keys), column_names);
 }
 
 void registerDictionaryFlat(DictionaryFactory & factory)
@@ -543,19 +485,32 @@ void registerDictionaryFlat(DictionaryFactory & factory)
                              DictionarySourcePtr source_ptr) -> DictionaryPtr
     {
         if (dict_struct.key)
-            throw Exception{"'key' is not supported for dictionary of layout 'flat'", ErrorCodes::UNSUPPORTED_METHOD};
+            throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "'key' is not supported for dictionary of layout 'flat'");
 
         if (dict_struct.range_min || dict_struct.range_max)
-            throw Exception{full_name
-                                + ": elements .structure.range_min and .structure.range_max should be defined only "
-                                  "for a dictionary of layout 'range_hashed'",
-                            ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                            "{}: elements .structure.range_min and .structure.range_max should be defined only "
+                            "for a dictionary of layout 'range_hashed'",
+                            full_name);
+
+        static constexpr size_t default_initial_array_size = 1024;
+        static constexpr size_t default_max_array_size = 500000;
+
+        String dictionary_layout_prefix = config_prefix + ".layout" + ".flat";
+
+        FlatDictionary::Configuration configuration
+        {
+            .initial_array_size = config.getUInt64(dictionary_layout_prefix + ".initial_array_size", default_initial_array_size),
+            .max_array_size = config.getUInt64(dictionary_layout_prefix + ".max_array_size", default_max_array_size),
+            .require_nonempty = config.getBool(config_prefix + ".require_nonempty", false)
+        };
 
         const auto dict_id = StorageID::fromDictionaryConfig(config, config_prefix);
         const DictionaryLifetime dict_lifetime{config, config_prefix + ".lifetime"};
-        const bool require_nonempty = config.getBool(config_prefix + ".require_nonempty", false);
-        return std::make_unique<FlatDictionary>(dict_id, dict_struct, std::move(source_ptr), dict_lifetime, require_nonempty);
+
+        return std::make_unique<FlatDictionary>(dict_id, dict_struct, std::move(source_ptr), dict_lifetime, std::move(configuration));
     };
+
     factory.registerLayout("flat", create_layout, false);
 }
 
diff --git a/src/Dictionaries/FlatDictionary.h b/src/Dictionaries/FlatDictionary.h
index 09721bf1a99..0a5f88f270a 100644
--- a/src/Dictionaries/FlatDictionary.h
+++ b/src/Dictionaries/FlatDictionary.h
@@ -26,13 +26,20 @@ namespace DB
 class FlatDictionary final : public IDictionary
 {
 public:
+    struct Configuration
+    {
+        size_t initial_array_size;
+        size_t max_array_size;
+        bool require_nonempty;
+    };
+
     FlatDictionary(
         const StorageID & dict_id_,
         const DictionaryStructure & dict_struct_,
         DictionarySourcePtr source_ptr_,
         const DictionaryLifetime dict_lifetime_,
-        bool require_nonempty_,
-        BlockPtr saved_block_ = nullptr);
+        Configuration configuration_,
+        BlockPtr previously_loaded_block_ = nullptr);
 
     std::string getTypeName() const override { return "Flat"; }
 
@@ -48,7 +55,7 @@ public:
 
     std::shared_ptr<const IExternalLoadable> clone() const override
     {
-        return std::make_shared<FlatDictionary>(getDictionaryID(), dict_struct, source_ptr->clone(), dict_lifetime, require_nonempty, saved_block);
+        return std::make_shared<FlatDictionary>(getDictionaryID(), dict_struct, source_ptr->clone(), dict_lifetime, configuration, previously_loaded_block);
     }
 
     const IDictionarySource * getSource() const override { return source_ptr.get(); }
@@ -113,6 +120,7 @@ private:
             Decimal32,
             Decimal64,
             Decimal128,
+            Decimal256,
             Float32,
             Float64,
             StringRef>
@@ -130,10 +138,11 @@ private:
             ContainerType<Decimal32>,
             ContainerType<Decimal64>,
             ContainerType<Decimal128>,
+            ContainerType<Decimal256>,
             ContainerType<Float32>,
             ContainerType<Float64>,
             ContainerType<StringRef>>
-            arrays;
+            container;
 
         std::unique_ptr<Arena> string_arena;
     };
@@ -143,54 +152,39 @@ private:
     void updateData();
     void loadData();
 
-    template <typename T>
-    void addAttributeSize(const Attribute & attribute);
-
     void calculateBytesAllocated();
 
-    template <typename T>
-    static void createAttributeImpl(Attribute & attribute, const Field & null_value);
-
-    static Attribute createAttribute(const DictionaryAttribute& attribute, const Field & null_value);
+    Attribute createAttribute(const DictionaryAttribute& attribute, const Field & null_value);
 
     template <typename AttributeType, typename OutputType, typename ValueSetter, typename DefaultValueExtractor>
     void getItemsImpl(
         const Attribute & attribute,
-        const PaddedPODArray<UInt64> & ids,
+        const PaddedPODArray<UInt64> & keys,
         ValueSetter && set_value,
         DefaultValueExtractor & default_value_extractor) const;
 
     template <typename T>
-    void resize(Attribute & attribute, const UInt64 id);
+    void resize(Attribute & attribute, UInt64 key);
 
     template <typename T>
-    void setAttributeValueImpl(Attribute & attribute, const UInt64 id, const T & value);
+    void setAttributeValueImpl(Attribute & attribute, UInt64 key, const T & value);
 
-    void setAttributeValue(Attribute & attribute, const UInt64 id, const Field & value);
-
-    const Attribute & getAttribute(const std::string & attribute_name) const;
-
-    template <typename ChildType, typename AncestorType>
-    void isInImpl(const ChildType & child_ids, const AncestorType & ancestor_ids, PaddedPODArray<UInt8> & out) const;
-
-    PaddedPODArray<UInt64> getIds() const;
+    void setAttributeValue(Attribute & attribute, UInt64 key, const Field & value);
 
     const DictionaryStructure dict_struct;
     const DictionarySourcePtr source_ptr;
     const DictionaryLifetime dict_lifetime;
-    const bool require_nonempty;
+    const Configuration configuration;
 
-    std::map<std::string, size_t> attribute_index_by_name;
     std::vector<Attribute> attributes;
-    std::vector<bool> loaded_ids;
+    std::vector<bool> loaded_keys;
 
     size_t bytes_allocated = 0;
     size_t element_count = 0;
     size_t bucket_count = 0;
     mutable std::atomic<size_t> query_count{0};
 
-    /// TODO: Remove
-    BlockPtr saved_block;
+    BlockPtr previously_loaded_block;
 };
 
 }
diff --git a/src/Dictionaries/HTTPDictionarySource.cpp b/src/Dictionaries/HTTPDictionarySource.cpp
index 62bf478afc4..b674d593444 100644
--- a/src/Dictionaries/HTTPDictionarySource.cpp
+++ b/src/Dictionaries/HTTPDictionarySource.cpp
@@ -30,7 +30,7 @@ HTTPDictionarySource::HTTPDictionarySource(
     const Poco::Util::AbstractConfiguration & config,
     const std::string & config_prefix,
     Block & sample_block_,
-    const Context & context_,
+    ContextPtr context_,
     bool check_config)
     : log(&Poco::Logger::get("HTTPDictionarySource"))
     , update_time{std::chrono::system_clock::from_time_t(0)}
@@ -44,7 +44,7 @@ HTTPDictionarySource::HTTPDictionarySource(
 {
 
     if (check_config)
-        context.getRemoteHostFilter().checkURL(Poco::URI(url));
+        context->getRemoteHostFilter().checkURL(Poco::URI(url));
 
     const auto & credentials_prefix = config_prefix + ".credentials";
 
@@ -80,7 +80,7 @@ HTTPDictionarySource::HTTPDictionarySource(const HTTPDictionarySource & other)
     , update_field{other.update_field}
     , format{other.format}
     , sample_block{other.sample_block}
-    , context(other.context)
+    , context(Context::createCopy(other.context))
     , timeouts(ConnectionTimeouts::getHTTPTimeouts(context))
 {
     credentials.setUsername(other.credentials.getUsername());
@@ -111,7 +111,7 @@ BlockInputStreamPtr HTTPDictionarySource::loadAll()
     auto in_ptr = std::make_unique<ReadWriteBufferFromHTTP>(
         uri, Poco::Net::HTTPRequest::HTTP_GET, ReadWriteBufferFromHTTP::OutStreamCallback(), timeouts,
         0, credentials, DBMS_DEFAULT_BUFFER_SIZE, header_entries);
-    auto input_stream = context.getInputFormat(format, *in_ptr, sample_block, max_block_size);
+    auto input_stream = context->getInputFormat(format, *in_ptr, sample_block, max_block_size);
     return std::make_shared<OwningBlockInputStream<ReadWriteBufferFromHTTP>>(input_stream, std::move(in_ptr));
 }
 
@@ -123,7 +123,7 @@ BlockInputStreamPtr HTTPDictionarySource::loadUpdatedAll()
     auto in_ptr = std::make_unique<ReadWriteBufferFromHTTP>(
         uri, Poco::Net::HTTPRequest::HTTP_GET, ReadWriteBufferFromHTTP::OutStreamCallback(), timeouts,
         0, credentials, DBMS_DEFAULT_BUFFER_SIZE, header_entries);
-    auto input_stream = context.getInputFormat(format, *in_ptr, sample_block, max_block_size);
+    auto input_stream = context->getInputFormat(format, *in_ptr, sample_block, max_block_size);
     return std::make_shared<OwningBlockInputStream<ReadWriteBufferFromHTTP>>(input_stream, std::move(in_ptr));
 }
 
@@ -136,7 +136,7 @@ BlockInputStreamPtr HTTPDictionarySource::loadIds(const std::vector<UInt64> & id
     ReadWriteBufferFromHTTP::OutStreamCallback out_stream_callback = [block, this](std::ostream & ostr)
     {
         WriteBufferFromOStream out_buffer(ostr);
-        auto output_stream = context.getOutputStreamParallelIfPossible(format, out_buffer, sample_block);
+        auto output_stream = context->getOutputStreamParallelIfPossible(format, out_buffer, sample_block);
         formatBlock(output_stream, block);
     };
 
@@ -144,7 +144,7 @@ BlockInputStreamPtr HTTPDictionarySource::loadIds(const std::vector<UInt64> & id
     auto in_ptr = std::make_unique<ReadWriteBufferFromHTTP>(
         uri, Poco::Net::HTTPRequest::HTTP_POST, out_stream_callback, timeouts,
         0, credentials, DBMS_DEFAULT_BUFFER_SIZE, header_entries);
-    auto input_stream = context.getInputFormat(format, *in_ptr, sample_block, max_block_size);
+    auto input_stream = context->getInputFormat(format, *in_ptr, sample_block, max_block_size);
     return std::make_shared<OwningBlockInputStream<ReadWriteBufferFromHTTP>>(input_stream, std::move(in_ptr));
 }
 
@@ -157,7 +157,7 @@ BlockInputStreamPtr HTTPDictionarySource::loadKeys(const Columns & key_columns,
     ReadWriteBufferFromHTTP::OutStreamCallback out_stream_callback = [block, this](std::ostream & ostr)
     {
         WriteBufferFromOStream out_buffer(ostr);
-        auto output_stream = context.getOutputStreamParallelIfPossible(format, out_buffer, sample_block);
+        auto output_stream = context->getOutputStreamParallelIfPossible(format, out_buffer, sample_block);
         formatBlock(output_stream, block);
     };
 
@@ -165,7 +165,7 @@ BlockInputStreamPtr HTTPDictionarySource::loadKeys(const Columns & key_columns,
     auto in_ptr = std::make_unique<ReadWriteBufferFromHTTP>(
         uri, Poco::Net::HTTPRequest::HTTP_POST, out_stream_callback, timeouts,
         0, credentials, DBMS_DEFAULT_BUFFER_SIZE, header_entries);
-    auto input_stream = context.getInputFormat(format, *in_ptr, sample_block, max_block_size);
+    auto input_stream = context->getInputFormat(format, *in_ptr, sample_block, max_block_size);
     return std::make_shared<OwningBlockInputStream<ReadWriteBufferFromHTTP>>(input_stream, std::move(in_ptr));
 }
 
@@ -201,14 +201,14 @@ void registerDictionarySourceHTTP(DictionarySourceFactory & factory)
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
-                                 const Context & context,
+                                 ContextPtr context,
                                  const std::string & /* default_database */,
                                  bool check_config) -> DictionarySourcePtr
     {
         if (dict_struct.has_expressions)
-            throw Exception{"Dictionary source of type `http` does not support attribute expressions", ErrorCodes::LOGICAL_ERROR};
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Dictionary source of type `http` does not support attribute expressions");
 
-        Context context_local_copy = copyContextAndApplySettings(config_prefix, context, config);
+        auto context_local_copy = copyContextAndApplySettings(config_prefix, context, config);
 
         return std::make_unique<HTTPDictionarySource>(
             dict_struct, config, config_prefix + ".http",
diff --git a/src/Dictionaries/HTTPDictionarySource.h b/src/Dictionaries/HTTPDictionarySource.h
index e7920132e83..c42c67ec8c9 100644
--- a/src/Dictionaries/HTTPDictionarySource.h
+++ b/src/Dictionaries/HTTPDictionarySource.h
@@ -26,7 +26,7 @@ public:
         const Poco::Util::AbstractConfiguration & config,
         const std::string & config_prefix,
         Block & sample_block_,
-        const Context & context_,
+        ContextPtr context_,
         bool check_config);
 
     HTTPDictionarySource(const HTTPDictionarySource & other);
@@ -65,7 +65,7 @@ private:
     std::string update_field;
     const std::string format;
     Block sample_block;
-    Context context;
+    ContextPtr context;
     ConnectionTimeouts timeouts;
 };
 
diff --git a/src/Dictionaries/HashedDictionary.cpp b/src/Dictionaries/HashedDictionary.cpp
index 3fbab4c3e39..2a403554a80 100644
--- a/src/Dictionaries/HashedDictionary.cpp
+++ b/src/Dictionaries/HashedDictionary.cpp
@@ -1,9 +1,5 @@
 #include "HashedDictionary.h"
 
-#include <ext/size.h>
-
-#include <absl/container/flat_hash_map.h>
-
 #include <Core/Defines.h>
 #include <DataTypes/DataTypesDecimal.h>
 #include <Columns/ColumnsNumber.h>
@@ -46,13 +42,13 @@ HashedDictionary<dictionary_key_type, sparse>::HashedDictionary(
     DictionarySourcePtr source_ptr_,
     const DictionaryLifetime dict_lifetime_,
     bool require_nonempty_,
-    BlockPtr saved_block_)
+    BlockPtr previously_loaded_block_)
     : IDictionary(dict_id_)
     , dict_struct(dict_struct_)
     , source_ptr(std::move(source_ptr_))
     , dict_lifetime(dict_lifetime_)
     , require_nonempty(require_nonempty_)
-    , saved_block(std::move(saved_block_))
+    , previously_loaded_block(std::move(previously_loaded_block_))
 {
     createAttributes();
     loadData();
@@ -127,7 +123,7 @@ ColumnPtr HashedDictionary<dictionary_key_type, sparse>::getColumn(
                 [&](const size_t row, const auto value) { return out[row] = value; },
                 [&](const size_t row)
                 {
-                    out[row] = 0;
+                    out[row] = ValueType();
                     (*vec_null_map_to)[row] = true;
                 },
                 default_value_extractor);
@@ -347,7 +343,7 @@ void HashedDictionary<dictionary_key_type, sparse>::createAttributes()
 template <DictionaryKeyType dictionary_key_type, bool sparse>
 void HashedDictionary<dictionary_key_type, sparse>::updateData()
 {
-    if (!saved_block || saved_block->rows() == 0)
+    if (!previously_loaded_block || previously_loaded_block->rows() == 0)
     {
         auto stream = source_ptr->loadUpdatedAll();
         stream->readPrefix();
@@ -355,13 +351,13 @@ void HashedDictionary<dictionary_key_type, sparse>::updateData()
         while (const auto block = stream->read())
         {
             /// We are using this to keep saved data if input stream consists of multiple blocks
-            if (!saved_block)
-                saved_block = std::make_shared<DB::Block>(block.cloneEmpty());
+            if (!previously_loaded_block)
+                previously_loaded_block = std::make_shared<DB::Block>(block.cloneEmpty());
 
             for (const auto attribute_idx : ext::range(0, attributes.size() + 1))
             {
                 const IColumn & update_column = *block.getByPosition(attribute_idx).column.get();
-                MutableColumnPtr saved_column = saved_block->getByPosition(attribute_idx).column->assumeMutable();
+                MutableColumnPtr saved_column = previously_loaded_block->getByPosition(attribute_idx).column->assumeMutable();
                 saved_column->insertRangeFrom(update_column, 0, update_column.size());
             }
         }
@@ -369,70 +365,17 @@ void HashedDictionary<dictionary_key_type, sparse>::updateData()
     }
     else
     {
-        size_t skip_keys_size_offset = dict_struct.getKeysSize();
-
-        Columns saved_block_key_columns;
-        saved_block_key_columns.reserve(skip_keys_size_offset);
-
-        /// Split into keys columns and attribute columns
-        for (size_t i = 0; i < skip_keys_size_offset; ++i)
-            saved_block_key_columns.emplace_back(saved_block->safeGetByPosition(i).column);
-
-
-        DictionaryKeysArenaHolder<dictionary_key_type> arena_holder;
-        DictionaryKeysExtractor<dictionary_key_type> saved_keys_extractor(saved_block_key_columns, arena_holder.getComplexKeyArena());
-        auto saved_keys_extracted_from_block = saved_keys_extractor.extractAllKeys();
-
         auto stream = source_ptr->loadUpdatedAll();
-        stream->readPrefix();
-
-        while (Block block = stream->read())
-        {
-            /// TODO: Rewrite
-            Columns block_key_columns;
-            block_key_columns.reserve(skip_keys_size_offset);
-
-            /// Split into keys columns and attribute columns
-            for (size_t i = 0; i < skip_keys_size_offset; ++i)
-                block_key_columns.emplace_back(block.safeGetByPosition(i).column);
-
-            DictionaryKeysExtractor<dictionary_key_type> block_keys_extractor(saved_block_key_columns, arena_holder.getComplexKeyArena());
-            auto keys_extracted_from_block = block_keys_extractor.extractAllKeys();
-
-            absl::flat_hash_map<KeyType, std::vector<size_t>, DefaultHash<KeyType>> update_keys;
-            for (size_t row = 0; row < keys_extracted_from_block.size(); ++row)
-            {
-                auto key = keys_extracted_from_block[row];
-                update_keys[key].push_back(row);
-            }
-
-            IColumn::Filter filter(saved_keys_extracted_from_block.size());
-
-            for (size_t row = 0; row < saved_keys_extracted_from_block.size(); ++row)
-            {
-                auto key = saved_keys_extracted_from_block[row];
-                auto it = update_keys.find(key);
-                filter[row] = (it == update_keys.end());
-            }
-
-            auto block_columns = block.mutateColumns();
-            for (const auto attribute_idx : ext::range(0, attributes.size() + 1))
-            {
-                auto & column = saved_block->safeGetByPosition(attribute_idx).column;
-                const auto & filtered_column = column->filter(filter, -1);
-                block_columns[attribute_idx]->insertRangeFrom(*filtered_column.get(), 0, filtered_column->size());
-            }
-
-            saved_block->setColumns(std::move(block_columns));
-        }
-
-        stream->readSuffix();
+        mergeBlockWithStream<dictionary_key_type>(
+            dict_struct.getKeysSize(),
+            *previously_loaded_block,
+            stream);
     }
 
-    if (saved_block)
+    if (previously_loaded_block)
     {
-        resize(saved_block->rows());
-        blockToAttributes(*saved_block.get());
+        resize(previously_loaded_block->rows());
+        blockToAttributes(*previously_loaded_block.get());
     }
 }
 
@@ -604,7 +547,7 @@ void HashedDictionary<dictionary_key_type, sparse>::loadData()
 
     if (require_nonempty && 0 == element_count)
         throw Exception(ErrorCodes::DICTIONARY_IS_EMPTY,
-            "({}): dictionary source is empty and 'require_nonempty' property is set.",
+            "{}: dictionary source is empty and 'require_nonempty' property is set.",
             full_name);
 }
 
@@ -624,7 +567,11 @@ void HashedDictionary<dictionary_key_type, sparse>::calculateBytesAllocated()
 
             if constexpr (sparse || std::is_same_v<AttributeValueType, Field>)
             {
-                bytes_allocated += container.max_size() * (sizeof(KeyType) + sizeof(AttributeValueType));
+                /// bucket_count() - Returns table size, that includes empty and deleted
+                /// size()         - Returns table size, w/o empty and deleted
+                /// and since this is sparsehash, empty cells should not be significant,
+                /// and since items cannot be removed from the dictionary, deleted is also not important.
+                bytes_allocated += container.size() * (sizeof(KeyType) + sizeof(AttributeValueType));
                 bucket_count = container.bucket_count();
             }
             else
@@ -729,10 +676,10 @@ void registerDictionaryHashed(DictionaryFactory & factory)
             throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "'id' is not supported for complex key hashed dictionary");
 
         if (dict_struct.range_min || dict_struct.range_max)
-            throw Exception{full_name
-                                + ": elements .structure.range_min and .structure.range_max should be defined only "
-                                  "for a dictionary of layout 'range_hashed'",
-                            ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                "{}: elements .structure.range_min and .structure.range_max should be defined only "
+                "for a dictionary of layout 'range_hashed'",
+                full_name);
 
         const auto dict_id = StorageID::fromDictionaryConfig(config, config_prefix);
         const DictionaryLifetime dict_lifetime{config, config_prefix + ".lifetime"};
diff --git a/src/Dictionaries/HashedDictionary.h b/src/Dictionaries/HashedDictionary.h
index 3882b669324..0d0ab8dcb43 100644
--- a/src/Dictionaries/HashedDictionary.h
+++ b/src/Dictionaries/HashedDictionary.h
@@ -41,7 +41,7 @@ public:
         DictionarySourcePtr source_ptr_,
         const DictionaryLifetime dict_lifetime_,
         bool require_nonempty_,
-        BlockPtr saved_block_ = nullptr);
+        BlockPtr previously_loaded_block_ = nullptr);
 
     std::string getTypeName() const override
     {
@@ -67,7 +67,7 @@ public:
 
     std::shared_ptr<const IExternalLoadable> clone() const override
     {
-        return std::make_shared<HashedDictionary<dictionary_key_type, sparse>>(getDictionaryID(), dict_struct, source_ptr->clone(), dict_lifetime, require_nonempty, saved_block);
+        return std::make_shared<HashedDictionary<dictionary_key_type, sparse>>(getDictionaryID(), dict_struct, source_ptr->clone(), dict_lifetime, require_nonempty, previously_loaded_block);
     }
 
     const IDictionarySource * getSource() const override { return source_ptr.get(); }
@@ -152,6 +152,7 @@ private:
             Decimal32,
             Decimal64,
             Decimal128,
+            Decimal256,
             Float32,
             Float64,
             StringRef>
@@ -170,13 +171,13 @@ private:
             CollectionType<Decimal32>,
             CollectionType<Decimal64>,
             CollectionType<Decimal128>,
+            CollectionType<Decimal256>,
             CollectionType<Float32>,
             CollectionType<Float64>,
             CollectionType<StringRef>>
             container;
 
         std::unique_ptr<Arena> string_arena;
-
     };
 
     void createAttributes();
@@ -219,8 +220,7 @@ private:
     size_t bucket_count = 0;
     mutable std::atomic<size_t> query_count{0};
 
-    /// TODO: Remove
-    BlockPtr saved_block;
+    BlockPtr previously_loaded_block;
     Arena complex_key_arena;
 };
 
diff --git a/src/Dictionaries/HierarchyDictionariesUtils.cpp b/src/Dictionaries/HierarchyDictionariesUtils.cpp
index fffe0d30e0e..5bca6a5ac1a 100644
--- a/src/Dictionaries/HierarchyDictionariesUtils.cpp
+++ b/src/Dictionaries/HierarchyDictionariesUtils.cpp
@@ -52,7 +52,7 @@ namespace
             const auto * parent_key_column_typed = checkAndGetColumn<ColumnVector<UInt64>>(*parent_key_column);
             if (!parent_key_column_typed)
                 throw Exception(ErrorCodes::UNSUPPORTED_METHOD,
-                    "Parent key column should be UInt64. Actual ({})",
+                    "Parent key column should be UInt64. Actual {}",
                     hierarchical_attribute.type->getName());
 
             const auto & parent_keys = parent_key_column_typed->getData();
diff --git a/src/Dictionaries/IPAddressDictionary.cpp b/src/Dictionaries/IPAddressDictionary.cpp
index d66c285bc42..5c5f71e0b1d 100644
--- a/src/Dictionaries/IPAddressDictionary.cpp
+++ b/src/Dictionaries/IPAddressDictionary.cpp
@@ -124,20 +124,20 @@ static size_t formatIPWithPrefix(const unsigned char * src, UInt8 prefix_len, bo
 static void validateKeyTypes(const DataTypes & key_types)
 {
     if (key_types.empty() || key_types.size() > 2)
-        throw Exception{"Expected a single IP address or IP with mask", ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected a single IP address or IP with mask");
 
     const auto * key_ipv4type = typeid_cast<const DataTypeUInt32 *>(key_types[0].get());
     const auto * key_ipv6type = typeid_cast<const DataTypeFixedString *>(key_types[0].get());
 
     if (key_ipv4type == nullptr && (key_ipv6type == nullptr || key_ipv6type->getN() != 16))
-        throw Exception{"Key does not match, expected either `IPv4` (`UInt32`) or `IPv6` (`FixedString(16)`)",
-                        ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH,
+            "Key does not match, expected either `IPv4` (`UInt32`) or `IPv6` (`FixedString(16)`)");
 
     if (key_types.size() > 1)
     {
         const auto * mask_col_type = typeid_cast<const DataTypeUInt8 *>(key_types[1].get());
         if (mask_col_type == nullptr)
-            throw Exception{"Mask do not match, expected UInt8", ErrorCodes::TYPE_MISMATCH};
+            throw Exception(ErrorCodes::TYPE_MISMATCH, "Mask do not match, expected UInt8");
     }
 }
 
@@ -293,7 +293,7 @@ ColumnUInt8::Ptr IPAddressDictionary::hasKeys(const Columns & key_columns, const
         {
             auto addr = first_column->getDataAt(i);
             if (unlikely(addr.size != IPV6_BINARY_LENGTH))
-                throw Exception("Expected key to be FixedString(16)", ErrorCodes::LOGICAL_ERROR);
+                throw Exception(ErrorCodes::LOGICAL_ERROR, "Expected key to be FixedString(16)");
 
             auto found = tryLookupIPv6(reinterpret_cast<const uint8_t *>(addr.data));
             out[i] = (found != ipNotFound());
@@ -316,8 +316,10 @@ void IPAddressDictionary::createAttributes()
             attributes.push_back(createAttributeWithType(attribute.underlying_type, attribute.null_value));
 
             if (attribute.hierarchical)
-                throw Exception{full_name + ": hierarchical attributes not supported for dictionary of type " + getTypeName(),
-                                ErrorCodes::TYPE_MISMATCH};
+                throw Exception(ErrorCodes::TYPE_MISMATCH,
+                    "{}: hierarchical attributes not supported for dictionary of type {}",
+                    full_name,
+                    getTypeName());
         }
     };
 
@@ -492,7 +494,7 @@ void IPAddressDictionary::loadData()
     LOG_TRACE(logger, "{} ip records are read", ip_records.size());
 
     if (require_nonempty && 0 == element_count)
-        throw Exception{full_name + ": dictionary source is empty and 'require_nonempty' property is set.", ErrorCodes::DICTIONARY_IS_EMPTY};
+        throw Exception(ErrorCodes::DICTIONARY_IS_EMPTY, "{}: dictionary source is empty and 'require_nonempty' property is set.", full_name);
 }
 
 template <typename T>
@@ -591,7 +593,7 @@ void IPAddressDictionary::getItemsByTwoKeyColumnsImpl(
     {
         const auto * key_ip_column_ptr = typeid_cast<const ColumnVector<UInt32> *>(&*key_columns.front());
         if (key_ip_column_ptr == nullptr)
-            throw Exception{"Expected a UInt32 IP column", ErrorCodes::TYPE_MISMATCH};
+            throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected a UInt32 IP column");
 
         const auto & key_mask_column = assert_cast<const ColumnVector<UInt8> &>(*key_columns.back());
 
@@ -625,7 +627,7 @@ void IPAddressDictionary::getItemsByTwoKeyColumnsImpl(
 
     const auto * key_ip_column_ptr = typeid_cast<const ColumnFixedString *>(&*key_columns.front());
     if (key_ip_column_ptr == nullptr || key_ip_column_ptr->getN() != IPV6_BINARY_LENGTH)
-        throw Exception{"Expected a FixedString(16) IP column", ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected a FixedString(16) IP column");
 
     const auto & key_mask_column = assert_cast<const ColumnVector<UInt8> &>(*key_columns.back());
 
@@ -698,7 +700,7 @@ void IPAddressDictionary::getItemsImpl(
         {
             auto addr = first_column->getDataAt(i);
             if (addr.size != IPV6_BINARY_LENGTH)
-                throw Exception("Expected key to be FixedString(16)", ErrorCodes::LOGICAL_ERROR);
+                throw Exception(ErrorCodes::LOGICAL_ERROR, "Expected key to be FixedString(16)");
 
             auto found = tryLookupIPv6(reinterpret_cast<const uint8_t *>(addr.data));
             if (found != ipNotFound())
@@ -744,7 +746,7 @@ const IPAddressDictionary::Attribute & IPAddressDictionary::getAttribute(const s
 {
     const auto it = attribute_index_by_name.find(attribute_name);
     if (it == std::end(attribute_index_by_name))
-        throw Exception{full_name + ": no such attribute '" + attribute_name + "'", ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "{}: no such attribute '{}'", full_name, attribute_name);
 
     return attributes[it->second];
 }
@@ -921,7 +923,7 @@ void registerDictionaryTrie(DictionaryFactory & factory)
                              DictionarySourcePtr source_ptr) -> DictionaryPtr
     {
         if (!dict_struct.key || dict_struct.key->size() != 1)
-            throw Exception{"Dictionary of layout 'ip_trie' has to have one 'key'", ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Dictionary of layout 'ip_trie' has to have one 'key'");
 
         const auto dict_id = StorageID::fromDictionaryConfig(config, config_prefix);
         const DictionaryLifetime dict_lifetime{config, config_prefix + ".lifetime"};
diff --git a/src/Dictionaries/IPAddressDictionary.h b/src/Dictionaries/IPAddressDictionary.h
index cf79caa75fc..619d1579e4e 100644
--- a/src/Dictionaries/IPAddressDictionary.h
+++ b/src/Dictionaries/IPAddressDictionary.h
@@ -101,6 +101,7 @@ private:
             Decimal32,
             Decimal64,
             Decimal128,
+            Decimal256,
             Float32,
             Float64,
             String>
@@ -118,6 +119,7 @@ private:
             ContainerType<Decimal32>,
             ContainerType<Decimal64>,
             ContainerType<Decimal128>,
+            ContainerType<Decimal256>,
             ContainerType<Float32>,
             ContainerType<Float64>,
             ContainerType<StringRef>>
diff --git a/src/Dictionaries/LibraryDictionarySource.cpp b/src/Dictionaries/LibraryDictionarySource.cpp
index 0632dd3e30f..f09869b5a30 100644
--- a/src/Dictionaries/LibraryDictionarySource.cpp
+++ b/src/Dictionaries/LibraryDictionarySource.cpp
@@ -1,4 +1,5 @@
 #include "LibraryDictionarySource.h"
+
 #include <DataStreams/OneBlockInputStream.h>
 #include <Interpreters/Context.h>
 #include <Poco/File.h>
@@ -6,307 +7,186 @@
 #include <ext/bit_cast.h>
 #include <ext/range.h>
 #include <ext/scope_guard.h>
-#include <Common/StringUtils/StringUtils.h>
 #include "DictionarySourceFactory.h"
+#include "DictionarySourceHelpers.h"
 #include "DictionaryStructure.h"
 #include "LibraryDictionarySourceExternal.h"
 #include "registerDictionaries.h"
+#include <IO/WriteBufferFromString.h>
+#include <IO/WriteHelpers.h>
+
 
 namespace DB
 {
+
 namespace ErrorCodes
 {
-    extern const int SIZES_OF_COLUMNS_DOESNT_MATCH;
     extern const int FILE_DOESNT_EXIST;
     extern const int EXTERNAL_LIBRARY_ERROR;
     extern const int PATH_ACCESS_DENIED;
 }
 
 
-class CStringsHolder
-{
-public:
-    using Container = std::vector<std::string>;
-    explicit CStringsHolder(const Container & strings_pass)
-    {
-        strings_holder = strings_pass;
-        strings.size = strings_holder.size();
-        ptr_holder = std::make_unique<ClickHouseLibrary::CString[]>(strings.size);
-        strings.data = ptr_holder.get();
-        size_t i = 0;
-        for (auto & str : strings_holder)
-        {
-            strings.data[i] = str.c_str();
-            ++i;
-        }
-    }
-
-    ClickHouseLibrary::CStrings strings; // will pass pointer to lib
-
-private:
-    std::unique_ptr<ClickHouseLibrary::CString[]> ptr_holder = nullptr;
-    Container strings_holder;
-};
-
-
-namespace
-{
-    constexpr auto lib_config_settings = ".settings";
-
-
-    CStringsHolder getLibSettings(const Poco::Util::AbstractConfiguration & config, const std::string & config_root)
-    {
-        Poco::Util::AbstractConfiguration::Keys config_keys;
-        config.keys(config_root, config_keys);
-        CStringsHolder::Container strings;
-        for (const auto & key : config_keys)
-        {
-            std::string key_name = key;
-            auto bracket_pos = key.find('[');
-            if (bracket_pos != std::string::npos && bracket_pos > 0)
-                key_name = key.substr(0, bracket_pos);
-            strings.emplace_back(key_name);
-            strings.emplace_back(config.getString(config_root + "." + key));
-        }
-        return CStringsHolder(strings);
-    }
-
-
-    Block dataToBlock(const Block & sample_block, const ClickHouseLibrary::RawClickHouseLibraryTable data)
-    {
-        if (!data)
-            throw Exception("LibraryDictionarySource: No data returned", ErrorCodes::EXTERNAL_LIBRARY_ERROR);
-
-        const auto * columns_received = static_cast<const ClickHouseLibrary::Table *>(data);
-        if (columns_received->error_code)
-            throw Exception(
-                "LibraryDictionarySource: Returned error: " + std::to_string(columns_received->error_code) + " "
-                    + (columns_received->error_string ? columns_received->error_string : ""),
-                ErrorCodes::EXTERNAL_LIBRARY_ERROR);
-
-        MutableColumns columns = sample_block.cloneEmptyColumns();
-
-        for (size_t col_n = 0; col_n < columns_received->size; ++col_n)
-        {
-            if (columns.size() != columns_received->data[col_n].size)
-                throw Exception(
-                    "LibraryDictionarySource: Returned unexpected number of columns: " + std::to_string(columns_received->data[col_n].size)
-                        + ", must be " + std::to_string(columns.size()),
-                    ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
-
-            for (size_t row_n = 0; row_n < columns_received->data[col_n].size; ++row_n)
-            {
-                const auto & field = columns_received->data[col_n].data[row_n];
-                if (!field.data)
-                {
-                    /// sample_block contains null_value (from config) inside corresponding column
-                    const auto & col = sample_block.getByPosition(row_n);
-                    columns[row_n]->insertFrom(*(col.column), 0);
-                }
-                else
-                {
-                    const auto & size = field.size;
-                    columns[row_n]->insertData(static_cast<const char *>(field.data), size);
-                }
-            }
-        }
-
-        return sample_block.cloneWithColumns(std::move(columns));
-    }
-}
-
-
 LibraryDictionarySource::LibraryDictionarySource(
     const DictionaryStructure & dict_struct_,
     const Poco::Util::AbstractConfiguration & config,
     const std::string & config_prefix_,
     Block & sample_block_,
-    const Context & context,
+    ContextPtr context_,
     bool check_config)
     : log(&Poco::Logger::get("LibraryDictionarySource"))
     , dict_struct{dict_struct_}
     , config_prefix{config_prefix_}
     , path{config.getString(config_prefix + ".path", "")}
+    , dictionary_id(getDictID())
     , sample_block{sample_block_}
+    , context(Context::createCopy(context_))
 {
 
     if (check_config)
     {
-        const String dictionaries_lib_path = context.getDictionariesLibPath();
+        const String dictionaries_lib_path = context->getDictionariesLibPath();
         if (!startsWith(path, dictionaries_lib_path))
-            throw Exception("LibraryDictionarySource: Library path " + path + " is not inside " + dictionaries_lib_path, ErrorCodes::PATH_ACCESS_DENIED);
+            throw Exception(ErrorCodes::PATH_ACCESS_DENIED, "LibraryDictionarySource: Library path {} is not inside {}", path, dictionaries_lib_path);
     }
 
     if (!Poco::File(path).exists())
-        throw Exception(
-            "LibraryDictionarySource: Can't load library " + Poco::File(path).path() + ": file doesn't exist",
-            ErrorCodes::FILE_DOESNT_EXIST);
+        throw Exception(ErrorCodes::FILE_DOESNT_EXIST, "LibraryDictionarySource: Can't load library {}: file doesn't exist", Poco::File(path).path());
 
     description.init(sample_block);
-    library = std::make_shared<SharedLibrary>(path, RTLD_LAZY
-#if defined(RTLD_DEEPBIND) && !defined(ADDRESS_SANITIZER) // Does not exists in FreeBSD. Cannot work with Address Sanitizer.
-        | RTLD_DEEPBIND
-#endif
-    );
-    settings = std::make_shared<CStringsHolder>(getLibSettings(config, config_prefix + lib_config_settings));
+    bridge_helper = std::make_shared<LibraryBridgeHelper>(context, description.sample_block, dictionary_id);
+    auto res = bridge_helper->initLibrary(path, getLibrarySettingsString(config, config_prefix + ".settings"), getDictAttributesString());
 
-    if (auto lib_new = library->tryGet<ClickHouseLibrary::LibraryNewFunc>(ClickHouseLibrary::LIBRARY_CREATE_NEW_FUNC_NAME))
-        lib_data = lib_new(&settings->strings, ClickHouseLibrary::log);
+    if (!res)
+        throw Exception(ErrorCodes::EXTERNAL_LIBRARY_ERROR, "Failed to create shared library from path: {}", path);
 }
 
+
+LibraryDictionarySource::~LibraryDictionarySource()
+{
+    bridge_helper->removeLibrary();
+}
+
+
 LibraryDictionarySource::LibraryDictionarySource(const LibraryDictionarySource & other)
     : log(&Poco::Logger::get("LibraryDictionarySource"))
     , dict_struct{other.dict_struct}
     , config_prefix{other.config_prefix}
     , path{other.path}
+    , dictionary_id{getDictID()}
     , sample_block{other.sample_block}
-    , library{other.library}
+    , context(other.context)
     , description{other.description}
-    , settings{other.settings}
 {
-    if (auto lib_clone = library->tryGet<ClickHouseLibrary::LibraryCloneFunc>(ClickHouseLibrary::LIBRARY_CLONE_FUNC_NAME))
-        lib_data = lib_clone(other.lib_data);
-    else if (auto lib_new = library->tryGet<ClickHouseLibrary::LibraryNewFunc>(ClickHouseLibrary::LIBRARY_CREATE_NEW_FUNC_NAME))
-        lib_data = lib_new(&settings->strings, ClickHouseLibrary::log);
+    bridge_helper = std::make_shared<LibraryBridgeHelper>(context, description.sample_block, dictionary_id);
+    bridge_helper->cloneLibrary(other.dictionary_id);
 }
 
-LibraryDictionarySource::~LibraryDictionarySource()
+
+bool LibraryDictionarySource::isModified() const
 {
-    if (auto lib_delete = library->tryGet<ClickHouseLibrary::LibraryDeleteFunc>(ClickHouseLibrary::LIBRARY_DELETE_FUNC_NAME))
-        lib_delete(lib_data);
+    return bridge_helper->isModified();
 }
 
+
+bool LibraryDictionarySource::supportsSelectiveLoad() const
+{
+    return bridge_helper->supportsSelectiveLoad();
+}
+
+
 BlockInputStreamPtr LibraryDictionarySource::loadAll()
 {
     LOG_TRACE(log, "loadAll {}", toString());
-
-    auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(dict_struct.attributes.size());
-    ClickHouseLibrary::CStrings columns{static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()),
-                                        dict_struct.attributes.size()};
-    size_t i = 0;
-    for (const auto & a : dict_struct.attributes)
-    {
-        columns.data[i] = a.name.c_str();
-        ++i;
-    }
-
-    auto load_all_func = library->get<ClickHouseLibrary::LibraryLoadAllFunc>(ClickHouseLibrary::LIBRARY_LOAD_ALL_FUNC_NAME);
-    auto data_new_func = library->get<ClickHouseLibrary::LibraryDataNewFunc>(ClickHouseLibrary::LIBRARY_DATA_NEW_FUNC_NAME);
-    auto data_delete_func = library->get<ClickHouseLibrary::LibraryDataDeleteFunc>(ClickHouseLibrary::LIBRARY_DATA_DELETE_FUNC_NAME);
-
-    ClickHouseLibrary::LibraryData data_ptr = data_new_func(lib_data);
-    SCOPE_EXIT(data_delete_func(lib_data, data_ptr));
-
-    ClickHouseLibrary::RawClickHouseLibraryTable data = load_all_func(data_ptr, &settings->strings, &columns);
-    auto block = dataToBlock(description.sample_block, data);
-
-    return std::make_shared<OneBlockInputStream>(block);
+    return bridge_helper->loadAll();
 }
 
+
 BlockInputStreamPtr LibraryDictionarySource::loadIds(const std::vector<UInt64> & ids)
 {
     LOG_TRACE(log, "loadIds {} size = {}", toString(), ids.size());
-
-    const ClickHouseLibrary::VectorUInt64 ids_data{ext::bit_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(ids.data()), ids.size()};
-    auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(dict_struct.attributes.size());
-    ClickHouseLibrary::CStrings columns_pass{static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()),
-                                             dict_struct.attributes.size()};
-    size_t i = 0;
-    for (const auto & a : dict_struct.attributes)
-    {
-        columns_pass.data[i] = a.name.c_str();
-        ++i;
-    }
-
-    auto load_ids_func = library->get<ClickHouseLibrary::LibraryLoadIdsFunc>(ClickHouseLibrary::LIBRARY_LOAD_IDS_FUNC_NAME);
-    auto data_new_func = library->get<ClickHouseLibrary::LibraryDataNewFunc>(ClickHouseLibrary::LIBRARY_DATA_NEW_FUNC_NAME);
-    auto data_delete_func = library->get<ClickHouseLibrary::LibraryDataDeleteFunc>(ClickHouseLibrary::LIBRARY_DATA_DELETE_FUNC_NAME);
-
-    ClickHouseLibrary::LibraryData data_ptr = data_new_func(lib_data);
-    SCOPE_EXIT(data_delete_func(lib_data, data_ptr));
-
-    ClickHouseLibrary::RawClickHouseLibraryTable data = load_ids_func(data_ptr, &settings->strings, &columns_pass, &ids_data);
-    auto block = dataToBlock(description.sample_block, data);
-
-    return std::make_shared<OneBlockInputStream>(block);
+    return bridge_helper->loadIds(getDictIdsString(ids));
 }
 
+
 BlockInputStreamPtr LibraryDictionarySource::loadKeys(const Columns & key_columns, const std::vector<std::size_t> & requested_rows)
 {
     LOG_TRACE(log, "loadKeys {} size = {}", toString(), requested_rows.size());
-
-    auto holder = std::make_unique<ClickHouseLibrary::Row[]>(key_columns.size());
-    std::vector<std::unique_ptr<ClickHouseLibrary::Field[]>> column_data_holders;
-    for (size_t i = 0; i < key_columns.size(); ++i)
-    {
-        auto cell_holder = std::make_unique<ClickHouseLibrary::Field[]>(requested_rows.size());
-        for (size_t j = 0; j < requested_rows.size(); ++j)
-        {
-            auto data_ref = key_columns[i]->getDataAt(requested_rows[j]);
-            cell_holder[j] = ClickHouseLibrary::Field{.data = static_cast<const void *>(data_ref.data), .size = data_ref.size};
-        }
-        holder[i]
-            = ClickHouseLibrary::Row{.data = static_cast<ClickHouseLibrary::Field *>(cell_holder.get()), .size = requested_rows.size()};
-
-        column_data_holders.push_back(std::move(cell_holder));
-    }
-
-    ClickHouseLibrary::Table request_cols{.data = static_cast<ClickHouseLibrary::Row *>(holder.get()), .size = key_columns.size()};
-
-    auto load_keys_func = library->get<ClickHouseLibrary::LibraryLoadKeysFunc>(ClickHouseLibrary::LIBRARY_LOAD_KEYS_FUNC_NAME);
-    auto data_new_func = library->get<ClickHouseLibrary::LibraryDataNewFunc>(ClickHouseLibrary::LIBRARY_DATA_NEW_FUNC_NAME);
-    auto data_delete_func = library->get<ClickHouseLibrary::LibraryDataDeleteFunc>(ClickHouseLibrary::LIBRARY_DATA_DELETE_FUNC_NAME);
-
-    ClickHouseLibrary::LibraryData data_ptr = data_new_func(lib_data);
-    SCOPE_EXIT(data_delete_func(lib_data, data_ptr));
-
-    ClickHouseLibrary::RawClickHouseLibraryTable data = load_keys_func(data_ptr, &settings->strings, &request_cols);
-    auto block = dataToBlock(description.sample_block, data);
-
-    return std::make_shared<OneBlockInputStream>(block);
+    auto block = blockForKeys(dict_struct, key_columns, requested_rows);
+    return bridge_helper->loadKeys(block);
 }
 
-bool LibraryDictionarySource::isModified() const
-{
-    if (auto func_is_modified = library->tryGet<ClickHouseLibrary::LibraryIsModifiedFunc>(
-        ClickHouseLibrary::LIBRARY_IS_MODIFIED_FUNC_NAME))
-        return func_is_modified(lib_data, &settings->strings);
-
-    return true;
-}
-
-bool LibraryDictionarySource::supportsSelectiveLoad() const
-{
-    if (auto func_supports_selective_load = library->tryGet<ClickHouseLibrary::LibrarySupportsSelectiveLoadFunc>(
-            ClickHouseLibrary::LIBRARY_SUPPORTS_SELECTIVE_LOAD_FUNC_NAME))
-        return func_supports_selective_load(lib_data, &settings->strings);
-
-    return true;
-}
 
 DictionarySourcePtr LibraryDictionarySource::clone() const
 {
     return std::make_unique<LibraryDictionarySource>(*this);
 }
 
+
 std::string LibraryDictionarySource::toString() const
 {
     return path;
 }
 
+
+String LibraryDictionarySource::getLibrarySettingsString(const Poco::Util::AbstractConfiguration & config, const std::string & config_root)
+{
+    Poco::Util::AbstractConfiguration::Keys config_keys;
+    config.keys(config_root, config_keys);
+    WriteBufferFromOwnString out;
+    std::vector<std::string> settings;
+
+    for (const auto & key : config_keys)
+    {
+        std::string key_name = key;
+        auto bracket_pos = key.find('[');
+
+        if (bracket_pos != std::string::npos && bracket_pos > 0)
+            key_name = key.substr(0, bracket_pos);
+
+        settings.push_back(key_name);
+        settings.push_back(config.getString(config_root + "." + key));
+    }
+
+    writeVectorBinary(settings, out);
+    return out.str();
+}
+
+
+String LibraryDictionarySource::getDictIdsString(const std::vector<UInt64> & ids)
+{
+    WriteBufferFromOwnString out;
+    writeVectorBinary(ids, out);
+    return out.str();
+}
+
+
+String LibraryDictionarySource::getDictAttributesString()
+{
+    std::vector<String> attributes_names(dict_struct.attributes.size());
+    for (size_t i = 0; i < dict_struct.attributes.size(); ++i)
+        attributes_names[i] = dict_struct.attributes[i].name;
+    WriteBufferFromOwnString out;
+    writeVectorBinary(attributes_names, out);
+    return out.str();
+}
+
+
 void registerDictionarySourceLibrary(DictionarySourceFactory & factory)
 {
     auto create_table_source = [=](const DictionaryStructure & dict_struct,
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
-                                 const Context & context,
+                                 ContextPtr context,
                                  const std::string & /* default_database */,
                                  bool check_config) -> DictionarySourcePtr
     {
         return std::make_unique<LibraryDictionarySource>(dict_struct, config, config_prefix + ".library", sample_block, context, check_config);
     };
+
     factory.registerSource("library", create_table_source);
 }
 
+
 }
diff --git a/src/Dictionaries/LibraryDictionarySource.h b/src/Dictionaries/LibraryDictionarySource.h
index 4d73b3f97d4..1ab47c5a06f 100644
--- a/src/Dictionaries/LibraryDictionarySource.h
+++ b/src/Dictionaries/LibraryDictionarySource.h
@@ -1,10 +1,13 @@
 #pragma once
 
 #include <Common/SharedLibrary.h>
+#include <Bridge/LibraryBridgeHelper.h>
 #include <common/LocalDateTime.h>
+#include <Core/UUID.h>
 #include "DictionaryStructure.h"
 #include <Core/ExternalResultDescription.h>
 #include "IDictionarySource.h"
+#include <Interpreters/Context_fwd.h>
 
 
 namespace Poco
@@ -17,18 +20,17 @@ namespace Util
 }
 }
 
-
 namespace DB
 {
+
 namespace ErrorCodes
 {
     extern const int NOT_IMPLEMENTED;
 }
-class CStringsHolder;
 
-/// Allows loading dictionaries from dynamic libraries (.so)
-/// Experimental version
-/// Example: tests/external_dictionaries/dictionary_library/dictionary_library.cpp
+class CStringsHolder;
+using LibraryBridgeHelperPtr = std::shared_ptr<LibraryBridgeHelper>;
+
 class LibraryDictionarySource final : public IDictionarySource
 {
 public:
@@ -37,7 +39,7 @@ public:
         const Poco::Util::AbstractConfiguration & config,
         const std::string & config_prefix_,
         Block & sample_block_,
-        const Context & context,
+        ContextPtr context_,
         bool check_config);
 
     LibraryDictionarySource(const LibraryDictionarySource & other);
@@ -49,7 +51,7 @@ public:
 
     BlockInputStreamPtr loadUpdatedAll() override
     {
-        throw Exception{"Method loadUpdatedAll is unsupported for LibraryDictionarySource", ErrorCodes::NOT_IMPLEMENTED};
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method loadUpdatedAll is unsupported for LibraryDictionarySource");
     }
 
     BlockInputStreamPtr loadIds(const std::vector<UInt64> & ids) override;
@@ -68,18 +70,26 @@ public:
     std::string toString() const override;
 
 private:
-    Poco::Logger * log;
+    static String getDictIdsString(const std::vector<UInt64> & ids);
 
-    LocalDateTime getLastModification() const;
+    String getDictAttributesString();
+
+    static String getLibrarySettingsString(const Poco::Util::AbstractConfiguration & config, const std::string & config_root);
+
+    static Field getDictID() { return UUIDHelpers::generateV4(); }
+
+    Poco::Logger * log;
 
     const DictionaryStructure dict_struct;
     const std::string config_prefix;
     const std::string path;
+    const Field dictionary_id;
+
     Block sample_block;
-    SharedLibraryPtr library;
+    ContextPtr context;
+
+    LibraryBridgeHelperPtr bridge_helper;
     ExternalResultDescription description;
-    std::shared_ptr<CStringsHolder> settings;
-    void * lib_data = nullptr;
 };
 
 }
diff --git a/src/Dictionaries/MongoDBDictionarySource.cpp b/src/Dictionaries/MongoDBDictionarySource.cpp
index 5b5d0c4d20f..0ab45dc4593 100644
--- a/src/Dictionaries/MongoDBDictionarySource.cpp
+++ b/src/Dictionaries/MongoDBDictionarySource.cpp
@@ -13,7 +13,7 @@ void registerDictionarySourceMongoDB(DictionarySourceFactory & factory)
         const Poco::Util::AbstractConfiguration & config,
         const std::string & root_config_prefix,
         Block & sample_block,
-        const Context &,
+        ContextPtr,
         const std::string & /* default_database */,
         bool /* check_config */)
     {
@@ -126,7 +126,7 @@ MongoDBDictionarySource::MongoDBDictionarySource(
 #if POCO_VERSION >= 0x01070800
             Poco::MongoDB::Database poco_db(db);
             if (!poco_db.authenticate(*connection, user, password, method.empty() ? Poco::MongoDB::Database::AUTH_SCRAM_SHA1 : method))
-                throw Exception("Cannot authenticate in MongoDB, incorrect user or password", ErrorCodes::MONGODB_CANNOT_AUTHENTICATE);
+                throw Exception(ErrorCodes::MONGODB_CANNOT_AUTHENTICATE, "Cannot authenticate in MongoDB, incorrect user or password");
 #else
             authenticate(*connection, db, user, password);
 #endif
@@ -151,7 +151,7 @@ BlockInputStreamPtr MongoDBDictionarySource::loadAll()
 BlockInputStreamPtr MongoDBDictionarySource::loadIds(const std::vector<UInt64> & ids)
 {
     if (!dict_struct.id)
-        throw Exception{"'id' is required for selective loading", ErrorCodes::UNSUPPORTED_METHOD};
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "'id' is required for selective loading");
 
     auto cursor = createCursor(db, collection, sample_block);
 
@@ -172,7 +172,7 @@ BlockInputStreamPtr MongoDBDictionarySource::loadIds(const std::vector<UInt64> &
 BlockInputStreamPtr MongoDBDictionarySource::loadKeys(const Columns & key_columns, const std::vector<size_t> & requested_rows)
 {
     if (!dict_struct.key)
-        throw Exception{"'key' is required for selective loading", ErrorCodes::UNSUPPORTED_METHOD};
+        throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "'key' is required for selective loading");
 
     auto cursor = createCursor(db, collection, sample_block);
 
@@ -198,6 +198,7 @@ BlockInputStreamPtr MongoDBDictionarySource::loadKeys(const Columns & key_column
                 case AttributeUnderlyingType::utDecimal32:
                 case AttributeUnderlyingType::utDecimal64:
                 case AttributeUnderlyingType::utDecimal128:
+                case AttributeUnderlyingType::utDecimal256:
                     key.add(attr.second.name, Int32(key_columns[attr.first]->get64(row_idx)));
                     break;
 
diff --git a/src/Dictionaries/MongoDBDictionarySource.h b/src/Dictionaries/MongoDBDictionarySource.h
index ad7b66fe1a7..fef5749190f 100644
--- a/src/Dictionaries/MongoDBDictionarySource.h
+++ b/src/Dictionaries/MongoDBDictionarySource.h
@@ -50,7 +50,7 @@ public:
 
     BlockInputStreamPtr loadUpdatedAll() override
     {
-        throw Exception{"Method loadUpdatedAll is unsupported for MongoDBDictionarySource", ErrorCodes::NOT_IMPLEMENTED};
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method loadUpdatedAll is unsupported for MongoDBDictionarySource");
     }
 
     bool supportsSelectiveLoad() const override { return true; }
diff --git a/src/Dictionaries/MySQLDictionarySource.cpp b/src/Dictionaries/MySQLDictionarySource.cpp
index a1d0cbe7ffc..a78da1c7e74 100644
--- a/src/Dictionaries/MySQLDictionarySource.cpp
+++ b/src/Dictionaries/MySQLDictionarySource.cpp
@@ -18,7 +18,7 @@ void registerDictionarySourceMysql(DictionarySourceFactory & factory)
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
-                                 const Context & /* context */,
+                                 ContextPtr /* context */,
                                  const std::string & /* default_database */,
                                  bool /* check_config */) -> DictionarySourcePtr {
 #if USE_MYSQL
@@ -28,8 +28,8 @@ void registerDictionarySourceMysql(DictionarySourceFactory & factory)
         (void)config;
         (void)config_prefix;
         (void)sample_block;
-        throw Exception{"Dictionary source of type `mysql` is disabled because ClickHouse was built without mysql support.",
-                        ErrorCodes::SUPPORT_IS_DISABLED};
+        throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
+            "Dictionary source of type `mysql` is disabled because ClickHouse was built without mysql support.");
 #endif
     };
     factory.registerSource("mysql", create_table_source);
@@ -70,7 +70,7 @@ MySQLDictionarySource::MySQLDictionarySource(
     , update_field{config.getString(config_prefix + ".update_field", "")}
     , dont_check_update_time{config.getBool(config_prefix + ".dont_check_update_time", false)}
     , sample_block{sample_block_}
-    , pool{mysqlxx::PoolFactory::instance().get(config, config_prefix)}
+    , pool{std::make_shared<mysqlxx::PoolWithFailover>(mysqlxx::PoolFactory::instance().get(config, config_prefix))}
     , query_builder{dict_struct, db, "", table, where, IdentifierQuotingStyle::Backticks}
     , load_all_query{query_builder.composeLoadAllQuery()}
     , invalidate_query{config.getString(config_prefix + ".invalidate_query", "")}
@@ -119,67 +119,43 @@ std::string MySQLDictionarySource::getUpdateFieldAndDate()
     }
 }
 
-BlockInputStreamPtr MySQLDictionarySource::retriedCreateMySqlBIStream(const std::string & data_fetch_query_str, const size_t max_tries)
+BlockInputStreamPtr MySQLDictionarySource::loadFromQuery(const String & query)
 {
-    size_t count_connection_lost = 0;
-
-    while (true)
-    {
-        auto connection = pool.get();
-
-        try
-        {
-            return std::make_shared<MySQLBlockInputStream>(
-                    connection, data_fetch_query_str, sample_block, max_block_size, close_connection);
-        }
-        catch (const mysqlxx::ConnectionLost & ecl)  /// There are two retriable failures: CR_SERVER_GONE_ERROR, CR_SERVER_LOST
-        {
-            if (++count_connection_lost < max_tries)
-            {
-                LOG_WARNING(log, ecl.displayText());
-                LOG_WARNING(log, "Lost connection ({}/{}). Trying to reconnect...", count_connection_lost, max_tries);
-                continue;
-            }
-
-            LOG_ERROR(log, "Failed ({}/{}) to create BlockInputStream for MySQL dictionary source.", count_connection_lost, max_tries);
-            throw;
-        }
-    }
+    return std::make_shared<MySQLWithFailoverBlockInputStream>(
+            pool, query, sample_block, max_block_size, close_connection, false, max_tries_for_mysql_block_input_stream);
 }
 
 BlockInputStreamPtr MySQLDictionarySource::loadAll()
 {
-    auto connection = pool.get();
+    auto connection = pool->get();
     last_modification = getLastModification(connection, false);
 
     LOG_TRACE(log, load_all_query);
-    return retriedCreateMySqlBIStream(load_all_query, max_tries_for_mysql_block_input_stream);
+    return loadFromQuery(load_all_query);
 }
 
 BlockInputStreamPtr MySQLDictionarySource::loadUpdatedAll()
 {
-    auto connection = pool.get();
+    auto connection = pool->get();
     last_modification = getLastModification(connection, false);
 
     std::string load_update_query = getUpdateFieldAndDate();
     LOG_TRACE(log, load_update_query);
-    return retriedCreateMySqlBIStream(load_update_query, max_tries_for_mysql_block_input_stream);
+    return loadFromQuery(load_update_query);
 }
 
 BlockInputStreamPtr MySQLDictionarySource::loadIds(const std::vector<UInt64> & ids)
 {
     /// We do not log in here and do not update the modification time, as the request can be large, and often called.
-
     const auto query = query_builder.composeLoadIdsQuery(ids);
-    return retriedCreateMySqlBIStream(query, max_tries_for_mysql_block_input_stream);
+    return loadFromQuery(query);
 }
 
 BlockInputStreamPtr MySQLDictionarySource::loadKeys(const Columns & key_columns, const std::vector<size_t> & requested_rows)
 {
     /// We do not log in here and do not update the modification time, as the request can be large, and often called.
-
     const auto query = query_builder.composeLoadKeysQuery(key_columns, requested_rows, ExternalQueryBuilder::AND_OR_CHAIN);
-    return retriedCreateMySqlBIStream(query, max_tries_for_mysql_block_input_stream);
+    return loadFromQuery(query);
 }
 
 bool MySQLDictionarySource::isModified() const
@@ -195,7 +171,7 @@ bool MySQLDictionarySource::isModified() const
 
     if (dont_check_update_time)
         return true;
-    auto connection = pool.get();
+    auto connection = pool->get();
     return getLastModification(connection, true) > last_modification;
 }
 
@@ -293,7 +269,7 @@ std::string MySQLDictionarySource::doInvalidateQuery(const std::string & request
     Block invalidate_sample_block;
     ColumnPtr column(ColumnString::create());
     invalidate_sample_block.insert(ColumnWithTypeAndName(column, std::make_shared<DataTypeString>(), "Sample Block"));
-    MySQLBlockInputStream block_input_stream(pool.get(), request, invalidate_sample_block, 1, close_connection);
+    MySQLBlockInputStream block_input_stream(pool->get(), request, invalidate_sample_block, 1, close_connection);
     return readInvalidateQuery(block_input_stream);
 }
 
diff --git a/src/Dictionaries/MySQLDictionarySource.h b/src/Dictionaries/MySQLDictionarySource.h
index 54bc2da6a56..dcd911146aa 100644
--- a/src/Dictionaries/MySQLDictionarySource.h
+++ b/src/Dictionaries/MySQLDictionarySource.h
@@ -34,7 +34,7 @@ public:
     MySQLDictionarySource(
         const DictionaryStructure & dict_struct_,
         const Poco::Util::AbstractConfiguration & config,
-        const std::string & config_prefix,
+        const String & config_prefix,
         const Block & sample_block_);
 
     /// copy-constructor is provided in order to support cloneability
@@ -60,6 +60,8 @@ public:
     std::string toString() const override;
 
 private:
+    BlockInputStreamPtr loadFromQuery(const String & query);
+
     std::string getUpdateFieldAndDate();
 
     static std::string quoteForLike(const std::string s);
@@ -69,9 +71,6 @@ private:
     // execute invalidate_query. expects single cell in result
     std::string doInvalidateQuery(const std::string & request) const;
 
-    /// A helper method for recovering from "Lost connection to MySQL server during query" errors
-    BlockInputStreamPtr retriedCreateMySqlBIStream(const std::string & query_str, const size_t max_tries);
-
     Poco::Logger * log;
 
     std::chrono::time_point<std::chrono::system_clock> update_time;
@@ -82,7 +81,7 @@ private:
     const std::string update_field;
     const bool dont_check_update_time;
     Block sample_block;
-    mutable mysqlxx::PoolWithFailover pool;
+    mutable mysqlxx::PoolWithFailoverPtr pool;
     ExternalQueryBuilder query_builder;
     const std::string load_all_query;
     LocalDateTime last_modification;
diff --git a/src/Dictionaries/PolygonDictionary.cpp b/src/Dictionaries/PolygonDictionary.cpp
index 7046741b3a0..64d435cf632 100644
--- a/src/Dictionaries/PolygonDictionary.cpp
+++ b/src/Dictionaries/PolygonDictionary.cpp
@@ -151,7 +151,7 @@ BlockInputStreamPtr IPolygonDictionary::getBlockInputStream(const Names &, size_
 {
     // TODO: In order for this to work one would first have to support retrieving arrays from dictionaries.
     //  I believe this is a separate task done by some other people.
-    throw Exception{"Reading the dictionary is not allowed", ErrorCodes::UNSUPPORTED_METHOD};
+    throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "Reading the dictionary is not allowed");
 }
 
 void IPolygonDictionary::setup()
@@ -164,9 +164,9 @@ void IPolygonDictionary::setup()
         attributes.emplace_back(std::move(column));
 
         if (attribute.hierarchical)
-            throw Exception{ErrorCodes::TYPE_MISMATCH,
+            throw Exception(ErrorCodes::TYPE_MISMATCH,
                             "{}: hierarchical attributes not supported for dictionary of polygonal type",
-                            getDictionaryID().getNameForLogs()};
+                            getDictionaryID().getNameForLogs());
     }
 }
 
@@ -248,13 +248,13 @@ void IPolygonDictionary::calculateBytesAllocated()
 std::vector<IPolygonDictionary::Point> IPolygonDictionary::extractPoints(const Columns & key_columns)
 {
     if (key_columns.size() != 2)
-        throw Exception{"Expected two columns of coordinates with type Float64", ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Expected two columns of coordinates with type Float64");
 
     const auto * column_x = typeid_cast<const ColumnVector<Float64>*>(key_columns[0].get());
     const auto * column_y = typeid_cast<const ColumnVector<Float64>*>(key_columns[1].get());
 
     if (!column_x || !column_y)
-        throw Exception{"Expected columns of Float64", ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected columns of Float64");
 
     const auto rows = key_columns.front()->size();
 
@@ -392,17 +392,17 @@ const IColumn * unrollMultiPolygons(const ColumnPtr & column, Offset & offset)
 {
     const auto * ptr_multi_polygons = typeid_cast<const ColumnArray*>(column.get());
     if (!ptr_multi_polygons)
-        throw Exception{"Expected a column containing arrays of polygons", ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected a column containing arrays of polygons");
     offset.multi_polygon_offsets.assign(ptr_multi_polygons->getOffsets());
 
     const auto * ptr_polygons = typeid_cast<const ColumnArray*>(&ptr_multi_polygons->getData());
     if (!ptr_polygons)
-        throw Exception{"Expected a column containing arrays of rings when reading polygons", ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected a column containing arrays of rings when reading polygons");
     offset.polygon_offsets.assign(ptr_polygons->getOffsets());
 
     const auto * ptr_rings = typeid_cast<const ColumnArray*>(&ptr_polygons->getData());
     if (!ptr_rings)
-        throw Exception{"Expected a column containing arrays of points when reading rings", ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected a column containing arrays of points when reading rings");
     offset.ring_offsets.assign(ptr_rings->getOffsets());
 
     return ptr_rings->getDataPtr().get();
@@ -412,7 +412,7 @@ const IColumn * unrollSimplePolygons(const ColumnPtr & column, Offset & offset)
 {
     const auto * ptr_polygons = typeid_cast<const ColumnArray*>(column.get());
     if (!ptr_polygons)
-        throw Exception{"Expected a column containing arrays of points", ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected a column containing arrays of points");
     offset.ring_offsets.assign(ptr_polygons->getOffsets());
     std::iota(offset.polygon_offsets.begin(), offset.polygon_offsets.end(), 1);
     offset.multi_polygon_offsets.assign(offset.polygon_offsets);
@@ -425,13 +425,13 @@ void handlePointsReprByArrays(const IColumn * column, Data & data, Offset & offs
     const auto * ptr_points = typeid_cast<const ColumnArray*>(column);
     const auto * ptr_coord = typeid_cast<const ColumnVector<Float64>*>(&ptr_points->getData());
     if (!ptr_coord)
-        throw Exception{"Expected coordinates to be of type Float64", ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected coordinates to be of type Float64");
     const auto & offsets = ptr_points->getOffsets();
     IColumn::Offset prev_offset = 0;
     for (size_t i = 0; i < offsets.size(); ++i)
     {
         if (offsets[i] - prev_offset != 2)
-            throw Exception{"All points should be two-dimensional", ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "All points should be two-dimensional");
         prev_offset = offsets[i];
         addNewPoint(ptr_coord->getElement(2 * i), ptr_coord->getElement(2 * i + 1), data, offset);
     }
@@ -441,13 +441,13 @@ void handlePointsReprByTuples(const IColumn * column, Data & data, Offset & offs
 {
     const auto * ptr_points = typeid_cast<const ColumnTuple*>(column);
     if (!ptr_points)
-        throw Exception{"Expected a column of tuples representing points", ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected a column of tuples representing points");
     if (ptr_points->tupleSize() != 2)
-        throw Exception{"Points should be two-dimensional", ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Points should be two-dimensional");
     const auto * column_x = typeid_cast<const ColumnVector<Float64>*>(&ptr_points->getColumn(0));
     const auto * column_y = typeid_cast<const ColumnVector<Float64>*>(&ptr_points->getColumn(1));
     if (!column_x || !column_y)
-        throw Exception{"Expected coordinates to be of type Float64", ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "Expected coordinates to be of type Float64");
     for (size_t i = 0; i < column_x->size(); ++i)
     {
         addNewPoint(column_x->getElement(i), column_y->getElement(i), data, offset);
@@ -473,8 +473,8 @@ void IPolygonDictionary::extractPolygons(const ColumnPtr & column)
     }
 
     if (!offset.allRingsHaveAPositiveArea())
-        throw Exception{"Every ring included in a polygon or excluded from it should contain at least 3 points",
-                        ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS,
+            "Every ring included in a polygon or excluded from it should contain at least 3 points");
 
     /** Adding the first empty polygon */
     data.addPolygon(true);
diff --git a/src/Dictionaries/PolygonDictionaryImplementations.cpp b/src/Dictionaries/PolygonDictionaryImplementations.cpp
index cb4bd05fd83..fb4fb605465 100644
--- a/src/Dictionaries/PolygonDictionaryImplementations.cpp
+++ b/src/Dictionaries/PolygonDictionaryImplementations.cpp
@@ -172,10 +172,10 @@ DictionaryPtr createLayout(const std::string & ,
     const String name = config.getString(config_prefix + ".name");
 
     if (!dict_struct.key)
-        throw Exception{"'key' is required for a polygon dictionary", ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "'key' is required for a polygon dictionary");
     if (dict_struct.key->size() != 1)
-        throw Exception{"The 'key' should consist of a single attribute for a polygon dictionary",
-                        ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS,
+            "The 'key' should consist of a single attribute for a polygon dictionary");
 
     IPolygonDictionary::InputType input_type;
     IPolygonDictionary::PointType point_type;
@@ -206,19 +206,19 @@ DictionaryPtr createLayout(const std::string & ,
         point_type = IPolygonDictionary::PointType::Tuple;
     }
     else
-        throw Exception{"The key type " + key_type->getName() +
-                        " is not one of the following allowed types for a polygon dictionary: " +
-                        multi_polygon_array.getName() + " " +
-                        multi_polygon_tuple.getName() + " " +
-                        simple_polygon_array.getName() + " " +
-                        simple_polygon_tuple.getName() + " ",
-                        ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS,
+            "The key type {} is not one of the following allowed types for a polygon dictionary: {} {} {} {} ",
+            key_type->getName(),
+            multi_polygon_array.getName(),
+            multi_polygon_tuple.getName(),
+            simple_polygon_array.getName(),
+            simple_polygon_tuple.getName());
 
     if (dict_struct.range_min || dict_struct.range_max)
-        throw Exception{name
-                        + ": elements range_min and range_max should be defined only "
-                          "for a dictionary of layout 'range_hashed'",
-                        ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS,
+            "{}: elements range_min and range_max should be defined only "
+            "for a dictionary of layout 'range_hashed'",
+            name);
 
     const DictionaryLifetime dict_lifetime{config, config_prefix + ".lifetime"};
 
diff --git a/src/Dictionaries/PostgreSQLDictionarySource.cpp b/src/Dictionaries/PostgreSQLDictionarySource.cpp
index 79298fc2fb3..54022dfd5cb 100644
--- a/src/Dictionaries/PostgreSQLDictionarySource.cpp
+++ b/src/Dictionaries/PostgreSQLDictionarySource.cpp
@@ -31,7 +31,7 @@ PostgreSQLDictionarySource::PostgreSQLDictionarySource(
     const Block & sample_block_)
     : dict_struct{dict_struct_}
     , sample_block(sample_block_)
-    , connection(std::make_shared<PostgreSQLReplicaConnection>(config_, config_prefix))
+    , connection(std::make_shared<postgres::PoolWithFailover>(config_, config_prefix))
     , log(&Poco::Logger::get("PostgreSQLDictionarySource"))
     , db(config_.getString(fmt::format("{}.db", config_prefix), ""))
     , table(config_.getString(fmt::format("{}.table", config_prefix), ""))
@@ -167,7 +167,7 @@ void registerDictionarySourcePostgreSQL(DictionarySourceFactory & factory)
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & root_config_prefix,
                                  Block & sample_block,
-                                 const Context & /* context */,
+                                 ContextPtr /* context */,
                                  const std::string & /* default_database */,
                                  bool /* check_config */) -> DictionarySourcePtr
     {
@@ -180,8 +180,8 @@ void registerDictionarySourcePostgreSQL(DictionarySourceFactory & factory)
         (void)config;
         (void)root_config_prefix;
         (void)sample_block;
-        throw Exception{"Dictionary source of type `postgresql` is disabled because ClickHouse was built without postgresql support.",
-                        ErrorCodes::SUPPORT_IS_DISABLED};
+        throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
+            "Dictionary source of type `postgresql` is disabled because ClickHouse was built without postgresql support.");
 #endif
     };
     factory.registerSource("postgresql", create_table_source);
diff --git a/src/Dictionaries/PostgreSQLDictionarySource.h b/src/Dictionaries/PostgreSQLDictionarySource.h
index dd2d35db83a..f1520a37a79 100644
--- a/src/Dictionaries/PostgreSQLDictionarySource.h
+++ b/src/Dictionaries/PostgreSQLDictionarySource.h
@@ -11,7 +11,7 @@
 #include <Core/Block.h>
 #include <common/LocalDateTime.h>
 #include <common/logger_useful.h>
-#include <Storages/PostgreSQL/PostgreSQLReplicaConnection.h>
+#include <Storages/PostgreSQL/PostgreSQLPoolWithFailover.h>
 #include <pqxx/pqxx>
 
 
@@ -51,7 +51,7 @@ private:
 
     const DictionaryStructure dict_struct;
     Block sample_block;
-    PostgreSQLReplicaConnectionPtr connection;
+    postgres::PoolWithFailoverPtr connection;
     Poco::Logger * log;
 
     const std::string db;
diff --git a/src/Dictionaries/RangeHashedDictionary.cpp b/src/Dictionaries/RangeHashedDictionary.cpp
index 30395114a8e..1bdcd942b4a 100644
--- a/src/Dictionaries/RangeHashedDictionary.cpp
+++ b/src/Dictionaries/RangeHashedDictionary.cpp
@@ -260,8 +260,8 @@ void RangeHashedDictionary::createAttributes()
         attributes.push_back(createAttribute(attribute, attribute.null_value));
 
         if (attribute.hierarchical)
-            throw Exception{ErrorCodes::BAD_ARGUMENTS, "Hierarchical attributes not supported by {} dictionary.",
-                            getDictionaryID().getNameForLogs()};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Hierarchical attributes not supported by {} dictionary.",
+                            getDictionaryID().getNameForLogs());
     }
 }
 
@@ -311,8 +311,8 @@ void RangeHashedDictionary::loadData()
     stream->readSuffix();
 
     if (require_nonempty && 0 == element_count)
-        throw Exception{full_name + ": dictionary source is empty and 'require_nonempty' property is set.",
-                        ErrorCodes::DICTIONARY_IS_EMPTY};
+        throw Exception(ErrorCodes::DICTIONARY_IS_EMPTY,
+            "{}: dictionary source is empty and 'require_nonempty' property is set.");
 }
 
 template <typename T>
@@ -497,7 +497,7 @@ const RangeHashedDictionary::Attribute & RangeHashedDictionary::getAttribute(con
 {
     const auto it = attribute_index_by_name.find(attribute_name);
     if (it == std::end(attribute_index_by_name))
-        throw Exception{full_name + ": no such attribute '" + attribute_name + "'", ErrorCodes::BAD_ARGUMENTS};
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "{}: no such attribute '{}'", full_name, attribute_name);
 
     return attributes[it->second];
 }
@@ -507,8 +507,9 @@ RangeHashedDictionary::getAttributeWithType(const std::string & attribute_name,
 {
     const auto & attribute = getAttribute(attribute_name);
     if (attribute.type != type)
-        throw Exception{attribute_name + ": type mismatch: attribute " + attribute_name + " has type " + toString(attribute.type),
-                        ErrorCodes::TYPE_MISMATCH};
+        throw Exception(ErrorCodes::TYPE_MISMATCH, "attribute {} has type {}",
+            attribute_name,
+            toString(attribute.type));
 
     return attribute;
 }
@@ -613,8 +614,9 @@ BlockInputStreamPtr RangeHashedDictionary::getBlockInputStream(const Names & col
     ListType::forEach(callable);
 
     if (!callable.stream)
-        throw Exception(
-            "Unexpected range type for RangeHashed dictionary: " + dict_struct.range_min->type->getName(), ErrorCodes::LOGICAL_ERROR);
+        throw Exception(ErrorCodes::LOGICAL_ERROR,
+            "Unexpected range type for RangeHashed dictionary: {}",
+            dict_struct.range_min->type->getName());
 
     return callable.stream;
 }
@@ -629,11 +631,12 @@ void registerDictionaryRangeHashed(DictionaryFactory & factory)
                              DictionarySourcePtr source_ptr) -> DictionaryPtr
     {
         if (dict_struct.key)
-            throw Exception{"'key' is not supported for dictionary of layout 'range_hashed'", ErrorCodes::UNSUPPORTED_METHOD};
+            throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "'key' is not supported for dictionary of layout 'range_hashed'");
 
         if (!dict_struct.range_min || !dict_struct.range_max)
-            throw Exception{full_name + ": dictionary of layout 'range_hashed' requires .structure.range_min and .structure.range_max",
-                            ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                "{}: dictionary of layout 'range_hashed' requires .structure.range_min and .structure.range_max",
+                full_name);
 
         const auto dict_id = StorageID::fromDictionaryConfig(config, config_prefix);
         const DictionaryLifetime dict_lifetime{config, config_prefix + ".lifetime"};
diff --git a/src/Dictionaries/RangeHashedDictionary.h b/src/Dictionaries/RangeHashedDictionary.h
index ca2a925df5e..8a286f530ba 100644
--- a/src/Dictionaries/RangeHashedDictionary.h
+++ b/src/Dictionaries/RangeHashedDictionary.h
@@ -112,6 +112,7 @@ private:
             Decimal32,
             Decimal64,
             Decimal128,
+            Decimal256,
             Float32,
             Float64,
             StringRef>
@@ -129,6 +130,7 @@ private:
             Ptr<Decimal32>,
             Ptr<Decimal64>,
             Ptr<Decimal128>,
+            Ptr<Decimal256>,
             Ptr<Float32>,
             Ptr<Float64>,
             Ptr<StringRef>>
diff --git a/src/Dictionaries/RedisBlockInputStream.cpp b/src/Dictionaries/RedisBlockInputStream.cpp
index 39cc2d610df..f74ac348a99 100644
--- a/src/Dictionaries/RedisBlockInputStream.cpp
+++ b/src/Dictionaries/RedisBlockInputStream.cpp
@@ -57,7 +57,7 @@ namespace DB
         void insertValue(IColumn & column, const ValueType type, const Poco::Redis::BulkString & bulk_string)
         {
             if (bulk_string.isNull())
-                throw Exception{"Type mismatch, expected not Null String", ErrorCodes::TYPE_MISMATCH};
+                throw Exception(ErrorCodes::TYPE_MISMATCH, "Type mismatch, expected not Null String");
 
             const String & string_value = bulk_string.value();
             switch (type)
@@ -112,7 +112,9 @@ namespace DB
                     assert_cast<ColumnUInt128 &>(column).insertValue(parse<UUID>(string_value));
                     break;
                 default:
-                    throw Exception("Value of unsupported type:" + column.getName(), ErrorCodes::UNKNOWN_TYPE);
+                    throw Exception(ErrorCodes::UNKNOWN_TYPE,
+                        "Value of unsupported type: {}",
+                        column.getName());
             }
         }
     }
@@ -152,8 +154,9 @@ namespace DB
                 const auto & keys_array = keys.get<RedisArray>(cursor);
                 if (keys_array.size() < 2)
                 {
-                    throw Exception{"Too low keys in request to source: " + DB::toString(keys_array.size())
-                                    + ", expected 2 or more", ErrorCodes::LOGICAL_ERROR};
+                    throw Exception(ErrorCodes::LOGICAL_ERROR,
+                        "Too low keys in request to source: {}, expected 2 or more",
+                        DB::toString(keys_array.size()));
                 }
 
                 if (num_rows + keys_array.size() - 1 > max_block_size)
@@ -166,8 +169,8 @@ namespace DB
                 auto values = client->execute<RedisArray>(command_for_values);
 
                 if (keys_array.size() != values.size() + 1) // 'HMGET' primary_key secondary_keys
-                    throw Exception{"Inconsistent sizes of keys and values in Redis request",
-                                    ErrorCodes::NUMBER_OF_COLUMNS_DOESNT_MATCH};
+                    throw Exception(ErrorCodes::NUMBER_OF_COLUMNS_DOESNT_MATCH,
+                        "Inconsistent sizes of keys and values in Redis request");
 
                 const auto & primary_key = keys_array.get<RedisBulkString>(0);
                 for (size_t i = 0; i < values.size(); ++i)
@@ -196,7 +199,8 @@ namespace DB
 
             auto values = client->execute<RedisArray>(command_for_values);
             if (values.size() != need_values)
-                throw Exception{"Inconsistent sizes of keys and values in Redis request", ErrorCodes::INTERNAL_REDIS_ERROR};
+                throw Exception(ErrorCodes::INTERNAL_REDIS_ERROR,
+                    "Inconsistent sizes of keys and values in Redis request");
 
             for (size_t i = 0; i < values.size(); ++i)
             {
diff --git a/src/Dictionaries/RedisDictionarySource.cpp b/src/Dictionaries/RedisDictionarySource.cpp
index f1d0c0c5d3c..8144b37e63d 100644
--- a/src/Dictionaries/RedisDictionarySource.cpp
+++ b/src/Dictionaries/RedisDictionarySource.cpp
@@ -12,7 +12,7 @@ void registerDictionarySourceRedis(DictionarySourceFactory & factory)
                                    const Poco::Util::AbstractConfiguration & config,
                                    const String & config_prefix,
                                    Block & sample_block,
-                                   const Context & /* context */,
+                                   ContextPtr /* context */,
                                    const std::string & /* default_database */,
                                    bool /* check_config */) -> DictionarySourcePtr {
         return std::make_unique<RedisDictionarySource>(dict_struct, config, config_prefix + ".redis", sample_block);
@@ -66,25 +66,27 @@ namespace DB
             , client{std::make_shared<Poco::Redis::Client>(host, port)}
     {
         if (dict_struct.attributes.size() != 1)
-            throw Exception{"Invalid number of non key columns for Redis source: " +
-                            DB::toString(dict_struct.attributes.size()) + ", expected 1",
-                            ErrorCodes::INVALID_CONFIG_PARAMETER};
+            throw Exception(ErrorCodes::INVALID_CONFIG_PARAMETER,
+                "Invalid number of non key columns for Redis source: {}, expected 1",
+                DB::toString(dict_struct.attributes.size()));
 
         if (storage_type == RedisStorageType::HASH_MAP)
         {
             if (!dict_struct.key)
-                throw Exception{"Redis source with storage type \'hash_map\' must have key",
-                                ErrorCodes::INVALID_CONFIG_PARAMETER};
+                throw Exception(ErrorCodes::INVALID_CONFIG_PARAMETER,
+                    "Redis source with storage type \'hash_map\' must have key");
 
             if (dict_struct.key->size() != 2)
-                throw Exception{"Redis source with storage type \'hash_map\' requires 2 keys",
-                                ErrorCodes::INVALID_CONFIG_PARAMETER};
+                throw Exception(ErrorCodes::INVALID_CONFIG_PARAMETER,
+                    "Redis source with storage type \'hash_map\' requires 2 keys");
             // suppose key[0] is primary key, key[1] is secondary key
 
             for (const auto & key : *dict_struct.key)
                 if (!isInteger(key.type) && !isString(key.type))
                     throw Exception(ErrorCodes::INVALID_CONFIG_PARAMETER,
-                        "Redis source supports only integer or string key, but key '{}' of type {} given", key.name, key.type->getName());
+                        "Redis source supports only integer or string key, but key '{}' of type {} given",
+                        key.name,
+                        key.type->getName());
         }
 
         if (!password.empty())
@@ -93,8 +95,9 @@ namespace DB
             command << password;
             String reply = client->execute<String>(command);
             if (reply != "OK")
-                throw Exception{"Authentication failed with reason "
-                     + reply, ErrorCodes::INTERNAL_REDIS_ERROR};
+                throw Exception(ErrorCodes::INTERNAL_REDIS_ERROR,
+                    "Authentication failed with reason {}",
+                    reply);
         }
 
         if (db_index != 0)
@@ -103,8 +106,10 @@ namespace DB
             command << std::to_string(db_index);
             String reply = client->execute<String>(command);
             if (reply != "OK")
-                throw Exception{"Selecting database with index " + DB::toString(db_index)
-                    + " failed with reason " + reply, ErrorCodes::INTERNAL_REDIS_ERROR};
+                throw Exception(ErrorCodes::INTERNAL_REDIS_ERROR,
+                    "Selecting database with index {} failed with reason {}",
+                    DB::toString(db_index),
+                    reply);
         }
     }
 
@@ -215,10 +220,10 @@ namespace DB
             client->connect(host, port);
 
         if (storage_type == RedisStorageType::HASH_MAP)
-            throw Exception{"Cannot use loadIds with 'hash_map' storage type", ErrorCodes::UNSUPPORTED_METHOD};
+            throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "Cannot use loadIds with 'hash_map' storage type");
 
         if (!dict_struct.id)
-            throw Exception{"'id' is required for selective loading", ErrorCodes::UNSUPPORTED_METHOD};
+            throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "'id' is required for selective loading");
 
         RedisArray keys;
 
@@ -234,7 +239,7 @@ namespace DB
             client->connect(host, port);
 
         if (key_columns.size() != dict_struct.key->size())
-            throw Exception{"The size of key_columns does not equal to the size of dictionary key", ErrorCodes::LOGICAL_ERROR};
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "The size of key_columns does not equal to the size of dictionary key");
 
         RedisArray keys;
         for (auto row : requested_rows)
@@ -268,7 +273,7 @@ namespace DB
         if (storage_type_str == "hash_map")
             return RedisStorageType::HASH_MAP;
         else if (!storage_type_str.empty() && storage_type_str != "simple")
-            throw Exception("Unknown storage type " + storage_type_str + " for Redis dictionary", ErrorCodes::INVALID_CONFIG_PARAMETER);
+            throw Exception(ErrorCodes::INVALID_CONFIG_PARAMETER, "Unknown storage type {} for Redis dictionary", storage_type_str);
 
         return RedisStorageType::SIMPLE;
     }
diff --git a/src/Dictionaries/RedisDictionarySource.h b/src/Dictionaries/RedisDictionarySource.h
index 71d2a7e724a..b2c5859decd 100644
--- a/src/Dictionaries/RedisDictionarySource.h
+++ b/src/Dictionaries/RedisDictionarySource.h
@@ -63,7 +63,7 @@ namespace ErrorCodes
 
         BlockInputStreamPtr loadUpdatedAll() override
         {
-            throw Exception{"Method loadUpdatedAll is unsupported for RedisDictionarySource", ErrorCodes::NOT_IMPLEMENTED};
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method loadUpdatedAll is unsupported for RedisDictionarySource");
         }
 
         bool supportsSelectiveLoad() const override { return true; }
diff --git a/src/Dictionaries/SSDCacheDictionaryStorage.h b/src/Dictionaries/SSDCacheDictionaryStorage.h
index 67f0465a2c7..7d72beca35e 100644
--- a/src/Dictionaries/SSDCacheDictionaryStorage.h
+++ b/src/Dictionaries/SSDCacheDictionaryStorage.h
@@ -465,7 +465,7 @@ public:
         /// If cache file is in directory that does not exists create it
         if (!std::filesystem::exists(parent_path_directory))
             if (!std::filesystem::create_directories(parent_path_directory))
-                throw Exception{"Failed to create directories.", ErrorCodes::CANNOT_CREATE_DIRECTORY};
+                throw Exception(ErrorCodes::CANNOT_CREATE_DIRECTORY, "Failed to create directories.");
 
         ProfileEvents::increment(ProfileEvents::FileOpen);
 
@@ -514,7 +514,7 @@ public:
         while (io_submit(aio_context.ctx, 1, &write_request_ptr) < 0)
         {
             if (errno != EINTR)
-                throw Exception("Cannot submit request for asynchronous IO on file " + file_path, ErrorCodes::CANNOT_IO_SUBMIT);
+                throw Exception(ErrorCodes::CANNOT_IO_SUBMIT, "Cannot submit request for asynchronous IO on file {}", file_path);
         }
 
         // CurrentMetrics::Increment metric_increment_write{CurrentMetrics::Write};
@@ -524,7 +524,7 @@ public:
         while (io_getevents(aio_context.ctx, 1, 1, &event, nullptr) < 0)
         {
             if (errno != EINTR)
-                throw Exception("Failed to wait for asynchronous IO completion on file " + file_path, ErrorCodes::CANNOT_IO_GETEVENTS);
+                throw Exception(ErrorCodes::CANNOT_IO_GETEVENTS, "Failed to wait for asynchronous IO completion on file {}", file_path);
         }
 
         // Unpoison the memory returned from an uninstrumented system function.
@@ -536,7 +536,10 @@ public:
         ProfileEvents::increment(ProfileEvents::WriteBufferAIOWriteBytes, bytes_written);
 
         if (bytes_written != static_cast<decltype(bytes_written)>(block_size * buffer_size_in_blocks))
-            throw Exception("Not all data was written for asynchronous IO on file " + file_path + ". returned: " + std::to_string(bytes_written), ErrorCodes::AIO_WRITE_ERROR);
+            throw Exception(ErrorCodes::AIO_WRITE_ERROR,
+                "Not all data was written for asynchronous IO on file {}. returned: {}",
+                file_path,
+                std::to_string(bytes_written));
 
         if (::fsync(file.fd) < 0)
             throwFromErrnoWithPath("Cannot fsync " + file_path, file_path, ErrorCodes::CANNOT_FSYNC);
@@ -593,7 +596,10 @@ public:
 
         if (read_bytes != static_cast<ssize_t>(buffer_size_in_bytes))
             throw Exception(ErrorCodes::AIO_READ_ERROR,
-                "GC: AIO failed to read file ({}). Expected bytes ({}). Actual bytes ({})", file_path, buffer_size_in_bytes, read_bytes);
+                "GC: AIO failed to read file {}. Expected bytes {}. Actual bytes {}",
+                file_path,
+                buffer_size_in_bytes,
+                read_bytes);
 
         SSDCacheBlock block(block_size);
 
@@ -694,7 +700,10 @@ public:
                 {
                     std::string calculated_check_sum = std::to_string(block.calculateCheckSum());
                     std::string check_sum = std::to_string(block.getCheckSum());
-                    throw Exception("Cache data corrupted. Checksum validation failed. Calculated " +  calculated_check_sum + " in block " + check_sum, ErrorCodes::CORRUPTED_DATA);
+                    throw Exception(ErrorCodes::CORRUPTED_DATA,
+                        "Cache data corrupted. Checksum validation failed. Calculated {} in block {}",
+                        calculated_check_sum,
+                        check_sum);
                 }
 
                 std::forward<FetchBlockFunc>(func)(blocks_to_fetch[block_to_fetch_index], block.getBlockData());
@@ -835,7 +844,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::simple)
             return fetchColumnsForKeysImpl<SimpleKeysStorageFetchResult>(keys, fetch_request);
         else
-            throw Exception("Method insertColumnsForKeys is not supported for complex key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method insertColumnsForKeys is not supported for complex key storage");
     }
 
     void insertColumnsForKeys(const PaddedPODArray<UInt64> & keys, Columns columns) override
@@ -843,7 +852,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::simple)
             insertColumnsForKeysImpl(keys, columns);
         else
-            throw Exception("Method insertColumnsForKeys is not supported for complex key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method insertColumnsForKeys is not supported for complex key storage");
     }
 
     void insertDefaultKeys(const PaddedPODArray<UInt64> & keys) override
@@ -851,7 +860,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::simple)
             insertDefaultKeysImpl(keys);
         else
-            throw Exception("Method insertDefaultKeysImpl is not supported for complex key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method insertDefaultKeysImpl is not supported for complex key storage");
     }
 
     PaddedPODArray<UInt64> getCachedSimpleKeys() const override
@@ -859,7 +868,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::simple)
             return getCachedKeysImpl();
         else
-            throw Exception("Method getCachedSimpleKeys is not supported for complex key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method getCachedSimpleKeys is not supported for complex key storage");
     }
 
     bool supportsComplexKeys() const override { return dictionary_key_type == DictionaryKeyType::complex; }
@@ -871,7 +880,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::complex)
             return fetchColumnsForKeysImpl<ComplexKeysStorageFetchResult>(keys, fetch_request);
         else
-            throw Exception("Method fetchColumnsForKeys is not supported for simple key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method fetchColumnsForKeys is not supported for simple key storage");
     }
 
     void insertColumnsForKeys(const PaddedPODArray<StringRef> & keys, Columns columns) override
@@ -879,7 +888,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::complex)
             insertColumnsForKeysImpl(keys, columns);
         else
-            throw Exception("Method insertColumnsForKeys is not supported for simple key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method insertColumnsForKeys is not supported for simple key storage");
     }
 
     void insertDefaultKeys(const PaddedPODArray<StringRef> & keys) override
@@ -887,7 +896,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::complex)
             insertDefaultKeysImpl(keys);
         else
-            throw Exception("Method insertDefaultKeysImpl is not supported for simple key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method insertDefaultKeysImpl is not supported for simple key storage");
     }
 
     PaddedPODArray<StringRef> getCachedComplexKeys() const override
@@ -895,7 +904,7 @@ public:
         if constexpr (dictionary_key_type == DictionaryKeyType::complex)
             return getCachedKeysImpl();
         else
-            throw Exception("Method getCachedSimpleKeys is not supported for simple key storage", ErrorCodes::NOT_IMPLEMENTED);
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method getCachedSimpleKeys is not supported for simple key storage");
     }
 
     size_t getSize() const override { return index.size(); }
@@ -1108,7 +1117,7 @@ private:
             SSDCacheKeyType ssd_cache_key { key, allocated_size_for_columns, block_start };
 
             if (!SSDCacheBlock::canBeWrittenInEmptyBlock(ssd_cache_key, configuration.block_size))
-                throw Exception("Serialized columns size is greater than allowed block size and metadata", ErrorCodes::UNSUPPORTED_METHOD);
+                throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "Serialized columns size is greater than allowed block size and metadata");
 
             /// We cannot reuse place that is already allocated in file or memory cache so we erase key from index
             eraseKeyFromIndex(key);
diff --git a/src/Dictionaries/XDBCDictionarySource.cpp b/src/Dictionaries/XDBCDictionarySource.cpp
index 37d54f3549c..ac7b9111a11 100644
--- a/src/Dictionaries/XDBCDictionarySource.cpp
+++ b/src/Dictionaries/XDBCDictionarySource.cpp
@@ -11,7 +11,6 @@
 #include <Interpreters/Context.h>
 #include <Poco/Net/HTTPRequest.h>
 #include <Poco/Util/AbstractConfiguration.h>
-#include <Common/XDBCBridgeHelper.h>
 #include <common/LocalDateTime.h>
 #include <common/logger_useful.h>
 #include "DictionarySourceFactory.h"
@@ -41,7 +40,7 @@ namespace
             const Poco::URI & uri,
             std::function<void(std::ostream &)> callback,
             const Block & sample_block,
-            const Context & context,
+            ContextPtr context,
             UInt64 max_block_size,
             const ConnectionTimeouts & timeouts,
             const String name_)
@@ -89,9 +88,9 @@ namespace
         else
         {
             if (!schema.empty())
-                throw Exception{"Dictionary source of type " + bridge_.getName() + " specifies a schema but schema is not supported by "
-                                    + bridge_.getName() + "-driver",
-                                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                    "Dictionary source of type {0} specifies a schema but schema is not supported by {0}-driver",
+                    bridge_.getName());
         }
 
         return {dict_struct_, db_, schema, table, where_, bridge_.getIdentifierQuotingStyle()};
@@ -106,9 +105,10 @@ XDBCDictionarySource::XDBCDictionarySource(
     const Poco::Util::AbstractConfiguration & config_,
     const std::string & config_prefix_,
     const Block & sample_block_,
-    const Context & context_,
+    ContextPtr context_,
     const BridgeHelperPtr bridge_)
-    : log(&Poco::Logger::get(bridge_->getName() + "DictionarySource"))
+    : WithContext(context_->getGlobalContext())
+    , log(&Poco::Logger::get(bridge_->getName() + "DictionarySource"))
     , update_time{std::chrono::system_clock::from_time_t(0)}
     , dict_struct{dict_struct_}
     , db{config_.getString(config_prefix_ + ".db", "")}
@@ -122,7 +122,6 @@ XDBCDictionarySource::XDBCDictionarySource(
     , invalidate_query{config_.getString(config_prefix_ + ".invalidate_query", "")}
     , bridge_helper{bridge_}
     , timeouts{ConnectionTimeouts::getHTTPTimeouts(context_)}
-    , global_context(context_.getGlobalContext())
 {
     bridge_url = bridge_helper->getMainURI();
 
@@ -133,7 +132,8 @@ XDBCDictionarySource::XDBCDictionarySource(
 
 /// copy-constructor is provided in order to support cloneability
 XDBCDictionarySource::XDBCDictionarySource(const XDBCDictionarySource & other)
-    : log(&Poco::Logger::get(other.bridge_helper->getName() + "DictionarySource"))
+    : WithContext(other.getContext())
+    , log(&Poco::Logger::get(other.bridge_helper->getName() + "DictionarySource"))
     , update_time{other.update_time}
     , dict_struct{other.dict_struct}
     , db{other.db}
@@ -148,7 +148,6 @@ XDBCDictionarySource::XDBCDictionarySource(const XDBCDictionarySource & other)
     , bridge_helper{other.bridge_helper}
     , bridge_url{other.bridge_url}
     , timeouts{other.timeouts}
-    , global_context{other.global_context}
 {
 }
 
@@ -244,7 +243,7 @@ std::string XDBCDictionarySource::doInvalidateQuery(const std::string & request)
         invalidate_url,
         [request](std::ostream & os) { os << "query=" << request; },
         invalidate_sample_block,
-        global_context,
+        getContext(),
         max_block_size,
         timeouts,
         bridge_helper->getName() + "BlockInputStream");
@@ -259,7 +258,7 @@ BlockInputStreamPtr XDBCDictionarySource::loadBase(const std::string & query) co
         bridge_url,
         [query](std::ostream & os) { os << "query=" << query; },
         sample_block,
-        global_context,
+        getContext(),
         max_block_size,
         timeouts,
         bridge_helper->getName() + "BlockInputStream");
@@ -275,12 +274,12 @@ void registerDictionarySourceXDBC(DictionarySourceFactory & factory)
                                    const Poco::Util::AbstractConfiguration & config,
                                    const std::string & config_prefix,
                                    Block & sample_block,
-                                   const Context & context,
+                                   ContextPtr context,
                                    const std::string & /* default_database */,
                                    bool /* check_config */) -> DictionarySourcePtr {
 #if USE_ODBC
         BridgeHelperPtr bridge = std::make_shared<XDBCBridgeHelper<ODBCBridgeMixin>>(
-            context, context.getSettings().http_receive_timeout, config.getString(config_prefix + ".odbc.connection_string"));
+            context, context->getSettings().http_receive_timeout, config.getString(config_prefix + ".odbc.connection_string"));
         return std::make_unique<XDBCDictionarySource>(dict_struct, config, config_prefix + ".odbc", sample_block, context, bridge);
 #else
         (void)dict_struct;
@@ -288,8 +287,8 @@ void registerDictionarySourceXDBC(DictionarySourceFactory & factory)
         (void)config_prefix;
         (void)sample_block;
         (void)context;
-        throw Exception{"Dictionary source of type `odbc` is disabled because poco library was built without ODBC support.",
-                        ErrorCodes::SUPPORT_IS_DISABLED};
+        throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
+            "Dictionary source of type `odbc` is disabled because poco library was built without ODBC support.");
 #endif
     };
     factory.registerSource("odbc", create_table_source);
@@ -301,11 +300,11 @@ void registerDictionarySourceJDBC(DictionarySourceFactory & factory)
                                  const Poco::Util::AbstractConfiguration & /* config */,
                                  const std::string & /* config_prefix */,
                                  Block & /* sample_block */,
-                                 const Context & /* context */,
+                                 ContextPtr /* context */,
                                  const std::string & /* default_database */,
                                  bool /* check_config */) -> DictionarySourcePtr {
-        throw Exception{"Dictionary source of type `jdbc` is disabled until consistent support for nullable fields.",
-                        ErrorCodes::SUPPORT_IS_DISABLED};
+        throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
+            "Dictionary source of type `jdbc` is disabled until consistent support for nullable fields.");
         //        BridgeHelperPtr bridge = std::make_shared<XDBCBridgeHelper<JDBCBridgeMixin>>(config, context.getSettings().http_receive_timeout, config.getString(config_prefix + ".connection_string"));
         //        return std::make_unique<XDBCDictionarySource>(dict_struct, config, config_prefix + ".jdbc", sample_block, context, bridge);
     };
diff --git a/src/Dictionaries/XDBCDictionarySource.h b/src/Dictionaries/XDBCDictionarySource.h
index 87bc42c76ab..438f48027e5 100644
--- a/src/Dictionaries/XDBCDictionarySource.h
+++ b/src/Dictionaries/XDBCDictionarySource.h
@@ -3,7 +3,7 @@
 #include <IO/ConnectionTimeouts.h>
 #include <Poco/Data/SessionPool.h>
 #include <Poco/URI.h>
-#include <Common/XDBCBridgeHelper.h>
+#include <Bridge/XDBCBridgeHelper.h>
 #include "DictionaryStructure.h"
 #include "ExternalQueryBuilder.h"
 #include "IDictionarySource.h"
@@ -23,7 +23,7 @@ class Logger;
 namespace DB
 {
 /// Allows loading dictionaries from a XDBC source via bridges
-class XDBCDictionarySource final : public IDictionarySource
+class XDBCDictionarySource final : public IDictionarySource, WithContext
 {
 public:
     XDBCDictionarySource(
@@ -31,7 +31,7 @@ public:
         const Poco::Util::AbstractConfiguration & config_,
         const std::string & config_prefix_,
         const Block & sample_block_,
-        const Context & context_,
+        ContextPtr context_,
         BridgeHelperPtr bridge);
 
     /// copy-constructor is provided in order to support cloneability
@@ -82,7 +82,6 @@ private:
     BridgeHelperPtr bridge_helper;
     Poco::URI bridge_url;
     ConnectionTimeouts timeouts;
-    const Context & global_context;
 };
 
 }
diff --git a/src/Dictionaries/getDictionaryConfigurationFromAST.cpp b/src/Dictionaries/getDictionaryConfigurationFromAST.cpp
index 04ba1db09fc..55a965394a1 100644
--- a/src/Dictionaries/getDictionaryConfigurationFromAST.cpp
+++ b/src/Dictionaries/getDictionaryConfigurationFromAST.cpp
@@ -299,8 +299,8 @@ void buildPrimaryKeyConfiguration(
     if (!complex)
     {
         if (key_names.size() != 1)
-            throw Exception("Primary key for simple dictionary must contain exactly one element",
-                ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+            throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION,
+                "Primary key for simple dictionary must contain exactly one element");
 
         AutoPtr<Element> id_element(doc->createElement("id"));
         root->appendChild(id_element);
@@ -317,8 +317,8 @@ void buildPrimaryKeyConfiguration(
     else
     {
         if (children.size() < key_names.size())
-            throw Exception(
-                "Primary key fields count is more, than dictionary attributes count.", ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+            throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION,
+                "Primary key fields count is more, than dictionary attributes count.");
 
         AutoPtr<Element> key_element(doc->createElement("key"));
         root->appendChild(key_element);
@@ -336,8 +336,9 @@ void buildPrimaryKeyConfiguration(
                 }
             }
             if (!found)
-                throw Exception(
-                    "Primary key field '" + key_name + "' not found among attributes.", ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+                throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION,
+                    "Primary key field '{}' not found among attributes.",
+                    key_name);
         }
     }
 }
@@ -358,7 +359,7 @@ NamesToTypeNames buildDictionaryAttributesConfiguration(
     {
         const ASTDictionaryAttributeDeclaration * dict_attr = child->as<const ASTDictionaryAttributeDeclaration>();
         if (!dict_attr->type)
-            throw Exception("Dictionary attribute must has type", ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+            throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Dictionary attribute must has type");
 
         attributes_names_and_types.emplace(dict_attr->name, queryToString(dict_attr->type));
         if (std::find(key_columns.begin(), key_columns.end(), dict_attr->name) == key_columns.end())
@@ -374,7 +375,7 @@ void buildConfigurationFromFunctionWithKeyValueArguments(
     AutoPtr<Document> doc,
     AutoPtr<Element> root,
     const ASTExpressionList * ast_expr_list,
-    const Context & context)
+    ContextPtr context)
 {
     const auto & children = ast_expr_list->children;
     for (size_t i = 0; i != children.size(); ++i)
@@ -416,9 +417,8 @@ void buildConfigurationFromFunctionWithKeyValueArguments(
         }
         else
         {
-            throw Exception(
-                "Incorrect ASTPair contains wrong value, should be literal, identifier or list",
-                ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+            throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION,
+                "Incorrect ASTPair contains wrong value, should be literal, identifier or list");
         }
     }
 }
@@ -442,7 +442,7 @@ void buildSourceConfiguration(
     AutoPtr<Element> root,
     const ASTFunctionWithKeyValueArguments * source,
     const ASTDictionarySettings * settings,
-    const Context & context)
+    ContextPtr context)
 {
     AutoPtr<Element> outer_element(doc->createElement("source"));
     root->appendChild(outer_element);
@@ -470,24 +470,24 @@ void buildSourceConfiguration(
 void checkAST(const ASTCreateQuery & query)
 {
     if (!query.is_dictionary || query.dictionary == nullptr)
-        throw Exception("Cannot convert dictionary to configuration from non-dictionary AST.", ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+        throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Cannot convert dictionary to configuration from non-dictionary AST.");
 
     if (query.dictionary_attributes_list == nullptr || query.dictionary_attributes_list->children.empty())
-        throw Exception("Cannot create dictionary with empty attributes list", ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+        throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Cannot create dictionary with empty attributes list");
 
     if (query.dictionary->layout == nullptr)
-        throw Exception("Cannot create dictionary with empty layout", ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+        throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Cannot create dictionary with empty layout");
 
     const auto is_direct_layout = !strcasecmp(query.dictionary->layout->layout_type.data(), "direct") ||
                                 !strcasecmp(query.dictionary->layout->layout_type.data(), "complex_key_direct");
     if (query.dictionary->lifetime == nullptr && !is_direct_layout)
-        throw Exception("Cannot create dictionary with empty lifetime", ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+        throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Cannot create dictionary with empty lifetime");
 
     if (query.dictionary->primary_key == nullptr)
-        throw Exception("Cannot create dictionary without primary key", ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+        throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Cannot create dictionary without primary key");
 
     if (query.dictionary->source == nullptr)
-        throw Exception("Cannot create dictionary with empty source", ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+        throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Cannot create dictionary with empty source");
 
     /// Range can be empty
 }
@@ -496,14 +496,14 @@ void checkPrimaryKey(const NamesToTypeNames & all_attrs, const Names & key_attrs
 {
     for (const auto & key_attr : key_attrs)
         if (all_attrs.count(key_attr) == 0)
-            throw Exception("Unknown key attribute '" + key_attr + "'", ErrorCodes::INCORRECT_DICTIONARY_DEFINITION);
+            throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Unknown key attribute '{}'", key_attr);
 }
 
 }
 
 
 DictionaryConfigurationPtr
-getDictionaryConfigurationFromAST(const ASTCreateQuery & query, const Context & context, const std::string & database_)
+getDictionaryConfigurationFromAST(const ASTCreateQuery & query, ContextPtr context, const std::string & database_)
 {
     checkAST(query);
 
diff --git a/src/Dictionaries/getDictionaryConfigurationFromAST.h b/src/Dictionaries/getDictionaryConfigurationFromAST.h
index 5132e3c77e0..de8659e4d7b 100644
--- a/src/Dictionaries/getDictionaryConfigurationFromAST.h
+++ b/src/Dictionaries/getDictionaryConfigurationFromAST.h
@@ -2,6 +2,7 @@
 
 #include <Poco/Util/AbstractConfiguration.h>
 #include <Parsers/ASTCreateQuery.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
@@ -11,5 +12,5 @@ using DictionaryConfigurationPtr = Poco::AutoPtr<Poco::Util::AbstractConfigurati
 /// This function is necessary because all loadable objects configuration are Poco::AbstractConfiguration
 /// Can throw exception if query is ill-formed
 DictionaryConfigurationPtr
-getDictionaryConfigurationFromAST(const ASTCreateQuery & query, const Context & context, const std::string & database_ = "");
+getDictionaryConfigurationFromAST(const ASTCreateQuery & query, ContextPtr context, const std::string & database_ = "");
 }
diff --git a/src/Dictionaries/readInvalidateQuery.cpp b/src/Dictionaries/readInvalidateQuery.cpp
index 587fce6631c..4664b61bfc4 100644
--- a/src/Dictionaries/readInvalidateQuery.cpp
+++ b/src/Dictionaries/readInvalidateQuery.cpp
@@ -20,17 +20,17 @@ std::string readInvalidateQuery(IBlockInputStream & block_input_stream)
 
     Block block = block_input_stream.read();
     if (!block)
-        throw Exception("Empty response", ErrorCodes::RECEIVED_EMPTY_DATA);
+        throw Exception(ErrorCodes::RECEIVED_EMPTY_DATA, "Empty response");
 
     auto columns = block.columns();
     if (columns > 1)
-        throw Exception("Expected single column in resultset, got " + std::to_string(columns), ErrorCodes::TOO_MANY_COLUMNS);
+        throw Exception(ErrorCodes::TOO_MANY_COLUMNS, "Expected single column in resultset, got {}", std::to_string(columns));
 
     auto rows = block.rows();
     if (rows == 0)
-        throw Exception("Expected single row in resultset, got 0", ErrorCodes::RECEIVED_EMPTY_DATA);
+        throw Exception(ErrorCodes::RECEIVED_EMPTY_DATA, "Expected single row in resultset, got 0");
     if (rows > 1)
-        throw Exception("Expected single row in resultset, got at least " + std::to_string(rows), ErrorCodes::TOO_MANY_ROWS);
+        throw Exception(ErrorCodes::TOO_MANY_ROWS, "Expected single row in resultset, got at least {}", std::to_string(rows));
 
     WriteBufferFromOwnString out;
     auto & column_type = block.getByPosition(0);
@@ -38,7 +38,7 @@ std::string readInvalidateQuery(IBlockInputStream & block_input_stream)
 
     while ((block = block_input_stream.read()))
         if (block.rows() > 0)
-            throw Exception("Expected single row in resultset, got at least " + std::to_string(rows + 1), ErrorCodes::TOO_MANY_ROWS);
+            throw Exception(ErrorCodes::TOO_MANY_ROWS, "Expected single row in resultset, got at least {}", std::to_string(rows + 1));
 
     block_input_stream.readSuffix();
     return out.str();
diff --git a/src/Dictionaries/registerCacheDictionaries.cpp b/src/Dictionaries/registerCacheDictionaries.cpp
index b93a08acb76..9cc90c44418 100644
--- a/src/Dictionaries/registerCacheDictionaries.cpp
+++ b/src/Dictionaries/registerCacheDictionaries.cpp
@@ -26,7 +26,7 @@ CacheDictionaryStorageConfiguration parseCacheStorageConfiguration(
     const size_t size = config.getUInt64(dictionary_configuration_prefix + "size_in_cells");
     if (size == 0)
         throw Exception(ErrorCodes::TOO_SMALL_BUFFER_SIZE,
-            "({}): cache dictionary cannot have 0 cells",
+            "{}: cache dictionary cannot have 0 cells",
             full_name);
 
     size_t dict_lifetime_seconds = static_cast<size_t>(dict_lifetime.max_sec);
@@ -68,26 +68,26 @@ SSDCacheDictionaryStorageConfiguration parseSSDCacheStorageConfiguration(
     const size_t file_size = config.getInt64(dictionary_configuration_prefix + "file_size", DEFAULT_FILE_SIZE_BYTES);
     if (file_size % block_size != 0)
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "({}): file_size must be a multiple of block_size",
+            "{}: file_size must be a multiple of block_size",
             full_name);
 
     const size_t read_buffer_size = config.getInt64(dictionary_configuration_prefix + "read_buffer_size", DEFAULT_READ_BUFFER_SIZE_BYTES);
     if (read_buffer_size % block_size != 0)
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "({}): read_buffer_size must be a multiple of block_size",
+            "{}: read_buffer_size must be a multiple of block_size",
             full_name);
 
     const size_t write_buffer_size
         = config.getInt64(dictionary_configuration_prefix + "write_buffer_size", DEFAULT_WRITE_BUFFER_SIZE_BYTES);
     if (write_buffer_size % block_size != 0)
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "({}): write_buffer_size must be a multiple of block_size",
+            "{}: write_buffer_size must be a multiple of block_size",
             full_name);
 
     auto directory_path = config.getString(dictionary_configuration_prefix + "path");
     if (directory_path.empty())
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "({}): ssd cache dictionary cannot have empty path",
+            "{}: ssd cache dictionary cannot have empty path",
             full_name);
 
     if (directory_path.at(0) != '/')
@@ -119,7 +119,7 @@ CacheDictionaryUpdateQueueConfiguration parseCacheDictionaryUpdateQueueConfigura
     const size_t max_update_queue_size = config.getUInt64(layout_prefix + ".cache.max_update_queue_size", 100000);
     if (max_update_queue_size == 0)
         throw Exception(ErrorCodes::TOO_SMALL_BUFFER_SIZE,
-            "({}): dictionary of layout '({})' cannot have empty update queue of size 0",
+            "{}: dictionary of layout '{}' cannot have empty update queue of size 0",
             full_name,
             layout_type);
 
@@ -127,7 +127,7 @@ CacheDictionaryUpdateQueueConfiguration parseCacheDictionaryUpdateQueueConfigura
         = config.getUInt64(layout_prefix + ".cache.update_queue_push_timeout_milliseconds", 10);
     if (update_queue_push_timeout_milliseconds < 10)
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "({}): dictionary of layout '({})' have too little update_queue_push_timeout",
+            "{}: dictionary of layout '{}' have too little update_queue_push_timeout",
             full_name,
             layout_type);
 
@@ -136,7 +136,7 @@ CacheDictionaryUpdateQueueConfiguration parseCacheDictionaryUpdateQueueConfigura
     const size_t max_threads_for_updates = config.getUInt64(layout_prefix + ".max_threads_for_updates", 4);
     if (max_threads_for_updates == 0)
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "({}): dictionary of layout) '({})' cannot have zero threads for updates",
+            "{}: dictionary of layout) '{}' cannot have zero threads for updates",
             full_name,
             layout_type);
 
@@ -169,14 +169,14 @@ DictionaryPtr createCacheDictionaryLayout(
 
     if (dict_struct.range_min || dict_struct.range_max)
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "({}): elements .structure.range_min and .structure.range_max should be defined only "
-                  "for a dictionary of layout 'range_hashed'",
+            "{}: elements .structure.range_min and .structure.range_max should be defined only "
+            "for a dictionary of layout 'range_hashed'",
             full_name);
 
     const bool require_nonempty = config.getBool(config_prefix + ".require_nonempty", false);
     if (require_nonempty)
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "({}): cache dictionary of layout cannot have 'require_nonempty' attribute set",
+            "{}: cache dictionary of layout cannot have 'require_nonempty' attribute set",
             full_name);
 
     const auto & layout_prefix = config_prefix + ".layout";
@@ -222,14 +222,14 @@ DictionaryPtr createSSDCacheDictionaryLayout(
 
     if (dict_struct.range_min || dict_struct.range_max)
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "({}): elements .structure.range_min and .structure.range_max should be defined only "
-                  "for a dictionary of layout 'range_hashed'",
+            "{}: elements .structure.range_min and .structure.range_max should be defined only "
+            "for a dictionary of layout 'range_hashed'",
             full_name);
 
     const bool require_nonempty = config.getBool(config_prefix + ".require_nonempty", false);
     if (require_nonempty)
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "({}): cache dictionary of layout cannot have 'require_nonempty' attribute set",
+            "{}: cache dictionary of layout cannot have 'require_nonempty' attribute set",
             full_name);
 
     const auto & layout_prefix = config_prefix + ".layout";
diff --git a/src/Disks/DiskFactory.cpp b/src/Disks/DiskFactory.cpp
index b604269ae16..03412be9729 100644
--- a/src/Disks/DiskFactory.cpp
+++ b/src/Disks/DiskFactory.cpp
@@ -24,7 +24,7 @@ DiskPtr DiskFactory::create(
     const String & name,
     const Poco::Util::AbstractConfiguration & config,
     const String & config_prefix,
-    const Context & context) const
+    ContextConstPtr context) const
 {
     const auto disk_type = config.getString(config_prefix + ".type", "local");
 
diff --git a/src/Disks/DiskFactory.h b/src/Disks/DiskFactory.h
index d41f14bd753..ba833d9e25f 100644
--- a/src/Disks/DiskFactory.h
+++ b/src/Disks/DiskFactory.h
@@ -1,17 +1,18 @@
 #pragma once
 
-#include <common/types.h>
 #include <Disks/IDisk.h>
+#include <Interpreters/Context_fwd.h>
+#include <common/types.h>
+
+#include <boost/noncopyable.hpp>
+#include <Poco/Util/AbstractConfiguration.h>
 
 #include <functional>
 #include <unordered_map>
-#include <boost/noncopyable.hpp>
-#include <Poco/Util/AbstractConfiguration.h>
 
 
 namespace DB
 {
-class Context;
 
 /**
  * Disk factory. Responsible for creating new disk objects.
@@ -23,7 +24,7 @@ public:
         const String & name,
         const Poco::Util::AbstractConfiguration & config,
         const String & config_prefix,
-        const Context & context)>;
+        ContextConstPtr context)>;
 
     static DiskFactory & instance();
 
@@ -33,7 +34,7 @@ public:
         const String & name,
         const Poco::Util::AbstractConfiguration & config,
         const String & config_prefix,
-        const Context & context) const;
+        ContextConstPtr context) const;
 
 private:
     using DiskTypeRegistry = std::unordered_map<String, Creator>;
diff --git a/src/Disks/DiskLocal.cpp b/src/Disks/DiskLocal.cpp
index 69732bc271e..9d2bad0373d 100644
--- a/src/Disks/DiskLocal.cpp
+++ b/src/Disks/DiskLocal.cpp
@@ -363,7 +363,7 @@ void registerDiskLocal(DiskFactory & factory)
     auto creator = [](const String & name,
                       const Poco::Util::AbstractConfiguration & config,
                       const String & config_prefix,
-                      const Context & context) -> DiskPtr {
+                      ContextConstPtr context) -> DiskPtr {
         String path = config.getString(config_prefix + ".path", "");
         if (name == "default")
         {
@@ -371,7 +371,7 @@ void registerDiskLocal(DiskFactory & factory)
                 throw Exception(
                     "\"default\" disk path should be provided in <path> not it <storage_configuration>",
                     ErrorCodes::UNKNOWN_ELEMENT_IN_CONFIG);
-            path = context.getPath();
+            path = context->getPath();
         }
         else
         {
@@ -402,7 +402,7 @@ void registerDiskLocal(DiskFactory & factory)
                 throw Exception("'keep_free_space_ratio' have to be between 0 and 1", ErrorCodes::EXCESSIVE_ELEMENT_IN_CONFIG);
             String tmp_path = path;
             if (tmp_path.empty())
-                tmp_path = context.getPath();
+                tmp_path = context->getPath();
 
             // Create tmp disk for getting total disk space.
             keep_free_space_bytes = static_cast<UInt64>(DiskLocal("tmp", tmp_path, 0).getTotalSpace() * ratio);
diff --git a/src/Disks/DiskMemory.cpp b/src/Disks/DiskMemory.cpp
index d8b3c74d0d9..68257ec4948 100644
--- a/src/Disks/DiskMemory.cpp
+++ b/src/Disks/DiskMemory.cpp
@@ -451,7 +451,7 @@ void registerDiskMemory(DiskFactory & factory)
     auto creator = [](const String & name,
                       const Poco::Util::AbstractConfiguration & /*config*/,
                       const String & /*config_prefix*/,
-                      const Context & /*context*/) -> DiskPtr { return std::make_shared<DiskMemory>(name); };
+                      ContextConstPtr /*context*/) -> DiskPtr { return std::make_shared<DiskMemory>(name); };
     factory.registerDiskType("memory", creator);
 }
 
diff --git a/src/Disks/DiskSelector.cpp b/src/Disks/DiskSelector.cpp
index 0fb728a4f02..e317d8508da 100644
--- a/src/Disks/DiskSelector.cpp
+++ b/src/Disks/DiskSelector.cpp
@@ -18,7 +18,7 @@ namespace ErrorCodes
     extern const int UNKNOWN_DISK;
 }
 
-DiskSelector::DiskSelector(const Poco::Util::AbstractConfiguration & config, const String & config_prefix, const Context & context)
+DiskSelector::DiskSelector(const Poco::Util::AbstractConfiguration & config, const String & config_prefix, ContextConstPtr context)
 {
     Poco::Util::AbstractConfiguration::Keys keys;
     config.keys(config_prefix, keys);
@@ -40,12 +40,12 @@ DiskSelector::DiskSelector(const Poco::Util::AbstractConfiguration & config, con
         disks.emplace(disk_name, factory.create(disk_name, config, disk_config_prefix, context));
     }
     if (!has_default_disk)
-        disks.emplace(default_disk_name, std::make_shared<DiskLocal>(default_disk_name, context.getPath(), 0));
+        disks.emplace(default_disk_name, std::make_shared<DiskLocal>(default_disk_name, context->getPath(), 0));
 }
 
 
 DiskSelectorPtr DiskSelector::updateFromConfig(
-    const Poco::Util::AbstractConfiguration & config, const String & config_prefix, const Context & context) const
+    const Poco::Util::AbstractConfiguration & config, const String & config_prefix, ContextPtr context) const
 {
     Poco::Util::AbstractConfiguration::Keys keys;
     config.keys(config_prefix, keys);
diff --git a/src/Disks/DiskSelector.h b/src/Disks/DiskSelector.h
index 5d023fe1fbc..6b7e8174d3d 100644
--- a/src/Disks/DiskSelector.h
+++ b/src/Disks/DiskSelector.h
@@ -10,7 +10,6 @@
 namespace DB
 {
 
-class Context;
 class DiskSelector;
 using DiskSelectorPtr = std::shared_ptr<const DiskSelector>;
 using DisksMap = std::map<String, DiskPtr>;
@@ -20,13 +19,13 @@ using DisksMap = std::map<String, DiskPtr>;
 class DiskSelector
 {
 public:
-    DiskSelector(const Poco::Util::AbstractConfiguration & config, const String & config_prefix, const Context & context);
+    DiskSelector(const Poco::Util::AbstractConfiguration & config, const String & config_prefix, ContextConstPtr context);
     DiskSelector(const DiskSelector & from) : disks(from.disks) { }
 
     DiskSelectorPtr updateFromConfig(
         const Poco::Util::AbstractConfiguration & config,
         const String & config_prefix,
-        const Context & context
+        ContextPtr context
     ) const;
 
     /// Get disk by name
diff --git a/src/Disks/S3/registerDiskS3.cpp b/src/Disks/S3/registerDiskS3.cpp
index 3ce2f909760..a15b6bcf822 100644
--- a/src/Disks/S3/registerDiskS3.cpp
+++ b/src/Disks/S3/registerDiskS3.cpp
@@ -109,13 +109,13 @@ void registerDiskS3(DiskFactory & factory)
     auto creator = [](const String & name,
                       const Poco::Util::AbstractConfiguration & config,
                       const String & config_prefix,
-                      const Context & context) -> DiskPtr {
-        Poco::File disk{context.getPath() + "disks/" + name};
+                      ContextConstPtr context) -> DiskPtr {
+        Poco::File disk{context->getPath() + "disks/" + name};
         disk.createDirectories();
 
         S3::PocoHTTPClientConfiguration client_configuration = S3::ClientFactory::instance().createClientConfiguration(
-            context.getRemoteHostFilter(),
-            context.getGlobalContext().getSettingsRef().s3_max_redirects);
+            context->getRemoteHostFilter(),
+            context->getGlobalContext()->getSettingsRef().s3_max_redirects);
 
         S3::URI uri(Poco::URI(config.getString(config_prefix + ".endpoint")));
         if (uri.key.back() != '/')
@@ -143,7 +143,7 @@ void registerDiskS3(DiskFactory & factory)
             config.getBool(config_prefix + ".use_environment_credentials", config.getBool("s3.use_environment_credentials", false))
         );
 
-        String metadata_path = config.getString(config_prefix + ".metadata_path", context.getPath() + "disks/" + name + "/");
+        String metadata_path = config.getString(config_prefix + ".metadata_path", context->getPath() + "disks/" + name + "/");
 
         auto s3disk = std::make_shared<DiskS3>(
             name,
@@ -152,8 +152,8 @@ void registerDiskS3(DiskFactory & factory)
             uri.bucket,
             uri.key,
             metadata_path,
-            context.getSettingsRef().s3_min_upload_part_size,
-            context.getSettingsRef().s3_max_single_part_upload_size,
+            context->getSettingsRef().s3_min_upload_part_size,
+            context->getSettingsRef().s3_max_single_part_upload_size,
             config.getUInt64(config_prefix + ".min_bytes_for_seek", 1024 * 1024),
             config.getBool(config_prefix + ".send_metadata", false),
             config.getInt(config_prefix + ".thread_pool_size", 16),
@@ -174,7 +174,7 @@ void registerDiskS3(DiskFactory & factory)
 
         if (cache_enabled)
         {
-            String cache_path = config.getString(config_prefix + ".cache_path", context.getPath() + "disks/" + name + "/cache/");
+            String cache_path = config.getString(config_prefix + ".cache_path", context->getPath() + "disks/" + name + "/cache/");
 
             if (metadata_path == cache_path)
                 throw Exception("Metadata and cache path should be different: " + metadata_path, ErrorCodes::BAD_ARGUMENTS);
diff --git a/src/Formats/FormatFactory.cpp b/src/Formats/FormatFactory.cpp
index f7f32cf9b6f..6774c5eed88 100644
--- a/src/Formats/FormatFactory.cpp
+++ b/src/Formats/FormatFactory.cpp
@@ -43,16 +43,15 @@ const FormatFactory::Creators & FormatFactory::getCreators(const String & name)
     throw Exception("Unknown format " + name, ErrorCodes::UNKNOWN_FORMAT);
 }
 
-FormatSettings getFormatSettings(const Context & context)
+FormatSettings getFormatSettings(ContextConstPtr context)
 {
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = context->getSettingsRef();
 
     return getFormatSettings(context, settings);
 }
 
 template <typename Settings>
-FormatSettings getFormatSettings(const Context & context,
-    const Settings & settings)
+FormatSettings getFormatSettings(ContextConstPtr context, const Settings & settings)
 {
     FormatSettings format_settings;
 
@@ -99,8 +98,8 @@ FormatSettings getFormatSettings(const Context & context,
     format_settings.regexp.regexp = settings.format_regexp;
     format_settings.regexp.skip_unmatched = settings.format_regexp_skip_unmatched;
     format_settings.schema.format_schema = settings.format_schema;
-    format_settings.schema.format_schema_path = context.getFormatSchemaPath();
-    format_settings.schema.is_server = context.hasGlobalContext() && (context.getGlobalContext().getApplicationType() == Context::ApplicationType::SERVER);
+    format_settings.schema.format_schema_path = context->getFormatSchemaPath();
+    format_settings.schema.is_server = context->hasGlobalContext() && (context->getGlobalContext()->getApplicationType() == Context::ApplicationType::SERVER);
     format_settings.skip_unknown_fields = settings.input_format_skip_unknown_fields;
     format_settings.template_settings.resultset_format = settings.format_template_resultset;
     format_settings.template_settings.row_between_delimiter = settings.format_template_rows_between_delimiter;
@@ -120,26 +119,22 @@ FormatSettings getFormatSettings(const Context & context,
     {
         const Poco::URI & avro_schema_registry_url = settings.format_avro_schema_registry_url;
         if (!avro_schema_registry_url.empty())
-            context.getRemoteHostFilter().checkURL(avro_schema_registry_url);
+            context->getRemoteHostFilter().checkURL(avro_schema_registry_url);
     }
 
     return format_settings;
 }
 
-template
-FormatSettings getFormatSettings<FormatFactorySettings>(const Context & context,
-    const FormatFactorySettings & settings);
+template FormatSettings getFormatSettings<FormatFactorySettings>(ContextConstPtr context, const FormatFactorySettings & settings);
 
-template
-FormatSettings getFormatSettings<Settings>(const Context & context,
-    const Settings & settings);
+template FormatSettings getFormatSettings<Settings>(ContextConstPtr context, const Settings & settings);
 
 
 InputFormatPtr FormatFactory::getInput(
     const String & name,
     ReadBuffer & buf,
     const Block & sample,
-    const Context & context,
+    ContextConstPtr context,
     UInt64 max_block_size,
     const std::optional<FormatSettings> & _format_settings) const
 {
@@ -154,7 +149,7 @@ InputFormatPtr FormatFactory::getInput(
         throw Exception("Format " + name + " is not suitable for input (with processors)", ErrorCodes::FORMAT_IS_NOT_SUITABLE_FOR_INPUT);
     }
 
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
     const auto & file_segmentation_engine = getCreators(name).file_segmentation_engine;
 
     // Doesn't make sense to use parallel parsing with less than four threads
@@ -204,13 +199,17 @@ InputFormatPtr FormatFactory::getInput(
     return format;
 }
 
-BlockOutputStreamPtr FormatFactory::getOutputStreamParallelIfPossible(const String & name,
-    WriteBuffer & buf, const Block & sample, const Context & context,
-    WriteCallback callback, const std::optional<FormatSettings> & _format_settings) const
+BlockOutputStreamPtr FormatFactory::getOutputStreamParallelIfPossible(
+    const String & name,
+    WriteBuffer & buf,
+    const Block & sample,
+    ContextConstPtr context,
+    WriteCallback callback,
+    const std::optional<FormatSettings> & _format_settings) const
 {
     const auto & output_getter = getCreators(name).output_processor_creator;
 
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
     bool parallel_formatting = settings.output_format_parallel_formatting;
 
     if (output_getter && parallel_formatting && getCreators(name).supports_parallel_formatting
@@ -237,12 +236,15 @@ BlockOutputStreamPtr FormatFactory::getOutputStreamParallelIfPossible(const Stri
 }
 
 
-BlockOutputStreamPtr FormatFactory::getOutputStream(const String & name,
-    WriteBuffer & buf, const Block & sample, const Context & context,
-    WriteCallback callback, const std::optional<FormatSettings> & _format_settings) const
+BlockOutputStreamPtr FormatFactory::getOutputStream(
+    const String & name,
+    WriteBuffer & buf,
+    const Block & sample,
+    ContextConstPtr context,
+    WriteCallback callback,
+    const std::optional<FormatSettings> & _format_settings) const
 {
-    auto format_settings = _format_settings
-        ? *_format_settings : getFormatSettings(context);
+    auto format_settings = _format_settings ? *_format_settings : getFormatSettings(context);
 
     if (!getCreators(name).output_processor_creator)
     {
@@ -267,7 +269,7 @@ InputFormatPtr FormatFactory::getInputFormat(
     const String & name,
     ReadBuffer & buf,
     const Block & sample,
-    const Context & context,
+    ContextConstPtr context,
     UInt64 max_block_size,
     const std::optional<FormatSettings> & _format_settings) const
 {
@@ -275,13 +277,12 @@ InputFormatPtr FormatFactory::getInputFormat(
     if (!input_getter)
         throw Exception("Format " + name + " is not suitable for input", ErrorCodes::FORMAT_IS_NOT_SUITABLE_FOR_INPUT);
 
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
 
-    if (context.hasQueryContext() && settings.log_queries)
-        context.getQueryContext().addQueryFactoriesInfo(Context::QueryLogFactories::Format, name);
+    if (context->hasQueryContext() && settings.log_queries)
+        context->getQueryContext()->addQueryFactoriesInfo(Context::QueryLogFactories::Format, name);
 
-    auto format_settings = _format_settings
-        ? *_format_settings : getFormatSettings(context);
+    auto format_settings = _format_settings ? *_format_settings : getFormatSettings(context);
 
     RowInputFormatParams params;
     params.max_block_size = max_block_size;
@@ -289,7 +290,6 @@ InputFormatPtr FormatFactory::getInputFormat(
     params.allow_errors_ratio = format_settings.input_allow_errors_ratio;
     params.max_execution_time = settings.max_execution_time;
     params.timeout_overflow_mode = settings.timeout_overflow_mode;
-
     auto format = input_getter(buf, sample, params, format_settings);
 
     /// It's a kludge. Because I cannot remove context from values format.
@@ -300,18 +300,20 @@ InputFormatPtr FormatFactory::getInputFormat(
 }
 
 OutputFormatPtr FormatFactory::getOutputFormatParallelIfPossible(
-    const String & name, WriteBuffer & buf, const Block & sample,
-    const Context & context, WriteCallback callback,
+    const String & name,
+    WriteBuffer & buf,
+    const Block & sample,
+    ContextConstPtr context,
+    WriteCallback callback,
     const std::optional<FormatSettings> & _format_settings) const
 {
     const auto & output_getter = getCreators(name).output_processor_creator;
     if (!output_getter)
         throw Exception("Format " + name + " is not suitable for output (with processors)", ErrorCodes::FORMAT_IS_NOT_SUITABLE_FOR_OUTPUT);
 
-    auto format_settings = _format_settings
-        ? *_format_settings : getFormatSettings(context);
+    auto format_settings = _format_settings ? *_format_settings : getFormatSettings(context);
 
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
 
     if (settings.output_format_parallel_formatting && getCreators(name).supports_parallel_formatting
         && !settings.output_format_json_array_of_rows)
@@ -322,8 +324,8 @@ OutputFormatPtr FormatFactory::getOutputFormatParallelIfPossible(
 
         ParallelFormattingOutputFormat::Params builder{buf, sample, formatter_creator, settings.max_threads};
 
-        if (context.hasQueryContext() && settings.log_queries)
-            context.getQueryContext().addQueryFactoriesInfo(Context::QueryLogFactories::Format, name);
+        if (context->hasQueryContext() && settings.log_queries)
+            context->getQueryContext()->addQueryFactoriesInfo(Context::QueryLogFactories::Format, name);
 
         return std::make_shared<ParallelFormattingOutputFormat>(builder);
     }
@@ -333,16 +335,19 @@ OutputFormatPtr FormatFactory::getOutputFormatParallelIfPossible(
 
 
 OutputFormatPtr FormatFactory::getOutputFormat(
-    const String & name, WriteBuffer & buf, const Block & sample,
-    const Context & context, WriteCallback callback,
+    const String & name,
+    WriteBuffer & buf,
+    const Block & sample,
+    ContextConstPtr context,
+    WriteCallback callback,
     const std::optional<FormatSettings> & _format_settings) const
 {
     const auto & output_getter = getCreators(name).output_processor_creator;
     if (!output_getter)
         throw Exception("Format " + name + " is not suitable for output (with processors)", ErrorCodes::FORMAT_IS_NOT_SUITABLE_FOR_OUTPUT);
 
-    if (context.hasQueryContext() && context.getSettingsRef().log_queries)
-        context.getQueryContext().addQueryFactoriesInfo(Context::QueryLogFactories::Format, name);
+    if (context->hasQueryContext() && context->getSettingsRef().log_queries)
+        context->getQueryContext()->addQueryFactoriesInfo(Context::QueryLogFactories::Format, name);
 
     RowOutputFormatParams params;
     params.callback = std::move(callback);
@@ -412,11 +417,26 @@ void FormatFactory::markOutputFormatSupportsParallelFormatting(const String & na
 {
     auto & target = dict[name].supports_parallel_formatting;
     if (target)
-        throw Exception("FormatFactory: Output format " + name + " is already marked as supporting parallel formatting.", ErrorCodes::LOGICAL_ERROR);
+        throw Exception("FormatFactory: Output format " + name + " is already marked as supporting parallel formatting", ErrorCodes::LOGICAL_ERROR);
     target = true;
 }
 
 
+void FormatFactory::markFormatAsColumnOriented(const String & name)
+{
+    auto & target = dict[name].is_column_oriented;
+    if (target)
+        throw Exception("FormatFactory: Format " + name + " is already marked as column oriented", ErrorCodes::LOGICAL_ERROR);
+    target = true;
+}
+
+
+bool FormatFactory::checkIfFormatIsColumnOriented(const String & name)
+{
+    const auto & target = getCreators(name);
+    return target.is_column_oriented;
+}
+
 FormatFactory & FormatFactory::instance()
 {
     static FormatFactory ret;
diff --git a/src/Formats/FormatFactory.h b/src/Formats/FormatFactory.h
index 4fa7e9a0c01..d5e4b1b0341 100644
--- a/src/Formats/FormatFactory.h
+++ b/src/Formats/FormatFactory.h
@@ -1,21 +1,22 @@
 #pragma once
 
-#include <common/types.h>
 #include <Columns/IColumn.h>
 #include <DataStreams/IBlockStream_fwd.h>
 #include <Formats/FormatSettings.h>
+#include <Interpreters/Context_fwd.h>
 #include <IO/BufferWithOwnMemory.h>
+#include <common/types.h>
+
+#include <boost/noncopyable.hpp>
 
 #include <functional>
 #include <memory>
 #include <unordered_map>
-#include <boost/noncopyable.hpp>
 
 namespace DB
 {
 
 class Block;
-class Context;
 struct Settings;
 struct FormatFactorySettings;
 
@@ -34,11 +35,10 @@ struct RowOutputFormatParams;
 using InputFormatPtr = std::shared_ptr<IInputFormat>;
 using OutputFormatPtr = std::shared_ptr<IOutputFormat>;
 
-FormatSettings getFormatSettings(const Context & context);
+FormatSettings getFormatSettings(ContextConstPtr context);
 
 template <typename T>
-FormatSettings getFormatSettings(const Context & context,
-    const T & settings);
+FormatSettings getFormatSettings(ContextConstPtr context, const T & settings);
 
 /** Allows to create an IBlockInputStream or IBlockOutputStream by the name of the format.
   * Note: format and compression are independent things.
@@ -101,6 +101,7 @@ private:
         OutputProcessorCreator output_processor_creator;
         FileSegmentationEngine file_segmentation_engine;
         bool supports_parallel_formatting{false};
+        bool is_column_oriented{false};
     };
 
     using FormatsDictionary = std::unordered_map<String, Creators>;
@@ -112,38 +113,52 @@ public:
         const String & name,
         ReadBuffer & buf,
         const Block & sample,
-        const Context & context,
+        ContextConstPtr context,
         UInt64 max_block_size,
         const std::optional<FormatSettings> & format_settings = std::nullopt) const;
 
     /// Checks all preconditions. Returns ordinary stream if parallel formatting cannot be done.
     /// Currently used only in Client. Don't use it something else! Better look at getOutputFormatParallelIfPossible.
-    BlockOutputStreamPtr getOutputStreamParallelIfPossible(const String & name, WriteBuffer & buf,
-        const Block & sample, const Context & context, WriteCallback callback = {},
+    BlockOutputStreamPtr getOutputStreamParallelIfPossible(
+        const String & name,
+        WriteBuffer & buf,
+        const Block & sample,
+        ContextConstPtr context,
+        WriteCallback callback = {},
         const std::optional<FormatSettings> & format_settings = std::nullopt) const;
 
     /// Currently used only in Client. Don't use it something else! Better look at getOutputFormat.
-    BlockOutputStreamPtr getOutputStream(const String & name, WriteBuffer & buf,
-        const Block & sample, const Context & context, WriteCallback callback = {},
+    BlockOutputStreamPtr getOutputStream(
+        const String & name,
+        WriteBuffer & buf,
+        const Block & sample,
+        ContextConstPtr context,
+        WriteCallback callback = {},
         const std::optional<FormatSettings> & format_settings = std::nullopt) const;
 
     InputFormatPtr getInputFormat(
         const String & name,
         ReadBuffer & buf,
         const Block & sample,
-        const Context & context,
+        ContextConstPtr context,
         UInt64 max_block_size,
         const std::optional<FormatSettings> & format_settings = std::nullopt) const;
 
     /// Checks all preconditions. Returns ordinary format if parallel formatting cannot be done.
     OutputFormatPtr getOutputFormatParallelIfPossible(
-        const String & name, WriteBuffer & buf, const Block & sample,
-        const Context & context, WriteCallback callback = {},
+        const String & name,
+        WriteBuffer & buf,
+        const Block & sample,
+        ContextConstPtr context,
+        WriteCallback callback = {},
         const std::optional<FormatSettings> & format_settings = std::nullopt) const;
 
     OutputFormatPtr getOutputFormat(
-        const String & name, WriteBuffer & buf, const Block & sample,
-        const Context & context, WriteCallback callback = {},
+        const String & name,
+        WriteBuffer & buf,
+        const Block & sample,
+        ContextConstPtr context,
+        WriteCallback callback = {},
         const std::optional<FormatSettings> & format_settings = std::nullopt) const;
 
     /// Register format by its name.
@@ -155,6 +170,9 @@ public:
     void registerOutputFormatProcessor(const String & name, OutputProcessorCreator output_creator);
 
     void markOutputFormatSupportsParallelFormatting(const String & name);
+    void markFormatAsColumnOriented(const String & name);
+
+    bool checkIfFormatIsColumnOriented(const String & name);
 
     const FormatsDictionary & getAllFormats() const
     {
diff --git a/src/Formats/MySQLBlockInputStream.cpp b/src/Formats/MySQLBlockInputStream.cpp
index da2a175e49f..e2620c71fbb 100644
--- a/src/Formats/MySQLBlockInputStream.cpp
+++ b/src/Formats/MySQLBlockInputStream.cpp
@@ -1,26 +1,29 @@
 #if !defined(ARCADIA_BUILD)
-#    include "config_core.h"
+#include "config_core.h"
 #endif
 
 #if USE_MYSQL
-#    include <vector>
-#    include <Columns/ColumnNullable.h>
-#    include <Columns/ColumnString.h>
-#    include <Columns/ColumnsNumber.h>
-#    include <Columns/ColumnDecimal.h>
-#    include <Columns/ColumnFixedString.h>
-#    include <DataTypes/IDataType.h>
-#    include <DataTypes/DataTypeNullable.h>
-#    include <IO/ReadBufferFromString.h>
-#    include <IO/ReadHelpers.h>
-#    include <IO/WriteHelpers.h>
-#    include <IO/Operators.h>
-#    include <Common/assert_cast.h>
-#    include <ext/range.h>
-#    include "MySQLBlockInputStream.h"
+#include <vector>
+#include <Columns/ColumnNullable.h>
+#include <Columns/ColumnString.h>
+#include <Columns/ColumnsNumber.h>
+#include <Columns/ColumnDecimal.h>
+#include <Columns/ColumnFixedString.h>
+#include <DataTypes/IDataType.h>
+#include <DataTypes/DataTypeNullable.h>
+#include <IO/ReadBufferFromString.h>
+#include <IO/ReadHelpers.h>
+#include <IO/WriteHelpers.h>
+#include <IO/Operators.h>
+#include <Common/assert_cast.h>
+#include <ext/range.h>
+#include <common/logger_useful.h>
+#include "MySQLBlockInputStream.h"
+
 
 namespace DB
 {
+
 namespace ErrorCodes
 {
     extern const int NUMBER_OF_COLUMNS_DOESNT_MATCH;
@@ -36,6 +39,7 @@ MySQLBlockInputStream::Connection::Connection(
 {
 }
 
+/// Used in MaterializeMySQL and in doInvalidateQuery for dictionary source.
 MySQLBlockInputStream::MySQLBlockInputStream(
     const mysqlxx::PoolWithFailover::Entry & entry,
     const std::string & query_str,
@@ -43,7 +47,8 @@ MySQLBlockInputStream::MySQLBlockInputStream(
     const UInt64 max_block_size_,
     const bool auto_close_,
     const bool fetch_by_name_)
-    : connection{std::make_unique<Connection>(entry, query_str)}
+    : log(&Poco::Logger::get("MySQLBlockInputStream"))
+    , connection{std::make_unique<Connection>(entry, query_str)}
     , max_block_size{max_block_size_}
     , auto_close{auto_close_}
     , fetch_by_name(fetch_by_name_)
@@ -52,6 +57,62 @@ MySQLBlockInputStream::MySQLBlockInputStream(
     initPositionMappingFromQueryResultStructure();
 }
 
+/// For descendant MySQLWithFailoverBlockInputStream
+MySQLBlockInputStream::MySQLBlockInputStream(
+    const Block & sample_block_,
+    UInt64 max_block_size_,
+    bool auto_close_,
+    bool fetch_by_name_)
+    : log(&Poco::Logger::get("MySQLBlockInputStream"))
+    , max_block_size(max_block_size_)
+    , auto_close(auto_close_)
+    , fetch_by_name(fetch_by_name_)
+{
+    description.init(sample_block_);
+}
+
+/// Used by MySQL storage / table function and dictionary source.
+MySQLWithFailoverBlockInputStream::MySQLWithFailoverBlockInputStream(
+    mysqlxx::PoolWithFailoverPtr pool_,
+    const std::string & query_str_,
+    const Block & sample_block_,
+    const UInt64 max_block_size_,
+    const bool auto_close_,
+    const bool fetch_by_name_,
+    const size_t max_tries_)
+    : MySQLBlockInputStream(sample_block_, max_block_size_, auto_close_, fetch_by_name_)
+    , pool(pool_)
+    , query_str(query_str_)
+    , max_tries(max_tries_)
+{
+}
+
+void MySQLWithFailoverBlockInputStream::readPrefix()
+{
+    size_t count_connect_attempts = 0;
+
+    /// For recovering from "Lost connection to MySQL server during query" errors
+    while (true)
+    {
+        try
+        {
+            connection = std::make_unique<Connection>(pool->get(), query_str);
+            break;
+        }
+        catch (const mysqlxx::ConnectionLost & ecl)  /// There are two retriable failures: CR_SERVER_GONE_ERROR, CR_SERVER_LOST
+        {
+            LOG_WARNING(log, "Failed connection ({}/{}). Trying to reconnect... (Info: {})", count_connect_attempts, max_tries, ecl.displayText());
+        }
+
+        if (++count_connect_attempts > max_tries)
+        {
+            LOG_ERROR(log, "Failed to create connection to MySQL. ({}/{})", count_connect_attempts, max_tries);
+            throw;
+        }
+    }
+
+    initPositionMappingFromQueryResultStructure();
+}
 
 namespace
 {
@@ -139,6 +200,7 @@ Block MySQLBlockInputStream::readImpl()
     {
         if (auto_close)
            connection->entry.disconnect();
+
         return {};
     }
 
@@ -191,18 +253,6 @@ Block MySQLBlockInputStream::readImpl()
     return description.sample_block.cloneWithColumns(std::move(columns));
 }
 
-MySQLBlockInputStream::MySQLBlockInputStream(
-    const Block & sample_block_,
-    UInt64 max_block_size_,
-    bool auto_close_,
-    bool fetch_by_name_)
-    : max_block_size(max_block_size_)
-    , auto_close(auto_close_)
-    , fetch_by_name(fetch_by_name_)
-{
-    description.init(sample_block_);
-}
-
 void MySQLBlockInputStream::initPositionMappingFromQueryResultStructure()
 {
     position_mapping.resize(description.sample_block.columns());
@@ -250,25 +300,6 @@ void MySQLBlockInputStream::initPositionMappingFromQueryResultStructure()
     }
 }
 
-MySQLLazyBlockInputStream::MySQLLazyBlockInputStream(
-    mysqlxx::Pool & pool_,
-    const std::string & query_str_,
-    const Block & sample_block_,
-    const UInt64 max_block_size_,
-    const bool auto_close_,
-    const bool fetch_by_name_)
-    : MySQLBlockInputStream(sample_block_, max_block_size_, auto_close_, fetch_by_name_)
-    , pool(pool_)
-    , query_str(query_str_)
-{
-}
-
-void MySQLLazyBlockInputStream::readPrefix()
-{
-    connection = std::make_unique<Connection>(pool.get(), query_str);
-    initPositionMappingFromQueryResultStructure();
-}
-
 }
 
 #endif
diff --git a/src/Formats/MySQLBlockInputStream.h b/src/Formats/MySQLBlockInputStream.h
index 269b630fcc7..86380c1597a 100644
--- a/src/Formats/MySQLBlockInputStream.h
+++ b/src/Formats/MySQLBlockInputStream.h
@@ -41,6 +41,7 @@ protected:
         mysqlxx::UseQueryResult result;
     };
 
+    Poco::Logger * log;
     std::unique_ptr<Connection> connection;
 
     const UInt64 max_block_size;
@@ -52,22 +53,27 @@ protected:
 
 /// Like MySQLBlockInputStream, but allocates connection only when reading is starting.
 /// It allows to create a lot of stream objects without occupation of all connection pool.
-class MySQLLazyBlockInputStream final : public MySQLBlockInputStream
+/// Also makes attempts to reconnect in case of connection failures.
+class MySQLWithFailoverBlockInputStream final : public MySQLBlockInputStream
 {
 public:
-    MySQLLazyBlockInputStream(
-        mysqlxx::Pool & pool_,
+    static constexpr inline auto MAX_TRIES_MYSQL_CONNECT = 5;
+
+    MySQLWithFailoverBlockInputStream(
+        mysqlxx::PoolWithFailoverPtr pool_,
         const std::string & query_str_,
         const Block & sample_block_,
         const UInt64 max_block_size_,
         const bool auto_close_ = false,
-        const bool fetch_by_name_ = false);
+        const bool fetch_by_name_ = false,
+        const size_t max_tries_ = MAX_TRIES_MYSQL_CONNECT);
 
 private:
     void readPrefix() override;
 
-    mysqlxx::Pool & pool;
+    mysqlxx::PoolWithFailoverPtr pool;
     std::string query_str;
+    size_t max_tries;
 };
 
 }
diff --git a/src/Functions/FunctionBase64Conversion.h b/src/Functions/FunctionBase64Conversion.h
index 4887e9fe8cc..d060b86c54b 100644
--- a/src/Functions/FunctionBase64Conversion.h
+++ b/src/Functions/FunctionBase64Conversion.h
@@ -61,7 +61,7 @@ class FunctionBase64Conversion : public IFunction
 public:
     static constexpr auto name = Func::name;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionBase64Conversion>();
     }
diff --git a/src/Functions/FunctionBinaryArithmetic.h b/src/Functions/FunctionBinaryArithmetic.h
index bb85ae32622..ef9d05b4b5e 100644
--- a/src/Functions/FunctionBinaryArithmetic.h
+++ b/src/Functions/FunctionBinaryArithmetic.h
@@ -512,7 +512,7 @@ class FunctionBinaryArithmetic : public IFunction
     static constexpr const bool is_multiply = IsOperation<Op>::multiply;
     static constexpr const bool is_division = IsOperation<Op>::division;
 
-    const Context & context;
+    ContextPtr context;
     bool check_decimal_overflow = true;
 
     template <typename F>
@@ -593,7 +593,7 @@ class FunctionBinaryArithmetic : public IFunction
     }
 
     static FunctionOverloadResolverPtr
-    getFunctionForIntervalArithmetic(const DataTypePtr & type0, const DataTypePtr & type1, const Context & context)
+    getFunctionForIntervalArithmetic(const DataTypePtr & type0, const DataTypePtr & type1, ContextPtr context)
     {
         bool first_is_date_or_datetime = isDateOrDateTime(type0);
         bool second_is_date_or_datetime = isDateOrDateTime(type1);
@@ -939,9 +939,9 @@ class FunctionBinaryArithmetic : public IFunction
 
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context & context) { return std::make_shared<FunctionBinaryArithmetic>(context); }
+    static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionBinaryArithmetic>(context); }
 
-    explicit FunctionBinaryArithmetic(const Context & context_)
+    explicit FunctionBinaryArithmetic(ContextPtr context_)
     :   context(context_),
         check_decimal_overflow(decimalCheckArithmeticOverflow(context))
     {}
@@ -955,7 +955,7 @@ public:
         return getReturnTypeImplStatic(arguments, context);
     }
 
-    static DataTypePtr getReturnTypeImplStatic(const DataTypes & arguments, const Context & context)
+    static DataTypePtr getReturnTypeImplStatic(const DataTypes & arguments, ContextPtr context)
     {
         /// Special case when multiply aggregate function state
         if (isAggregateMultiply(arguments[0], arguments[1]))
@@ -1367,7 +1367,7 @@ public:
         const ColumnWithTypeAndName & left_,
         const ColumnWithTypeAndName & right_,
         const DataTypePtr & return_type_,
-        const Context & context)
+        ContextPtr context)
     {
         return std::make_shared<FunctionBinaryArithmeticWithConstants>(left_, right_, return_type_, context);
     }
@@ -1376,7 +1376,7 @@ public:
         const ColumnWithTypeAndName & left_,
         const ColumnWithTypeAndName & right_,
         const DataTypePtr & return_type_,
-        const Context & context_)
+        ContextPtr context_)
         : Base(context_), left(left_), right(right_), return_type(return_type_)
     {
     }
@@ -1530,12 +1530,12 @@ class BinaryArithmeticOverloadResolver : public IFunctionOverloadResolverImpl
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionOverloadResolverImplPtr create(const Context & context)
+    static FunctionOverloadResolverImplPtr create(ContextPtr context)
     {
         return std::make_unique<BinaryArithmeticOverloadResolver>(context);
     }
 
-    explicit BinaryArithmeticOverloadResolver(const Context & context_) : context(context_) {}
+    explicit BinaryArithmeticOverloadResolver(ContextPtr context_) : context(context_) {}
 
     String getName() const override { return name; }
     size_t getNumberOfArguments() const override { return 2; }
@@ -1571,6 +1571,6 @@ public:
     }
 
 private:
-    const Context & context;
+    ContextPtr context;
 };
 }
diff --git a/src/Functions/FunctionBitTestMany.h b/src/Functions/FunctionBitTestMany.h
index 6d527c66390..a2be56c42b0 100644
--- a/src/Functions/FunctionBitTestMany.h
+++ b/src/Functions/FunctionBitTestMany.h
@@ -24,7 +24,7 @@ struct FunctionBitTestMany : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitTestMany>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitTestMany>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionCustomWeekToSomething.h b/src/Functions/FunctionCustomWeekToSomething.h
index 5634ea11584..4050bb512bd 100644
--- a/src/Functions/FunctionCustomWeekToSomething.h
+++ b/src/Functions/FunctionCustomWeekToSomething.h
@@ -24,7 +24,7 @@ class FunctionCustomWeekToSomething : public IFunction
 {
 public:
     static constexpr auto name = Transform::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionCustomWeekToSomething>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionCustomWeekToSomething>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionDateOrDateTimeAddInterval.h b/src/Functions/FunctionDateOrDateTimeAddInterval.h
index 95b9e25ead1..8a9d454028c 100644
--- a/src/Functions/FunctionDateOrDateTimeAddInterval.h
+++ b/src/Functions/FunctionDateOrDateTimeAddInterval.h
@@ -352,7 +352,7 @@ class FunctionDateOrDateTimeAddInterval : public IFunction
 {
 public:
     static constexpr auto name = Transform::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionDateOrDateTimeAddInterval>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionDateOrDateTimeAddInterval>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/FunctionDateOrDateTimeToSomething.h b/src/Functions/FunctionDateOrDateTimeToSomething.h
index abe859e2f29..b9d0a7f45fe 100644
--- a/src/Functions/FunctionDateOrDateTimeToSomething.h
+++ b/src/Functions/FunctionDateOrDateTimeToSomething.h
@@ -24,7 +24,7 @@ class FunctionDateOrDateTimeToSomething : public IFunction
 {
 public:
     static constexpr auto name = Transform::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionDateOrDateTimeToSomething>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionDateOrDateTimeToSomething>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/FunctionFQDN.cpp b/src/Functions/FunctionFQDN.cpp
index 7b3b89eb511..9cad9011cd4 100644
--- a/src/Functions/FunctionFQDN.cpp
+++ b/src/Functions/FunctionFQDN.cpp
@@ -12,7 +12,7 @@ class FunctionFQDN : public IFunction
 {
 public:
     static constexpr auto name = "FQDN";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionFQDN>();
     }
diff --git a/src/Functions/FunctionFactory.cpp b/src/Functions/FunctionFactory.cpp
index e13f310de09..35ac9ab647b 100644
--- a/src/Functions/FunctionFactory.cpp
+++ b/src/Functions/FunctionFactory.cpp
@@ -52,7 +52,7 @@ void FunctionFactory::registerFunction(const
 
 FunctionOverloadResolverImplPtr FunctionFactory::getImpl(
     const std::string & name,
-    const Context & context) const
+    ContextPtr context) const
 {
     auto res = tryGetImpl(name, context);
     if (!res)
@@ -82,14 +82,14 @@ std::vector<std::string> FunctionFactory::getAllNames() const
 
 FunctionOverloadResolverPtr FunctionFactory::get(
     const std::string & name,
-    const Context & context) const
+    ContextPtr context) const
 {
     return std::make_shared<FunctionOverloadResolverAdaptor>(getImpl(name, context));
 }
 
 FunctionOverloadResolverImplPtr FunctionFactory::tryGetImpl(
     const std::string & name_param,
-    const Context & context) const
+    ContextPtr context) const
 {
     String name = getAliasToOrName(name_param);
     FunctionOverloadResolverImplPtr res;
@@ -110,7 +110,7 @@ FunctionOverloadResolverImplPtr FunctionFactory::tryGetImpl(
 
     if (CurrentThread::isInitialized())
     {
-        const auto * query_context = CurrentThread::get().getQueryContext();
+        auto query_context = CurrentThread::get().getQueryContext();
         if (query_context && query_context->getSettingsRef().log_queries)
             query_context->addQueryFactoriesInfo(Context::QueryLogFactories::Function, name);
     }
@@ -120,7 +120,7 @@ FunctionOverloadResolverImplPtr FunctionFactory::tryGetImpl(
 
 FunctionOverloadResolverPtr FunctionFactory::tryGet(
         const std::string & name,
-        const Context & context) const
+        ContextPtr context) const
 {
     auto impl = tryGetImpl(name, context);
     return impl ? std::make_shared<FunctionOverloadResolverAdaptor>(std::move(impl))
diff --git a/src/Functions/FunctionFactory.h b/src/Functions/FunctionFactory.h
index 7990e78daf8..96238a88420 100644
--- a/src/Functions/FunctionFactory.h
+++ b/src/Functions/FunctionFactory.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Functions/IFunctionAdaptors.h>
+#include <Interpreters/Context_fwd.h>
 #include <Common/IFactoryWithAliases.h>
 
 #include <functional>
@@ -12,14 +13,12 @@
 namespace DB
 {
 
-class Context;
-
-
 /** Creates function by name.
   * Function could use for initialization (take ownership of shared_ptr, for example)
   *  some dictionaries from Context.
   */
-class FunctionFactory : private boost::noncopyable, public IFactoryWithAliases<std::function<FunctionOverloadResolverImplPtr(const Context &)>>
+class FunctionFactory : private boost::noncopyable,
+                        public IFactoryWithAliases<std::function<FunctionOverloadResolverImplPtr(ContextPtr)>>
 {
 public:
     static FunctionFactory & instance();
@@ -43,14 +42,14 @@ public:
     std::vector<std::string> getAllNames() const;
 
     /// Throws an exception if not found.
-    FunctionOverloadResolverPtr get(const std::string & name, const Context & context) const;
+    FunctionOverloadResolverPtr get(const std::string & name, ContextPtr context) const;
 
     /// Returns nullptr if not found.
-    FunctionOverloadResolverPtr tryGet(const std::string & name, const Context & context) const;
+    FunctionOverloadResolverPtr tryGet(const std::string & name, ContextPtr context) const;
 
     /// The same methods to get developer interface implementation.
-    FunctionOverloadResolverImplPtr getImpl(const std::string & name, const Context & context) const;
-    FunctionOverloadResolverImplPtr tryGetImpl(const std::string & name, const Context & context) const;
+    FunctionOverloadResolverImplPtr getImpl(const std::string & name, ContextPtr context) const;
+    FunctionOverloadResolverImplPtr tryGetImpl(const std::string & name, ContextPtr context) const;
 
 private:
     using Functions = std::unordered_map<std::string, Value>;
@@ -59,7 +58,7 @@ private:
     Functions case_insensitive_functions;
 
     template <typename Function>
-    static FunctionOverloadResolverImplPtr createDefaultFunction(const Context & context)
+    static FunctionOverloadResolverImplPtr createDefaultFunction(ContextPtr context)
     {
         return std::make_unique<DefaultOverloadResolver>(Function::create(context));
     }
diff --git a/src/Functions/FunctionFile.cpp b/src/Functions/FunctionFile.cpp
index f477f6123c3..9247152367b 100644
--- a/src/Functions/FunctionFile.cpp
+++ b/src/Functions/FunctionFile.cpp
@@ -21,12 +21,12 @@ namespace ErrorCodes
 }
 
 /// A function to read file as a string.
-class FunctionFile : public IFunction
+class FunctionFile : public IFunction, WithContext
 {
 public:
     static constexpr auto name = "file";
-    static FunctionPtr create(const Context &context) { return std::make_shared<FunctionFile>(context); }
-    explicit FunctionFile(const Context &context_) : context(context_) {}
+    static FunctionPtr create(ContextPtr context_) { return std::make_shared<FunctionFile>(context_); }
+    explicit FunctionFile(ContextPtr context_) : WithContext(context_) {}
 
     String getName() const override { return name; }
 
@@ -68,7 +68,7 @@ public:
         {
             const char * filename = reinterpret_cast<const char *>(&chars[source_offset]);
 
-            const String user_files_path = context.getUserFilesPath();
+            const String user_files_path = getContext()->getUserFilesPath();
             String user_files_absolute_path = Poco::Path(user_files_path).makeAbsolute().makeDirectory().toString();
             Poco::Path poco_filepath = Poco::Path(filename);
             if (poco_filepath.isRelative())
@@ -113,7 +113,7 @@ private:
     void checkReadIsAllowedOrThrow(const std::string & user_files_absolute_path, const std::string & file_absolute_path) const
     {
         // If run in Local mode, no need for path checking.
-        if (context.getApplicationType() != Context::ApplicationType::LOCAL)
+        if (getContext()->getApplicationType() != Context::ApplicationType::LOCAL)
             if (file_absolute_path.find(user_files_absolute_path) != 0)
                 throw Exception("File is not inside " + user_files_absolute_path, ErrorCodes::DATABASE_ACCESS_DENIED);
 
@@ -121,8 +121,6 @@ private:
         if (path_poco_file.exists() && path_poco_file.isDirectory())
             throw Exception("File can't be a directory", ErrorCodes::INCORRECT_FILE_NAME);
     }
-
-    const Context & context;
 };
 
 
diff --git a/src/Functions/FunctionJoinGet.cpp b/src/Functions/FunctionJoinGet.cpp
index 49f155c687b..2ad9985d44c 100644
--- a/src/Functions/FunctionJoinGet.cpp
+++ b/src/Functions/FunctionJoinGet.cpp
@@ -36,7 +36,7 @@ ExecutableFunctionImplPtr FunctionJoinGet<or_null>::prepare(const ColumnsWithTyp
 }
 
 static std::pair<std::shared_ptr<StorageJoin>, String>
-getJoin(const ColumnsWithTypeAndName & arguments, const Context & context)
+getJoin(const ColumnsWithTypeAndName & arguments, ContextPtr context)
 {
     String join_name;
     if (const auto * name_col = checkAndGetColumnConst<ColumnString>(arguments[0].column.get()))
@@ -52,7 +52,7 @@ getJoin(const ColumnsWithTypeAndName & arguments, const Context & context)
     String database_name;
     if (dot == String::npos)
     {
-        database_name = context.getCurrentDatabase();
+        database_name = context->getCurrentDatabase();
         dot = 0;
     }
     else
@@ -88,12 +88,12 @@ FunctionBaseImplPtr JoinGetOverloadResolver<or_null>::build(const ColumnsWithTyp
             "Number of arguments for function " + getName() + " doesn't match: passed " + toString(arguments.size())
                 + ", should be greater or equal to 3",
             ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
-    auto [storage_join, attr_name] = getJoin(arguments, context);
+    auto [storage_join, attr_name] = getJoin(arguments, getContext());
     DataTypes data_types(arguments.size() - 2);
     for (size_t i = 2; i < arguments.size(); ++i)
         data_types[i - 2] = arguments[i].type;
     auto return_type = storage_join->joinGetCheckAndGetReturnType(data_types, attr_name, or_null);
-    auto table_lock = storage_join->lockForShare(context.getInitialQueryId(), context.getSettingsRef().lock_acquire_timeout);
+    auto table_lock = storage_join->lockForShare(getContext()->getInitialQueryId(), getContext()->getSettingsRef().lock_acquire_timeout);
     return std::make_unique<FunctionJoinGet<or_null>>(table_lock, storage_join, attr_name, data_types, return_type);
 }
 
diff --git a/src/Functions/FunctionJoinGet.h b/src/Functions/FunctionJoinGet.h
index f88b58e961a..016ef15f2d5 100644
--- a/src/Functions/FunctionJoinGet.h
+++ b/src/Functions/FunctionJoinGet.h
@@ -1,5 +1,7 @@
 #pragma once
+
 #include <Functions/IFunctionImpl.h>
+#include <Interpreters/Context_fwd.h>
 #include <Storages/IStorage_fwd.h>
 #include <Storages/TableLockHolder.h>
 #include <Core/Block.h>
@@ -7,7 +9,6 @@
 namespace DB
 {
 
-class Context;
 class HashJoin;
 class StorageJoin;
 using StorageJoinPtr = std::shared_ptr<StorageJoin>;
@@ -73,13 +74,13 @@ private:
 };
 
 template <bool or_null>
-class JoinGetOverloadResolver final : public IFunctionOverloadResolverImpl
+class JoinGetOverloadResolver final : public IFunctionOverloadResolverImpl, WithContext
 {
 public:
     static constexpr auto name = or_null ? "joinGetOrNull" : "joinGet";
-    static FunctionOverloadResolverImplPtr create(const Context & context) { return std::make_unique<JoinGetOverloadResolver>(context); }
+    static FunctionOverloadResolverImplPtr create(ContextPtr context_) { return std::make_unique<JoinGetOverloadResolver>(context_); }
 
-    explicit JoinGetOverloadResolver(const Context & context_) : context(context_) {}
+    explicit JoinGetOverloadResolver(ContextPtr context_) : WithContext(context_) {}
 
     String getName() const override { return name; }
 
@@ -92,9 +93,6 @@ public:
     bool isVariadic() const override { return true; }
     size_t getNumberOfArguments() const override { return 0; }
     ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {0, 1}; }
-
-private:
-    const Context & context;
 };
 
 }
diff --git a/src/Functions/FunctionMathBinaryFloat64.h b/src/Functions/FunctionMathBinaryFloat64.h
index 0a0688dc75c..00f6909f65c 100644
--- a/src/Functions/FunctionMathBinaryFloat64.h
+++ b/src/Functions/FunctionMathBinaryFloat64.h
@@ -28,7 +28,7 @@ class FunctionMathBinaryFloat64 : public IFunction
 {
 public:
     static constexpr auto name = Impl::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMathBinaryFloat64>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMathBinaryFloat64>(); }
     static_assert(Impl::rows_per_iteration > 0, "Impl must process at least one row per iteration");
 
     bool useDefaultImplementationForConstants() const override { return true; }
diff --git a/src/Functions/FunctionMathConstFloat64.h b/src/Functions/FunctionMathConstFloat64.h
index f03f469bc35..04ade5b4637 100644
--- a/src/Functions/FunctionMathConstFloat64.h
+++ b/src/Functions/FunctionMathConstFloat64.h
@@ -13,7 +13,7 @@ class FunctionMathConstFloat64 : public IFunction
 {
 public:
     static constexpr auto name = Impl::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMathConstFloat64>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMathConstFloat64>(); }
 
 private:
     String getName() const override { return name; }
diff --git a/src/Functions/FunctionMathUnary.h b/src/Functions/FunctionMathUnary.h
index 49b0428811a..e24d19e5a9b 100644
--- a/src/Functions/FunctionMathUnary.h
+++ b/src/Functions/FunctionMathUnary.h
@@ -35,7 +35,7 @@ class FunctionMathUnary : public IFunction
 {
 public:
     static constexpr auto name = Impl::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMathUnary>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMathUnary>(); }
 
 private:
     String getName() const override { return name; }
diff --git a/src/Functions/FunctionNumericPredicate.h b/src/Functions/FunctionNumericPredicate.h
index 72a17adac4c..9bb0f700fe0 100644
--- a/src/Functions/FunctionNumericPredicate.h
+++ b/src/Functions/FunctionNumericPredicate.h
@@ -1,8 +1,10 @@
 #pragma once
+
 #include <Functions/IFunctionImpl.h>
 #include <Functions/FunctionHelpers.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnsNumber.h>
+#include <Interpreters/Context_fwd.h>
 #include <ext/range.h>
 
 
@@ -21,7 +23,7 @@ class FunctionNumericPredicate : public IFunction
 {
 public:
     static constexpr auto name = Impl::name;
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionNumericPredicate>();
     }
diff --git a/src/Functions/FunctionStartsEndsWith.h b/src/Functions/FunctionStartsEndsWith.h
index 2899bc259d5..87c07c5efd2 100644
--- a/src/Functions/FunctionStartsEndsWith.h
+++ b/src/Functions/FunctionStartsEndsWith.h
@@ -142,7 +142,7 @@ template <typename Name>
 class FunctionStartsEndsWith : public TargetSpecific::Default::FunctionStartsEndsWith<Name>
 {
 public:
-    explicit FunctionStartsEndsWith(const Context & context) : selector(context)
+    explicit FunctionStartsEndsWith(ContextPtr context) : selector(context)
     {
         selector.registerImplementation<TargetArch::Default,
             TargetSpecific::Default::FunctionStartsEndsWith<Name>>();
@@ -164,7 +164,7 @@ public:
         return selector.selectAndExecute(arguments, result_type, input_rows_count);
     }
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionStartsEndsWith<Name>>(context);
     }
diff --git a/src/Functions/FunctionStringOrArrayToT.h b/src/Functions/FunctionStringOrArrayToT.h
index e00acc006cf..40ce62a5666 100644
--- a/src/Functions/FunctionStringOrArrayToT.h
+++ b/src/Functions/FunctionStringOrArrayToT.h
@@ -25,7 +25,7 @@ class FunctionStringOrArrayToT : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionStringOrArrayToT>();
     }
diff --git a/src/Functions/FunctionStringReplace.h b/src/Functions/FunctionStringReplace.h
index bd8edbf9202..2e99f58531a 100644
--- a/src/Functions/FunctionStringReplace.h
+++ b/src/Functions/FunctionStringReplace.h
@@ -23,7 +23,7 @@ class FunctionStringReplace : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionStringReplace>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionStringReplace>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionStringToString.h b/src/Functions/FunctionStringToString.h
index 4123b41c547..36009dc30c0 100644
--- a/src/Functions/FunctionStringToString.h
+++ b/src/Functions/FunctionStringToString.h
@@ -1,9 +1,11 @@
 #pragma once
+
 #include <DataTypes/DataTypeString.h>
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnFixedString.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/IFunctionImpl.h>
+#include <Interpreters/Context_fwd.h>
 
 
 namespace DB
@@ -21,7 +23,7 @@ class FunctionStringToString : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionStringToString>();
     }
diff --git a/src/Functions/FunctionUnaryArithmetic.h b/src/Functions/FunctionUnaryArithmetic.h
index 06469a83e3e..9145c4a2ec5 100644
--- a/src/Functions/FunctionUnaryArithmetic.h
+++ b/src/Functions/FunctionUnaryArithmetic.h
@@ -110,7 +110,7 @@ class FunctionUnaryArithmetic : public IFunction
 
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionUnaryArithmetic>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionUnaryArithmetic>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/FunctionUnixTimestamp64.h b/src/Functions/FunctionUnixTimestamp64.h
index 20e225990bd..18f9c7a8b02 100644
--- a/src/Functions/FunctionUnixTimestamp64.h
+++ b/src/Functions/FunctionUnixTimestamp64.h
@@ -33,7 +33,7 @@ public:
 
     static_assert(std::is_same_v<SourceDataType, DataTypeDateTime64> || std::is_same_v<ResultDataType, DataTypeDateTime64>);
 
-    static auto create(const Context &)
+    static auto create(ContextPtr)
     {
         return std::make_shared<FunctionUnixTimestamp64<Impl>>();
     }
diff --git a/src/Functions/FunctionsAES.h b/src/Functions/FunctionsAES.h
index 8af4a27ecc9..b76b454fd77 100644
--- a/src/Functions/FunctionsAES.h
+++ b/src/Functions/FunctionsAES.h
@@ -141,7 +141,7 @@ class FunctionEncrypt : public IFunction
 public:
     static constexpr OpenSSLDetails::CompatibilityMode compatibility_mode = Impl::compatibility_mode;
     static constexpr auto name = Impl::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionEncrypt>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionEncrypt>(); }
 
 private:
     using CipherMode = OpenSSLDetails::CipherMode;
@@ -416,7 +416,7 @@ class FunctionDecrypt : public IFunction
 public:
     static constexpr OpenSSLDetails::CompatibilityMode compatibility_mode = Impl::compatibility_mode;
     static constexpr auto name = Impl::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionDecrypt>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionDecrypt>(); }
 
 private:
     using CipherMode = OpenSSLDetails::CipherMode;
diff --git a/src/Functions/FunctionsBitmap.h b/src/Functions/FunctionsBitmap.h
index a79365ec16c..aa4a6b50ea3 100644
--- a/src/Functions/FunctionsBitmap.h
+++ b/src/Functions/FunctionsBitmap.h
@@ -93,7 +93,7 @@ class FunctionBitmapBuildImpl : public IFunction
 public:
     static constexpr auto name = Name::name;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitmapBuildImpl>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitmapBuildImpl>(); }
 
     String getName() const override { return name; }
 
@@ -221,7 +221,7 @@ class FunctionBitmapToArrayImpl : public IFunction
 public:
     static constexpr auto name = Name::name;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitmapToArrayImpl>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitmapToArrayImpl>(); }
 
     String getName() const override { return name; }
 
@@ -311,7 +311,7 @@ class FunctionBitmapSubset : public IFunction
 public:
     static constexpr auto name = Impl::name;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitmapSubset<Impl>>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitmapSubset<Impl>>(); }
 
     String getName() const override { return name; }
 
@@ -469,7 +469,7 @@ class FunctionBitmapTransform : public IFunction
 public:
     static constexpr auto name = "bitmapTransform";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitmapTransform>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitmapTransform>(); }
 
     String getName() const override { return name; }
 
@@ -635,7 +635,7 @@ class FunctionBitmapSelfCardinalityImpl : public IFunction
 public:
     static constexpr auto name = Impl::name;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitmapSelfCardinalityImpl<Impl>>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitmapSelfCardinalityImpl<Impl>>(); }
 
     String getName() const override { return name; }
 
@@ -807,7 +807,7 @@ class FunctionBitmapContains : public IFunction
 public:
     static constexpr auto name = "bitmapContains";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitmapContains>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitmapContains>(); }
 
     String getName() const override { return name; }
 
@@ -911,7 +911,7 @@ class FunctionBitmapCardinality : public IFunction
 public:
     static constexpr auto name = Name::name;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitmapCardinality>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitmapCardinality>(); }
 
     String getName() const override { return name; }
 
@@ -1054,7 +1054,7 @@ class FunctionBitmap : public IFunction
 public:
     static constexpr auto name = Name::name;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitmap>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitmap>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionsCoding.h b/src/Functions/FunctionsCoding.h
index ee15561f133..933d4f01b92 100644
--- a/src/Functions/FunctionsCoding.h
+++ b/src/Functions/FunctionsCoding.h
@@ -1,28 +1,29 @@
 #pragma once
 
-#include <Common/formatIPv6.h>
-#include <Common/hex.h>
-#include <Common/IPv6ToBinary.h>
-#include <Common/typeid_cast.h>
-#include <IO/WriteHelpers.h>
-#include <DataTypes/DataTypeFactory.h>
-#include <DataTypes/DataTypesNumber.h>
-#include <DataTypes/DataTypeString.h>
-#include <DataTypes/DataTypeFixedString.h>
+#include <Columns/ColumnArray.h>
+#include <Columns/ColumnConst.h>
+#include <Columns/ColumnDecimal.h>
+#include <Columns/ColumnFixedString.h>
+#include <Columns/ColumnString.h>
+#include <Columns/ColumnTuple.h>
+#include <Columns/ColumnsNumber.h>
 #include <DataTypes/DataTypeArray.h>
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
-#include <DataTypes/DataTypeUUID.h>
+#include <DataTypes/DataTypeFactory.h>
+#include <DataTypes/DataTypeFixedString.h>
+#include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypeTuple.h>
-#include <Columns/ColumnsNumber.h>
-#include <Columns/ColumnString.h>
-#include <Columns/ColumnFixedString.h>
-#include <Columns/ColumnArray.h>
-#include <Columns/ColumnConst.h>
-#include <Columns/ColumnTuple.h>
-#include <Columns/ColumnDecimal.h>
-#include <Functions/IFunctionImpl.h>
+#include <DataTypes/DataTypeUUID.h>
+#include <DataTypes/DataTypesNumber.h>
 #include <Functions/FunctionHelpers.h>
+#include <Functions/IFunctionImpl.h>
+#include <Interpreters/Context_fwd.h>
+#include <IO/WriteHelpers.h>
+#include <Common/IPv6ToBinary.h>
+#include <Common/formatIPv6.h>
+#include <Common/hex.h>
+#include <Common/typeid_cast.h>
 
 #include <arpa/inet.h>
 #include <ext/range.h>
@@ -68,7 +69,7 @@ class FunctionIPv6NumToString : public IFunction
 {
 public:
     static constexpr auto name = "IPv6NumToString";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionIPv6NumToString>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIPv6NumToString>(); }
 
     String getName() const override { return name; }
 
@@ -138,7 +139,7 @@ class FunctionCutIPv6 : public IFunction
 {
 public:
     static constexpr auto name = "cutIPv6";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionCutIPv6>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionCutIPv6>(); }
 
     String getName() const override { return name; }
 
@@ -261,7 +262,7 @@ class FunctionIPv6StringToNum : public IFunction
 {
 public:
     static constexpr auto name = "IPv6StringToNum";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionIPv6StringToNum>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIPv6StringToNum>(); }
 
     static inline bool tryParseIPv4(const char * pos)
     {
@@ -339,7 +340,7 @@ class FunctionIPv4NumToString : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionIPv4NumToString<mask_tail_octets, Name>>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIPv4NumToString<mask_tail_octets, Name>>(); }
 
     String getName() const override
     {
@@ -400,7 +401,7 @@ class FunctionIPv4StringToNum : public IFunction
 {
 public:
     static constexpr auto name = "IPv4StringToNum";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionIPv4StringToNum>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIPv4StringToNum>(); }
 
     String getName() const override
     {
@@ -463,7 +464,7 @@ class FunctionIPv4ToIPv6 : public IFunction
 {
 public:
      static constexpr auto name = "IPv4ToIPv6";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionIPv4ToIPv6>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIPv4ToIPv6>(); }
 
     String getName() const override { return name; }
 
@@ -518,7 +519,7 @@ class FunctionToIPv4 : public FunctionIPv4StringToNum
 {
 public:
     static constexpr auto name = "toIPv4";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionToIPv4>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionToIPv4>(); }
 
     String getName() const override
     {
@@ -541,7 +542,7 @@ class FunctionToIPv6 : public FunctionIPv6StringToNum
 {
 public:
     static constexpr auto name = "toIPv6";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionToIPv6>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionToIPv6>(); }
 
     String getName() const override { return name; }
 
@@ -559,7 +560,7 @@ class FunctionMACNumToString : public IFunction
 {
 public:
     static constexpr auto name = "MACNumToString";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMACNumToString>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMACNumToString>(); }
 
     String getName() const override
     {
@@ -689,7 +690,7 @@ class FunctionMACStringTo : public IFunction
 {
 public:
     static constexpr auto name = Impl::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMACStringTo<Impl>>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMACStringTo<Impl>>(); }
 
     String getName() const override
     {
@@ -752,7 +753,7 @@ class FunctionUUIDNumToString : public IFunction
 
 public:
     static constexpr auto name = "UUIDNumToString";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionUUIDNumToString>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionUUIDNumToString>(); }
 
     String getName() const override
     {
@@ -850,7 +851,7 @@ private:
 
 public:
     static constexpr auto name = "UUIDStringToNum";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionUUIDStringToNum>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionUUIDStringToNum>(); }
 
     String getName() const override
     {
@@ -954,7 +955,7 @@ class FunctionHex : public IFunction
 {
 public:
     static constexpr auto name = "hex";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionHex>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionHex>(); }
 
     String getName() const override
     {
@@ -1237,7 +1238,7 @@ class FunctionUnhex : public IFunction
 {
 public:
     static constexpr auto name = "unhex";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionUnhex>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionUnhex>(); }
 
     String getName() const override
     {
@@ -1326,7 +1327,7 @@ class FunctionChar : public IFunction
 {
 public:
     static constexpr auto name = "char";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionChar>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionChar>(); }
 
     String getName() const override
     {
@@ -1421,7 +1422,7 @@ class FunctionBitmaskToArray : public IFunction
 {
 public:
     static constexpr auto name = "bitmaskToArray";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitmaskToArray>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitmaskToArray>(); }
 
     String getName() const override
     {
@@ -1507,7 +1508,7 @@ class FunctionToStringCutToZero : public IFunction
 {
 public:
     static constexpr auto name = "toStringCutToZero";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionToStringCutToZero>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionToStringCutToZero>(); }
 
     String getName() const override
     {
@@ -1672,7 +1673,7 @@ private:
 
 public:
     static constexpr auto name = "IPv6CIDRToRange";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionIPv6CIDRToRange>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIPv6CIDRToRange>(); }
 
     String getName() const override { return name; }
     size_t getNumberOfArguments() const override { return 2; }
@@ -1786,7 +1787,7 @@ private:
 
 public:
     static constexpr auto name = "IPv4CIDRToRange";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionIPv4CIDRToRange>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIPv4CIDRToRange>(); }
 
     String getName() const override { return name; }
     size_t getNumberOfArguments() const override { return 2; }
@@ -1867,7 +1868,7 @@ class FunctionIsIPv4String : public FunctionIPv4StringToNum
 public:
     static constexpr auto name = "isIPv4String";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionIsIPv4String>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIsIPv4String>(); }
 
     String getName() const override { return name; }
 
@@ -1913,7 +1914,7 @@ class FunctionIsIPv6String : public FunctionIPv6StringToNum
 public:
     static constexpr auto name = "isIPv6String";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionIsIPv6String>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIsIPv6String>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionsComparison.h b/src/Functions/FunctionsComparison.h
index bbfa1ea20d8..025b7c67b21 100644
--- a/src/Functions/FunctionsComparison.h
+++ b/src/Functions/FunctionsComparison.h
@@ -552,22 +552,18 @@ struct NameLessOrEquals    { static constexpr auto name = "lessOrEquals"; };
 struct NameGreaterOrEquals { static constexpr auto name = "greaterOrEquals"; };
 
 
-template <
-    template <typename, typename> class Op,
-    typename Name>
+template <template <typename, typename> class Op, typename Name>
 class FunctionComparison : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context & context) { return std::make_shared<FunctionComparison>(context); }
+    static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionComparison>(context); }
 
-    explicit FunctionComparison(const Context & context_)
-    :   context(context_),
-        check_decimal_overflow(decimalCheckComparisonOverflow(context))
-    {}
+    explicit FunctionComparison(ContextPtr context_)
+        : context(context_), check_decimal_overflow(decimalCheckComparisonOverflow(context)) {}
 
 private:
-    const Context & context;
+    ContextPtr context;
     bool check_decimal_overflow = true;
 
     template <typename T0, typename T1>
diff --git a/src/Functions/FunctionsConsistentHashing.h b/src/Functions/FunctionsConsistentHashing.h
index faf66579fc4..17432cd7e78 100644
--- a/src/Functions/FunctionsConsistentHashing.h
+++ b/src/Functions/FunctionsConsistentHashing.h
@@ -6,6 +6,7 @@
 #include <Functions/FunctionHelpers.h>
 #include <Functions/IFunctionImpl.h>
 #include <Common/typeid_cast.h>
+#include <Interpreters/Context_fwd.h>
 
 
 namespace DB
@@ -23,7 +24,7 @@ class FunctionConsistentHashImpl : public IFunction
 public:
     static constexpr auto name = Impl::name;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionConsistentHashImpl<Impl>>();
     }
diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h
index 10aa1987559..9b40be58862 100644
--- a/src/Functions/FunctionsConversion.h
+++ b/src/Functions/FunctionsConversion.h
@@ -1290,7 +1290,7 @@ public:
     static constexpr bool to_string_or_fixed_string = std::is_same_v<ToDataType, DataTypeFixedString> ||
                                                       std::is_same_v<ToDataType, DataTypeString>;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionConvert>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionConvert>(); }
     static FunctionPtr create() { return std::make_shared<FunctionConvert>(); }
 
     String getName() const override
@@ -1586,7 +1586,7 @@ public:
 
     static constexpr bool to_datetime64 = std::is_same_v<ToDataType, DataTypeDateTime64>;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionConvertFromString>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionConvertFromString>(); }
     static FunctionPtr create() { return std::make_shared<FunctionConvertFromString>(); }
 
     String getName() const override
@@ -2275,7 +2275,7 @@ private:
     std::optional<Diagnostic> diagnostic;
     CastType cast_type;
 
-    WrapperType createFunctionAdaptor(FunctionPtr function, const DataTypePtr & from_type) const
+    static WrapperType createFunctionAdaptor(FunctionPtr function, const DataTypePtr & from_type)
     {
         auto function_adaptor = FunctionOverloadResolverAdaptor(std::make_unique<DefaultOverloadResolver>(function))
                                     .build({ColumnWithTypeAndName{nullptr, from_type, ""}});
@@ -2367,7 +2367,7 @@ private:
         };
     }
 
-    WrapperType createStringWrapper(const DataTypePtr & from_type) const
+    static WrapperType createStringWrapper(const DataTypePtr & from_type)
     {
         FunctionPtr function = FunctionToString::create();
         return createFunctionAdaptor(function, from_type);
@@ -2641,7 +2641,7 @@ private:
     WrapperType createMapToMapWrrapper(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
+            (ColumnsWithTypeAndName & arguments, const DataTypePtr &, const ColumnNullable * nullable_source, size_t /*input_rows_count*/) -> ColumnPtr
         {
             const auto * col = arguments.front().column.get();
             const auto & column_map = typeid_cast<const ColumnMap &>(*col);
@@ -2651,7 +2651,7 @@ private:
             for (size_t i = 0; i < 2; ++i)
             {
                 ColumnsWithTypeAndName element = {{nested_data.getColumnPtr(i), from_kv_types[i], ""}};
-                converted_columns[i] = element_wrappers[i](element, to_kv_types[i], nullable_source, input_rows_count);
+                converted_columns[i] = element_wrappers[i](element, to_kv_types[i], nullable_source, (element[0].column)->size());
             }
 
             return ColumnMap::create(converted_columns[0], converted_columns[1], column_map.getNestedColumn().getOffsetsPtr());
@@ -2662,7 +2662,7 @@ private:
     WrapperType createArrayToMapWrrapper(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
+            (ColumnsWithTypeAndName & arguments, const DataTypePtr &, const ColumnNullable * nullable_source, size_t /*input_rows_count*/) -> ColumnPtr
         {
             const auto * col = arguments.front().column.get();
             const auto & column_array = typeid_cast<const ColumnArray &>(*col);
@@ -2672,7 +2672,7 @@ private:
             for (size_t i = 0; i < 2; ++i)
             {
                 ColumnsWithTypeAndName element = {{nested_data.getColumnPtr(i), from_kv_types[i], ""}};
-                converted_columns[i] = element_wrappers[i](element, to_kv_types[i], nullable_source, input_rows_count);
+                converted_columns[i] = element_wrappers[i](element, to_kv_types[i], nullable_source, (element[0].column)->size());
             }
 
             return ColumnMap::create(converted_columns[0], converted_columns[1], column_array.getOffsetsPtr());
@@ -3125,43 +3125,43 @@ public:
 
     static MonotonicityForRange getMonotonicityInformation(const DataTypePtr & from_type, const IDataType * to_type)
     {
-        if (const auto type = checkAndGetDataType<DataTypeUInt8>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeUInt8>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeUInt16>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeUInt16>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeUInt32>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeUInt32>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeUInt64>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeUInt64>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeUInt256>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeUInt256>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeInt8>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeInt8>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeInt16>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeInt16>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeInt32>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeInt32>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeInt64>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeInt64>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeInt128>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeInt128>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeInt256>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeInt256>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeFloat32>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeFloat32>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeFloat64>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeFloat64>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeDate>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeDate>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeDateTime>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeDateTime>(to_type))
             return monotonicityForType(type);
-        if (const auto type = checkAndGetDataType<DataTypeString>(to_type))
+        if (const auto *const type = checkAndGetDataType<DataTypeString>(to_type))
             return monotonicityForType(type);
         if (isEnum(from_type))
         {
-            if (const auto type = checkAndGetDataType<DataTypeEnum8>(to_type))
+            if (const auto *const type = checkAndGetDataType<DataTypeEnum8>(to_type))
                 return monotonicityForType(type);
-            if (const auto type = checkAndGetDataType<DataTypeEnum16>(to_type))
+            if (const auto *const type = checkAndGetDataType<DataTypeEnum16>(to_type))
                 return monotonicityForType(type);
         }
         /// other types like Null, FixedString, Array and Tuple have no monotonicity defined
@@ -3184,9 +3184,9 @@ public:
         ? accurate_cast_name
         : (cast_type == CastType::accurateOrNull ? accurate_cast_or_null_name : cast_name);
 
-    static FunctionOverloadResolverImplPtr create(const Context & context)
+    static FunctionOverloadResolverImplPtr create(ContextPtr context)
     {
-        return createImpl(context.getSettingsRef().cast_keep_nullable);
+        return createImpl(context->getSettingsRef().cast_keep_nullable);
     }
 
     static FunctionOverloadResolverImplPtr createImpl(bool keep_nullable, std::optional<Diagnostic> diagnostic = {})
diff --git a/src/Functions/FunctionsEmbeddedDictionaries.h b/src/Functions/FunctionsEmbeddedDictionaries.h
index 01456365740..7584a217a26 100644
--- a/src/Functions/FunctionsEmbeddedDictionaries.h
+++ b/src/Functions/FunctionsEmbeddedDictionaries.h
@@ -483,81 +483,81 @@ struct NameRegionIn                    { static constexpr auto name = "regionIn"
 struct FunctionRegionToCity :
     public FunctionTransformWithDictionary<UInt32, RegionToCityImpl,    RegionsHierarchyGetter,    NameRegionToCity>
 {
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<base_type>(context.getEmbeddedDictionaries().getRegionsHierarchies());
+        return std::make_shared<base_type>(context->getEmbeddedDictionaries().getRegionsHierarchies());
     }
 };
 
 struct FunctionRegionToArea :
     public FunctionTransformWithDictionary<UInt32, RegionToAreaImpl,    RegionsHierarchyGetter,    NameRegionToArea>
 {
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<base_type>(context.getEmbeddedDictionaries().getRegionsHierarchies());
+        return std::make_shared<base_type>(context->getEmbeddedDictionaries().getRegionsHierarchies());
     }
 };
 
 struct FunctionRegionToDistrict :
     public FunctionTransformWithDictionary<UInt32, RegionToDistrictImpl, RegionsHierarchyGetter, NameRegionToDistrict>
 {
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<base_type>(context.getEmbeddedDictionaries().getRegionsHierarchies());
+        return std::make_shared<base_type>(context->getEmbeddedDictionaries().getRegionsHierarchies());
     }
 };
 
 struct FunctionRegionToCountry :
     public FunctionTransformWithDictionary<UInt32, RegionToCountryImpl, RegionsHierarchyGetter, NameRegionToCountry>
 {
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<base_type>(context.getEmbeddedDictionaries().getRegionsHierarchies());
+        return std::make_shared<base_type>(context->getEmbeddedDictionaries().getRegionsHierarchies());
     }
 };
 
 struct FunctionRegionToContinent :
     public FunctionTransformWithDictionary<UInt32, RegionToContinentImpl, RegionsHierarchyGetter, NameRegionToContinent>
 {
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<base_type>(context.getEmbeddedDictionaries().getRegionsHierarchies());
+        return std::make_shared<base_type>(context->getEmbeddedDictionaries().getRegionsHierarchies());
     }
 };
 
 struct FunctionRegionToTopContinent :
     public FunctionTransformWithDictionary<UInt32, RegionToTopContinentImpl, RegionsHierarchyGetter, NameRegionToTopContinent>
 {
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<base_type>(context.getEmbeddedDictionaries().getRegionsHierarchies());
+        return std::make_shared<base_type>(context->getEmbeddedDictionaries().getRegionsHierarchies());
     }
 };
 
 struct FunctionRegionToPopulation :
     public FunctionTransformWithDictionary<UInt32, RegionToPopulationImpl, RegionsHierarchyGetter, NameRegionToPopulation>
 {
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<base_type>(context.getEmbeddedDictionaries().getRegionsHierarchies());
+        return std::make_shared<base_type>(context->getEmbeddedDictionaries().getRegionsHierarchies());
     }
 };
 
 struct FunctionRegionIn :
     public FunctionIsInWithDictionary<UInt32, RegionInImpl, RegionsHierarchyGetter,    NameRegionIn>
 {
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<base_type>(context.getEmbeddedDictionaries().getRegionsHierarchies());
+        return std::make_shared<base_type>(context->getEmbeddedDictionaries().getRegionsHierarchies());
     }
 };
 
 struct FunctionRegionHierarchy :
     public FunctionHierarchyWithDictionary<UInt32, RegionHierarchyImpl, RegionsHierarchyGetter, NameRegionHierarchy>
 {
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<base_type>(context.getEmbeddedDictionaries().getRegionsHierarchies());
+        return std::make_shared<base_type>(context->getEmbeddedDictionaries().getRegionsHierarchies());
     }
 };
 
@@ -567,9 +567,9 @@ class FunctionRegionToName : public IFunction
 {
 public:
     static constexpr auto name = "regionToName";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<FunctionRegionToName>(context.getEmbeddedDictionaries().getRegionsNames());
+        return std::make_shared<FunctionRegionToName>(context->getEmbeddedDictionaries().getRegionsNames());
     }
 
 private:
@@ -643,9 +643,9 @@ public:
 
             const ColumnUInt32::Container & region_ids = col_from->getData();
 
-            for (size_t i = 0; i < region_ids.size(); ++i)
+            for (unsigned int region_id : region_ids)
             {
-                const StringRef & name_ref = dict.getRegionName(region_ids[i], language);
+                const StringRef & name_ref = dict.getRegionName(region_id, language);
                 col_to->insertDataWithTerminatingZero(name_ref.data, name_ref.size + 1);
             }
 
diff --git a/src/Functions/FunctionsExternalDictionaries.h b/src/Functions/FunctionsExternalDictionaries.h
index 1f8ef60b4af..6157b532cb9 100644
--- a/src/Functions/FunctionsExternalDictionaries.h
+++ b/src/Functions/FunctionsExternalDictionaries.h
@@ -62,18 +62,18 @@ namespace ErrorCodes
   */
 
 
-class FunctionDictHelper
+class FunctionDictHelper : WithContext
 {
 public:
-    explicit FunctionDictHelper(const Context & context_) : context(context_) {}
+    explicit FunctionDictHelper(ContextPtr context_) : WithContext(context_) {}
 
     std::shared_ptr<const IDictionary> getDictionary(const String & dictionary_name)
     {
-        auto dict = context.getExternalDictionariesLoader().getDictionary(dictionary_name, context);
+        auto dict = getContext()->getExternalDictionariesLoader().getDictionary(dictionary_name, getContext());
 
         if (!access_checked)
         {
-            context.checkAccess(AccessType::dictGet, dict->getDatabaseOrNoDatabaseTag(), dict->getDictionaryID().getTableName());
+            getContext()->checkAccess(AccessType::dictGet, dict->getDatabaseOrNoDatabaseTag(), dict->getDictionaryID().getTableName());
             access_checked = true;
         }
 
@@ -97,26 +97,25 @@ public:
             return false;
 
         if (sample_columns.columns() < 3)
-            throw Exception{"Wrong arguments count", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Wrong arguments count");
 
         const auto * dict_name_col = checkAndGetColumnConst<ColumnString>(sample_columns.getByPosition(0).column.get());
         if (!dict_name_col)
-            throw Exception{"First argument of function dictGet... must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "First argument of function dictGet must be a constant string");
 
         const auto * attr_name_col = checkAndGetColumnConst<ColumnString>(sample_columns.getByPosition(1).column.get());
         if (!attr_name_col)
-            throw Exception{"Second argument of function dictGet... must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Second argument of function dictGet... must be a constant string");
 
         return getDictionary(dict_name_col->getValue<String>())->isInjective(attr_name_col->getValue<String>());
     }
 
     DictionaryStructure getDictionaryStructure(const String & dictionary_name) const
     {
-        return context.getExternalDictionariesLoader().getDictionaryStructure(dictionary_name, context);
+        return getContext()->getExternalDictionariesLoader().getDictionaryStructure(dictionary_name, getContext());
     }
 
 private:
-    const Context & context;
     /// Access cannot be not granted, since in this case checkAccess() will throw and access_checked will not be updated.
     std::atomic<bool> access_checked = false;
 
@@ -133,12 +132,12 @@ class FunctionDictHas final : public IFunction
 public:
     static constexpr auto name = "dictHas";
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionDictHas>(context);
     }
 
-    explicit FunctionDictHas(const Context & context_) : helper(context_) {}
+    explicit FunctionDictHas(ContextPtr context_) : helper(context_) {}
 
     String getName() const override { return name; }
 
@@ -154,16 +153,22 @@ public:
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
         if (arguments.size() < 2)
-            throw Exception{"Wrong argument count for function " + getName(), ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
+                "Wrong argument count for function {}",
+                getName());
 
         if (!isString(arguments[0]))
-            throw Exception{"Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
-                + ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                "Illegal type {} of first argument of function, expected a string",
+                arguments[0]->getName(),
+                getName());
 
         if (!WhichDataType(arguments[1]).isUInt64() &&
             !isTuple(arguments[1]))
-            throw Exception{"Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
-                + ", must be UInt64 or tuple(...).", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                "Illegal type {} of second argument of function {} must be UInt64 or tuple(...)",
+                arguments[1]->getName(),
+                getName());
 
         return std::make_shared<DataTypeUInt8>();
     }
@@ -193,31 +198,39 @@ public:
         if (dictionary_key_type == DictionaryKeyType::range)
         {
             if (arguments.size() != 3)
-                throw Exception{"Wrong argument count for function " + getName()
-                    + " when dictionary has key type range", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+                throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
+                    "Wrong argument count for function {} when dictionary has key type range",
+                    getName());
 
             range_col = arguments[2].column;
             range_col_type = arguments[2].type;
 
             if (!(range_col_type->isValueRepresentedByInteger() && range_col_type->getSizeOfValueInMemory() <= sizeof(Int64)))
-                throw Exception{"Illegal type " + range_col_type->getName() + " of fourth argument of function "
-                        + getName() + " must be convertible to Int64.",
-                    ErrorCodes::ILLEGAL_COLUMN};
+                throw Exception(ErrorCodes::ILLEGAL_COLUMN,
+                    "Illegal type {} of fourth argument of function {} must be convertible to Int64.",
+                    range_col_type->getName(),
+                    getName());
         }
 
         if (dictionary_key_type == DictionaryKeyType::simple)
         {
             if (!key_column_type.isUInt64())
-                throw Exception{"Second argument of function " + getName() + " must be " + dictionary->getStructure().getKeyDescription(),
-                    ErrorCodes::TYPE_MISMATCH};
+                 throw Exception(
+                     ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                     "Second argument of function {} must be UInt64 when dictionary is simple. Actual type {}.",
+                     getName(),
+                     key_column_with_type.type->getName());
 
             return dictionary->hasKeys({key_column}, {std::make_shared<DataTypeUInt64>()});
         }
         else if (dictionary_key_type == DictionaryKeyType::complex)
         {
             if (!key_column_type.isTuple())
-                throw Exception{"Second argument of function " + getName() + " must be " + dictionary->getStructure().getKeyDescription(),
-                    ErrorCodes::TYPE_MISMATCH};
+                throw Exception(
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                    "Second argument of function {} must be tuple when dictionary is complex. Actual type {}.",
+                    getName(),
+                    key_column_with_type.type->getName());
 
             /// Functions in external dictionaries_loader only support full-value (not constant) columns with keys.
             ColumnPtr key_column_full = key_column->convertToFullColumnIfConst();
@@ -228,7 +241,16 @@ public:
             return dictionary->hasKeys(key_columns, key_types);
         }
         else
+        {
+            if (!key_column_type.isUInt64())
+                throw Exception(
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                    "Second argument of function {} must be UInt64 when dictionary is range. Actual type {}.",
+                    getName(),
+                    key_column_with_type.type->getName());
+
             return dictionary->hasKeys({key_column, range_col}, {std::make_shared<DataTypeUInt64>(), range_col_type});
+        }
     }
 
 private:
@@ -248,12 +270,12 @@ class FunctionDictGetNoType final : public IFunction
 public:
     static constexpr auto name = dictionary_get_function_type == DictionaryGetFunctionType::get ? "dictGet" : "dictGetOrDefault";
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionDictGetNoType>(context);
     }
 
-    explicit FunctionDictGetNoType(const Context & context_) : helper(context_) {}
+    explicit FunctionDictGetNoType(ContextPtr context_) : helper(context_) {}
 
     String getName() const override { return name; }
 
@@ -273,14 +295,18 @@ public:
     DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
     {
         if (arguments.size() < 3)
-            throw Exception{"Wrong argument count for function " + getName(), ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
+                "Wrong argument count for function {}",
+                getName());
 
         String dictionary_name;
         if (const auto * name_col = checkAndGetColumnConst<ColumnString>(arguments[0].column.get()))
             dictionary_name = name_col->getValue<String>();
         else
-            throw Exception{"Illegal type " + arguments[0].type->getName() + " of first argument of function " + getName()
-                + ", expected a const string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                "Illegal type {} of first argument of function {}, expected a const string.",
+                arguments[0].type->getName(),
+                getName());
 
         Strings attribute_names = getAttributeNamesFromColumn(arguments[1].column, arguments[1].type);
 
@@ -311,17 +337,20 @@ public:
         if (const auto * name_col = checkAndGetColumnConst<ColumnString>(arguments[0].column.get()))
             dictionary_name = name_col->getValue<String>();
         else
-            throw Exception{"Illegal type " + arguments[0].type->getName() + " of first argument of function " + getName()
-                + ", expected a const string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                "Illegal type {} of first argument of function {}, expected a const string.",
+                arguments[0].type->getName(),
+                getName());
 
         Strings attribute_names = getAttributeNamesFromColumn(arguments[1].column, arguments[1].type);
 
         auto dictionary = helper.getDictionary(dictionary_name);
 
         if (!WhichDataType(arguments[2].type).isUInt64() && !isTuple(arguments[2].type))
-            throw Exception{"Illegal type " + arguments[2].type->getName() + " of third argument of function "
-                    + getName() + ", must be UInt64 or tuple(...).",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                "Illegal type {} of third argument of function {}, must be UInt64 or tuple(...).",
+                arguments[2].type->getName(),
+                getName());
 
         auto dictionary_key_type = dictionary->getKeyType();
 
@@ -333,15 +362,20 @@ public:
         if (dictionary_key_type == DictionaryKeyType::range)
         {
             if (current_arguments_index >= arguments.size())
-                throw Exception{"Wrong argument count for function " + getName(), ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+                throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
+                    "Number of arguments for function {} doesn't match: passed {} should be {}",
+                    getName(),
+                    arguments.size(),
+                    arguments.size() + 1);
 
             range_col = arguments[current_arguments_index].column;
             range_col_type = arguments[current_arguments_index].type;
 
             if (!(range_col_type->isValueRepresentedByInteger() && range_col_type->getSizeOfValueInMemory() <= sizeof(Int64)))
-                throw Exception{"Illegal type " + range_col_type->getName() + " of fourth argument of function "
-                        + getName() + " must be convertible to Int64.",
-                    ErrorCodes::ILLEGAL_COLUMN};
+                throw Exception(ErrorCodes::ILLEGAL_COLUMN,
+                    "Illegal type {} of fourth argument of function must be convertible to Int64.",
+                    range_col_type->getName(),
+                    getName());
 
             ++current_arguments_index;
         }
@@ -351,7 +385,11 @@ public:
         if (dictionary_get_function_type == DictionaryGetFunctionType::getOrDefault)
         {
             if (current_arguments_index >= arguments.size())
-                throw Exception{"Wrong argument count for function " + getName(), ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+                throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
+                    "Number of arguments for function {} doesn't match: passed {} should be {}",
+                    getName(),
+                    arguments.size(),
+                    arguments.size() + 1);
 
             const auto & column_before_cast = arguments[current_arguments_index];
 
@@ -361,10 +399,14 @@ public:
 
                 for (const auto & nested_type : nested_types)
                     if (nested_type->isNullable())
-                        throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Wrong argument for function ({}) default values column nullable is not supported", getName());
+                        throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                            "Wrong argument for function {} default values column nullable is not supported",
+                            getName());
             }
             else if (column_before_cast.type->isNullable())
-                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Wrong argument for function ({}) default values column nullable is not supported", getName());
+                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                    "Wrong argument for function {} default values column nullable is not supported",
+                    getName());
 
             auto result_type_no_nullable = removeNullable(result_type);
 
@@ -378,11 +420,12 @@ public:
 
                 if (!tuple_column)
                     throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                        "Wrong argument for function ({}) default values column must be tuple", getName());
+                        "Wrong argument for function {} default values column must be tuple",
+                        getName());
 
                 if (tuple_column->tupleSize() != attribute_names.size())
                     throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                        "Wrong argument for function ({}) default values tuple column must contain same column size as requested attributes",
+                        "Wrong argument for function {} default values tuple column must contain same column size as requested attributes",
                         getName());
 
                 default_cols = tuple_column->getColumnsCopy();
@@ -406,7 +449,7 @@ public:
             if (!WhichDataType(key_col_with_type.type).isUInt64())
                  throw Exception(
                      ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                     "Third argument of function ({}) must be uint64 when dictionary is simple. Actual type ({}).",
+                     "Third argument of function {} must be UInt64 when dictionary is simple. Actual type {}.",
                      getName(),
                      key_col_with_type.type->getName());
 
@@ -436,7 +479,7 @@ public:
             if (!isTuple(key_col_with_type.type))
                  throw Exception(
                      ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                     "Third argument of function ({}) must be tuple when dictionary is complex. Actual type ({}).",
+                     "Third argument of function {} must be tuple when dictionary is complex. Actual type {}.",
                      getName(),
                      key_col_with_type.type->getName());
 
@@ -446,7 +489,7 @@ public:
             if (!isTuple(key_col_with_type.type))
                 throw Exception(
                     ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                    "Third argument of function ({}) must be tuple when dictionary is complex. Actual type ({}).",
+                    "Third argument of function {} must be tuple when dictionary is complex. Actual type {}.",
                     getName(),
                     key_col_with_type.type->getName());
 
@@ -479,7 +522,7 @@ public:
             if (!WhichDataType(key_col_with_type.type).isUInt64())
                  throw Exception(
                      ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                     "Third argument of function ({}) must be uint64 when dictionary is range. Actual type ({}).",
+                     "Third argument of function {} must be UInt64 when dictionary is range. Actual type {}.",
                      getName(),
                      key_col_with_type.type->getName());
 
@@ -505,7 +548,7 @@ public:
                     default_cols.front());
         }
         else
-            throw Exception{"Unknown dictionary identifier type", ErrorCodes::BAD_ARGUMENTS};
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unknown dictionary identifier type");
 
         return result;
     }
@@ -525,7 +568,7 @@ private:
 
             if (tuple_size < 1)
                 throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                    "Tuple second argument of function ({}) must contain multiple constant string columns");
+                    "Tuple second argument of function {} must contain multiple constant string columns");
 
             for (size_t i = 0; i < tuple_col.tupleSize(); ++i)
             {
@@ -535,7 +578,7 @@ private:
 
                 if (!attribute_name_column)
                     throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                        "Tuple second argument of function ({}) must contain multiple constant string columns",
+                        "Tuple second argument of function {} must contain multiple constant string columns",
                         getName());
 
                 attribute_names.emplace_back(attribute_name_column->getDataAt(0));
@@ -543,7 +586,7 @@ private:
         }
         else
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type ({}) of second argument of function ({}), expected a const string or const tuple of const strings.",
+                "Illegal type {} of second argument of function {}, expected a const string or const tuple of const strings.",
                 type->getName(),
                 getName());
 
@@ -561,12 +604,12 @@ class FunctionDictGetImpl final : public IFunction
 public:
     static constexpr auto name = Name::name;
 
-    static FunctionPtr create(const Context &context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionDictGetImpl>(context);
     }
 
-    explicit FunctionDictGetImpl(const Context & context_) : impl(context_) {}
+    explicit FunctionDictGetImpl(ContextPtr context_) : impl(context_) {}
 
     String getName() const override { return name; }
 
@@ -700,12 +743,12 @@ class FunctionDictGetOrNull final : public IFunction
 public:
     static constexpr auto name = "dictGetOrNull";
 
-    static FunctionPtr create(const Context &context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionDictGetOrNull>(context);
     }
 
-    explicit FunctionDictGetOrNull(const Context & context_)
+    explicit FunctionDictGetOrNull(ContextPtr context_)
         : dictionary_get_func_impl(context_)
         , dictionary_has_func_impl(context_)
     {}
@@ -852,6 +895,7 @@ private:
     const FunctionDictGetNoType<DictionaryGetFunctionType::get> dictionary_get_func_impl;
     const FunctionDictHas dictionary_has_func_impl;
 };
+
 /// Functions to work with hierarchies.
 
 class FunctionDictGetHierarchy final : public IFunction
@@ -859,12 +903,12 @@ class FunctionDictGetHierarchy final : public IFunction
 public:
     static constexpr auto name = "dictGetHierarchy";
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionDictGetHierarchy>(context);
     }
 
-    explicit FunctionDictGetHierarchy(const Context & context_) : helper(context_) {}
+    explicit FunctionDictGetHierarchy(ContextPtr context_) : helper(context_) {}
 
     String getName() const override { return name; }
 
@@ -879,13 +923,13 @@ private:
     {
         if (!isString(arguments[0]))
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type of first argument of function ({}). Expected String. Actual type ({})",
+                "Illegal type of first argument of function {}. Expected String. Actual type {}",
                 getName(),
                 arguments[0]->getName());
 
         if (!WhichDataType(arguments[1]).isUInt64())
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type of second argument of function ({}). Expected UInt64. Actual type ({})",
+                "Illegal type of second argument of function {}. Expected UInt64. Actual type {}",
                 getName(),
                 arguments[1]->getName());
 
@@ -903,7 +947,7 @@ private:
 
         if (!dictionary->hasHierarchy())
             throw Exception(ErrorCodes::UNSUPPORTED_METHOD,
-                "Dictionary ({}) does not support hierarchy",
+                "Dictionary {} does not support hierarchy",
                 dictionary->getFullName());
 
         ColumnPtr result = dictionary->getHierarchy(arguments[1].column, std::make_shared<DataTypeUInt64>());
@@ -919,12 +963,12 @@ class FunctionDictIsIn final : public IFunction
 public:
     static constexpr auto name = "dictIsIn";
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionDictIsIn>(context);
     }
 
-    explicit FunctionDictIsIn(const Context & context_)
+    explicit FunctionDictIsIn(ContextPtr context_)
         : helper(context_) {}
 
     String getName() const override { return name; }
@@ -939,19 +983,19 @@ private:
     {
         if (!isString(arguments[0]))
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type of first argument of function ({}). Expected String. Actual type ({})",
+                "Illegal type of first argument of function {}. Expected String. Actual type {}",
                 getName(),
                 arguments[0]->getName());
 
         if (!WhichDataType(arguments[1]).isUInt64())
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type of second argument of function ({}). Expected UInt64. Actual type ({})",
+                "Illegal type of second argument of function {}. Expected UInt64. Actual type {}",
                 getName(),
                 arguments[1]->getName());
 
         if (!WhichDataType(arguments[2]).isUInt64())
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type of third argument of function ({}). Expected UInt64. Actual type ({})",
+                "Illegal type of third argument of function {}. Expected UInt64. Actual type {}",
                 getName(),
                 arguments[2]->getName());
 
@@ -968,7 +1012,9 @@ private:
         auto dict = helper.getDictionary(arguments[0].column);
 
         if (!dict->hasHierarchy())
-            throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "Dictionary ({}) does not support hierarchy", dict->getFullName());
+            throw Exception(ErrorCodes::UNSUPPORTED_METHOD,
+                "Dictionary {} does not support hierarchy",
+                dict->getFullName());
 
         ColumnPtr res = dict->isInHierarchy(arguments[1].column, arguments[2].column, std::make_shared<DataTypeUInt64>());
 
@@ -983,12 +1029,12 @@ class FunctionDictGetChildren final : public IFunction
 public:
     static constexpr auto name = "dictGetChildren";
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionDictGetChildren>(context);
     }
 
-    explicit FunctionDictGetChildren(const Context & context_)
+    explicit FunctionDictGetChildren(ContextPtr context_)
         : helper(context_) {}
 
     String getName() const override { return name; }
@@ -1004,13 +1050,13 @@ private:
     {
         if (!isString(arguments[0]))
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type of first argument of function ({}). Expected String. Actual type ({})",
+                "Illegal type of first argument of function {}. Expected String. Actual type {}",
                 getName(),
                 arguments[0]->getName());
 
         if (!WhichDataType(arguments[1]).isUInt64())
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type of second argument of function ({}). Expected UInt64. Actual type ({})",
+                "Illegal type of second argument of function {}. Expected UInt64. Actual type {}",
                 getName(),
                 arguments[1]->getName());
 
@@ -1026,7 +1072,7 @@ private:
 
         if (!dictionary->hasHierarchy())
             throw Exception(ErrorCodes::UNSUPPORTED_METHOD,
-                "Dictionary ({}) does not support hierarchy",
+                "Dictionary {} does not support hierarchy",
                 dictionary->getFullName());
 
         ColumnPtr result = dictionary->getDescendants(arguments[1].column, std::make_shared<DataTypeUInt64>(), 1);
@@ -1042,12 +1088,12 @@ class FunctionDictGetDescendants final : public IFunction
 public:
     static constexpr auto name = "dictGetDescendants";
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionDictGetDescendants>(context);
     }
 
-    explicit FunctionDictGetDescendants(const Context & context_)
+    explicit FunctionDictGetDescendants(ContextPtr context_)
         : helper(context_) {}
 
     String getName() const override { return name; }
@@ -1067,27 +1113,27 @@ private:
         if (arguments_size < 2 || arguments_size > 3)
         {
             throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
-                "Illegal arguments size of function ({}). Expects 2 or 3 arguments size. Actual size ({})",
+                "Illegal arguments size of function {}. Expects 2 or 3 arguments size. Actual size {}",
                 getName(),
                 arguments_size);
         }
 
         if (!isString(arguments[0]))
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type of first argument of function ({}). Expected const String. Actual type ({})",
+                "Illegal type of first argument of function {}. Expected const String. Actual type {}",
                 getName(),
                 arguments[0]->getName());
 
         if (!WhichDataType(arguments[1]).isUInt64())
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type of second argument of function ({}). Expected UInt64. Actual type ({})",
+                "Illegal type of second argument of function {}. Expected UInt64. Actual type {}",
                 getName(),
                 arguments[1]->getName());
 
         if (arguments.size() == 3 && !isUnsignedInteger(arguments[2]))
         {
             throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                "Illegal type of third argument of function ({}). Expected const unsigned integer. Actual type ({})",
+                "Illegal type of third argument of function {}. Expected const unsigned integer. Actual type {}",
                 getName(),
                 arguments[2]->getName());
         }
@@ -1108,7 +1154,7 @@ private:
         {
             if (!isColumnConst(*arguments[2].column))
                 throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                    "Illegal type of third argument of function ({}). Expected const unsigned integer.",
+                    "Illegal type of third argument of function {}. Expected const unsigned integer.",
                     getName());
 
             level = static_cast<size_t>(arguments[2].column->get64(0));
@@ -1116,7 +1162,7 @@ private:
 
         if (!dictionary->hasHierarchy())
             throw Exception(ErrorCodes::UNSUPPORTED_METHOD,
-                "Dictionary ({}) does not support hierarchy",
+                "Dictionary {} does not support hierarchy",
                 dictionary->getFullName());
 
         ColumnPtr res = dictionary->getDescendants(arguments[1].column, std::make_shared<DataTypeUInt64>(), level);
diff --git a/src/Functions/FunctionsExternalModels.cpp b/src/Functions/FunctionsExternalModels.cpp
index ecec9383252..da46f7fcb38 100644
--- a/src/Functions/FunctionsExternalModels.cpp
+++ b/src/Functions/FunctionsExternalModels.cpp
@@ -18,9 +18,9 @@
 namespace DB
 {
 
-FunctionPtr FunctionModelEvaluate::create(const Context & context)
+FunctionPtr FunctionModelEvaluate::create(ContextPtr context)
 {
-    return std::make_shared<FunctionModelEvaluate>(context.getExternalModelsLoader());
+    return std::make_shared<FunctionModelEvaluate>(context->getExternalModelsLoader());
 }
 
 namespace ErrorCodes
diff --git a/src/Functions/FunctionsExternalModels.h b/src/Functions/FunctionsExternalModels.h
index 9bb6cc5a77c..9f46e70c906 100644
--- a/src/Functions/FunctionsExternalModels.h
+++ b/src/Functions/FunctionsExternalModels.h
@@ -1,11 +1,12 @@
 #pragma once
+
 #include <Functions/IFunctionImpl.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
 
 class ExternalModelsLoader;
-class Context;
 
 /// Evaluate external model.
 /// First argument - model name, the others - model arguments.
@@ -16,7 +17,7 @@ class FunctionModelEvaluate final : public IFunction
 public:
     static constexpr auto name = "modelEvaluate";
 
-    static FunctionPtr create(const Context & context);
+    static FunctionPtr create(ContextPtr context);
 
     explicit FunctionModelEvaluate(const ExternalModelsLoader & models_loader_) : models_loader(models_loader_) {}
 
diff --git a/src/Functions/FunctionsHashing.h b/src/Functions/FunctionsHashing.h
index 41152660e4f..94f8acbdf66 100644
--- a/src/Functions/FunctionsHashing.h
+++ b/src/Functions/FunctionsHashing.h
@@ -535,7 +535,7 @@ class FunctionStringHashFixedString : public IFunction
 {
 public:
     static constexpr auto name = Impl::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionStringHashFixedString>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionStringHashFixedString>(); }
 
     String getName() const override
     {
@@ -700,7 +700,7 @@ template <typename Impl, typename Name>
 class FunctionIntHash : public TargetSpecific::Default::FunctionIntHash<Impl, Name>
 {
 public:
-    explicit FunctionIntHash(const Context & context) : selector(context)
+    explicit FunctionIntHash(ContextPtr context) : selector(context)
     {
         selector.registerImplementation<TargetArch::Default,
             TargetSpecific::Default::FunctionIntHash<Impl, Name>>();
@@ -718,7 +718,7 @@ public:
         return selector.selectAndExecute(arguments, result_type, input_rows_count);
     }
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionIntHash>(context);
     }
@@ -1076,7 +1076,7 @@ template <typename Impl>
 class FunctionAnyHash : public TargetSpecific::Default::FunctionAnyHash<Impl>
 {
 public:
-    explicit FunctionAnyHash(const Context & context) : selector(context)
+    explicit FunctionAnyHash(ContextPtr context) : selector(context)
     {
         selector.registerImplementation<TargetArch::Default,
             TargetSpecific::Default::FunctionAnyHash<Impl>>();
@@ -1094,7 +1094,7 @@ public:
         return selector.selectAndExecute(arguments, result_type, input_rows_count);
     }
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionAnyHash>(context);
     }
@@ -1181,7 +1181,7 @@ class FunctionURLHash : public IFunction
 {
 public:
     static constexpr auto name = "URLHash";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionURLHash>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionURLHash>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionsJSON.h b/src/Functions/FunctionsJSON.h
index f066bb1029a..c2fd44e2e2a 100644
--- a/src/Functions/FunctionsJSON.h
+++ b/src/Functions/FunctionsJSON.h
@@ -270,11 +270,11 @@ private:
 
 
 template <typename Name, template<typename> typename Impl>
-class FunctionJSON : public IFunction
+class FunctionJSON : public IFunction, WithContext
 {
 public:
-    static FunctionPtr create(const Context & context_) { return std::make_shared<FunctionJSON>(context_); }
-    FunctionJSON(const Context & context_) : context(context_) {}
+    static FunctionPtr create(ContextPtr context_) { return std::make_shared<FunctionJSON>(context_); }
+    FunctionJSON(ContextPtr context_) : WithContext(context_) {}
 
     static constexpr auto name = Name::name;
     String getName() const override { return Name::name; }
@@ -291,7 +291,7 @@ public:
     {
         /// Choose JSONParser.
 #if USE_SIMDJSON
-        if (context.getSettingsRef().allow_simdjson)
+        if (getContext()->getSettingsRef().allow_simdjson)
             return FunctionJSONHelpers::Executor<Name, Impl, SimdJSONParser>::run(arguments, result_type, input_rows_count);
 #endif
 
@@ -301,9 +301,6 @@ public:
         return FunctionJSONHelpers::Executor<Name, Impl, DummyJSONParser>::run(arguments, result_type, input_rows_count);
 #endif
     }
-
-private:
-    const Context & context;
 };
 
 
@@ -613,8 +610,8 @@ struct JSONExtractTree
     class Node
     {
     public:
-        Node() {}
-        virtual ~Node() {}
+        Node() = default;
+        virtual ~Node() = default;
         virtual bool insertResultToColumn(IColumn &, const Element &) = 0;
     };
 
diff --git a/src/Functions/FunctionsLogical.h b/src/Functions/FunctionsLogical.h
index a5579ebdf8a..12733348762 100644
--- a/src/Functions/FunctionsLogical.h
+++ b/src/Functions/FunctionsLogical.h
@@ -138,7 +138,7 @@ class FunctionAnyArityLogical : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionAnyArityLogical>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionAnyArityLogical>(); }
 
 public:
     String getName() const override
@@ -203,7 +203,7 @@ class FunctionUnaryLogical : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionUnaryLogical>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionUnaryLogical>(); }
 
 public:
     String getName() const override
diff --git a/src/Functions/FunctionsMultiStringFuzzySearch.h b/src/Functions/FunctionsMultiStringFuzzySearch.h
index 551c6e97495..90b5bc72744 100644
--- a/src/Functions/FunctionsMultiStringFuzzySearch.h
+++ b/src/Functions/FunctionsMultiStringFuzzySearch.h
@@ -34,9 +34,9 @@ class FunctionsMultiStringFuzzySearch : public IFunction
 
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        if (Impl::is_using_hyperscan && !context.getSettingsRef().allow_hyperscan)
+        if (Impl::is_using_hyperscan && !context->getSettingsRef().allow_hyperscan)
             throw Exception(
                 "Hyperscan functions are disabled, because setting 'allow_hyperscan' is set to 0", ErrorCodes::FUNCTION_NOT_ALLOWED);
 
diff --git a/src/Functions/FunctionsMultiStringPosition.h b/src/Functions/FunctionsMultiStringPosition.h
index 2c0f2ae8f7b..b137d2d0c80 100644
--- a/src/Functions/FunctionsMultiStringPosition.h
+++ b/src/Functions/FunctionsMultiStringPosition.h
@@ -51,7 +51,7 @@ class FunctionsMultiStringPosition : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionsMultiStringPosition>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionsMultiStringPosition>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionsMultiStringSearch.h b/src/Functions/FunctionsMultiStringSearch.h
index f1185c2d850..e39ee5f816e 100644
--- a/src/Functions/FunctionsMultiStringSearch.h
+++ b/src/Functions/FunctionsMultiStringSearch.h
@@ -47,9 +47,9 @@ class FunctionsMultiStringSearch : public IFunction
 
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        if (Impl::is_using_hyperscan && !context.getSettingsRef().allow_hyperscan)
+        if (Impl::is_using_hyperscan && !context->getSettingsRef().allow_hyperscan)
             throw Exception(
                 "Hyperscan functions are disabled, because setting 'allow_hyperscan' is set to 0", ErrorCodes::FUNCTION_NOT_ALLOWED);
 
diff --git a/src/Functions/FunctionsRandom.h b/src/Functions/FunctionsRandom.h
index f7b0ac8c2e0..c933f70e9b3 100644
--- a/src/Functions/FunctionsRandom.h
+++ b/src/Functions/FunctionsRandom.h
@@ -91,7 +91,7 @@ template <typename ToType, typename Name>
 class FunctionRandom : public FunctionRandomImpl<TargetSpecific::Default::RandImpl, ToType, Name>
 {
 public:
-    explicit FunctionRandom(const Context & context) : selector(context)
+    explicit FunctionRandom(ContextPtr context) : selector(context)
     {
         selector.registerImplementation<TargetArch::Default,
             FunctionRandomImpl<TargetSpecific::Default::RandImpl, ToType, Name>>();
@@ -107,7 +107,7 @@ public:
         return selector.selectAndExecute(arguments, result_type, input_rows_count);
     }
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionRandom<ToType, Name>>(context);
     }
diff --git a/src/Functions/FunctionsRound.h b/src/Functions/FunctionsRound.h
index b190bc5bd8b..01074984ebf 100644
--- a/src/Functions/FunctionsRound.h
+++ b/src/Functions/FunctionsRound.h
@@ -526,7 +526,7 @@ class FunctionRounding : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionRounding>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionRounding>(); }
 
     String getName() const override
     {
@@ -635,7 +635,7 @@ class FunctionRoundDown : public IFunction
 {
 public:
     static constexpr auto name = "roundDown";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionRoundDown>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionRoundDown>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionsStringArray.h b/src/Functions/FunctionsStringArray.h
index 6d1b8723653..60dd624bd4f 100644
--- a/src/Functions/FunctionsStringArray.h
+++ b/src/Functions/FunctionsStringArray.h
@@ -345,7 +345,7 @@ class FunctionTokens : public IFunction
 {
 public:
     static constexpr auto name = Generator::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionTokens>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionTokens>(); }
 
     String getName() const override
     {
@@ -508,7 +508,7 @@ private:
 
 public:
     static constexpr auto name = "arrayStringConcat";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayStringConcat>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayStringConcat>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/FunctionsStringHash.h b/src/Functions/FunctionsStringHash.h
index 72fb6e4c76d..1001d3143f8 100644
--- a/src/Functions/FunctionsStringHash.h
+++ b/src/Functions/FunctionsStringHash.h
@@ -10,6 +10,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/IFunctionImpl.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
@@ -34,7 +35,7 @@ public:
     static constexpr size_t max_shingle_size = 25;
     static constexpr size_t max_num_hashes = 25;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionsStringHash>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionsStringHash>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionsStringSearch.h b/src/Functions/FunctionsStringSearch.h
index 75579b28fd3..abbf4e5e650 100644
--- a/src/Functions/FunctionsStringSearch.h
+++ b/src/Functions/FunctionsStringSearch.h
@@ -51,7 +51,7 @@ class FunctionsStringSearch : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionsStringSearch>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionsStringSearch>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionsStringSearchToString.h b/src/Functions/FunctionsStringSearchToString.h
index 3b910ae51af..424a54be434 100644
--- a/src/Functions/FunctionsStringSearchToString.h
+++ b/src/Functions/FunctionsStringSearchToString.h
@@ -36,7 +36,7 @@ class FunctionsStringSearchToString : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionsStringSearchToString>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionsStringSearchToString>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/FunctionsStringSimilarity.h b/src/Functions/FunctionsStringSimilarity.h
index ba725fbd598..cd5ed405c89 100644
--- a/src/Functions/FunctionsStringSimilarity.h
+++ b/src/Functions/FunctionsStringSimilarity.h
@@ -6,6 +6,7 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/IFunctionImpl.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
@@ -32,7 +33,7 @@ class FunctionsStringSimilarity : public IFunction
 public:
     static constexpr auto name = Name::name;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionsStringSimilarity>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionsStringSimilarity>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/IFunction.h b/src/Functions/IFunction.h
index e94449335fb..f9217d30707 100644
--- a/src/Functions/IFunction.h
+++ b/src/Functions/IFunction.h
@@ -1,16 +1,16 @@
 #pragma once
 
-#include <memory>
-
-#include <Core/Names.h>
-#include <Core/ColumnsWithTypeAndName.h>
 #include <Core/ColumnNumbers.h>
+#include <Core/ColumnsWithTypeAndName.h>
+#include <Core/Names.h>
 #include <DataTypes/IDataType.h>
 
 #if !defined(ARCADIA_BUILD)
 #    include "config_core.h"
 #endif
 
+#include <memory>
+
 /// This file contains user interface for functions.
 /// For developer interface (in case you need to implement a new function) see IFunctionImpl.h
 
diff --git a/src/Functions/IFunctionAdaptors.h b/src/Functions/IFunctionAdaptors.h
index cbb71c99b1b..2b9034dc784 100644
--- a/src/Functions/IFunctionAdaptors.h
+++ b/src/Functions/IFunctionAdaptors.h
@@ -1,4 +1,5 @@
 #pragma once
+
 #include <Functions/IFunctionImpl.h>
 
 namespace DB
diff --git a/src/Functions/IFunctionImpl.h b/src/Functions/IFunctionImpl.h
index a9ec6926c63..f75fe07122d 100644
--- a/src/Functions/IFunctionImpl.h
+++ b/src/Functions/IFunctionImpl.h
@@ -1,4 +1,5 @@
 #pragma once
+
 #include <Functions/IFunction.h>
 
 /// This file contains developer interface for functions.
diff --git a/src/Functions/LeastGreatestGeneric.h b/src/Functions/LeastGreatestGeneric.h
index b13286daded..583f0851777 100644
--- a/src/Functions/LeastGreatestGeneric.h
+++ b/src/Functions/LeastGreatestGeneric.h
@@ -30,7 +30,7 @@ class FunctionLeastGreatestGeneric : public IFunction
 {
 public:
     static constexpr auto name = kind == LeastGreatest::Least ? "least" : "greatest";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionLeastGreatestGeneric<kind>>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionLeastGreatestGeneric<kind>>(); }
 
 private:
     String getName() const override { return name; }
@@ -92,12 +92,12 @@ class LeastGreatestOverloadResolver : public IFunctionOverloadResolverImpl
 public:
     static constexpr auto name = kind == LeastGreatest::Least ? "least" : "greatest";
 
-    static FunctionOverloadResolverImplPtr create(const Context & context)
+    static FunctionOverloadResolverImplPtr create(ContextPtr context)
     {
         return std::make_unique<LeastGreatestOverloadResolver<kind, SpecializedFunction>>(context);
     }
 
-    explicit LeastGreatestOverloadResolver(const Context & context_) : context(context_) {}
+    explicit LeastGreatestOverloadResolver(ContextPtr context_) : context(context_) {}
 
     String getName() const override { return name; }
     size_t getNumberOfArguments() const override { return 0; }
@@ -127,7 +127,7 @@ public:
     }
 
 private:
-    const Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Functions/PerformanceAdaptors.h b/src/Functions/PerformanceAdaptors.h
index 5d4d013691c..113ee24ca6f 100644
--- a/src/Functions/PerformanceAdaptors.h
+++ b/src/Functions/PerformanceAdaptors.h
@@ -172,7 +172,7 @@ namespace detail
  * /// default implementation.
  * class MyFunction : public MyDefaultImpl
  * {
- *     MyFunction(const Context & context) : selector(context) {
+ *     MyFunction(ContextPtr context) : selector(context) {
  *         /// Register all implementations in constructor.
  *         /// There could be as many implementation for every target as you want.
  *         selector.registerImplementation<TargetArch::Default, MyDefaultImpl>();
@@ -185,7 +185,7 @@ namespace detail
  *         selector.selectAndExecute(...);
  *     }
  *
- *     static FunctionPtr create(const Context & context) {
+ *     static FunctionPtr create(ContextPtr context) {
  *         return std::make_shared<MyFunction>(context);
  *     }
  * private:
@@ -193,12 +193,12 @@ namespace detail
  * };
  */
 template <typename FunctionInterface>
-class ImplementationSelector
+class ImplementationSelector : WithContext
 {
 public:
     using ImplementationPtr = std::shared_ptr<FunctionInterface>;
 
-    ImplementationSelector(const Context & context_) : context(context_) {}
+    ImplementationSelector(ContextPtr context_) : WithContext(context_) {}
 
     /* Select the best implementation based on previous runs.
      * If FunctionInterface is IFunction, then "executeImpl" method of the implementation will be called
@@ -248,7 +248,7 @@ public:
         if (isArchSupported(Arch))
         {
             // TODO(dakovalkov): make this option better.
-            const auto & choose_impl = context.getSettingsRef().function_implementation.value;
+            const auto & choose_impl = getContext()->getSettingsRef().function_implementation.value;
             if (choose_impl.empty() || choose_impl == detail::getImplementationTag<FunctionImpl>(Arch))
             {
                 implementations.emplace_back(std::make_shared<FunctionImpl>(std::forward<Args>(args)...));
@@ -258,7 +258,6 @@ public:
     }
 
 private:
-    const Context & context;
     std::vector<ImplementationPtr> implementations;
     mutable detail::PerformanceStatistics statistics; /// It is protected by internal mutex.
 };
diff --git a/src/Functions/TargetSpecific.h b/src/Functions/TargetSpecific.h
index 8de6a3dbec4..e6d3fe6d665 100644
--- a/src/Functions/TargetSpecific.h
+++ b/src/Functions/TargetSpecific.h
@@ -36,15 +36,15 @@
  * int func() {
  * #if USE_MULTITARGET_CODE
  *     if (isArchSupported(TargetArch::AVX2))
- *         return TargetSpecifc::AVX2::funcImpl();
+ *         return TargetSpecific::AVX2::funcImpl();
  * #endif
- *     return TargetSpecifc::Default::funcImpl();
+ *     return TargetSpecific::Default::funcImpl();
  * }
  *
  * Sometimes code may benefit from compiling with different options.
  * For these purposes use DECLARE_MULTITARGET_CODE macros. It will create a copy
  * of the code for every supported target and compile it with different options.
- * These copies are available via TargetSpecifc namespaces described above.
+ * These copies are available via TargetSpecific namespaces described above.
  *
  * Inside every TargetSpecific namespace there is a constexpr variable BuildArch,
  * which indicates the target platform for current code.
@@ -106,7 +106,7 @@ String toString(TargetArch arch);
 /* Clang shows warning when there aren't any objects to apply pragma.
  * To prevent this warning we define this function inside every macros with pragmas.
  */
-#   define DUMMY_FUNCTION_DEFINITION void __dummy_function_definition();
+#   define DUMMY_FUNCTION_DEFINITION [[maybe_unused]] void __dummy_function_definition();
 #else
 #   define BEGIN_AVX512F_SPECIFIC_CODE \
         _Pragma("GCC push_options") \
diff --git a/src/Functions/URL/FirstSignificantSubdomainCustomImpl.h b/src/Functions/URL/FirstSignificantSubdomainCustomImpl.h
index d6868834f75..4670d610725 100644
--- a/src/Functions/URL/FirstSignificantSubdomainCustomImpl.h
+++ b/src/Functions/URL/FirstSignificantSubdomainCustomImpl.h
@@ -36,7 +36,7 @@ class FunctionCutToFirstSignificantSubdomainCustomImpl : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionCutToFirstSignificantSubdomainCustomImpl>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionCutToFirstSignificantSubdomainCustomImpl>(); }
 
     String getName() const override { return name; }
     size_t getNumberOfArguments() const override { return 2; }
diff --git a/src/Functions/URL/port.cpp b/src/Functions/URL/port.cpp
index adc3ffa5001..382ea71eda5 100644
--- a/src/Functions/URL/port.cpp
+++ b/src/Functions/URL/port.cpp
@@ -21,7 +21,7 @@ namespace ErrorCodes
 struct FunctionPort : public IFunction
 {
     static constexpr auto name = "port";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionPort>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionPort>(); }
 
     String getName() const override { return name; }
     bool isVariadic() const override { return true; }
diff --git a/src/Functions/abtesting.cpp b/src/Functions/abtesting.cpp
index 7bed2f4a2b9..871357fe450 100644
--- a/src/Functions/abtesting.cpp
+++ b/src/Functions/abtesting.cpp
@@ -168,7 +168,7 @@ class FunctionBayesAB : public IFunction
 public:
     static constexpr auto name = "bayesAB";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionBayesAB>();
     }
diff --git a/src/Functions/addressToLine.cpp b/src/Functions/addressToLine.cpp
index a115b13e54a..554e154e866 100644
--- a/src/Functions/addressToLine.cpp
+++ b/src/Functions/addressToLine.cpp
@@ -36,9 +36,9 @@ class FunctionAddressToLine : public IFunction
 {
 public:
     static constexpr auto name = "addressToLine";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        context.checkAccess(AccessType::addressToLine);
+        context->checkAccess(AccessType::addressToLine);
         return std::make_shared<FunctionAddressToLine>();
     }
 
diff --git a/src/Functions/addressToSymbol.cpp b/src/Functions/addressToSymbol.cpp
index 5accfd1dd94..db8fe8d3b60 100644
--- a/src/Functions/addressToSymbol.cpp
+++ b/src/Functions/addressToSymbol.cpp
@@ -28,9 +28,9 @@ class FunctionAddressToSymbol : public IFunction
 {
 public:
     static constexpr auto name = "addressToSymbol";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        context.checkAccess(AccessType::addressToSymbol);
+        context->checkAccess(AccessType::addressToSymbol);
         return std::make_shared<FunctionAddressToSymbol>();
     }
 
diff --git a/src/Functions/appendTrailingCharIfAbsent.cpp b/src/Functions/appendTrailingCharIfAbsent.cpp
index 7ba9a870105..aa939860560 100644
--- a/src/Functions/appendTrailingCharIfAbsent.cpp
+++ b/src/Functions/appendTrailingCharIfAbsent.cpp
@@ -24,7 +24,7 @@ class FunctionAppendTrailingCharIfAbsent : public IFunction
 {
 public:
     static constexpr auto name = "appendTrailingCharIfAbsent";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionAppendTrailingCharIfAbsent>();
     }
diff --git a/src/Functions/array/FunctionArrayMapped.h b/src/Functions/array/FunctionArrayMapped.h
index e336a86d994..4b6320824fa 100644
--- a/src/Functions/array/FunctionArrayMapped.h
+++ b/src/Functions/array/FunctionArrayMapped.h
@@ -11,6 +11,7 @@
 #include <Functions/IFunctionImpl.h>
 #include <Functions/FunctionHelpers.h>
 #include <IO/WriteHelpers.h>
+#include <Interpreters/Context_fwd.h>
 
 
 namespace DB
@@ -43,7 +44,7 @@ class FunctionArrayMapped : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayMapped>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayMapped>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/array/array.cpp b/src/Functions/array/array.cpp
index ef36069015c..3c6d4066e7c 100644
--- a/src/Functions/array/array.cpp
+++ b/src/Functions/array/array.cpp
@@ -14,7 +14,7 @@ class FunctionArray : public IFunction
 {
 public:
     static constexpr auto name = "array";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionArray>();
     }
diff --git a/src/Functions/array/arrayConcat.cpp b/src/Functions/array/arrayConcat.cpp
index 5ab22dede19..2908fbef7e0 100644
--- a/src/Functions/array/arrayConcat.cpp
+++ b/src/Functions/array/arrayConcat.cpp
@@ -26,7 +26,7 @@ class FunctionArrayConcat : public IFunction
 {
 public:
     static constexpr auto name = "arrayConcat";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayConcat>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayConcat>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/array/arrayDistinct.cpp b/src/Functions/array/arrayDistinct.cpp
index e3be840b01f..cf73a577def 100644
--- a/src/Functions/array/arrayDistinct.cpp
+++ b/src/Functions/array/arrayDistinct.cpp
@@ -26,7 +26,7 @@ class FunctionArrayDistinct : public IFunction
 public:
     static constexpr auto name = "arrayDistinct";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionArrayDistinct>();
     }
diff --git a/src/Functions/array/arrayElement.cpp b/src/Functions/array/arrayElement.cpp
index 2d6a99c2258..4254b00e4bc 100644
--- a/src/Functions/array/arrayElement.cpp
+++ b/src/Functions/array/arrayElement.cpp
@@ -41,7 +41,7 @@ class FunctionArrayElement : public IFunction
 {
 public:
     static constexpr auto name = "arrayElement";
-    static FunctionPtr create(const Context & context);
+    static FunctionPtr create(ContextPtr context);
 
     String getName() const override;
 
@@ -449,7 +449,7 @@ struct ArrayElementGenericImpl
 }
 
 
-FunctionPtr FunctionArrayElement::create(const Context &)
+FunctionPtr FunctionArrayElement::create(ContextPtr)
 {
     return std::make_shared<FunctionArrayElement>();
 }
diff --git a/src/Functions/array/arrayEnumerate.cpp b/src/Functions/array/arrayEnumerate.cpp
index 82bb25e2129..b77fc9a468f 100644
--- a/src/Functions/array/arrayEnumerate.cpp
+++ b/src/Functions/array/arrayEnumerate.cpp
@@ -22,7 +22,7 @@ class FunctionArrayEnumerate : public IFunction
 public:
     static constexpr auto name = "arrayEnumerate";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionArrayEnumerate>();
     }
diff --git a/src/Functions/array/arrayEnumerateExtended.h b/src/Functions/array/arrayEnumerateExtended.h
index 39bdd2a515e..9edf7959354 100644
--- a/src/Functions/array/arrayEnumerateExtended.h
+++ b/src/Functions/array/arrayEnumerateExtended.h
@@ -30,7 +30,7 @@ template <typename Derived>
 class FunctionArrayEnumerateExtended : public IFunction
 {
 public:
-    static FunctionPtr create(const Context &) { return std::make_shared<Derived>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<Derived>(); }
 
     String getName() const override { return Derived::name; }
 
diff --git a/src/Functions/array/arrayEnumerateRanked.h b/src/Functions/array/arrayEnumerateRanked.h
index ce82b8bcd86..2d13482b01e 100644
--- a/src/Functions/array/arrayEnumerateRanked.h
+++ b/src/Functions/array/arrayEnumerateRanked.h
@@ -90,7 +90,7 @@ template <typename Derived>
 class FunctionArrayEnumerateRankedExtended : public IFunction
 {
 public:
-    static FunctionPtr create(const Context & /* context */) { return std::make_shared<Derived>(); }
+    static FunctionPtr create(ContextPtr /* context */) { return std::make_shared<Derived>(); }
 
     String getName() const override { return Derived::name; }
 
diff --git a/src/Functions/array/arrayFlatten.cpp b/src/Functions/array/arrayFlatten.cpp
index f9330bcd432..e1b8f96b2ee 100644
--- a/src/Functions/array/arrayFlatten.cpp
+++ b/src/Functions/array/arrayFlatten.cpp
@@ -20,7 +20,7 @@ class ArrayFlatten : public IFunction
 public:
     static constexpr auto name = "arrayFlatten";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<ArrayFlatten>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<ArrayFlatten>(); }
 
     size_t getNumberOfArguments() const override { return 1; }
     bool useDefaultImplementationForConstants() const override { return true; }
diff --git a/src/Functions/array/arrayIndex.h b/src/Functions/array/arrayIndex.h
index bc9e0b5608d..fb9496e634f 100644
--- a/src/Functions/array/arrayIndex.h
+++ b/src/Functions/array/arrayIndex.h
@@ -354,7 +354,7 @@ class FunctionArrayIndex : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayIndex>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayIndex>(); }
 
     /// Get function name.
     String getName() const override { return name; }
diff --git a/src/Functions/array/arrayIntersect.cpp b/src/Functions/array/arrayIntersect.cpp
index 736069d6060..7275a1395c0 100644
--- a/src/Functions/array/arrayIntersect.cpp
+++ b/src/Functions/array/arrayIntersect.cpp
@@ -38,8 +38,8 @@ class FunctionArrayIntersect : public IFunction
 {
 public:
     static constexpr auto name = "arrayIntersect";
-    static FunctionPtr create(const Context & context) { return std::make_shared<FunctionArrayIntersect>(context); }
-    explicit FunctionArrayIntersect(const Context & context_) : context(context_) {}
+    static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionArrayIntersect>(context); }
+    explicit FunctionArrayIntersect(ContextPtr context_) : context(context_) {}
 
     String getName() const override { return name; }
 
@@ -53,7 +53,7 @@ public:
     bool useDefaultImplementationForConstants() const override { return true; }
 
 private:
-    const Context & context;
+    ContextPtr context;
 
     /// Initially allocate a piece of memory for 64 elements. NOTE: This is just a guess.
     static constexpr size_t INITIAL_SIZE_DEGREE = 6;
@@ -281,7 +281,7 @@ FunctionArrayIntersect::CastArgumentsResult FunctionArrayIntersect::castColumns(
     return {.initial = initial_columns, .casted = casted_columns};
 }
 
-static ColumnPtr callFunctionNotEquals(ColumnWithTypeAndName first, ColumnWithTypeAndName second, const Context & context)
+static ColumnPtr callFunctionNotEquals(ColumnWithTypeAndName first, ColumnWithTypeAndName second, ContextPtr context)
 {
     ColumnsWithTypeAndName args{first, second};
     auto eq_func = FunctionFactory::instance().get("notEquals", context)->build(args);
diff --git a/src/Functions/array/arrayJoin.cpp b/src/Functions/array/arrayJoin.cpp
index c4991b0663e..1ba215239ec 100644
--- a/src/Functions/array/arrayJoin.cpp
+++ b/src/Functions/array/arrayJoin.cpp
@@ -20,7 +20,7 @@ class FunctionArrayJoin : public IFunction
 {
 public:
     static constexpr auto name = "arrayJoin";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionArrayJoin>();
     }
diff --git a/src/Functions/array/arrayPopBack.cpp b/src/Functions/array/arrayPopBack.cpp
index d69e59e7128..0b532c22661 100644
--- a/src/Functions/array/arrayPopBack.cpp
+++ b/src/Functions/array/arrayPopBack.cpp
@@ -9,7 +9,7 @@ class FunctionArrayPopBack : public FunctionArrayPop
 {
 public:
     static constexpr auto name = "arrayPopBack";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayPopBack>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayPopBack>(); }
     FunctionArrayPopBack() : FunctionArrayPop(false, name) {}
 };
 
diff --git a/src/Functions/array/arrayPopFront.cpp b/src/Functions/array/arrayPopFront.cpp
index ca9ce923aaa..57eedf9b44a 100644
--- a/src/Functions/array/arrayPopFront.cpp
+++ b/src/Functions/array/arrayPopFront.cpp
@@ -9,7 +9,7 @@ class FunctionArrayPopFront : public FunctionArrayPop
 {
 public:
     static constexpr auto name = "arrayPopFront";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayPopFront>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayPopFront>(); }
     FunctionArrayPopFront() : FunctionArrayPop(true, name) {}
 };
 
diff --git a/src/Functions/array/arrayPushBack.cpp b/src/Functions/array/arrayPushBack.cpp
index 3c6d4113b88..3171bca9d2c 100644
--- a/src/Functions/array/arrayPushBack.cpp
+++ b/src/Functions/array/arrayPushBack.cpp
@@ -9,7 +9,7 @@ class FunctionArrayPushBack : public FunctionArrayPush
 {
 public:
     static constexpr auto name = "arrayPushBack";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayPushBack>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayPushBack>(); }
     FunctionArrayPushBack() : FunctionArrayPush(false, name) {}
 };
 
diff --git a/src/Functions/array/arrayPushFront.cpp b/src/Functions/array/arrayPushFront.cpp
index 49f47170f3c..d12dfe02af1 100644
--- a/src/Functions/array/arrayPushFront.cpp
+++ b/src/Functions/array/arrayPushFront.cpp
@@ -10,7 +10,7 @@ class FunctionArrayPushFront : public FunctionArrayPush
 {
 public:
     static constexpr auto name = "arrayPushFront";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayPushFront>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayPushFront>(); }
     FunctionArrayPushFront() : FunctionArrayPush(true, name) {}
 };
 
diff --git a/src/Functions/array/arrayReduce.cpp b/src/Functions/array/arrayReduce.cpp
index 342a4b18854..1e1ae08ff3a 100644
--- a/src/Functions/array/arrayReduce.cpp
+++ b/src/Functions/array/arrayReduce.cpp
@@ -11,7 +11,7 @@
 #include <AggregateFunctions/parseAggregateFunctionParameters.h>
 #include <Common/Arena.h>
 
-#include <ext/scope_guard.h>
+#include <ext/scope_guard_safe.h>
 
 
 namespace DB
@@ -37,7 +37,7 @@ class FunctionArrayReduce : public IFunction
 {
 public:
     static constexpr auto name = "arrayReduce";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayReduce>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayReduce>(); }
 
     String getName() const override { return name; }
 
@@ -172,7 +172,7 @@ ColumnPtr FunctionArrayReduce::executeImpl(const ColumnsWithTypeAndName & argume
         }
     }
 
-    SCOPE_EXIT({
+    SCOPE_EXIT_MEMORY_SAFE({
         for (size_t i = 0; i < input_rows_count; ++i)
             agg_func.destroy(places[i]);
     });
diff --git a/src/Functions/array/arrayReduceInRanges.cpp b/src/Functions/array/arrayReduceInRanges.cpp
index 9839d2a8fe7..ea87fc96630 100644
--- a/src/Functions/array/arrayReduceInRanges.cpp
+++ b/src/Functions/array/arrayReduceInRanges.cpp
@@ -13,7 +13,7 @@
 #include <AggregateFunctions/parseAggregateFunctionParameters.h>
 #include <Common/Arena.h>
 
-#include <ext/scope_guard.h>
+#include <ext/scope_guard_safe.h>
 
 
 namespace DB
@@ -40,7 +40,7 @@ class FunctionArrayReduceInRanges : public IFunction
 public:
     static const size_t minimum_step = 64;
     static constexpr auto name = "arrayReduceInRanges";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayReduceInRanges>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayReduceInRanges>(); }
 
     String getName() const override { return name; }
 
@@ -252,7 +252,7 @@ ColumnPtr FunctionArrayReduceInRanges::executeImpl(const ColumnsWithTypeAndName
             }
         }
 
-        SCOPE_EXIT({
+        SCOPE_EXIT_MEMORY_SAFE({
             for (size_t j = 0; j < place_total; ++j)
                 agg_func.destroy(places[j]);
         });
@@ -331,7 +331,7 @@ ColumnPtr FunctionArrayReduceInRanges::executeImpl(const ColumnsWithTypeAndName
             AggregateDataPtr place = arena->alignedAlloc(agg_func.sizeOfData(), agg_func.alignOfData());
             agg_func.create(place);
 
-            SCOPE_EXIT({
+            SCOPE_EXIT_MEMORY_SAFE({
                 agg_func.destroy(place);
             });
 
diff --git a/src/Functions/array/arrayResize.cpp b/src/Functions/array/arrayResize.cpp
index 0f7f20d7747..eead7a0fa84 100644
--- a/src/Functions/array/arrayResize.cpp
+++ b/src/Functions/array/arrayResize.cpp
@@ -25,7 +25,7 @@ class FunctionArrayResize : public IFunction
 {
 public:
     static constexpr auto name = "arrayResize";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayResize>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayResize>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/array/arrayReverse.cpp b/src/Functions/array/arrayReverse.cpp
index 1eb07c53497..5928ab0d72f 100644
--- a/src/Functions/array/arrayReverse.cpp
+++ b/src/Functions/array/arrayReverse.cpp
@@ -24,7 +24,7 @@ class FunctionArrayReverse : public IFunction
 {
 public:
     static constexpr auto name = "arrayReverse";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayReverse>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayReverse>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/array/arrayScalarProduct.h b/src/Functions/array/arrayScalarProduct.h
index 2ff8b88b2f0..6a23d6a45d8 100644
--- a/src/Functions/array/arrayScalarProduct.h
+++ b/src/Functions/array/arrayScalarProduct.h
@@ -25,7 +25,7 @@ class FunctionArrayScalarProduct : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayScalarProduct>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayScalarProduct>(); }
 
 private:
     using ResultColumnType = ColumnVector<typename Method::ResultType>;
diff --git a/src/Functions/array/arraySlice.cpp b/src/Functions/array/arraySlice.cpp
index 1e72e6a45cf..859d3b99db2 100644
--- a/src/Functions/array/arraySlice.cpp
+++ b/src/Functions/array/arraySlice.cpp
@@ -34,7 +34,7 @@ class FunctionArraySlice : public IFunction
 {
 public:
     static constexpr auto name = "arraySlice";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArraySlice>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArraySlice>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/array/arrayUniq.cpp b/src/Functions/array/arrayUniq.cpp
index 70246872f6b..ba0bcf8cd0c 100644
--- a/src/Functions/array/arrayUniq.cpp
+++ b/src/Functions/array/arrayUniq.cpp
@@ -31,7 +31,7 @@ class FunctionArrayUniq : public IFunction
 public:
     static constexpr auto name = "arrayUniq";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayUniq>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayUniq>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/array/arrayWithConstant.cpp b/src/Functions/array/arrayWithConstant.cpp
index f9fc0ac3b66..453e95ed3b5 100644
--- a/src/Functions/array/arrayWithConstant.cpp
+++ b/src/Functions/array/arrayWithConstant.cpp
@@ -30,7 +30,7 @@ class FunctionArrayWithConstant : public IFunction
 public:
     static constexpr auto name = "arrayWithConstant";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayWithConstant>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayWithConstant>(); }
 
     String getName() const override { return name; }
     size_t getNumberOfArguments() const override { return 2; }
diff --git a/src/Functions/array/arrayZip.cpp b/src/Functions/array/arrayZip.cpp
index 5a377355710..f77b4f6dfe9 100644
--- a/src/Functions/array/arrayZip.cpp
+++ b/src/Functions/array/arrayZip.cpp
@@ -23,7 +23,7 @@ class FunctionArrayZip : public IFunction
 {
 public:
     static constexpr auto name = "arrayZip";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayZip>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayZip>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/array/emptyArray.cpp b/src/Functions/array/emptyArray.cpp
index ac227370180..54d9b794ba5 100644
--- a/src/Functions/array/emptyArray.cpp
+++ b/src/Functions/array/emptyArray.cpp
@@ -29,7 +29,7 @@ struct FunctionEmptyArray : public IFunction
 {
     static constexpr auto base_name = "emptyArray";
     static const String name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionEmptyArray>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionEmptyArray>(); }
 
 private:
     String getName() const override
diff --git a/src/Functions/array/emptyArrayToSingle.cpp b/src/Functions/array/emptyArrayToSingle.cpp
index e3bfe62ac22..8f726d55ab0 100644
--- a/src/Functions/array/emptyArrayToSingle.cpp
+++ b/src/Functions/array/emptyArrayToSingle.cpp
@@ -27,7 +27,7 @@ class FunctionEmptyArrayToSingle : public IFunction
 {
 public:
     static constexpr auto name = "emptyArrayToSingle";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionEmptyArrayToSingle>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionEmptyArrayToSingle>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/array/hasAll.cpp b/src/Functions/array/hasAll.cpp
index 27843b76f66..c1959515e9f 100644
--- a/src/Functions/array/hasAll.cpp
+++ b/src/Functions/array/hasAll.cpp
@@ -10,7 +10,7 @@ class FunctionArrayHasAll : public FunctionArrayHasAllAny
 {
 public:
     static constexpr auto name = "hasAll";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayHasAll>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayHasAll>(); }
     FunctionArrayHasAll() : FunctionArrayHasAllAny(GatherUtils::ArraySearchType::All, name) {}
 };
 
diff --git a/src/Functions/array/hasAny.cpp b/src/Functions/array/hasAny.cpp
index 085a01c008e..fac810c7ba1 100644
--- a/src/Functions/array/hasAny.cpp
+++ b/src/Functions/array/hasAny.cpp
@@ -10,7 +10,7 @@ class FunctionArrayHasAny : public FunctionArrayHasAllAny
 {
 public:
     static constexpr auto name = "hasAny";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayHasAny>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayHasAny>(); }
     FunctionArrayHasAny() : FunctionArrayHasAllAny(GatherUtils::ArraySearchType::Any, name) {}
 };
 
diff --git a/src/Functions/array/hasSubstr.cpp b/src/Functions/array/hasSubstr.cpp
index 73430824b57..886f82f577b 100644
--- a/src/Functions/array/hasSubstr.cpp
+++ b/src/Functions/array/hasSubstr.cpp
@@ -10,7 +10,7 @@ class FunctionArrayHasSubstr : public FunctionArrayHasAllAny
 {
 public:
     static constexpr auto name = "hasSubstr";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionArrayHasSubstr>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayHasSubstr>(); }
     FunctionArrayHasSubstr() : FunctionArrayHasAllAny(GatherUtils::ArraySearchType::Substr, name) {}
 };
 
diff --git a/src/Functions/array/mapOp.cpp b/src/Functions/array/mapOp.cpp
index c30488cb25b..78b7ce2b155 100644
--- a/src/Functions/array/mapOp.cpp
+++ b/src/Functions/array/mapOp.cpp
@@ -43,7 +43,7 @@ class FunctionMapOp : public IFunction
 {
 public:
     static constexpr auto name = (op_type == OpTypes::ADD) ? "mapAdd" : "mapSubtract";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMapOp>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMapOp>(); }
 
 private:
     String getName() const override { return name; }
diff --git a/src/Functions/array/mapPopulateSeries.cpp b/src/Functions/array/mapPopulateSeries.cpp
index c025117af69..eb2f6192346 100644
--- a/src/Functions/array/mapPopulateSeries.cpp
+++ b/src/Functions/array/mapPopulateSeries.cpp
@@ -23,7 +23,7 @@ class FunctionMapPopulateSeries : public IFunction
 {
 public:
     static constexpr auto name = "mapPopulateSeries";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMapPopulateSeries>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMapPopulateSeries>(); }
 
 private:
     String getName() const override { return name; }
diff --git a/src/Functions/array/range.cpp b/src/Functions/array/range.cpp
index ac968786923..1b1ab802578 100644
--- a/src/Functions/array/range.cpp
+++ b/src/Functions/array/range.cpp
@@ -32,7 +32,7 @@ class FunctionRange : public IFunction
 public:
     static constexpr auto name = "range";
     static constexpr size_t max_elements = 100'000'000;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionRange>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionRange>(); }
 
 private:
     String getName() const override { return name; }
diff --git a/src/Functions/assumeNotNull.cpp b/src/Functions/assumeNotNull.cpp
index ab0d50c8c56..83c595eb0ab 100644
--- a/src/Functions/assumeNotNull.cpp
+++ b/src/Functions/assumeNotNull.cpp
@@ -19,7 +19,7 @@ class FunctionAssumeNotNull : public IFunction
 public:
     static constexpr auto name = "assumeNotNull";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionAssumeNotNull>();
     }
diff --git a/src/Functions/bar.cpp b/src/Functions/bar.cpp
index 6f5298a8c5e..c2b5f93994e 100644
--- a/src/Functions/bar.cpp
+++ b/src/Functions/bar.cpp
@@ -29,7 +29,7 @@ class FunctionBar : public IFunction
 {
 public:
     static constexpr auto name = "bar";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionBar>();
     }
diff --git a/src/Functions/bitHammingDistance.cpp b/src/Functions/bitHammingDistance.cpp
index 9b9ff5b6c07..25b902b8bd5 100644
--- a/src/Functions/bitHammingDistance.cpp
+++ b/src/Functions/bitHammingDistance.cpp
@@ -74,7 +74,7 @@ class FunctionBitHammingDistance : public IFunction
 public:
     static constexpr auto name = "bitHammingDistance";
     using ResultType = UInt8;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitHammingDistance>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitHammingDistance>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/bitmaskToList.cpp b/src/Functions/bitmaskToList.cpp
index ccd163895ff..4b9a54f805f 100644
--- a/src/Functions/bitmaskToList.cpp
+++ b/src/Functions/bitmaskToList.cpp
@@ -30,7 +30,7 @@ class FunctionBitmaskToList : public IFunction
 {
 public:
     static constexpr auto name = "bitmaskToList";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionBitmaskToList>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionBitmaskToList>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/blockNumber.cpp b/src/Functions/blockNumber.cpp
index 512dd9bcf29..0b7d47a67ec 100644
--- a/src/Functions/blockNumber.cpp
+++ b/src/Functions/blockNumber.cpp
@@ -18,7 +18,7 @@ private:
 
 public:
     static constexpr auto name = "blockNumber";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionBlockNumber>();
     }
diff --git a/src/Functions/blockSerializedSize.cpp b/src/Functions/blockSerializedSize.cpp
index 5a66c5d08af..f34a354836a 100644
--- a/src/Functions/blockSerializedSize.cpp
+++ b/src/Functions/blockSerializedSize.cpp
@@ -15,7 +15,7 @@ class FunctionBlockSerializedSize : public IFunction
 public:
     static constexpr auto name = "blockSerializedSize";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionBlockSerializedSize>();
     }
diff --git a/src/Functions/blockSize.cpp b/src/Functions/blockSize.cpp
index f08c0b0d963..9572cc19c06 100644
--- a/src/Functions/blockSize.cpp
+++ b/src/Functions/blockSize.cpp
@@ -15,7 +15,7 @@ class FunctionBlockSize : public IFunction
 {
 public:
     static constexpr auto name = "blockSize";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionBlockSize>();
     }
diff --git a/src/Functions/buildId.cpp b/src/Functions/buildId.cpp
index 7361f0e4546..a0bad20023f 100644
--- a/src/Functions/buildId.cpp
+++ b/src/Functions/buildId.cpp
@@ -18,7 +18,7 @@ class FunctionBuildId : public IFunction
 {
 public:
     static constexpr auto name = "buildId";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionBuildId>();
     }
diff --git a/src/Functions/byteSize.cpp b/src/Functions/byteSize.cpp
index ea1a9c83581..76080f2850c 100644
--- a/src/Functions/byteSize.cpp
+++ b/src/Functions/byteSize.cpp
@@ -17,7 +17,7 @@ class FunctionByteSize : public IFunction
 {
 public:
     static constexpr auto name = "byteSize";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionByteSize>();
     }
diff --git a/src/Functions/caseWithExpression.cpp b/src/Functions/caseWithExpression.cpp
index 195eb7e72ae..24b5855cc5b 100644
--- a/src/Functions/caseWithExpression.cpp
+++ b/src/Functions/caseWithExpression.cpp
@@ -1,6 +1,6 @@
-#include <Functions/FunctionFactory.h>
 #include <DataTypes/DataTypeArray.h>
 #include <DataTypes/getLeastSupertype.h>
+#include <Functions/FunctionFactory.h>
 
 
 namespace DB
@@ -20,9 +20,9 @@ class FunctionCaseWithExpression : public IFunction
 {
 public:
     static constexpr auto name = "caseWithExpression";
-    static FunctionPtr create(const Context & context_) { return std::make_shared<FunctionCaseWithExpression>(context_); }
+    static FunctionPtr create(ContextPtr context_) { return std::make_shared<FunctionCaseWithExpression>(context_); }
 
-    explicit FunctionCaseWithExpression(const Context & context_) : context(context_) {}
+    explicit FunctionCaseWithExpression(ContextPtr context_) : context(context_) {}
     bool isVariadic() const override { return true; }
     size_t getNumberOfArguments() const override { return 0; }
     String getName() const override { return name; }
@@ -98,7 +98,7 @@ public:
     }
 
 private:
-    const Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Functions/coalesce.cpp b/src/Functions/coalesce.cpp
index 12521185532..05dd83c5b63 100644
--- a/src/Functions/coalesce.cpp
+++ b/src/Functions/coalesce.cpp
@@ -1,17 +1,18 @@
-#include <Functions/IFunctionImpl.h>
-#include <Functions/FunctionHelpers.h>
-#include <Functions/FunctionFactory.h>
-#include <DataTypes/DataTypesNumber.h>
-#include <DataTypes/DataTypeNullable.h>
-#include <DataTypes/DataTypeNothing.h>
-#include <DataTypes/getLeastSupertype.h>
-#include <Core/ColumnNumbers.h>
-#include <Columns/ColumnNullable.h>
 #include <Columns/ColumnLowCardinality.h>
+#include <Columns/ColumnNullable.h>
+#include <Core/ColumnNumbers.h>
+#include <DataTypes/DataTypeNothing.h>
+#include <DataTypes/DataTypeNullable.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/getLeastSupertype.h>
+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionHelpers.h>
+#include <Functions/IFunctionImpl.h>
 
 
 namespace DB
 {
+
 namespace
 {
 
@@ -23,12 +24,12 @@ class FunctionCoalesce : public IFunction
 public:
     static constexpr auto name = "coalesce";
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionCoalesce>(context);
     }
 
-    explicit FunctionCoalesce(const Context & context_) : context(context_) {}
+    explicit FunctionCoalesce(ContextPtr context_) : context(context_) {}
 
     std::string getName() const override
     {
@@ -159,7 +160,7 @@ public:
     }
 
 private:
-    const Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Functions/concat.cpp b/src/Functions/concat.cpp
index de4d5e9efc4..e8a3c44efb1 100644
--- a/src/Functions/concat.cpp
+++ b/src/Functions/concat.cpp
@@ -33,8 +33,8 @@ class ConcatImpl : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    explicit ConcatImpl(const Context & context_) : context(context_) {}
-    static FunctionPtr create(const Context & context) { return std::make_shared<ConcatImpl>(context); }
+    explicit ConcatImpl(ContextPtr context_) : context(context_) {}
+    static FunctionPtr create(ContextPtr context) { return std::make_shared<ConcatImpl>(context); }
 
     String getName() const override { return name; }
 
@@ -85,7 +85,7 @@ public:
     }
 
 private:
-    const Context & context;
+    ContextWeakPtr context;
 
     ColumnPtr executeBinary(const ColumnsWithTypeAndName & arguments, size_t input_rows_count) const
     {
@@ -191,9 +191,9 @@ class ConcatOverloadResolver : public IFunctionOverloadResolverImpl
 {
 public:
     static constexpr auto name = "concat";
-    static FunctionOverloadResolverImplPtr create(const Context & context) { return std::make_unique<ConcatOverloadResolver>(context); }
+    static FunctionOverloadResolverImplPtr create(ContextPtr context) { return std::make_unique<ConcatOverloadResolver>(context); }
 
-    explicit ConcatOverloadResolver(const Context & context_) : context(context_) {}
+    explicit ConcatOverloadResolver(ContextPtr context_) : context(context_) {}
 
     String getName() const override { return name; }
     size_t getNumberOfArguments() const override { return 0; }
@@ -223,7 +223,7 @@ public:
     }
 
 private:
-    const Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Functions/connectionId.cpp b/src/Functions/connectionId.cpp
index 1eec764d923..780ee5e19aa 100644
--- a/src/Functions/connectionId.cpp
+++ b/src/Functions/connectionId.cpp
@@ -8,14 +8,14 @@ namespace DB
 {
 
 /// Get the connection Id. It's used for MySQL handler only.
-class FunctionConnectionId : public IFunction
+class FunctionConnectionId : public IFunction, WithContext
 {
 public:
     static constexpr auto name = "connectionId";
 
-    explicit FunctionConnectionId(const Context & context_) : context(context_) {}
+    explicit FunctionConnectionId(ContextPtr context_) : WithContext(context_) {}
 
-    static FunctionPtr create(const Context & context) { return std::make_shared<FunctionConnectionId>(context); }
+    static FunctionPtr create(ContextPtr context_) { return std::make_shared<FunctionConnectionId>(context_); }
 
     String getName() const override { return name; }
 
@@ -25,11 +25,8 @@ public:
 
     ColumnPtr executeImpl(const ColumnsWithTypeAndName &, const DataTypePtr & result_type, size_t input_rows_count) const override
     {
-        return result_type->createColumnConst(input_rows_count, context.getClientInfo().connection_id);
+        return result_type->createColumnConst(input_rows_count, getContext()->getClientInfo().connection_id);
     }
-
-private:
-    const Context & context;
 };
 
 void registerFunctionConnectionId(FunctionFactory & factory)
diff --git a/src/Functions/convertCharset.cpp b/src/Functions/convertCharset.cpp
index c32bbc358f5..b204875b4ff 100644
--- a/src/Functions/convertCharset.cpp
+++ b/src/Functions/convertCharset.cpp
@@ -162,7 +162,7 @@ private:
 
 public:
     static constexpr auto name = "convertCharset";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionConvertCharset>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionConvertCharset>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/countDigits.cpp b/src/Functions/countDigits.cpp
index 4469e11a421..6dd927731b8 100644
--- a/src/Functions/countDigits.cpp
+++ b/src/Functions/countDigits.cpp
@@ -28,7 +28,7 @@ class FunctionCountDigits : public IFunction
 public:
     static constexpr auto name = "countDigits";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionCountDigits>();
     }
diff --git a/src/Functions/countMatches.h b/src/Functions/countMatches.h
index be3d06ffb84..4cae039a0d0 100644
--- a/src/Functions/countMatches.h
+++ b/src/Functions/countMatches.h
@@ -27,7 +27,7 @@ class FunctionCountMatches : public IFunction
 {
 public:
     static constexpr auto name = CountMatchesBase::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionCountMatches<CountMatchesBase>>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionCountMatches<CountMatchesBase>>(); }
 
     String getName() const override { return name; }
     size_t getNumberOfArguments() const override { return 2; }
diff --git a/src/Functions/currentDatabase.cpp b/src/Functions/currentDatabase.cpp
index 17dbc8d98e4..8be49c6cfe8 100644
--- a/src/Functions/currentDatabase.cpp
+++ b/src/Functions/currentDatabase.cpp
@@ -16,9 +16,9 @@ class FunctionCurrentDatabase : public IFunction
 
 public:
     static constexpr auto name = "currentDatabase";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<FunctionCurrentDatabase>(context.getCurrentDatabase());
+        return std::make_shared<FunctionCurrentDatabase>(context->getCurrentDatabase());
     }
 
     explicit FunctionCurrentDatabase(const String & db_name_) : db_name{db_name_}
diff --git a/src/Functions/currentUser.cpp b/src/Functions/currentUser.cpp
index 77eb2228d19..69780f4fa8b 100644
--- a/src/Functions/currentUser.cpp
+++ b/src/Functions/currentUser.cpp
@@ -16,9 +16,9 @@ class FunctionCurrentUser : public IFunction
 
 public:
     static constexpr auto name = "currentUser";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<FunctionCurrentUser>(context.getClientInfo().initial_user);
+        return std::make_shared<FunctionCurrentUser>(context->getClientInfo().initial_user);
     }
 
     explicit FunctionCurrentUser(const String & user_name_) : user_name{user_name_}
diff --git a/src/Functions/dateDiff.cpp b/src/Functions/dateDiff.cpp
index f660b92efc5..8cd5eae3441 100644
--- a/src/Functions/dateDiff.cpp
+++ b/src/Functions/dateDiff.cpp
@@ -3,12 +3,14 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnsNumber.h>
+#include <Columns/ColumnDecimal.h>
 
 #include <Functions/IFunctionImpl.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/FunctionFactory.h>
 #include <Functions/extractTimeZoneFromFunctionArguments.h>
 #include <Functions/DateTimeTransforms.h>
+#include <Functions/TransformDateTime64.h>
 
 #include <IO/WriteHelpers.h>
 
@@ -42,9 +44,10 @@ namespace
   */
 class FunctionDateDiff : public IFunction
 {
+    using ColumnDateTime64 = ColumnDecimal<DateTime64>;
 public:
     static constexpr auto name = "dateDiff";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionDateDiff>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionDateDiff>(); }
 
     String getName() const override
     {
@@ -133,17 +136,21 @@ private:
             dispatchForSecondColumn<Transform>(*x_vec_16, y, timezone_x, timezone_y, result);
         else if (const auto * x_vec_32 = checkAndGetColumn<ColumnUInt32>(&x))
             dispatchForSecondColumn<Transform>(*x_vec_32, y, timezone_x, timezone_y, result);
+        else if (const auto * x_vec_64 = checkAndGetColumn<ColumnDateTime64>(&x))
+            dispatchForSecondColumn<Transform>(*x_vec_64, y, timezone_x, timezone_y, result);
         else if (const auto * x_const_16 = checkAndGetColumnConst<ColumnUInt16>(&x))
             dispatchConstForSecondColumn<Transform>(x_const_16->getValue<UInt16>(), y, timezone_x, timezone_y, result);
         else if (const auto * x_const_32 = checkAndGetColumnConst<ColumnUInt32>(&x))
             dispatchConstForSecondColumn<Transform>(x_const_32->getValue<UInt32>(), y, timezone_x, timezone_y, result);
+        else if (const auto * x_const_64 = checkAndGetColumnConst<ColumnDateTime64>(&x))
+            dispatchConstForSecondColumn<Transform>(x_const_64->getValue<DecimalField<DateTime64>>(), y, timezone_x, timezone_y, result);
         else
-            throw Exception("Illegal column for first argument of function " + getName() + ", must be Date or DateTime", ErrorCodes::ILLEGAL_COLUMN);
+            throw Exception("Illegal column for first argument of function " + getName() + ", must be Date, DateTime or DateTime64", ErrorCodes::ILLEGAL_COLUMN);
     }
 
-    template <typename Transform, typename T1>
+    template <typename Transform, typename LeftColumnType>
     void dispatchForSecondColumn(
-        const ColumnVector<T1> & x, const IColumn & y,
+        const LeftColumnType & x, const IColumn & y,
         const DateLUTImpl & timezone_x, const DateLUTImpl & timezone_y,
         ColumnInt64::Container & result) const
     {
@@ -151,10 +158,14 @@ private:
             vectorVector<Transform>(x, *y_vec_16, timezone_x, timezone_y, result);
         else if (const auto * y_vec_32 = checkAndGetColumn<ColumnUInt32>(&y))
             vectorVector<Transform>(x, *y_vec_32, timezone_x, timezone_y, result);
+        else if (const auto * y_vec_64 = checkAndGetColumn<ColumnDateTime64>(&y))
+            vectorVector<Transform>(x, *y_vec_64, timezone_x, timezone_y, result);
         else if (const auto * y_const_16 = checkAndGetColumnConst<ColumnUInt16>(&y))
             vectorConstant<Transform>(x, y_const_16->getValue<UInt16>(), timezone_x, timezone_y, result);
         else if (const auto * y_const_32 = checkAndGetColumnConst<ColumnUInt32>(&y))
             vectorConstant<Transform>(x, y_const_32->getValue<UInt32>(), timezone_x, timezone_y, result);
+        else if (const auto * y_const_64 = checkAndGetColumnConst<ColumnDateTime64>(&y))
+            vectorConstant<Transform>(x, y_const_64->getValue<DecimalField<DateTime64>>(), timezone_x, timezone_y, result);
         else
             throw Exception("Illegal column for second argument of function " + getName() + ", must be Date or DateTime", ErrorCodes::ILLEGAL_COLUMN);
     }
@@ -169,49 +180,81 @@ private:
             constantVector<Transform>(x, *y_vec_16, timezone_x, timezone_y, result);
         else if (const auto * y_vec_32 = checkAndGetColumn<ColumnUInt32>(&y))
             constantVector<Transform>(x, *y_vec_32, timezone_x, timezone_y, result);
+        else if (const auto * y_vec_64 = checkAndGetColumn<ColumnDateTime64>(&y))
+            constantVector<Transform>(x, *y_vec_64, timezone_x, timezone_y, result);
         else
             throw Exception("Illegal column for second argument of function " + getName() + ", must be Date or DateTime", ErrorCodes::ILLEGAL_COLUMN);
     }
 
-    template <typename Transform, typename T1, typename T2>
+    template <typename Transform, typename LeftColumnType, typename RightColumnType>
     void vectorVector(
-        const ColumnVector<T1> & x, const ColumnVector<T2> & y,
+        const LeftColumnType & x, const RightColumnType & y,
         const DateLUTImpl & timezone_x, const DateLUTImpl & timezone_y,
         ColumnInt64::Container & result) const
     {
         const auto & x_data = x.getData();
         const auto & y_data = y.getData();
+
+        const auto transform_x = TransformDateTime64<Transform>(getScale(x));
+        const auto transform_y = TransformDateTime64<Transform>(getScale(y));
         for (size_t i = 0, size = x.size(); i < size; ++i)
-            result[i] = calculate<Transform>(x_data[i], y_data[i], timezone_x, timezone_y);
+                result[i] = calculate(transform_x, transform_y, x_data[i], y_data[i], timezone_x, timezone_y);
     }
 
-    template <typename Transform, typename T1, typename T2>
+    template <typename Transform, typename LeftColumnType, typename T2>
     void vectorConstant(
-        const ColumnVector<T1> & x, T2 y,
+        const LeftColumnType & x, T2 y,
         const DateLUTImpl & timezone_x, const DateLUTImpl & timezone_y,
         ColumnInt64::Container & result) const
     {
         const auto & x_data = x.getData();
+        const auto transform_x = TransformDateTime64<Transform>(getScale(x));
+        const auto transform_y = TransformDateTime64<Transform>(getScale(y));
+        const auto y_value = stripDecimalFieldValue(y);
+
         for (size_t i = 0, size = x.size(); i < size; ++i)
-            result[i] = calculate<Transform>(x_data[i], y, timezone_x, timezone_y);
+            result[i] = calculate(transform_x, transform_y, x_data[i], y_value, timezone_x, timezone_y);
     }
 
-    template <typename Transform, typename T1, typename T2>
+    template <typename Transform, typename T1, typename RightColumnType>
     void constantVector(
-        T1 x, const ColumnVector<T2> & y,
+        T1 x, const RightColumnType & y,
         const DateLUTImpl & timezone_x, const DateLUTImpl & timezone_y,
         ColumnInt64::Container & result) const
     {
         const auto & y_data = y.getData();
+        const auto transform_x = TransformDateTime64<Transform>(getScale(x));
+        const auto transform_y = TransformDateTime64<Transform>(getScale(y));
+        const auto x_value = stripDecimalFieldValue(x);
+
         for (size_t i = 0, size = y.size(); i < size; ++i)
-            result[i] = calculate<Transform>(x, y_data[i], timezone_x, timezone_y);
+            result[i] = calculate(transform_x, transform_y, x_value, y_data[i], timezone_x, timezone_y);
     }
 
-    template <typename Transform, typename T1, typename T2>
-    Int64 calculate(T1 x, T2 y, const DateLUTImpl & timezone_x, const DateLUTImpl & timezone_y) const
+    template <typename TransformX, typename TransformY, typename T1, typename T2>
+    Int64 calculate(const TransformX & transform_x, const TransformY & transform_y, T1 x, T2 y, const DateLUTImpl & timezone_x, const DateLUTImpl & timezone_y) const
     {
-        return Int64(Transform::execute(y, timezone_y))
-             - Int64(Transform::execute(x, timezone_x));
+        return Int64(transform_y.execute(y, timezone_y))
+             - Int64(transform_x.execute(x, timezone_x));
+    }
+
+    template <typename T>
+    static UInt32 getScale(const T & v)
+    {
+        if constexpr (std::is_same_v<T, ColumnDateTime64>)
+            return v.getScale();
+        else if constexpr (std::is_same_v<T, DecimalField<DateTime64>>)
+            return v.getScale();
+
+        return 0;
+    }
+    template <typename T>
+    static auto stripDecimalFieldValue(T && v)
+    {
+        if constexpr (std::is_same_v<std::decay_t<T>, DecimalField<DateTime64>>)
+            return v.getValue();
+        else
+            return v;
     }
 };
 
diff --git a/src/Functions/date_trunc.cpp b/src/Functions/date_trunc.cpp
index f55b3b56536..7952eda4f2b 100644
--- a/src/Functions/date_trunc.cpp
+++ b/src/Functions/date_trunc.cpp
@@ -25,9 +25,9 @@ class FunctionDateTrunc : public IFunction
 public:
     static constexpr auto name = "date_trunc";
 
-    explicit FunctionDateTrunc(const Context & context_) : context(context_) {}
+    explicit FunctionDateTrunc(ContextPtr context_) : context(context_) {}
 
-    static FunctionPtr create(const Context & context) { return std::make_shared<FunctionDateTrunc>(context); }
+    static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionDateTrunc>(context); }
 
     String getName() const override { return name; }
 
@@ -146,7 +146,7 @@ public:
     }
 
 private:
-    const Context & context;
+    ContextPtr context;
     mutable IntervalKind::Kind datepart_kind = IntervalKind::Kind::Second;
 };
 
diff --git a/src/Functions/defaultValueOfArgumentType.cpp b/src/Functions/defaultValueOfArgumentType.cpp
index a46715ffaad..85b2f261f60 100644
--- a/src/Functions/defaultValueOfArgumentType.cpp
+++ b/src/Functions/defaultValueOfArgumentType.cpp
@@ -13,7 +13,7 @@ class FunctionDefaultValueOfArgumentType : public IFunction
 {
 public:
     static constexpr auto name = "defaultValueOfArgumentType";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionDefaultValueOfArgumentType>();
     }
diff --git a/src/Functions/defaultValueOfTypeName.cpp b/src/Functions/defaultValueOfTypeName.cpp
index 4f6d19bbc53..7be985cf560 100644
--- a/src/Functions/defaultValueOfTypeName.cpp
+++ b/src/Functions/defaultValueOfTypeName.cpp
@@ -21,7 +21,7 @@ class FunctionDefaultValueOfTypeName : public IFunction
 {
 public:
     static constexpr auto name = "defaultValueOfTypeName";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionDefaultValueOfTypeName>();
     }
diff --git a/src/Functions/demange.cpp b/src/Functions/demange.cpp
index d6cddc18f7a..755a50dccbb 100644
--- a/src/Functions/demange.cpp
+++ b/src/Functions/demange.cpp
@@ -25,9 +25,9 @@ class FunctionDemangle : public IFunction
 {
 public:
     static constexpr auto name = "demangle";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        context.checkAccess(AccessType::demangle);
+        context->checkAccess(AccessType::demangle);
         return std::make_shared<FunctionDemangle>();
     }
 
diff --git a/src/Functions/dumpColumnStructure.cpp b/src/Functions/dumpColumnStructure.cpp
index 723b76616ed..827aabb8df9 100644
--- a/src/Functions/dumpColumnStructure.cpp
+++ b/src/Functions/dumpColumnStructure.cpp
@@ -14,7 +14,7 @@ class FunctionDumpColumnStructure : public IFunction
 {
 public:
     static constexpr auto name = "dumpColumnStructure";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionDumpColumnStructure>();
     }
diff --git a/src/Functions/errorCodeToName.cpp b/src/Functions/errorCodeToName.cpp
index 20e80e457c9..4b96c355cd9 100644
--- a/src/Functions/errorCodeToName.cpp
+++ b/src/Functions/errorCodeToName.cpp
@@ -19,7 +19,7 @@ class FunctionErrorCodeToName : public IFunction
 {
 public:
     static constexpr auto name = "errorCodeToName";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionErrorCodeToName>();
     }
diff --git a/src/Functions/evalMLMethod.cpp b/src/Functions/evalMLMethod.cpp
index 03d26db4043..7bdf4ea7db2 100644
--- a/src/Functions/evalMLMethod.cpp
+++ b/src/Functions/evalMLMethod.cpp
@@ -28,11 +28,11 @@ class FunctionEvalMLMethod : public IFunction
 {
 public:
     static constexpr auto name = "evalMLMethod";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionEvalMLMethod>(context);
     }
-    explicit FunctionEvalMLMethod(const Context & context_) : context(context_)
+    explicit FunctionEvalMLMethod(ContextPtr context_) : context(context_)
     {}
 
     String getName() const override
@@ -81,7 +81,7 @@ public:
         return agg_function->predictValues(arguments, context);
     }
 
-    const Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Functions/extractAllGroups.h b/src/Functions/extractAllGroups.h
index 7132c5dae82..c77d497cf17 100644
--- a/src/Functions/extractAllGroups.h
+++ b/src/Functions/extractAllGroups.h
@@ -51,7 +51,7 @@ public:
     static constexpr auto Kind = Impl::Kind;
     static constexpr auto name = Impl::Name;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionExtractAllGroups>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionExtractAllGroups>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/extractGroups.cpp b/src/Functions/extractGroups.cpp
index f20e2cf3e88..f1d728ee3f6 100644
--- a/src/Functions/extractGroups.cpp
+++ b/src/Functions/extractGroups.cpp
@@ -31,7 +31,7 @@ class FunctionExtractGroups : public IFunction
 {
 public:
     static constexpr auto name = "extractGroups";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionExtractGroups>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionExtractGroups>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/extractTextFromHTML.cpp b/src/Functions/extractTextFromHTML.cpp
index 528bd0c311f..5ca82eb317d 100644
--- a/src/Functions/extractTextFromHTML.cpp
+++ b/src/Functions/extractTextFromHTML.cpp
@@ -296,7 +296,7 @@ class FunctionExtractTextFromHTML : public IFunction
 public:
     static constexpr auto name = "extractTextFromHTML";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionExtractTextFromHTML>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionExtractTextFromHTML>(); }
     String getName() const override { return name; }
     size_t getNumberOfArguments() const override { return 1; }
     bool useDefaultImplementationForConstants() const override { return true; }
diff --git a/src/Functions/filesystem.cpp b/src/Functions/filesystem.cpp
index 879c48dbe67..565166d2a18 100644
--- a/src/Functions/filesystem.cpp
+++ b/src/Functions/filesystem.cpp
@@ -34,9 +34,9 @@ class FilesystemImpl : public IFunction
 public:
     static constexpr auto name = Impl::name;
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<FilesystemImpl<Impl>>(std::filesystem::space(context.getConfigRef().getString("path")));
+        return std::make_shared<FilesystemImpl<Impl>>(std::filesystem::space(context->getConfigRef().getString("path")));
     }
 
     explicit FilesystemImpl(std::filesystem::space_info spaceinfo_) : spaceinfo(spaceinfo_) { }
diff --git a/src/Functions/finalizeAggregation.cpp b/src/Functions/finalizeAggregation.cpp
index 91d80e1d692..6bf6932ceee 100644
--- a/src/Functions/finalizeAggregation.cpp
+++ b/src/Functions/finalizeAggregation.cpp
@@ -24,7 +24,7 @@ class FunctionFinalizeAggregation : public IFunction
 {
 public:
     static constexpr auto name = "finalizeAggregation";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionFinalizeAggregation>();
     }
diff --git a/src/Functions/formatDateTime.cpp b/src/Functions/formatDateTime.cpp
index 5128f077c5a..293710fc190 100644
--- a/src/Functions/formatDateTime.cpp
+++ b/src/Functions/formatDateTime.cpp
@@ -281,7 +281,7 @@ private:
 public:
     static constexpr auto name = Name::name;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionFormatDateTimeImpl>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionFormatDateTimeImpl>(); }
 
     String getName() const override
     {
@@ -480,7 +480,7 @@ public:
                     // since right now LUT does not support Int64-values and not format instructions for subsecond parts,
                     // treat DatTime64 values just as DateTime values by ignoring fractional and casting to UInt32.
                     const auto c = DecimalUtils::split(vec[i], scale);
-                    instruction.perform(pos, static_cast<UInt32>(c.whole), time_zone);
+                    instruction.perform(pos, static_cast<Int64>(c.whole), time_zone);
                 }
             }
             else
diff --git a/src/Functions/formatReadable.h b/src/Functions/formatReadable.h
index ae70c1afa87..7a11aa184d9 100644
--- a/src/Functions/formatReadable.h
+++ b/src/Functions/formatReadable.h
@@ -28,7 +28,7 @@ class FunctionFormatReadable : public IFunction
 {
 public:
     static constexpr auto name = Impl::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionFormatReadable<Impl>>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionFormatReadable<Impl>>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/formatReadableTimeDelta.cpp b/src/Functions/formatReadableTimeDelta.cpp
index 9ffdb8464e0..7913a53c9c3 100644
--- a/src/Functions/formatReadableTimeDelta.cpp
+++ b/src/Functions/formatReadableTimeDelta.cpp
@@ -38,7 +38,7 @@ class FunctionFormatReadableTimeDelta : public IFunction
 {
 public:
     static constexpr auto name = "formatReadableTimeDelta";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionFormatReadableTimeDelta>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionFormatReadableTimeDelta>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/formatRow.cpp b/src/Functions/formatRow.cpp
index e8f82669aae..e58149138ad 100644
--- a/src/Functions/formatRow.cpp
+++ b/src/Functions/formatRow.cpp
@@ -35,7 +35,7 @@ class FunctionFormatRow : public IFunction
 public:
     static constexpr auto name = no_newline ? "formatRowNoNewline" : "formatRow";
 
-    FunctionFormatRow(const String & format_name_, const Context & context_) : format_name(format_name_), context(context_)
+    FunctionFormatRow(const String & format_name_, ContextPtr context_) : format_name(format_name_), context(context_)
     {
         if (!FormatFactory::instance().getAllFormats().count(format_name))
             throw Exception("Unknown format " + format_name, ErrorCodes::UNKNOWN_FORMAT);
@@ -76,7 +76,7 @@ public:
 
 private:
     String format_name;
-    const Context & context;
+    ContextPtr context;
 };
 
 template <bool no_newline>
@@ -84,8 +84,8 @@ class FormatRowOverloadResolver : public IFunctionOverloadResolverImpl
 {
 public:
     static constexpr auto name = no_newline ? "formatRowNoNewline" : "formatRow";
-    static FunctionOverloadResolverImplPtr create(const Context & context) { return std::make_unique<FormatRowOverloadResolver>(context); }
-    explicit FormatRowOverloadResolver(const Context & context_) : context(context_) { }
+    static FunctionOverloadResolverImplPtr create(ContextPtr context) { return std::make_unique<FormatRowOverloadResolver>(context); }
+    explicit FormatRowOverloadResolver(ContextPtr context_) : context(context_) { }
     String getName() const override { return name; }
     bool isVariadic() const override { return true; }
     size_t getNumberOfArguments() const override { return 0; }
@@ -111,7 +111,7 @@ public:
     DataTypePtr getReturnType(const DataTypes &) const override { return std::make_shared<DataTypeString>(); }
 
 private:
-    const Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Functions/formatString.cpp b/src/Functions/formatString.cpp
index c97692bcb10..aac9d74904d 100644
--- a/src/Functions/formatString.cpp
+++ b/src/Functions/formatString.cpp
@@ -31,7 +31,7 @@ class FormatFunction : public IFunction
 public:
     static constexpr auto name = Name::name;
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FormatFunction>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FormatFunction>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/fromModifiedJulianDay.cpp b/src/Functions/fromModifiedJulianDay.cpp
index cd5699bfac5..3cf5f9b2216 100644
--- a/src/Functions/fromModifiedJulianDay.cpp
+++ b/src/Functions/fromModifiedJulianDay.cpp
@@ -151,7 +151,7 @@ namespace DB
     public:
         static constexpr auto name = Name::name;
 
-        static FunctionOverloadResolverImplPtr create(const Context &)
+        static FunctionOverloadResolverImplPtr create(ContextPtr)
         {
             return std::make_unique<FromModifiedJulianDayOverloadResolver<Name, nullOnErrors>>();
         }
diff --git a/src/Functions/fuzzBits.cpp b/src/Functions/fuzzBits.cpp
index a0631084742..eadaa0aad01 100644
--- a/src/Functions/fuzzBits.cpp
+++ b/src/Functions/fuzzBits.cpp
@@ -53,7 +53,7 @@ class FunctionFuzzBits : public IFunction
 public:
     static constexpr auto name = "fuzzBits";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionFuzzBits>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionFuzzBits>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/generateUUIDv4.cpp b/src/Functions/generateUUIDv4.cpp
index e519f5217b5..a1e50e3c54f 100644
--- a/src/Functions/generateUUIDv4.cpp
+++ b/src/Functions/generateUUIDv4.cpp
@@ -59,7 +59,7 @@ public:
 class FunctionGenerateUUIDv4 : public TargetSpecific::Default::FunctionGenerateUUIDv4
 {
 public:
-    explicit FunctionGenerateUUIDv4(const Context & context) : selector(context)
+    explicit FunctionGenerateUUIDv4(ContextPtr context) : selector(context)
     {
         selector.registerImplementation<TargetArch::Default,
             TargetSpecific::Default::FunctionGenerateUUIDv4>();
@@ -75,7 +75,7 @@ public:
         return selector.selectAndExecute(arguments, result_type, input_rows_count);
     }
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionGenerateUUIDv4>(context);
     }
diff --git a/src/Functions/geoToH3.cpp b/src/Functions/geoToH3.cpp
index 6518043d15f..7b3d742bb60 100644
--- a/src/Functions/geoToH3.cpp
+++ b/src/Functions/geoToH3.cpp
@@ -33,7 +33,7 @@ class FunctionGeoToH3 : public IFunction
 public:
     static constexpr auto name = "geoToH3";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionGeoToH3>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionGeoToH3>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/geohashDecode.cpp b/src/Functions/geohashDecode.cpp
index 7e73b501bd5..bf774905868 100644
--- a/src/Functions/geohashDecode.cpp
+++ b/src/Functions/geohashDecode.cpp
@@ -27,7 +27,7 @@ class FunctionGeohashDecode : public IFunction
 {
 public:
     static constexpr auto name = "geohashDecode";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionGeohashDecode>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionGeohashDecode>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/geohashEncode.cpp b/src/Functions/geohashEncode.cpp
index 794e77b4e24..15abe96e3e5 100644
--- a/src/Functions/geohashEncode.cpp
+++ b/src/Functions/geohashEncode.cpp
@@ -28,7 +28,7 @@ class FunctionGeohashEncode : public IFunction
 {
 public:
     static constexpr auto name = "geohashEncode";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionGeohashEncode>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionGeohashEncode>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/geohashesInBox.cpp b/src/Functions/geohashesInBox.cpp
index 0e18916053f..6bcae5c2440 100644
--- a/src/Functions/geohashesInBox.cpp
+++ b/src/Functions/geohashesInBox.cpp
@@ -29,7 +29,7 @@ class FunctionGeohashesInBox : public IFunction
 {
 public:
     static constexpr auto name = "geohashesInBox";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionGeohashesInBox>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionGeohashesInBox>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/getMacro.cpp b/src/Functions/getMacro.cpp
index 949016d862d..7fe41498d35 100644
--- a/src/Functions/getMacro.cpp
+++ b/src/Functions/getMacro.cpp
@@ -30,9 +30,9 @@ private:
 
 public:
     static constexpr auto name = "getMacro";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<FunctionGetMacro>(context.getMacros());
+        return std::make_shared<FunctionGetMacro>(context->getMacros());
     }
 
     explicit FunctionGetMacro(MultiVersion<Macros>::Version macros_) : macros(std::move(macros_)) {}
diff --git a/src/Functions/getScalar.cpp b/src/Functions/getScalar.cpp
index 4803c5a81d5..5520be9d9c2 100644
--- a/src/Functions/getScalar.cpp
+++ b/src/Functions/getScalar.cpp
@@ -20,16 +20,16 @@ namespace
 
 /** Get scalar value of sub queries from query context via IAST::Hash.
   */
-class FunctionGetScalar : public IFunction
+class FunctionGetScalar : public IFunction, WithContext
 {
 public:
     static constexpr auto name = "__getScalar";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context_)
     {
-        return std::make_shared<FunctionGetScalar>(context);
+        return std::make_shared<FunctionGetScalar>(context_);
     }
 
-    explicit FunctionGetScalar(const Context & context_) : context(context_) {}
+    explicit FunctionGetScalar(ContextPtr context_) : WithContext(context_) {}
 
     String getName() const override
     {
@@ -46,8 +46,8 @@ public:
         if (arguments.size() != 1 || !isString(arguments[0].type) || !arguments[0].column || !isColumnConst(*arguments[0].column))
             throw Exception("Function " + getName() + " accepts one const string argument", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
         auto scalar_name = assert_cast<const ColumnConst &>(*arguments[0].column).getValue<String>();
-        const Context & query_context = context.hasQueryContext() ? context.getQueryContext() : context;
-        scalar = query_context.getScalar(scalar_name).getByPosition(0);
+        ContextPtr query_context = getContext()->hasQueryContext() ? getContext()->getQueryContext() : getContext();
+        scalar = query_context->getScalar(scalar_name).getByPosition(0);
         return scalar.type;
     }
 
@@ -58,7 +58,6 @@ public:
 
 private:
     mutable ColumnWithTypeAndName scalar;
-    const Context & context;
 };
 
 }
diff --git a/src/Functions/getSetting.cpp b/src/Functions/getSetting.cpp
index 5da5f902d8c..6494f42c53c 100644
--- a/src/Functions/getSetting.cpp
+++ b/src/Functions/getSetting.cpp
@@ -19,13 +19,13 @@ namespace
 {
 
 /// Get the value of a setting.
-class FunctionGetSetting : public IFunction
+class FunctionGetSetting : public IFunction, WithContext
 {
 public:
     static constexpr auto name = "getSetting";
 
-    static FunctionPtr create(const Context & context_) { return std::make_shared<FunctionGetSetting>(context_); }
-    explicit FunctionGetSetting(const Context & context_) : context(context_) {}
+    static FunctionPtr create(ContextPtr context_) { return std::make_shared<FunctionGetSetting>(context_); }
+    explicit FunctionGetSetting(ContextPtr context_) : WithContext(context_) {}
 
     String getName() const override { return name; }
     bool isDeterministic() const override { return false; }
@@ -43,7 +43,7 @@ public:
                             ErrorCodes::ILLEGAL_COLUMN};
 
         std::string_view setting_name{column->getDataAt(0)};
-        value = context.getSettingsRef().get(setting_name);
+        value = getContext()->getSettingsRef().get(setting_name);
 
         DataTypePtr type = applyVisitor(FieldToDataType{}, value);
         value = convertFieldToType(value, *type);
@@ -57,7 +57,6 @@ public:
 
 private:
     mutable Field value;
-    const Context & context;
 };
 
 }
diff --git a/src/Functions/getSizeOfEnumType.cpp b/src/Functions/getSizeOfEnumType.cpp
index dea56bd3063..9499b0e3bf0 100644
--- a/src/Functions/getSizeOfEnumType.cpp
+++ b/src/Functions/getSizeOfEnumType.cpp
@@ -20,7 +20,7 @@ class FunctionGetSizeOfEnumType : public IFunction
 {
 public:
     static constexpr auto name = "getSizeOfEnumType";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionGetSizeOfEnumType>();
     }
diff --git a/src/Functions/globalVariable.cpp b/src/Functions/globalVariable.cpp
index 6482b3bb976..9f3c89b16e2 100644
--- a/src/Functions/globalVariable.cpp
+++ b/src/Functions/globalVariable.cpp
@@ -30,7 +30,7 @@ class FunctionGlobalVariable : public IFunction
 {
 public:
     static constexpr auto name = "globalVariable";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionGlobalVariable>();
     }
diff --git a/src/Functions/greatCircleDistance.cpp b/src/Functions/greatCircleDistance.cpp
index 801f8b3da7f..93ec7c9de4c 100644
--- a/src/Functions/greatCircleDistance.cpp
+++ b/src/Functions/greatCircleDistance.cpp
@@ -287,7 +287,7 @@ template <Method method>
 class FunctionGeoDistance : public TargetSpecific::Default::FunctionGeoDistance<method>
 {
 public:
-    explicit FunctionGeoDistance(const Context & context) : selector(context)
+    explicit FunctionGeoDistance(ContextPtr context) : selector(context)
     {
         selector.registerImplementation<TargetArch::Default,
             TargetSpecific::Default::FunctionGeoDistance<method>>();
@@ -307,7 +307,7 @@ public:
         return selector.selectAndExecute(arguments, result_type, input_rows_count);
     }
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionGeoDistance<method>>(context);
     }
diff --git a/src/Functions/h3EdgeAngle.cpp b/src/Functions/h3EdgeAngle.cpp
index 58ce5def111..ad8d1ee441f 100644
--- a/src/Functions/h3EdgeAngle.cpp
+++ b/src/Functions/h3EdgeAngle.cpp
@@ -32,7 +32,7 @@ class FunctionH3EdgeAngle : public IFunction
 public:
     static constexpr auto name = "h3EdgeAngle";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3EdgeAngle>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3EdgeAngle>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/h3EdgeLengthM.cpp b/src/Functions/h3EdgeLengthM.cpp
index 8f8aebc857e..85d307e1da3 100644
--- a/src/Functions/h3EdgeLengthM.cpp
+++ b/src/Functions/h3EdgeLengthM.cpp
@@ -37,7 +37,7 @@ class FunctionH3EdgeLengthM : public IFunction
 public:
     static constexpr auto name = "h3EdgeLengthM";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3EdgeLengthM>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3EdgeLengthM>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/h3GetBaseCell.cpp b/src/Functions/h3GetBaseCell.cpp
index 92d9ee5e3e0..fcad82098e6 100644
--- a/src/Functions/h3GetBaseCell.cpp
+++ b/src/Functions/h3GetBaseCell.cpp
@@ -29,7 +29,7 @@ class FunctionH3GetBaseCell : public IFunction
 public:
     static constexpr auto name = "h3GetBaseCell";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3GetBaseCell>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3GetBaseCell>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/h3GetResolution.cpp b/src/Functions/h3GetResolution.cpp
index f2676ccbb82..d1bfd899150 100644
--- a/src/Functions/h3GetResolution.cpp
+++ b/src/Functions/h3GetResolution.cpp
@@ -29,7 +29,7 @@ class FunctionH3GetResolution : public IFunction
 public:
     static constexpr auto name = "h3GetResolution";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3GetResolution>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3GetResolution>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/h3HexAreaM2.cpp b/src/Functions/h3HexAreaM2.cpp
index c7a16b57465..e44bf660333 100644
--- a/src/Functions/h3HexAreaM2.cpp
+++ b/src/Functions/h3HexAreaM2.cpp
@@ -32,7 +32,7 @@ class FunctionH3HexAreaM2 : public IFunction
 public:
     static constexpr auto name = "h3HexAreaM2";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3HexAreaM2>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3HexAreaM2>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/h3IndexesAreNeighbors.cpp b/src/Functions/h3IndexesAreNeighbors.cpp
index d43fca15012..56c69ed0a8b 100644
--- a/src/Functions/h3IndexesAreNeighbors.cpp
+++ b/src/Functions/h3IndexesAreNeighbors.cpp
@@ -29,7 +29,7 @@ class FunctionH3IndexesAreNeighbors : public IFunction
 public:
     static constexpr auto name = "h3IndexesAreNeighbors";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3IndexesAreNeighbors>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3IndexesAreNeighbors>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/h3IsValid.cpp b/src/Functions/h3IsValid.cpp
index 2918431e3b6..1e4840b3537 100644
--- a/src/Functions/h3IsValid.cpp
+++ b/src/Functions/h3IsValid.cpp
@@ -29,7 +29,7 @@ class FunctionH3IsValid : public IFunction
 public:
     static constexpr auto name = "h3IsValid";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3IsValid>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3IsValid>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/h3ToChildren.cpp b/src/Functions/h3ToChildren.cpp
index b63d4efc83e..9730aefe3d4 100644
--- a/src/Functions/h3ToChildren.cpp
+++ b/src/Functions/h3ToChildren.cpp
@@ -38,7 +38,7 @@ class FunctionH3ToChildren : public IFunction
 public:
     static constexpr auto name = "h3ToChildren";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3ToChildren>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3ToChildren>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/h3ToParent.cpp b/src/Functions/h3ToParent.cpp
index 73c1d002df5..4baf9527301 100644
--- a/src/Functions/h3ToParent.cpp
+++ b/src/Functions/h3ToParent.cpp
@@ -32,7 +32,7 @@ class FunctionH3ToParent : public IFunction
 public:
     static constexpr auto name = "h3ToParent";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3ToParent>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3ToParent>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/h3ToString.cpp b/src/Functions/h3ToString.cpp
index 16d7d14964a..dcd0951f67f 100644
--- a/src/Functions/h3ToString.cpp
+++ b/src/Functions/h3ToString.cpp
@@ -29,7 +29,7 @@ class FunctionH3ToString : public IFunction
 public:
     static constexpr auto name = "h3ToString";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3ToString>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3ToString>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/h3kRing.cpp b/src/Functions/h3kRing.cpp
index fd4a8ac57e8..40e73f9dea2 100644
--- a/src/Functions/h3kRing.cpp
+++ b/src/Functions/h3kRing.cpp
@@ -35,7 +35,7 @@ class FunctionH3KRing : public IFunction
 public:
     static constexpr auto name = "h3kRing";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionH3KRing>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionH3KRing>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/hasColumnInTable.cpp b/src/Functions/hasColumnInTable.cpp
index d5fe00e025f..28f83a63386 100644
--- a/src/Functions/hasColumnInTable.cpp
+++ b/src/Functions/hasColumnInTable.cpp
@@ -25,16 +25,16 @@ namespace
 /** Usage:
  *  hasColumnInTable(['hostname'[, 'username'[, 'password']],] 'database', 'table', 'column')
  */
-class FunctionHasColumnInTable : public IFunction
+class FunctionHasColumnInTable : public IFunction, WithContext
 {
 public:
     static constexpr auto name = "hasColumnInTable";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context_)
     {
-        return std::make_shared<FunctionHasColumnInTable>(context.getGlobalContext());
+        return std::make_shared<FunctionHasColumnInTable>(context_->getGlobalContext());
     }
 
-    explicit FunctionHasColumnInTable(const Context & global_context_) : global_context(global_context_)
+    explicit FunctionHasColumnInTable(ContextPtr global_context_) : WithContext(global_context_)
     {
     }
 
@@ -57,9 +57,6 @@ public:
     bool isDeterministic() const override { return false; }
 
     ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override;
-
-private:
-    const Context & global_context;
 };
 
 
@@ -117,7 +114,7 @@ ColumnPtr FunctionHasColumnInTable::executeImpl(const ColumnsWithTypeAndName & a
     bool has_column;
     if (host_name.empty())
     {
-        const StoragePtr & table = DatabaseCatalog::instance().getTable({database_name, table_name}, global_context);
+        const StoragePtr & table = DatabaseCatalog::instance().getTable({database_name, table_name}, getContext());
         auto table_metadata = table->getInMemoryMetadataPtr();
         has_column = table_metadata->getColumns().hasPhysical(column_name);
     }
@@ -126,14 +123,14 @@ ColumnPtr FunctionHasColumnInTable::executeImpl(const ColumnsWithTypeAndName & a
         std::vector<std::vector<String>> host_names = {{ host_name }};
 
         auto cluster = std::make_shared<Cluster>(
-            global_context.getSettings(),
+            getContext()->getSettings(),
             host_names,
             !user_name.empty() ? user_name : "default",
             password,
-            global_context.getTCPPort(),
+            getContext()->getTCPPort(),
             false);
 
-        auto remote_columns = getStructureOfRemoteTable(*cluster, {database_name, table_name}, global_context);
+        auto remote_columns = getStructureOfRemoteTable(*cluster, {database_name, table_name}, getContext());
         has_column = remote_columns.hasPhysical(column_name);
     }
 
diff --git a/src/Functions/hasThreadFuzzer.cpp b/src/Functions/hasThreadFuzzer.cpp
index 545ac0175f2..e9b48aa70f9 100644
--- a/src/Functions/hasThreadFuzzer.cpp
+++ b/src/Functions/hasThreadFuzzer.cpp
@@ -16,7 +16,7 @@ class FunctionHasThreadFuzzer : public IFunction
 {
 public:
     static constexpr auto name = "hasThreadFuzzer";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionHasThreadFuzzer>();
     }
diff --git a/src/Functions/hostName.cpp b/src/Functions/hostName.cpp
index beaaec37e70..250c410aa9c 100644
--- a/src/Functions/hostName.cpp
+++ b/src/Functions/hostName.cpp
@@ -15,7 +15,7 @@ class FunctionHostName : public IFunction
 {
 public:
     static constexpr auto name = "hostName";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionHostName>();
     }
diff --git a/src/Functions/identity.cpp b/src/Functions/identity.cpp
index cb8fcf28c23..2bfeb4cdda3 100644
--- a/src/Functions/identity.cpp
+++ b/src/Functions/identity.cpp
@@ -11,7 +11,7 @@ class FunctionIdentity : public IFunction
 {
 public:
     static constexpr auto name = "identity";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionIdentity>();
     }
diff --git a/src/Functions/if.cpp b/src/Functions/if.cpp
index 614bfcf700e..4883b827d7d 100644
--- a/src/Functions/if.cpp
+++ b/src/Functions/if.cpp
@@ -173,7 +173,7 @@ class FunctionIf : public FunctionIfBase</*null_is_false=*/false>
 {
 public:
     static constexpr auto name = "if";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionIf>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIf>(); }
 
 private:
     template <typename T0, typename T1>
diff --git a/src/Functions/ifNotFinite.cpp b/src/Functions/ifNotFinite.cpp
index 88b23da0126..8a80fbc82ee 100644
--- a/src/Functions/ifNotFinite.cpp
+++ b/src/Functions/ifNotFinite.cpp
@@ -17,9 +17,9 @@ class FunctionIfNotFinite : public IFunction
 public:
     static constexpr auto name = "ifNotFinite";
 
-    explicit FunctionIfNotFinite(const Context & context_) : context(context_) {}
+    explicit FunctionIfNotFinite(ContextPtr context_) : context(context_) {}
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionIfNotFinite>(context);
     }
@@ -59,7 +59,7 @@ public:
     }
 
 private:
-    const Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Functions/ifNull.cpp b/src/Functions/ifNull.cpp
index af29fa0e1f0..763d125a8b7 100644
--- a/src/Functions/ifNull.cpp
+++ b/src/Functions/ifNull.cpp
@@ -21,9 +21,9 @@ class FunctionIfNull : public IFunction
 public:
     static constexpr auto name = "ifNull";
 
-    explicit FunctionIfNull(const Context & context_) : context(context_) {}
+    explicit FunctionIfNull(ContextPtr context_) : context(context_) {}
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionIfNull>(context);
     }
@@ -83,7 +83,7 @@ public:
     }
 
 private:
-    const Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Functions/ignore.cpp b/src/Functions/ignore.cpp
index 1348144cb05..1a8a838036c 100644
--- a/src/Functions/ignore.cpp
+++ b/src/Functions/ignore.cpp
@@ -14,7 +14,7 @@ class FunctionIgnore : public IFunction
 {
 public:
     static constexpr auto name = "ignore";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionIgnore>();
     }
diff --git a/src/Functions/in.cpp b/src/Functions/in.cpp
index b9a0c81b508..aac8de14fe6 100644
--- a/src/Functions/in.cpp
+++ b/src/Functions/in.cpp
@@ -52,7 +52,7 @@ public:
     /// It is needed to perform type analysis without creation of set.
     static constexpr auto name = FunctionInName<negative, global, null_is_skipped, ignore_set>::name;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionIn>();
     }
diff --git a/src/Functions/initializeAggregation.cpp b/src/Functions/initializeAggregation.cpp
index 4b90b7956c5..75c3ea14de8 100644
--- a/src/Functions/initializeAggregation.cpp
+++ b/src/Functions/initializeAggregation.cpp
@@ -9,7 +9,7 @@
 #include <AggregateFunctions/parseAggregateFunctionParameters.h>
 #include <Common/Arena.h>
 
-#include <ext/scope_guard.h>
+#include <ext/scope_guard_safe.h>
 
 
 namespace DB
@@ -29,7 +29,7 @@ class FunctionInitializeAggregation : public IFunction
 {
 public:
     static constexpr auto name = "initializeAggregation";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionInitializeAggregation>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionInitializeAggregation>(); }
 
     String getName() const override { return name; }
 
@@ -132,7 +132,7 @@ ColumnPtr FunctionInitializeAggregation::executeImpl(const ColumnsWithTypeAndNam
         }
     }
 
-    SCOPE_EXIT({
+    SCOPE_EXIT_MEMORY_SAFE({
         for (size_t i = 0; i < input_rows_count; ++i)
             agg_func.destroy(places[i]);
     });
diff --git a/src/Functions/isConstant.cpp b/src/Functions/isConstant.cpp
index 09e14226b70..12514b71a11 100644
--- a/src/Functions/isConstant.cpp
+++ b/src/Functions/isConstant.cpp
@@ -15,7 +15,7 @@ class FunctionIsConstant : public IFunction
 {
 public:
     static constexpr auto name = "isConstant";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionIsConstant>();
     }
diff --git a/src/Functions/isDecimalOverflow.cpp b/src/Functions/isDecimalOverflow.cpp
index 9104b1f1dee..16d6752e6a5 100644
--- a/src/Functions/isDecimalOverflow.cpp
+++ b/src/Functions/isDecimalOverflow.cpp
@@ -28,7 +28,7 @@ class FunctionIsDecimalOverflow : public IFunction
 public:
     static constexpr auto name = "isDecimalOverflow";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionIsDecimalOverflow>();
     }
diff --git a/src/Functions/isIPAddressContainedIn.cpp b/src/Functions/isIPAddressContainedIn.cpp
index d31e03cb63e..fb5b8a3271d 100644
--- a/src/Functions/isIPAddressContainedIn.cpp
+++ b/src/Functions/isIPAddressContainedIn.cpp
@@ -125,7 +125,7 @@ namespace DB
     public:
         static constexpr auto name = "isIPAddressInRange";
         String getName() const override { return name; }
-        static FunctionPtr create(const Context &) { return std::make_shared<FunctionIsIPAddressContainedIn>(); }
+        static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionIsIPAddressContainedIn>(); }
 
         ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & /* return_type */, size_t input_rows_count) const override
         {
diff --git a/src/Functions/isNotNull.cpp b/src/Functions/isNotNull.cpp
index 104547ac485..0ba240833f5 100644
--- a/src/Functions/isNotNull.cpp
+++ b/src/Functions/isNotNull.cpp
@@ -19,7 +19,7 @@ class FunctionIsNotNull : public IFunction
 public:
     static constexpr auto name = "isNotNull";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionIsNotNull>();
     }
diff --git a/src/Functions/isNull.cpp b/src/Functions/isNull.cpp
index 35ba6b7b86d..142403aedf8 100644
--- a/src/Functions/isNull.cpp
+++ b/src/Functions/isNull.cpp
@@ -18,7 +18,7 @@ class FunctionIsNull : public IFunction
 public:
     static constexpr auto name = "isNull";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionIsNull>();
     }
diff --git a/src/Functions/isZeroOrNull.cpp b/src/Functions/isZeroOrNull.cpp
index ceaa03dee14..d1fd950c22c 100644
--- a/src/Functions/isZeroOrNull.cpp
+++ b/src/Functions/isZeroOrNull.cpp
@@ -26,7 +26,7 @@ class FunctionIsZeroOrNull : public IFunction
 public:
     static constexpr auto name = "isZeroOrNull";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionIsZeroOrNull>();
     }
diff --git a/src/Functions/logTrace.cpp b/src/Functions/logTrace.cpp
index 6f2719588f2..a56d9ef5de1 100644
--- a/src/Functions/logTrace.cpp
+++ b/src/Functions/logTrace.cpp
@@ -21,7 +21,7 @@ namespace
     {
     public:
         static constexpr auto name = "logTrace";
-        static FunctionPtr create(const Context &) { return std::make_shared<FunctionLogTrace>(); }
+        static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionLogTrace>(); }
 
         String getName() const override { return name; }
 
diff --git a/src/Functions/lowCardinalityIndices.cpp b/src/Functions/lowCardinalityIndices.cpp
index 67bee2f0d3f..25834b2b3a8 100644
--- a/src/Functions/lowCardinalityIndices.cpp
+++ b/src/Functions/lowCardinalityIndices.cpp
@@ -21,7 +21,7 @@ class FunctionLowCardinalityIndices: public IFunction
 {
 public:
     static constexpr auto name = "lowCardinalityIndices";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionLowCardinalityIndices>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionLowCardinalityIndices>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/lowCardinalityKeys.cpp b/src/Functions/lowCardinalityKeys.cpp
index a7cb6b45550..5bcc2429592 100644
--- a/src/Functions/lowCardinalityKeys.cpp
+++ b/src/Functions/lowCardinalityKeys.cpp
@@ -19,7 +19,7 @@ class FunctionLowCardinalityKeys: public IFunction
 {
 public:
     static constexpr auto name = "lowCardinalityKeys";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionLowCardinalityKeys>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionLowCardinalityKeys>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/map.cpp b/src/Functions/map.cpp
index 7418691e61b..d2ec10abd1c 100644
--- a/src/Functions/map.cpp
+++ b/src/Functions/map.cpp
@@ -34,7 +34,7 @@ class FunctionMap : public IFunction
 public:
     static constexpr auto name = "map";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionMap>();
     }
@@ -146,7 +146,7 @@ class FunctionMapContains : public IFunction
 {
 public:
     static constexpr auto name = NameMapContains::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMapContains>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMapContains>(); }
 
     String getName() const override
     {
@@ -209,7 +209,7 @@ class FunctionMapKeys : public IFunction
 {
 public:
     static constexpr auto name = "mapKeys";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMapKeys>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMapKeys>(); }
 
     String getName() const override
     {
@@ -256,7 +256,7 @@ class FunctionMapValues : public IFunction
 {
 public:
     static constexpr auto name = "mapValues";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMapValues>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMapValues>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/materialize.h b/src/Functions/materialize.h
index 5b06ac36da7..741669e69d9 100644
--- a/src/Functions/materialize.h
+++ b/src/Functions/materialize.h
@@ -11,7 +11,7 @@ class FunctionMaterialize : public IFunction
 {
 public:
     static constexpr auto name = "materialize";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionMaterialize>();
     }
diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index 8ca92954873..d9be4512851 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -35,7 +35,7 @@ class FunctionMultiIf final : public FunctionIfBase</*null_is_false=*/true>
 {
 public:
     static constexpr auto name = "multiIf";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMultiIf>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMultiIf>(); }
 
     String getName() const override { return name; }
     bool isVariadic() const override { return true; }
diff --git a/src/Functions/neighbor.cpp b/src/Functions/neighbor.cpp
index 598e1225877..e841fe9e79b 100644
--- a/src/Functions/neighbor.cpp
+++ b/src/Functions/neighbor.cpp
@@ -31,7 +31,7 @@ class FunctionNeighbor : public IFunction
 {
 public:
     static constexpr auto name = "neighbor";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionNeighbor>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionNeighbor>(); }
 
     /// Get the name of the function.
     String getName() const override { return name; }
diff --git a/src/Functions/normalizedQueryHash.cpp b/src/Functions/normalizedQueryHash.cpp
index 5704b5301ca..e08680518c1 100644
--- a/src/Functions/normalizedQueryHash.cpp
+++ b/src/Functions/normalizedQueryHash.cpp
@@ -51,7 +51,7 @@ class FunctionNormalizedQueryHash : public IFunction
 {
 public:
     static constexpr auto name = keep_names ? "normalizedQueryHashKeepNames" : "normalizedQueryHash";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionNormalizedQueryHash>();
     }
diff --git a/src/Functions/now.cpp b/src/Functions/now.cpp
index 79870ace007..8d7c185c2af 100644
--- a/src/Functions/now.cpp
+++ b/src/Functions/now.cpp
@@ -83,7 +83,7 @@ public:
     bool isVariadic() const override { return true; }
 
     size_t getNumberOfArguments() const override { return 0; }
-    static FunctionOverloadResolverImplPtr create(const Context &) { return std::make_unique<NowOverloadResolver>(); }
+    static FunctionOverloadResolverImplPtr create(ContextPtr) { return std::make_unique<NowOverloadResolver>(); }
 
     DataTypePtr getReturnType(const ColumnsWithTypeAndName & arguments) const override
     {
diff --git a/src/Functions/now64.cpp b/src/Functions/now64.cpp
index 32c7a95de17..503ce524437 100644
--- a/src/Functions/now64.cpp
+++ b/src/Functions/now64.cpp
@@ -106,7 +106,7 @@ public:
     bool isVariadic() const override { return true; }
 
     size_t getNumberOfArguments() const override { return 0; }
-    static FunctionOverloadResolverImplPtr create(const Context &) { return std::make_unique<Now64OverloadResolver>(); }
+    static FunctionOverloadResolverImplPtr create(ContextPtr) { return std::make_unique<Now64OverloadResolver>(); }
 
     DataTypePtr getReturnType(const ColumnsWithTypeAndName & arguments) const override
     {
diff --git a/src/Functions/nullIf.cpp b/src/Functions/nullIf.cpp
index 200425a7b83..332f85f918f 100644
--- a/src/Functions/nullIf.cpp
+++ b/src/Functions/nullIf.cpp
@@ -18,16 +18,16 @@ namespace
 class FunctionNullIf : public IFunction
 {
 private:
-    const Context & context;
+    ContextPtr context;
 public:
     static constexpr auto name = "nullIf";
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionNullIf>(context);
     }
 
-    explicit FunctionNullIf(const Context & context_) : context(context_) {}
+    explicit FunctionNullIf(ContextPtr context_) : context(context_) {}
 
     std::string getName() const override
     {
diff --git a/src/Functions/partitionId.cpp b/src/Functions/partitionId.cpp
index 39d6f1aff84..f501b120740 100644
--- a/src/Functions/partitionId.cpp
+++ b/src/Functions/partitionId.cpp
@@ -23,7 +23,7 @@ class FunctionPartitionId : public IFunction
 public:
     static constexpr auto name = "partitionId";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionPartitionId>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionPartitionId>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/pointInEllipses.cpp b/src/Functions/pointInEllipses.cpp
index 4edd400d55d..eed564ef988 100644
--- a/src/Functions/pointInEllipses.cpp
+++ b/src/Functions/pointInEllipses.cpp
@@ -39,7 +39,7 @@ class FunctionPointInEllipses : public IFunction
 {
 public:
     static constexpr auto name = "pointInEllipses";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionPointInEllipses>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionPointInEllipses>(); }
 
 private:
 
diff --git a/src/Functions/pointInPolygon.cpp b/src/Functions/pointInPolygon.cpp
index 8e4a05bdec5..842a5010190 100644
--- a/src/Functions/pointInPolygon.cpp
+++ b/src/Functions/pointInPolygon.cpp
@@ -60,10 +60,10 @@ public:
 
     explicit FunctionPointInPolygon(bool validate_) : validate(validate_) {}
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionPointInPolygon<PointInConstPolygonImpl>>(
-            context.getSettingsRef().validate_polygons);
+            context->getSettingsRef().validate_polygons);
     }
 
     String getName() const override
diff --git a/src/Functions/polygonArea.cpp b/src/Functions/polygonArea.cpp
index 7de0869609e..9a36b71d5b1 100644
--- a/src/Functions/polygonArea.cpp
+++ b/src/Functions/polygonArea.cpp
@@ -34,7 +34,7 @@ public:
 
     explicit FunctionPolygonArea() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionPolygonArea>();
     }
diff --git a/src/Functions/polygonConvexHull.cpp b/src/Functions/polygonConvexHull.cpp
index f445b4e4072..5bce3c5bbdd 100644
--- a/src/Functions/polygonConvexHull.cpp
+++ b/src/Functions/polygonConvexHull.cpp
@@ -33,7 +33,7 @@ public:
 
     explicit FunctionPolygonConvexHull() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionPolygonConvexHull>();
     }
diff --git a/src/Functions/polygonPerimeter.cpp b/src/Functions/polygonPerimeter.cpp
index e361fa2a387..5a6e293630e 100644
--- a/src/Functions/polygonPerimeter.cpp
+++ b/src/Functions/polygonPerimeter.cpp
@@ -33,7 +33,7 @@ public:
 
     explicit FunctionPolygonPerimeter() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionPolygonPerimeter>();
     }
diff --git a/src/Functions/polygonsDistance.cpp b/src/Functions/polygonsDistance.cpp
index 074fb5a9798..d6c4ff36e4d 100644
--- a/src/Functions/polygonsDistance.cpp
+++ b/src/Functions/polygonsDistance.cpp
@@ -35,7 +35,7 @@ public:
 
     explicit FunctionPolygonsDistance() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionPolygonsDistance>();
     }
diff --git a/src/Functions/polygonsEquals.cpp b/src/Functions/polygonsEquals.cpp
index 12f4cf09fa5..9e2902d0528 100644
--- a/src/Functions/polygonsEquals.cpp
+++ b/src/Functions/polygonsEquals.cpp
@@ -34,7 +34,7 @@ public:
 
     explicit FunctionPolygonsEquals() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionPolygonsEquals>();
     }
diff --git a/src/Functions/polygonsIntersection.cpp b/src/Functions/polygonsIntersection.cpp
index 8eaf6b97b2b..699488abab1 100644
--- a/src/Functions/polygonsIntersection.cpp
+++ b/src/Functions/polygonsIntersection.cpp
@@ -34,7 +34,7 @@ public:
 
     explicit FunctionPolygonsIntersection() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionPolygonsIntersection>();
     }
diff --git a/src/Functions/polygonsSymDifference.cpp b/src/Functions/polygonsSymDifference.cpp
index a7bdf0af32f..129e553f060 100644
--- a/src/Functions/polygonsSymDifference.cpp
+++ b/src/Functions/polygonsSymDifference.cpp
@@ -34,7 +34,7 @@ public:
 
     explicit FunctionPolygonsSymDifference() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionPolygonsSymDifference>();
     }
diff --git a/src/Functions/polygonsUnion.cpp b/src/Functions/polygonsUnion.cpp
index 834629f90ad..e7281c299d0 100644
--- a/src/Functions/polygonsUnion.cpp
+++ b/src/Functions/polygonsUnion.cpp
@@ -34,7 +34,7 @@ public:
 
     explicit FunctionPolygonsUnion() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionPolygonsUnion>();
     }
diff --git a/src/Functions/polygonsWithin.cpp b/src/Functions/polygonsWithin.cpp
index 68db1494a0d..2fd5b7e2225 100644
--- a/src/Functions/polygonsWithin.cpp
+++ b/src/Functions/polygonsWithin.cpp
@@ -36,7 +36,7 @@ public:
 
     explicit FunctionPolygonsWithin() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionPolygonsWithin>();
     }
diff --git a/src/Functions/randConstant.cpp b/src/Functions/randConstant.cpp
index acc178ae974..f1164beda8d 100644
--- a/src/Functions/randConstant.cpp
+++ b/src/Functions/randConstant.cpp
@@ -79,7 +79,7 @@ public:
     bool isVariadic() const override { return true; }
     size_t getNumberOfArguments() const override { return 0; }
 
-    static FunctionOverloadResolverImplPtr create(const Context &)
+    static FunctionOverloadResolverImplPtr create(ContextPtr)
     {
         return std::make_unique<RandomConstantOverloadResolver<ToType, Name>>();
     }
diff --git a/src/Functions/randomFixedString.cpp b/src/Functions/randomFixedString.cpp
index 2e493ddb43d..b358fc72ba6 100644
--- a/src/Functions/randomFixedString.cpp
+++ b/src/Functions/randomFixedString.cpp
@@ -77,7 +77,7 @@ public:
 class FunctionRandomFixedString : public FunctionRandomFixedStringImpl<TargetSpecific::Default::RandImpl>
 {
 public:
-    explicit FunctionRandomFixedString(const Context & context) : selector(context)
+    explicit FunctionRandomFixedString(ContextPtr context) : selector(context)
     {
         selector.registerImplementation<TargetArch::Default,
             FunctionRandomFixedStringImpl<TargetSpecific::Default::RandImpl>>();
@@ -93,7 +93,7 @@ public:
         return selector.selectAndExecute(arguments, result_type, input_rows_count);
     }
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionRandomFixedString>(context);
     }
diff --git a/src/Functions/randomPrintableASCII.cpp b/src/Functions/randomPrintableASCII.cpp
index ce7f809c151..c70163b237d 100644
--- a/src/Functions/randomPrintableASCII.cpp
+++ b/src/Functions/randomPrintableASCII.cpp
@@ -27,7 +27,7 @@ class FunctionRandomPrintableASCII : public IFunction
 {
 public:
     static constexpr auto name = "randomPrintableASCII";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionRandomPrintableASCII>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionRandomPrintableASCII>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/randomString.cpp b/src/Functions/randomString.cpp
index f51a75c0422..4cc108b1afe 100644
--- a/src/Functions/randomString.cpp
+++ b/src/Functions/randomString.cpp
@@ -97,7 +97,7 @@ public:
 class FunctionRandomString : public FunctionRandomStringImpl<TargetSpecific::Default::RandImpl>
 {
 public:
-    explicit FunctionRandomString(const Context & context) : selector(context)
+    explicit FunctionRandomString(ContextPtr context) : selector(context)
     {
         selector.registerImplementation<TargetArch::Default,
             FunctionRandomStringImpl<TargetSpecific::Default::RandImpl>>();
@@ -113,7 +113,7 @@ public:
         return selector.selectAndExecute(arguments, result_type, input_rows_count);
     }
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionRandomString>(context);
     }
diff --git a/src/Functions/randomStringUTF8.cpp b/src/Functions/randomStringUTF8.cpp
index 163092226f2..7c19993bfaa 100644
--- a/src/Functions/randomStringUTF8.cpp
+++ b/src/Functions/randomStringUTF8.cpp
@@ -30,7 +30,7 @@ class FunctionRandomStringUTF8 : public IFunction
 public:
     static constexpr auto name = "randomStringUTF8";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionRandomStringUTF8>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionRandomStringUTF8>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/readWkt.cpp b/src/Functions/readWkt.cpp
index 47312be2aa0..2ce4becb01c 100644
--- a/src/Functions/readWkt.cpp
+++ b/src/Functions/readWkt.cpp
@@ -68,7 +68,7 @@ public:
         return true;
     }
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionReadWkt<DataTypeName, Geometry, Serializer, NameHolder>>();
     }
diff --git a/src/Functions/regexpQuoteMeta.cpp b/src/Functions/regexpQuoteMeta.cpp
index a5ab5166fe3..0f1ec476a3b 100644
--- a/src/Functions/regexpQuoteMeta.cpp
+++ b/src/Functions/regexpQuoteMeta.cpp
@@ -21,7 +21,7 @@ class FunctionRegexpQuoteMeta : public IFunction
 public:
     static constexpr auto name = "regexpQuoteMeta";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionRegexpQuoteMeta>();
     }
diff --git a/src/Functions/reinterpretAs.cpp b/src/Functions/reinterpretAs.cpp
index 3f4ba3d23e1..f8a7b8eec84 100644
--- a/src/Functions/reinterpretAs.cpp
+++ b/src/Functions/reinterpretAs.cpp
@@ -47,7 +47,7 @@ class FunctionReinterpret : public IFunction
 public:
     static constexpr auto name = "reinterpret";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionReinterpret>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionReinterpret>(); }
 
     String getName() const override { return name; }
 
@@ -349,7 +349,7 @@ class FunctionReinterpretAs : public IFunction
 {
 public:
     static constexpr auto name = Name::name;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionReinterpretAs>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionReinterpretAs>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/repeat.cpp b/src/Functions/repeat.cpp
index 29347d6a275..221dc11a43d 100644
--- a/src/Functions/repeat.cpp
+++ b/src/Functions/repeat.cpp
@@ -173,7 +173,7 @@ class FunctionRepeat : public IFunction
 
 public:
     static constexpr auto name = "repeat";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionRepeat>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionRepeat>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/replicate.cpp b/src/Functions/replicate.cpp
index ca391bec6ce..4a452498417 100644
--- a/src/Functions/replicate.cpp
+++ b/src/Functions/replicate.cpp
@@ -4,6 +4,7 @@
 #include <Functions/FunctionHelpers.h>
 #include <DataTypes/DataTypeArray.h>
 #include <Columns/ColumnArray.h>
+#include <Interpreters/Context.h>
 
 
 namespace DB
diff --git a/src/Functions/replicate.h b/src/Functions/replicate.h
index 9a33951b2a3..a778114ffe9 100644
--- a/src/Functions/replicate.h
+++ b/src/Functions/replicate.h
@@ -1,11 +1,11 @@
 #pragma once
+
 #include <Functions/IFunctionImpl.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
 
-class Context;
-
 /// Creates an array, multiplying the column (the first argument) by the number of elements in the array (the second argument).
 /// Function may accept more then two arguments. If so, the first array with non-empty offsets is chosen.
 class FunctionReplicate : public IFunction
@@ -13,7 +13,7 @@ class FunctionReplicate : public IFunction
 public:
     static constexpr auto name = "replicate";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionReplicate>();
     }
diff --git a/src/Functions/reverse.cpp b/src/Functions/reverse.cpp
index 16676eaa936..ec29958dd48 100644
--- a/src/Functions/reverse.cpp
+++ b/src/Functions/reverse.cpp
@@ -57,7 +57,7 @@ class FunctionReverse : public IFunction
 {
 public:
     static constexpr auto name = "reverse";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionReverse>();
     }
@@ -117,9 +117,9 @@ class ReverseOverloadResolver : public IFunctionOverloadResolverImpl
 {
 public:
     static constexpr auto name = "reverse";
-    static FunctionOverloadResolverImplPtr create(const Context & context) { return std::make_unique<ReverseOverloadResolver>(context); }
+    static FunctionOverloadResolverImplPtr create(ContextPtr context) { return std::make_unique<ReverseOverloadResolver>(context); }
 
-    explicit ReverseOverloadResolver(const Context & context_) : context(context_) {}
+    explicit ReverseOverloadResolver(ContextPtr context_) : context(context_) {}
 
     String getName() const override { return name; }
     size_t getNumberOfArguments() const override { return 1; }
@@ -141,7 +141,7 @@ public:
     }
 
 private:
-    const Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Functions/rowNumberInAllBlocks.cpp b/src/Functions/rowNumberInAllBlocks.cpp
index 3aeaade7137..06b6e7c81b0 100644
--- a/src/Functions/rowNumberInAllBlocks.cpp
+++ b/src/Functions/rowNumberInAllBlocks.cpp
@@ -18,7 +18,7 @@ private:
 
 public:
     static constexpr auto name = "rowNumberInAllBlocks";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionRowNumberInAllBlocks>();
     }
diff --git a/src/Functions/rowNumberInBlock.cpp b/src/Functions/rowNumberInBlock.cpp
index 0a5cf63041f..7359a1c5f40 100644
--- a/src/Functions/rowNumberInBlock.cpp
+++ b/src/Functions/rowNumberInBlock.cpp
@@ -13,7 +13,7 @@ class FunctionRowNumberInBlock : public IFunction
 {
 public:
     static constexpr auto name = "rowNumberInBlock";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionRowNumberInBlock>();
     }
diff --git a/src/Functions/runningAccumulate.cpp b/src/Functions/runningAccumulate.cpp
index 1a01b88e22c..7c1b1f7162e 100644
--- a/src/Functions/runningAccumulate.cpp
+++ b/src/Functions/runningAccumulate.cpp
@@ -5,7 +5,7 @@
 #include <DataTypes/DataTypeAggregateFunction.h>
 #include <Common/AlignedBuffer.h>
 #include <Common/Arena.h>
-#include <ext/scope_guard.h>
+#include <ext/scope_guard_safe.h>
 
 
 namespace DB
@@ -33,7 +33,7 @@ class FunctionRunningAccumulate : public IFunction
 {
 public:
     static constexpr auto name = "runningAccumulate";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionRunningAccumulate>();
     }
@@ -104,7 +104,7 @@ public:
         const auto & states = column_with_states->getData();
 
         bool state_created = false;
-        SCOPE_EXIT({
+        SCOPE_EXIT_MEMORY_SAFE({
             if (state_created)
                 agg_func.destroy(place.data());
         });
diff --git a/src/Functions/runningConcurrency.cpp b/src/Functions/runningConcurrency.cpp
index e8be7b9c200..8403fc93c33 100644
--- a/src/Functions/runningConcurrency.cpp
+++ b/src/Functions/runningConcurrency.cpp
@@ -154,7 +154,7 @@ namespace DB
     public:
         static constexpr auto name = Name::name;
 
-        static FunctionOverloadResolverImplPtr create(const Context &)
+        static FunctionOverloadResolverImplPtr create(ContextPtr)
         {
             return std::make_unique<RunningConcurrencyOverloadResolver<Name, ConcurrencyDataType>>();
         }
diff --git a/src/Functions/runningDifference.h b/src/Functions/runningDifference.h
index db32b5f9a3f..4cd53d7b53a 100644
--- a/src/Functions/runningDifference.h
+++ b/src/Functions/runningDifference.h
@@ -124,7 +124,7 @@ private:
 public:
     static constexpr auto name = FunctionRunningDifferenceName<is_first_line_zero>::name;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionRunningDifferenceImpl<is_first_line_zero>>();
     }
diff --git a/src/Functions/sleep.h b/src/Functions/sleep.h
index 65566e36d1f..a3de2d13677 100644
--- a/src/Functions/sleep.h
+++ b/src/Functions/sleep.h
@@ -8,6 +8,7 @@
 #include <Common/assert_cast.h>
 #include <common/sleep.h>
 #include <IO/WriteHelpers.h>
+#include <Interpreters/Context_fwd.h>
 
 
 namespace DB
@@ -35,7 +36,7 @@ class FunctionSleep : public IFunction
 {
 public:
     static constexpr auto name = variant == FunctionSleepVariant::PerBlock ? "sleep" : "sleepEachRow";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionSleep<variant>>();
     }
diff --git a/src/Functions/stringToH3.cpp b/src/Functions/stringToH3.cpp
index 575382ec40f..9b02711db50 100644
--- a/src/Functions/stringToH3.cpp
+++ b/src/Functions/stringToH3.cpp
@@ -34,7 +34,7 @@ class FunctionStringToH3 : public IFunction
 public:
     static constexpr auto name = "stringToH3";
 
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionStringToH3>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionStringToH3>(); }
 
     std::string getName() const override { return name; }
 
diff --git a/src/Functions/substring.cpp b/src/Functions/substring.cpp
index 3fe82b5e0b0..cac1688c81a 100644
--- a/src/Functions/substring.cpp
+++ b/src/Functions/substring.cpp
@@ -36,7 +36,7 @@ class FunctionSubstring : public IFunction
 {
 public:
     static constexpr auto name = is_utf8 ? "substringUTF8" : "substring";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionSubstring>();
     }
diff --git a/src/Functions/svg.cpp b/src/Functions/svg.cpp
index d8a16af1e1d..39473816c8c 100644
--- a/src/Functions/svg.cpp
+++ b/src/Functions/svg.cpp
@@ -24,7 +24,7 @@ public:
 
     explicit FunctionSvg() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionSvg>();
     }
diff --git a/src/Functions/tcpPort.cpp b/src/Functions/tcpPort.cpp
index 26991c900ab..484843ced3f 100644
--- a/src/Functions/tcpPort.cpp
+++ b/src/Functions/tcpPort.cpp
@@ -14,9 +14,9 @@ class FunctionTcpPort : public IFunction
 public:
     static constexpr auto name = "tcpPort";
 
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<FunctionTcpPort>(context.getTCPPort());
+        return std::make_shared<FunctionTcpPort>(context->getTCPPort());
     }
 
     explicit FunctionTcpPort(UInt16 port_) : port(port_)
diff --git a/src/Functions/throwIf.cpp b/src/Functions/throwIf.cpp
index f74ab29186a..d12a90119b9 100644
--- a/src/Functions/throwIf.cpp
+++ b/src/Functions/throwIf.cpp
@@ -26,7 +26,7 @@ class FunctionThrowIf : public IFunction
 {
 public:
     static constexpr auto name = "throwIf";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionThrowIf>();
     }
diff --git a/src/Functions/tid.cpp b/src/Functions/tid.cpp
index 44321deb15f..d5402a00da3 100644
--- a/src/Functions/tid.cpp
+++ b/src/Functions/tid.cpp
@@ -13,7 +13,7 @@ namespace
     {
     public:
         static constexpr auto name = "tid";
-        static FunctionPtr create(const Context &) { return std::make_shared<FunctionTid>(); }
+        static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionTid>(); }
 
         String getName() const override { return name; }
 
diff --git a/src/Functions/timeSlots.cpp b/src/Functions/timeSlots.cpp
index ef5902eba11..9af16bf6fe0 100644
--- a/src/Functions/timeSlots.cpp
+++ b/src/Functions/timeSlots.cpp
@@ -109,7 +109,7 @@ class FunctionTimeSlots : public IFunction
 public:
     static constexpr auto name = "timeSlots";
     static constexpr UInt32 TIME_SLOT_SIZE = 1800;
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionTimeSlots>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionTimeSlots>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/timezone.cpp b/src/Functions/timezone.cpp
index 2cd0c28612b..178bfe76dc9 100644
--- a/src/Functions/timezone.cpp
+++ b/src/Functions/timezone.cpp
@@ -16,7 +16,7 @@ class FunctionTimezone : public IFunction
 {
 public:
     static constexpr auto name = "timezone";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionTimezone>();
     }
diff --git a/src/Functions/timezoneOf.cpp b/src/Functions/timezoneOf.cpp
index 1d007a6e10e..dd399b8be26 100644
--- a/src/Functions/timezoneOf.cpp
+++ b/src/Functions/timezoneOf.cpp
@@ -82,7 +82,7 @@ class FunctionTimezoneOfBuilder : public IFunctionOverloadResolverImpl
 public:
     static constexpr auto name = "timezoneOf";
     String getName() const override { return name; }
-    static FunctionOverloadResolverImplPtr create(const Context &) { return std::make_unique<FunctionTimezoneOfBuilder>(); }
+    static FunctionOverloadResolverImplPtr create(ContextPtr) { return std::make_unique<FunctionTimezoneOfBuilder>(); }
 
     size_t getNumberOfArguments() const override { return 1; }
 
diff --git a/src/Functions/toColumnTypeName.cpp b/src/Functions/toColumnTypeName.cpp
index 2b59accba84..56b464a0b01 100644
--- a/src/Functions/toColumnTypeName.cpp
+++ b/src/Functions/toColumnTypeName.cpp
@@ -14,7 +14,7 @@ class FunctionToColumnTypeName : public IFunction
 {
 public:
     static constexpr auto name = "toColumnTypeName";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionToColumnTypeName>();
     }
diff --git a/src/Functions/toFixedString.h b/src/Functions/toFixedString.h
index 23c9e92faaf..3911a758a51 100644
--- a/src/Functions/toFixedString.h
+++ b/src/Functions/toFixedString.h
@@ -32,7 +32,7 @@ class FunctionToFixedString : public IFunction
 {
 public:
     static constexpr auto name = "toFixedString";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionToFixedString>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionToFixedString>(); }
     static FunctionPtr create() { return std::make_shared<FunctionToFixedString>(); }
 
     String getName() const override
diff --git a/src/Functions/toLowCardinality.cpp b/src/Functions/toLowCardinality.cpp
index fe06b2d6087..4e35d2e1b32 100644
--- a/src/Functions/toLowCardinality.cpp
+++ b/src/Functions/toLowCardinality.cpp
@@ -14,7 +14,7 @@ class FunctionToLowCardinality: public IFunction
 {
 public:
     static constexpr auto name = "toLowCardinality";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionToLowCardinality>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionToLowCardinality>(); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/toModifiedJulianDay.cpp b/src/Functions/toModifiedJulianDay.cpp
index 32e9eb23987..3450de95a32 100644
--- a/src/Functions/toModifiedJulianDay.cpp
+++ b/src/Functions/toModifiedJulianDay.cpp
@@ -172,7 +172,7 @@ namespace DB
     public:
         static constexpr auto name = Name::name;
 
-        static FunctionOverloadResolverImplPtr create(const Context &)
+        static FunctionOverloadResolverImplPtr create(ContextPtr)
         {
             return std::make_unique<ToModifiedJulianDayOverloadResolver<Name, ToDataType, nullOnErrors>>();
         }
diff --git a/src/Functions/toNullable.cpp b/src/Functions/toNullable.cpp
index 5758fe41adf..af64142798e 100644
--- a/src/Functions/toNullable.cpp
+++ b/src/Functions/toNullable.cpp
@@ -16,7 +16,7 @@ class FunctionToNullable : public IFunction
 public:
     static constexpr auto name = "toNullable";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionToNullable>();
     }
diff --git a/src/Functions/toStartOfInterval.cpp b/src/Functions/toStartOfInterval.cpp
index f194da166aa..d21565f9cf0 100644
--- a/src/Functions/toStartOfInterval.cpp
+++ b/src/Functions/toStartOfInterval.cpp
@@ -184,7 +184,7 @@ namespace
 class FunctionToStartOfInterval : public IFunction
 {
 public:
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionToStartOfInterval>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionToStartOfInterval>(); }
 
     static constexpr auto name = function_name;
     String getName() const override { return name; }
diff --git a/src/Functions/toTimezone.cpp b/src/Functions/toTimezone.cpp
index d12f926b284..a5df3a87f2b 100644
--- a/src/Functions/toTimezone.cpp
+++ b/src/Functions/toTimezone.cpp
@@ -25,7 +25,7 @@ class FunctionToTimezone : public IFunction
 {
 public:
     static constexpr auto name = "toTimezone";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionToTimezone>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionToTimezone>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/toTypeName.cpp b/src/Functions/toTypeName.cpp
index 5de07e1d386..92d24b1dc99 100644
--- a/src/Functions/toTypeName.cpp
+++ b/src/Functions/toTypeName.cpp
@@ -65,7 +65,7 @@ class FunctionToTypeNameBuilder : public IFunctionOverloadResolverImpl
 public:
     static constexpr auto name = "toTypeName";
     String getName() const override { return name; }
-    static FunctionOverloadResolverImplPtr create(const Context &) { return std::make_unique<FunctionToTypeNameBuilder>(); }
+    static FunctionOverloadResolverImplPtr create(ContextPtr) { return std::make_unique<FunctionToTypeNameBuilder>(); }
 
     size_t getNumberOfArguments() const override { return 1; }
 
diff --git a/src/Functions/today.cpp b/src/Functions/today.cpp
index 511af881d73..65e94c047e6 100644
--- a/src/Functions/today.cpp
+++ b/src/Functions/today.cpp
@@ -71,7 +71,7 @@ public:
 
     size_t getNumberOfArguments() const override { return 0; }
 
-    static FunctionOverloadResolverImplPtr create(const Context &) { return std::make_unique<TodayOverloadResolver>(); }
+    static FunctionOverloadResolverImplPtr create(ContextPtr) { return std::make_unique<TodayOverloadResolver>(); }
 
     DataTypePtr getReturnType(const DataTypes &) const override { return std::make_shared<DataTypeDate>(); }
 
diff --git a/src/Functions/transform.cpp b/src/Functions/transform.cpp
index 07fbd5a7b96..b7c2b584ba0 100644
--- a/src/Functions/transform.cpp
+++ b/src/Functions/transform.cpp
@@ -58,7 +58,7 @@ class FunctionTransform : public IFunction
 {
 public:
     static constexpr auto name = "transform";
-    static FunctionPtr create(const Context &) { return std::make_shared<FunctionTransform>(); }
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionTransform>(); }
 
     String getName() const override
     {
diff --git a/src/Functions/trap.cpp b/src/Functions/trap.cpp
index 61ec52a1d07..f946a7fabfb 100644
--- a/src/Functions/trap.cpp
+++ b/src/Functions/trap.cpp
@@ -32,16 +32,16 @@ namespace ErrorCodes
 class FunctionTrap : public IFunction
 {
 private:
-    const Context & context;
+    ContextPtr context;
 
 public:
     static constexpr auto name = "trap";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
         return std::make_shared<FunctionTrap>(context);
     }
 
-    FunctionTrap(const Context & context_) : context(context_) {}
+    FunctionTrap(ContextPtr context_) : context(context_) {}
 
     String getName() const override
     {
diff --git a/src/Functions/tuple.cpp b/src/Functions/tuple.cpp
index 308090eb9bb..80a6f284bea 100644
--- a/src/Functions/tuple.cpp
+++ b/src/Functions/tuple.cpp
@@ -24,7 +24,7 @@ class FunctionTuple : public IFunction
 public:
     static constexpr auto name = "tuple";
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionTuple>();
     }
diff --git a/src/Functions/tupleElement.cpp b/src/Functions/tupleElement.cpp
index dbfa802a414..ecf1ed5203f 100644
--- a/src/Functions/tupleElement.cpp
+++ b/src/Functions/tupleElement.cpp
@@ -30,7 +30,7 @@ class FunctionTupleElement : public IFunction
 {
 public:
     static constexpr auto name = "tupleElement";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionTupleElement>();
     }
diff --git a/src/Functions/tupleHammingDistance.cpp b/src/Functions/tupleHammingDistance.cpp
index 0fd21e0ea91..9d660e388cb 100644
--- a/src/Functions/tupleHammingDistance.cpp
+++ b/src/Functions/tupleHammingDistance.cpp
@@ -19,14 +19,14 @@ namespace ErrorCodes
 class FunctionTupleHammingDistance : public IFunction
 {
 private:
-    const Context & context;
+    ContextPtr context;
 
 public:
     static constexpr auto name = "tupleHammingDistance";
     using ResultType = UInt8;
 
-    explicit FunctionTupleHammingDistance(const Context & context_) : context(context_) {}
-    static FunctionPtr create(const Context & context) { return std::make_shared<FunctionTupleHammingDistance>(context); }
+    explicit FunctionTupleHammingDistance(ContextPtr context_) : context(context_) {}
+    static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionTupleHammingDistance>(context); }
 
     String getName() const override { return name; }
 
diff --git a/src/Functions/uptime.cpp b/src/Functions/uptime.cpp
index b5662a87c93..f31cb2b0d17 100644
--- a/src/Functions/uptime.cpp
+++ b/src/Functions/uptime.cpp
@@ -13,9 +13,9 @@ class FunctionUptime : public IFunction
 {
 public:
     static constexpr auto name = "uptime";
-    static FunctionPtr create(const Context & context)
+    static FunctionPtr create(ContextPtr context)
     {
-        return std::make_shared<FunctionUptime>(context.getUptimeSeconds());
+        return std::make_shared<FunctionUptime>(context->getUptimeSeconds());
     }
 
     explicit FunctionUptime(time_t uptime_) : uptime(uptime_)
diff --git a/src/Functions/version.cpp b/src/Functions/version.cpp
index 37f9c7b1e98..0af269d8f89 100644
--- a/src/Functions/version.cpp
+++ b/src/Functions/version.cpp
@@ -16,7 +16,7 @@ class FunctionVersion : public IFunction
 {
 public:
     static constexpr auto name = "version";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionVersion>();
     }
diff --git a/src/Functions/visibleWidth.cpp b/src/Functions/visibleWidth.cpp
index ed4d2b3d501..7a2a2f54f45 100644
--- a/src/Functions/visibleWidth.cpp
+++ b/src/Functions/visibleWidth.cpp
@@ -19,7 +19,7 @@ class FunctionVisibleWidth : public IFunction
 {
 public:
     static constexpr auto name = "visibleWidth";
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionVisibleWidth>();
     }
diff --git a/src/Functions/wkt.cpp b/src/Functions/wkt.cpp
index 1d509a7c508..b5567a19e89 100644
--- a/src/Functions/wkt.cpp
+++ b/src/Functions/wkt.cpp
@@ -16,7 +16,7 @@ public:
 
     explicit FunctionWkt() = default;
 
-    static FunctionPtr create(const Context &)
+    static FunctionPtr create(ContextPtr)
     {
         return std::make_shared<FunctionWkt>();
     }
diff --git a/src/Functions/yesterday.cpp b/src/Functions/yesterday.cpp
index 7c0d1ebd38b..76c4e1c1d16 100644
--- a/src/Functions/yesterday.cpp
+++ b/src/Functions/yesterday.cpp
@@ -69,7 +69,7 @@ public:
 
     size_t getNumberOfArguments() const override { return 0; }
 
-    static FunctionOverloadResolverImplPtr create(const Context &) { return std::make_unique<YesterdayOverloadResolver>(); }
+    static FunctionOverloadResolverImplPtr create(ContextPtr) { return std::make_unique<YesterdayOverloadResolver>(); }
 
     DataTypePtr getReturnType(const DataTypes &) const override { return std::make_shared<DataTypeDate>(); }
 
diff --git a/src/IO/ConnectionTimeouts.h b/src/IO/ConnectionTimeouts.h
index 5f12a4edc79..ba3be840e77 100644
--- a/src/IO/ConnectionTimeouts.h
+++ b/src/IO/ConnectionTimeouts.h
@@ -1,11 +1,12 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
+
 #include <Poco/Timespan.h>
 
 namespace DB
 {
 
-class Context;
 struct Settings;
 
 struct ConnectionTimeouts
@@ -110,7 +111,7 @@ struct ConnectionTimeouts
     static ConnectionTimeouts getTCPTimeoutsWithoutFailover(const Settings & settings);
     /// Timeouts for the case when we will try many addresses in a loop.
     static ConnectionTimeouts getTCPTimeoutsWithFailover(const Settings & settings);
-    static ConnectionTimeouts getHTTPTimeouts(const Context & context);
+    static ConnectionTimeouts getHTTPTimeouts(ContextPtr context);
 };
 
 }
diff --git a/src/IO/ConnectionTimeoutsContext.h b/src/IO/ConnectionTimeoutsContext.h
index 1e688ff3798..8d6f96b82a3 100644
--- a/src/IO/ConnectionTimeoutsContext.h
+++ b/src/IO/ConnectionTimeoutsContext.h
@@ -27,10 +27,10 @@ inline ConnectionTimeouts ConnectionTimeouts::getTCPTimeoutsWithFailover(const S
         settings.receive_data_timeout_ms);
 }
 
-inline ConnectionTimeouts ConnectionTimeouts::getHTTPTimeouts(const Context & context)
+inline ConnectionTimeouts ConnectionTimeouts::getHTTPTimeouts(ContextPtr context)
 {
-    const auto & settings = context.getSettingsRef();
-    const auto & config = context.getConfigRef();
+    const auto & settings = context->getSettingsRef();
+    const auto & config = context->getConfigRef();
     Poco::Timespan http_keep_alive_timeout{config.getUInt("keep_alive_timeout", 10), 0};
     return ConnectionTimeouts(settings.http_connection_timeout, settings.http_send_timeout, settings.http_receive_timeout, settings.tcp_keep_alive_timeout, http_keep_alive_timeout);
 }
diff --git a/src/IO/PeekableReadBuffer.cpp b/src/IO/PeekableReadBuffer.cpp
index 15fdd9448ec..c7cef777afc 100644
--- a/src/IO/PeekableReadBuffer.cpp
+++ b/src/IO/PeekableReadBuffer.cpp
@@ -175,7 +175,7 @@ bool PeekableReadBuffer::nextImpl()
 
     if (checkpoint_at_end)
     {
-        checkpoint.emplace(working_buffer.begin());
+        checkpoint.emplace(position());
         peeked_size = 0;
         checkpoint_in_own_memory = false;
     }
diff --git a/src/IO/ReadHelpers.h b/src/IO/ReadHelpers.h
index 369237f329d..cf25b819e6c 100644
--- a/src/IO/ReadHelpers.h
+++ b/src/IO/ReadHelpers.h
@@ -773,7 +773,8 @@ inline ReturnType readDateTimeTextImpl(DateTime64 & datetime64, UInt32 scale, Re
         while (!buf.eof() && isNumericASCII(*buf.position()))
             ++buf.position();
     }
-    else if (scale && (whole >= 1000000000LL * scale))
+    /// 9908870400 is time_t value for 2184-01-01 UTC (a bit over the last year supported by DateTime64)
+    else if (whole >= 9908870400LL)
     {
         /// Unix timestamp with subsecond precision, already scaled to integer.
         /// For disambiguation we support only time since 2001-09-09 01:46:40 UTC and less than 30 000 years in future.
diff --git a/src/IO/S3/PocoHTTPClient.cpp b/src/IO/S3/PocoHTTPClient.cpp
index c31c12a1899..6bd6d0d36ba 100644
--- a/src/IO/S3/PocoHTTPClient.cpp
+++ b/src/IO/S3/PocoHTTPClient.cpp
@@ -259,7 +259,11 @@ void PocoHTTPClient::makeRequestInternal(
                 String error_message;
                 Poco::StreamCopier::copyToString(response_body_stream, error_message);
 
-                response->SetClientErrorType(Aws::Client::CoreErrors::NETWORK_CONNECTION);
+                if (Aws::Http::IsRetryableHttpResponseCode(response->GetResponseCode()))
+                    response->SetClientErrorType(Aws::Client::CoreErrors::NETWORK_CONNECTION);
+                else
+                    response->SetClientErrorType(Aws::Client::CoreErrors::USER_CANCELLED);
+
                 response->SetClientErrorMessage(error_message);
 
                 if (status_code == 429 || status_code == 503)
diff --git a/src/Interpreters/ActionLocksManager.cpp b/src/Interpreters/ActionLocksManager.cpp
index 76e5228bec3..0f9b4d01bdf 100644
--- a/src/Interpreters/ActionLocksManager.cpp
+++ b/src/Interpreters/ActionLocksManager.cpp
@@ -19,29 +19,27 @@ namespace ActionLocks
 }
 
 
-ActionLocksManager::ActionLocksManager(const Context & context)
-        : global_context(context.getGlobalContext())
+ActionLocksManager::ActionLocksManager(ContextPtr context_) : WithContext(context_->getGlobalContext())
 {
 }
 
 template <typename F>
-inline void forEachTable(F && f, const Context & context)
+inline void forEachTable(F && f, ContextPtr context)
 {
     for (auto & elem : DatabaseCatalog::instance().getDatabases())
         for (auto iterator = elem.second->getTablesIterator(context); iterator->isValid(); iterator->next())
             if (auto table = iterator->table())
                 f(table);
-
 }
 
-void ActionLocksManager::add(StorageActionBlockType action_type, const Context & context)
+void ActionLocksManager::add(StorageActionBlockType action_type, ContextPtr context_)
 {
-    forEachTable([&](const StoragePtr & table) { add(table, action_type); }, context);
+    forEachTable([&](const StoragePtr & table) { add(table, action_type); }, context_);
 }
 
 void ActionLocksManager::add(const StorageID & table_id, StorageActionBlockType action_type)
 {
-    if (auto table = DatabaseCatalog::instance().tryGetTable(table_id, global_context))
+    if (auto table = DatabaseCatalog::instance().tryGetTable(table_id, getContext()))
         add(table, action_type);
 }
 
@@ -66,7 +64,7 @@ void ActionLocksManager::remove(StorageActionBlockType action_type)
 
 void ActionLocksManager::remove(const StorageID & table_id, StorageActionBlockType action_type)
 {
-    if (auto table = DatabaseCatalog::instance().tryGetTable(table_id, global_context))
+    if (auto table = DatabaseCatalog::instance().tryGetTable(table_id, getContext()))
         remove(table, action_type);
 }
 
diff --git a/src/Interpreters/ActionLocksManager.h b/src/Interpreters/ActionLocksManager.h
index a39d8b5784f..f030afec891 100644
--- a/src/Interpreters/ActionLocksManager.h
+++ b/src/Interpreters/ActionLocksManager.h
@@ -1,9 +1,10 @@
 #pragma once
 
-#include <common/types.h>
+#include <Interpreters/Context_fwd.h>
+#include <Interpreters/StorageID.h>
 #include <Storages/IStorage_fwd.h>
 #include <Common/ActionLock.h>
-#include <Interpreters/StorageID.h>
+#include <common/types.h>
 
 #include <mutex>
 #include <unordered_map>
@@ -12,17 +13,15 @@
 namespace DB
 {
 
-class Context;
-
 /// Holds ActionLocks for tables
 /// Does not store pointers to tables
-class ActionLocksManager
+class ActionLocksManager : WithContext
 {
 public:
-    ActionLocksManager(const Context & context);
+    explicit ActionLocksManager(ContextPtr context);
 
     /// Adds new locks for each table
-    void add(StorageActionBlockType action_type, const Context & context);
+    void add(StorageActionBlockType action_type, ContextPtr context);
     /// Add new lock for a table if it has not been already added
     void add(const StorageID & table_id, StorageActionBlockType action_type);
     void add(const StoragePtr & table, StorageActionBlockType action_type);
@@ -43,7 +42,6 @@ private:
 
     mutable std::mutex mutex;
     StorageLocks storage_locks;
-    const Context & global_context;
 };
 
 }
diff --git a/src/Interpreters/ActionsDAG.cpp b/src/Interpreters/ActionsDAG.cpp
index f5bde5d23e7..4d2465b6e93 100644
--- a/src/Interpreters/ActionsDAG.cpp
+++ b/src/Interpreters/ActionsDAG.cpp
@@ -1349,7 +1349,7 @@ ColumnsWithTypeAndName prepareFunctionArguments(const ActionsDAG::NodeRawConstPt
 /// Create actions which calculate conjunction of selected nodes.
 /// Assume conjunction nodes are predicates (and may be used as arguments of function AND).
 ///
-/// Result actions add single column with conjunction result (it is always last in index).
+/// Result actions add single column with conjunction result (it is always first in index).
 /// No other columns are added or removed.
 ActionsDAGPtr ActionsDAG::cloneActionsForConjunction(NodeRawConstPtrs conjunction, const ColumnsWithTypeAndName & all_inputs)
 {
@@ -1414,6 +1414,20 @@ ActionsDAGPtr ActionsDAG::cloneActionsForConjunction(NodeRawConstPtrs conjunctio
         }
     }
 
+    const Node * result_predicate = nodes_mapping[*conjunction.begin()];
+
+    if (conjunction.size() > 1)
+    {
+        NodeRawConstPtrs args;
+        args.reserve(conjunction.size());
+        for (const auto * predicate : conjunction)
+            args.emplace_back(nodes_mapping[predicate]);
+
+        result_predicate = &actions->addFunction(func_builder_and, std::move(args), {});
+    }
+
+    actions->index.push_back(result_predicate);
+
     for (const auto & col : all_inputs)
     {
         const Node * input;
@@ -1430,19 +1444,6 @@ ActionsDAGPtr ActionsDAG::cloneActionsForConjunction(NodeRawConstPtrs conjunctio
         actions->index.push_back(input);
     }
 
-    const Node * result_predicate = nodes_mapping[*conjunction.begin()];
-
-    if (conjunction.size() > 1)
-    {
-        NodeRawConstPtrs args;
-        args.reserve(conjunction.size());
-        for (const auto * predicate : conjunction)
-            args.emplace_back(nodes_mapping[predicate]);
-
-        result_predicate = &actions->addFunction(func_builder_and, std::move(args), {});
-    }
-
-    actions->index.push_back(result_predicate);
     return actions;
 }
 
@@ -1458,6 +1459,11 @@ ActionsDAGPtr ActionsDAG::cloneActionsForFilterPushDown(
                             "Index for ActionsDAG does not contain filter column name {}. DAG:\n{}",
                             filter_name, dumpDAG());
 
+    /// If condition is constant let's do nothing.
+    /// It means there is nothing to push down or optimization was already applied.
+    if (predicate->type == ActionType::COLUMN)
+        return nullptr;
+
     std::unordered_set<const Node *> allowed_nodes;
 
     /// Get input nodes from available_inputs names.
@@ -1507,7 +1513,19 @@ ActionsDAGPtr ActionsDAG::cloneActionsForFilterPushDown(
             node.result_name = std::move(predicate->result_name);
             node.result_type = std::move(predicate->result_type);
             node.column = node.result_type->createColumnConst(0, 1);
-            *predicate = std::move(node);
+
+            if (predicate->type != ActionType::INPUT)
+                *predicate = std::move(node);
+            else
+            {
+                /// Special case. We cannot replace input to constant inplace.
+                /// Because we cannot affect inputs list for actions.
+                /// So we just add a new constant and update index.
+                const auto * new_predicate = &addNode(node);
+                for (auto & index_node : index)
+                    if (index_node == predicate)
+                        index_node = new_predicate;
+            }
         }
 
         removeUnusedActions(false);
diff --git a/src/Interpreters/ActionsDAG.h b/src/Interpreters/ActionsDAG.h
index 88ce2818a26..bdfb4644f5b 100644
--- a/src/Interpreters/ActionsDAG.h
+++ b/src/Interpreters/ActionsDAG.h
@@ -3,6 +3,7 @@
 #include <Core/ColumnsWithTypeAndName.h>
 #include <Core/NamesAndTypes.h>
 #include <Core/Names.h>
+#include <Interpreters/Context_fwd.h>
 
 #if !defined(ARCADIA_BUILD)
 #    include "config_core.h"
@@ -220,7 +221,7 @@ public:
     /// Create actions which may calculate part of filter using only available_inputs.
     /// If nothing may be calculated, returns nullptr.
     /// Otherwise, return actions which inputs are from available_inputs.
-    /// Returned actions add single column which may be used for filter.
+    /// Returned actions add single column which may be used for filter. Added column will be the first one.
     /// Also, replace some nodes of current inputs to constant 1 in case they are filtered.
     ///
     /// @param all_inputs should contain inputs from previous step, which will be used for result actions.
@@ -231,9 +232,9 @@ public:
     /// Pushed condition: z > 0
     /// GROUP BY step will transform columns `x, y, z` -> `sum(x), y, z`
     /// If we just add filter step with actions `z -> z > 0` before GROUP BY,
-    /// columns will be transformed like `x, y, z` -> `z, z > 0, x, y` -(remove filter)-> `z, x, y`.
+    /// columns will be transformed like `x, y, z` -> `z > 0, z, x, y` -(remove filter)-> `z, x, y`.
     /// To avoid it, add inputs from `all_inputs` list,
-    /// so actions `x, y, z -> x, y, z, z > 0` -(remove filter)-> `x, y, z` will not change columns order.
+    /// so actions `x, y, z -> z > 0, x, y, z` -(remove filter)-> `x, y, z` will not change columns order.
     ActionsDAGPtr cloneActionsForFilterPushDown(
         const std::string & filter_name,
         bool can_remove_filter,
diff --git a/src/Interpreters/ActionsVisitor.cpp b/src/Interpreters/ActionsVisitor.cpp
index 9045ed2c64f..21abf36c51c 100644
--- a/src/Interpreters/ActionsVisitor.cpp
+++ b/src/Interpreters/ActionsVisitor.cpp
@@ -127,7 +127,7 @@ static Block createBlockFromCollection(const Collection & collection, const Data
     return res;
 }
 
-static Field extractValueFromNode(const ASTPtr & node, const IDataType & type, const Context & context)
+static Field extractValueFromNode(const ASTPtr & node, const IDataType & type, ContextPtr context)
 {
     if (const auto * lit = node->as<ASTLiteral>())
     {
@@ -142,7 +142,7 @@ static Field extractValueFromNode(const ASTPtr & node, const IDataType & type, c
         throw Exception("Incorrect element of set. Must be literal or constant expression.", ErrorCodes::INCORRECT_ELEMENT_OF_SET);
 }
 
-static Block createBlockFromAST(const ASTPtr & node, const DataTypes & types, const Context & context)
+static Block createBlockFromAST(const ASTPtr & node, const DataTypes & types, ContextPtr context)
 {
     /// Will form a block with values from the set.
 
@@ -156,7 +156,7 @@ static Block createBlockFromAST(const ASTPtr & node, const DataTypes & types, co
     DataTypePtr tuple_type;
     Row tuple_values;
     const auto & list = node->as<ASTExpressionList &>();
-    bool transform_null_in = context.getSettingsRef().transform_null_in;
+    bool transform_null_in = context->getSettingsRef().transform_null_in;
     for (const auto & elem : list.children)
     {
         if (num_columns == 1)
@@ -245,7 +245,7 @@ Block createBlockForSet(
     const DataTypePtr & left_arg_type,
     const ASTPtr & right_arg,
     const DataTypes & set_element_types,
-    const Context & context)
+    ContextPtr context)
 {
     auto [right_arg_value, right_arg_type] = evaluateConstantExpression(right_arg, context);
 
@@ -259,7 +259,7 @@ Block createBlockForSet(
     };
 
     Block block;
-    bool tranform_null_in = context.getSettingsRef().transform_null_in;
+    bool tranform_null_in = context->getSettingsRef().transform_null_in;
 
     /// 1 in 1; (1, 2) in (1, 2); identity(tuple(tuple(tuple(1)))) in tuple(tuple(tuple(1))); etc.
     if (left_type_depth == right_type_depth)
@@ -288,9 +288,9 @@ Block createBlockForSet(
     const DataTypePtr & left_arg_type,
     const std::shared_ptr<ASTFunction> & right_arg,
     const DataTypes & set_element_types,
-    const Context & context)
+    ContextPtr context)
 {
-    auto get_tuple_type_from_ast = [&context](const auto & func) -> DataTypePtr
+    auto get_tuple_type_from_ast = [context](const auto & func) -> DataTypePtr
     {
         if (func && (func->name == "tuple" || func->name == "array") && !func->arguments->children.empty())
         {
@@ -337,7 +337,7 @@ Block createBlockForSet(
 
 SetPtr makeExplicitSet(
     const ASTFunction * node, const ActionsDAG & actions, bool create_ordered_set,
-    const Context & context, const SizeLimits & size_limits, PreparedSets & prepared_sets)
+    ContextPtr context, const SizeLimits & size_limits, PreparedSets & prepared_sets)
 {
     const IAST & args = *node->arguments;
 
@@ -371,7 +371,8 @@ SetPtr makeExplicitSet(
     else
         block = createBlockForSet(left_arg_type, right_arg, set_element_types, context);
 
-    SetPtr set = std::make_shared<Set>(size_limits, create_ordered_set, context.getSettingsRef().transform_null_in);
+    SetPtr set
+        = std::make_shared<Set>(size_limits, create_ordered_set, context->getSettingsRef().transform_null_in);
     set->setHeader(block.cloneEmpty());
     set->insertFromBlock(block);
     set->finishInsert();
@@ -429,11 +430,11 @@ public:
 };
 
 ActionsMatcher::Data::Data(
-    const Context & context_, SizeLimits set_size_limit_, size_t subquery_depth_,
+    ContextPtr context_, SizeLimits set_size_limit_, size_t subquery_depth_,
     const NamesAndTypesList & source_columns_, ActionsDAGPtr actions_dag,
     PreparedSets & prepared_sets_, SubqueriesForSets & subqueries_for_sets_,
     bool no_subqueries_, bool no_makeset_, bool only_consts_, bool create_source_for_in_)
-    : context(context_)
+    : WithContext(context_)
     , set_size_limit(set_size_limit_)
     , subquery_depth(subquery_depth_)
     , source_columns(source_columns_)
@@ -444,7 +445,7 @@ ActionsMatcher::Data::Data(
     , only_consts(only_consts_)
     , create_source_for_in(create_source_for_in_)
     , visit_depth(0)
-    , actions_stack(std::move(actions_dag), context)
+    , actions_stack(std::move(actions_dag), context_)
     , next_unique_suffix(actions_stack.getLastActions().getIndex().size() + 1)
 {
 }
@@ -454,8 +455,7 @@ bool ActionsMatcher::Data::hasColumn(const String & column_name) const
     return actions_stack.getLastActionsIndex().contains(column_name);
 }
 
-ScopeStack::ScopeStack(ActionsDAGPtr actions_dag, const Context & context_)
-    : context(context_)
+ScopeStack::ScopeStack(ActionsDAGPtr actions_dag, ContextPtr context_) : WithContext(context_)
 {
     auto & level = stack.emplace_back();
     level.actions_dag = std::move(actions_dag);
@@ -698,7 +698,7 @@ ASTs ActionsMatcher::doUntuple(const ASTFunction * function, ActionsMatcher::Dat
         else
             func->setAlias(data.getUniqueName("_ut_" + name));
 
-        auto function_builder = FunctionFactory::instance().get(func->name, data.context);
+        auto function_builder = FunctionFactory::instance().get(func->name, data.getContext());
         data.addFunction(function_builder, {tuple_name_type->name, literal->getColumnName()}, func->getColumnName());
 
         columns.push_back(std::move(func));
@@ -803,7 +803,7 @@ void ActionsMatcher::visit(const ASTFunction & node, const ASTPtr & ast, Data &
                 auto argument_name = node.arguments->children.at(0)->getColumnName();
 
                 data.addFunction(
-                        FunctionFactory::instance().get(node.name + "IgnoreSet", data.context),
+                        FunctionFactory::instance().get(node.name + "IgnoreSet", data.getContext()),
                         { argument_name, argument_name },
                         column_name);
             }
@@ -846,7 +846,7 @@ void ActionsMatcher::visit(const ASTFunction & node, const ASTPtr & ast, Data &
     FunctionOverloadResolverPtr function_builder;
     try
     {
-        function_builder = FunctionFactory::instance().get(node.name, data.context);
+        function_builder = FunctionFactory::instance().get(node.name, data.getContext());
     }
     catch (Exception & e)
     {
@@ -941,7 +941,7 @@ void ActionsMatcher::visit(const ASTFunction & node, const ASTPtr & ast, Data &
             else if (identifier && (functionIsJoinGet(node.name) || functionIsDictGet(node.name)) && arg == 0)
             {
                 auto table_id = IdentifierSemantic::extractDatabaseAndTable(*identifier);
-                table_id = data.context.resolveStorageID(table_id, Context::ResolveOrdinary);
+                table_id = data.getContext()->resolveStorageID(table_id, Context::ResolveOrdinary);
                 auto column_string = ColumnString::create();
                 column_string->insert(table_id.getDatabaseName() + "." + table_id.getTableName());
                 ColumnWithTypeAndName column(
@@ -1005,7 +1005,7 @@ void ActionsMatcher::visit(const ASTFunction & node, const ASTPtr & ast, Data &
 
                     auto lambda_actions = std::make_shared<ExpressionActions>(
                         lambda_dag,
-                        ExpressionActionsSettings::fromContext(data.context));
+                        ExpressionActionsSettings::fromContext(data.getContext()));
 
                     DataTypePtr result_type = lambda_actions->getSampleBlock().getByName(result_name).type;
 
@@ -1125,8 +1125,8 @@ SetPtr ActionsMatcher::makeSet(const ASTFunction & node, Data & data, bool no_su
         ///  and the table has the type Set (a previously prepared set).
         if (identifier)
         {
-            auto table_id = data.context.resolveStorageID(right_in_operand);
-            StoragePtr table = DatabaseCatalog::instance().tryGetTable(table_id, data.context);
+            auto table_id = data.getContext()->resolveStorageID(right_in_operand);
+            StoragePtr table = DatabaseCatalog::instance().tryGetTable(table_id, data.getContext());
 
             if (table)
             {
@@ -1151,7 +1151,7 @@ SetPtr ActionsMatcher::makeSet(const ASTFunction & node, Data & data, bool no_su
             return subquery_for_set.set;
         }
 
-        SetPtr set = std::make_shared<Set>(data.set_size_limit, false, data.context.getSettingsRef().transform_null_in);
+        SetPtr set = std::make_shared<Set>(data.set_size_limit, false, data.getContext()->getSettingsRef().transform_null_in);
 
         /** The following happens for GLOBAL INs or INs:
           * - in the addExternalStorage function, the IN (SELECT ...) subquery is replaced with IN _data1,
@@ -1163,7 +1163,7 @@ SetPtr ActionsMatcher::makeSet(const ASTFunction & node, Data & data, bool no_su
           */
         if (!subquery_for_set.source && data.create_source_for_in)
         {
-            auto interpreter = interpretSubquery(right_in_operand, data.context, data.subquery_depth, {});
+            auto interpreter = interpretSubquery(right_in_operand, data.getContext(), data.subquery_depth, {});
             subquery_for_set.source = std::make_unique<QueryPlan>();
             interpreter->buildQueryPlan(*subquery_for_set.source);
         }
@@ -1178,7 +1178,7 @@ SetPtr ActionsMatcher::makeSet(const ASTFunction & node, Data & data, bool no_su
         const auto & index = data.actions_stack.getLastActionsIndex();
         if (index.contains(left_in_operand->getColumnName()))
             /// An explicit enumeration of values in parentheses.
-            return makeExplicitSet(&node, last_actions, false, data.context, data.set_size_limit, data.prepared_sets);
+            return makeExplicitSet(&node, last_actions, false, data.getContext(), data.set_size_limit, data.prepared_sets);
         else
             return {};
     }
diff --git a/src/Interpreters/ActionsVisitor.h b/src/Interpreters/ActionsVisitor.h
index 42c3ea1e5bc..1d7d64f739a 100644
--- a/src/Interpreters/ActionsVisitor.h
+++ b/src/Interpreters/ActionsVisitor.h
@@ -1,15 +1,15 @@
 #pragma once
 
-#include <Parsers/IAST.h>
+#include <Interpreters/Context_fwd.h>
+#include <Interpreters/InDepthNodeVisitor.h>
 #include <Interpreters/PreparedSets.h>
 #include <Interpreters/SubqueryForSet.h>
-#include <Interpreters/InDepthNodeVisitor.h>
+#include <Parsers/IAST.h>
 
 
 namespace DB
 {
 
-class Context;
 class ASTFunction;
 
 class ExpressionActions;
@@ -24,7 +24,7 @@ using FunctionOverloadResolverPtr = std::shared_ptr<IFunctionOverloadResolver>;
 /// The case of an explicit enumeration of values.
 SetPtr makeExplicitSet(
     const ASTFunction * node, const ActionsDAG & actions, bool create_ordered_set,
-    const Context & context, const SizeLimits & limits, PreparedSets & prepared_sets);
+    ContextPtr context, const SizeLimits & limits, PreparedSets & prepared_sets);
 
 /** Create a block for set from expression.
   * 'set_element_types' - types of what are on the left hand side of IN.
@@ -41,7 +41,7 @@ Block createBlockForSet(
     const DataTypePtr & left_arg_type,
     const std::shared_ptr<ASTFunction> & right_arg,
     const DataTypes & set_element_types,
-    const Context & context);
+    ContextPtr context);
 
 /** Create a block for set from literal.
   * 'set_element_types' - types of what are on the left hand side of IN.
@@ -51,7 +51,7 @@ Block createBlockForSet(
     const DataTypePtr & left_arg_type,
     const ASTPtr & right_arg,
     const DataTypes & set_element_types,
-    const Context & context);
+    ContextPtr context);
 
 /** For ActionsVisitor
   * A stack of ExpressionActions corresponding to nested lambda expressions.
@@ -60,7 +60,7 @@ Block createBlockForSet(
   *  calculation of the product must be done outside the lambda expression (it does not depend on x),
   *  and the calculation of the sum is inside (depends on x).
   */
-struct ScopeStack
+struct ScopeStack : WithContext
 {
     class Index;
     using IndexPtr = std::unique_ptr<Index>;
@@ -80,9 +80,7 @@ struct ScopeStack
 
     Levels stack;
 
-    const Context & context;
-
-    ScopeStack(ActionsDAGPtr actions_dag, const Context & context_);
+    ScopeStack(ActionsDAGPtr actions_dag, ContextPtr context_);
 
     void pushLevel(const NamesAndTypesList & input_columns);
 
@@ -113,9 +111,8 @@ class ActionsMatcher
 public:
     using Visitor = ConstInDepthNodeVisitor<ActionsMatcher, true>;
 
-    struct Data
+    struct Data : public WithContext
     {
-        const Context & context;
         SizeLimits set_size_limit;
         size_t subquery_depth;
         const NamesAndTypesList & source_columns;
@@ -135,10 +132,18 @@ public:
          */
         int next_unique_suffix;
 
-        Data(const Context & context_, SizeLimits set_size_limit_, size_t subquery_depth_,
-                const NamesAndTypesList & source_columns_, ActionsDAGPtr actions_dag,
-                PreparedSets & prepared_sets_, SubqueriesForSets & subqueries_for_sets_,
-                bool no_subqueries_, bool no_makeset_, bool only_consts_, bool create_source_for_in_);
+        Data(
+            ContextPtr context_,
+            SizeLimits set_size_limit_,
+            size_t subquery_depth_,
+            const NamesAndTypesList & source_columns_,
+            ActionsDAGPtr actions_dag,
+            PreparedSets & prepared_sets_,
+            SubqueriesForSets & subqueries_for_sets_,
+            bool no_subqueries_,
+            bool no_makeset_,
+            bool only_consts_,
+            bool create_source_for_in_);
 
         /// Does result of the calculation already exists in the block.
         bool hasColumn(const String & column_name) const;
diff --git a/src/Interpreters/ArrayJoinAction.cpp b/src/Interpreters/ArrayJoinAction.cpp
index 77d63bd7752..3d176857601 100644
--- a/src/Interpreters/ArrayJoinAction.cpp
+++ b/src/Interpreters/ArrayJoinAction.cpp
@@ -16,10 +16,10 @@ namespace ErrorCodes
     extern const int TYPE_MISMATCH;
 }
 
-ArrayJoinAction::ArrayJoinAction(const NameSet & array_joined_columns_, bool array_join_is_left, const Context & context)
+ArrayJoinAction::ArrayJoinAction(const NameSet & array_joined_columns_, bool array_join_is_left, ContextPtr context)
     : columns(array_joined_columns_)
     , is_left(array_join_is_left)
-    , is_unaligned(context.getSettingsRef().enable_unaligned_array_join)
+    , is_unaligned(context->getSettingsRef().enable_unaligned_array_join)
 {
     if (columns.empty())
         throw Exception("No arrays to join", ErrorCodes::LOGICAL_ERROR);
diff --git a/src/Interpreters/ArrayJoinAction.h b/src/Interpreters/ArrayJoinAction.h
index 81f720f00ef..975bf25a953 100644
--- a/src/Interpreters/ArrayJoinAction.h
+++ b/src/Interpreters/ArrayJoinAction.h
@@ -2,13 +2,12 @@
 
 #include <Core/Names.h>
 #include <Core/Block.h>
+#include <Interpreters/Context_fwd.h>
 
 
 namespace DB
 {
 
-class Context;
-
 class IFunctionOverloadResolver;
 using FunctionOverloadResolverPtr = std::shared_ptr<IFunctionOverloadResolver>;
 
@@ -27,7 +26,7 @@ public:
     /// For LEFT ARRAY JOIN.
     FunctionOverloadResolverPtr function_builder;
 
-    ArrayJoinAction(const NameSet & array_joined_columns_, bool array_join_is_left, const Context & context);
+    ArrayJoinAction(const NameSet & array_joined_columns_, bool array_join_is_left, ContextPtr context);
     void prepare(ColumnsWithTypeAndName & sample) const;
     void execute(Block & block);
 };
diff --git a/src/Interpreters/AsynchronousMetrics.cpp b/src/Interpreters/AsynchronousMetrics.cpp
index 3d582293190..6eb143d17df 100644
--- a/src/Interpreters/AsynchronousMetrics.cpp
+++ b/src/Interpreters/AsynchronousMetrics.cpp
@@ -172,7 +172,7 @@ void AsynchronousMetrics::update()
     AsynchronousMetricValues new_values;
 
     {
-        if (auto mark_cache = global_context.getMarkCache())
+        if (auto mark_cache = getContext()->getMarkCache())
         {
             new_values["MarkCacheBytes"] = mark_cache->weight();
             new_values["MarkCacheFiles"] = mark_cache->count();
@@ -180,7 +180,7 @@ void AsynchronousMetrics::update()
     }
 
     {
-        if (auto uncompressed_cache = global_context.getUncompressedCache())
+        if (auto uncompressed_cache = getContext()->getUncompressedCache())
         {
             new_values["UncompressedCacheBytes"] = uncompressed_cache->weight();
             new_values["UncompressedCacheCells"] = uncompressed_cache->count();
@@ -188,7 +188,7 @@ void AsynchronousMetrics::update()
     }
 
     {
-        if (auto mmap_cache = global_context.getMMappedFileCache())
+        if (auto mmap_cache = getContext()->getMMappedFileCache())
         {
             new_values["MMapCacheCells"] = mmap_cache->count();
         }
@@ -201,7 +201,7 @@ void AsynchronousMetrics::update()
     }
 #endif
 
-    new_values["Uptime"] = global_context.getUptimeSeconds();
+    new_values["Uptime"] = getContext()->getUptimeSeconds();
 
     /// Process memory usage according to OS
 #if defined(OS_LINUX)
@@ -264,7 +264,7 @@ void AsynchronousMetrics::update()
             /// Check if database can contain MergeTree tables
             if (!db.second->canContainMergeTreeTables())
                 continue;
-            for (auto iterator = db.second->getTablesIterator(global_context); iterator->isValid(); iterator->next())
+            for (auto iterator = db.second->getTablesIterator(getContext()); iterator->isValid(); iterator->next())
             {
                 ++total_number_of_tables;
                 const auto & table = iterator->table();
@@ -307,14 +307,14 @@ void AsynchronousMetrics::update()
                 if (table_merge_tree)
                 {
                     calculateMax(max_part_count_for_partition, table_merge_tree->getMaxPartsCountForPartition());
-                    const auto & settings = global_context.getSettingsRef();
+                    const auto & settings = getContext()->getSettingsRef();
                     total_number_of_bytes += table_merge_tree->totalBytes(settings).value();
                     total_number_of_rows += table_merge_tree->totalRows(settings).value();
                     total_number_of_parts += table_merge_tree->getPartsCount();
                 }
                 if (table_replicated_merge_tree)
                 {
-                    const auto & settings = global_context.getSettingsRef();
+                    const auto & settings = getContext()->getSettingsRef();
                     total_number_of_bytes += table_replicated_merge_tree->totalBytes(settings).value();
                     total_number_of_rows += table_replicated_merge_tree->totalRows(settings).value();
                     total_number_of_parts += table_replicated_merge_tree->getPartsCount();
@@ -454,7 +454,7 @@ void AsynchronousMetrics::update()
     /// Add more metrics as you wish.
 
     // Log the new metrics.
-    if (auto log = global_context.getAsynchronousMetricLog())
+    if (auto log = getContext()->getAsynchronousMetricLog())
     {
         log->addValues(new_values);
     }
diff --git a/src/Interpreters/AsynchronousMetrics.h b/src/Interpreters/AsynchronousMetrics.h
index f727b1d6b48..38875c21edd 100644
--- a/src/Interpreters/AsynchronousMetrics.h
+++ b/src/Interpreters/AsynchronousMetrics.h
@@ -1,18 +1,19 @@
 #pragma once
 
-#include <thread>
-#include <mutex>
-#include <condition_variable>
-#include <unordered_map>
-#include <string>
-#include <Common/ThreadPool.h>
+#include <Interpreters/Context_fwd.h>
 #include <Common/MemoryStatisticsOS.h>
+#include <Common/ThreadPool.h>
+
+#include <condition_variable>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <unordered_map>
 
 
 namespace DB
 {
 
-class Context;
 class ProtocolServerAdapter;
 
 using AsynchronousMetricValue = double;
@@ -23,16 +24,16 @@ using AsynchronousMetricValues = std::unordered_map<std::string, AsynchronousMet
   *  calculates and updates some metrics,
   *  that are not updated automatically (so, need to be asynchronously calculated).
   */
-class AsynchronousMetrics
+class AsynchronousMetrics : WithContext
 {
 public:
 #if defined(ARCADIA_BUILD)
     /// This constructor needs only to provide backward compatibility with some other projects (hello, Arcadia).
     /// Never use this in the ClickHouse codebase.
     AsynchronousMetrics(
-        Context & global_context_,
+        ContextPtr global_context_,
         int update_period_seconds = 60)
-        : global_context(global_context_)
+        : WithContext(global_context_)
         , update_period(update_period_seconds)
     {
     }
@@ -42,11 +43,11 @@ public:
     /// in Arcadia -- it uses its own server implementation that also uses these
     /// metrics.
     AsynchronousMetrics(
-        Context & global_context_,
+        ContextPtr global_context_,
         int update_period_seconds,
         std::shared_ptr<std::vector<ProtocolServerAdapter>> servers_to_start_before_tables_,
         std::shared_ptr<std::vector<ProtocolServerAdapter>> servers_)
-        : global_context(global_context_)
+        : WithContext(global_context_)
         , update_period(update_period_seconds)
         , servers_to_start_before_tables(servers_to_start_before_tables_)
         , servers(servers_)
@@ -68,7 +69,6 @@ public:
     AsynchronousMetricValues getValues() const;
 
 private:
-    Context & global_context;
     const std::chrono::seconds update_period;
     std::shared_ptr<std::vector<ProtocolServerAdapter>> servers_to_start_before_tables{nullptr};
     std::shared_ptr<std::vector<ProtocolServerAdapter>> servers{nullptr};
diff --git a/src/Interpreters/CatBoostModel.cpp b/src/Interpreters/CatBoostModel.cpp
index 3e4329c6080..e19258540b9 100644
--- a/src/Interpreters/CatBoostModel.cpp
+++ b/src/Interpreters/CatBoostModel.cpp
@@ -480,20 +480,15 @@ void CatBoostLibHolder::initAPI()
 
 std::shared_ptr<CatBoostLibHolder> getCatBoostWrapperHolder(const std::string & lib_path)
 {
-    static std::weak_ptr<CatBoostLibHolder> ptr;
+    static std::shared_ptr<CatBoostLibHolder> ptr;
     static std::mutex mutex;
 
     std::lock_guard lock(mutex);
-    auto result = ptr.lock();
 
-    if (!result || result->getCurrentPath() != lib_path)
-    {
-        result = std::make_shared<CatBoostLibHolder>(lib_path);
-        /// This assignment is not atomic, which prevents from creating lock only inside 'if'.
-        ptr = result;
-    }
+    if (!ptr || ptr->getCurrentPath() != lib_path)
+        ptr = std::make_shared<CatBoostLibHolder>(lib_path);
 
-    return result;
+    return ptr;
 }
 
 }
diff --git a/src/Interpreters/ClientInfo.cpp b/src/Interpreters/ClientInfo.cpp
index 5449f397f49..223837aaf3d 100644
--- a/src/Interpreters/ClientInfo.cpp
+++ b/src/Interpreters/ClientInfo.cpp
@@ -60,6 +60,9 @@ void ClientInfo::write(WriteBuffer & out, const UInt64 server_protocol_revision)
     if (server_protocol_revision >= DBMS_MIN_REVISION_WITH_QUOTA_KEY_IN_CLIENT_INFO)
         writeBinary(quota_key, out);
 
+    if (server_protocol_revision >= DBMS_MIN_PROTOCOL_VERSION_WITH_DISTRIBUTED_DEPTH)
+        writeVarUInt(distributed_depth, out);
+
     if (interface == Interface::TCP)
     {
         if (server_protocol_revision >= DBMS_MIN_REVISION_WITH_VERSION_PATCH)
@@ -137,6 +140,9 @@ void ClientInfo::read(ReadBuffer & in, const UInt64 client_protocol_revision)
     if (client_protocol_revision >= DBMS_MIN_REVISION_WITH_QUOTA_KEY_IN_CLIENT_INFO)
         readBinary(quota_key, in);
 
+    if (client_protocol_revision >= DBMS_MIN_PROTOCOL_VERSION_WITH_DISTRIBUTED_DEPTH)
+        readVarUInt(distributed_depth, in);
+
     if (interface == Interface::TCP)
     {
         if (client_protocol_revision >= DBMS_MIN_REVISION_WITH_VERSION_PATCH)
diff --git a/src/Interpreters/ClientInfo.h b/src/Interpreters/ClientInfo.h
index bc471dc3aa4..21aae45bfab 100644
--- a/src/Interpreters/ClientInfo.h
+++ b/src/Interpreters/ClientInfo.h
@@ -96,6 +96,8 @@ public:
     /// Common
     String quota_key;
 
+    UInt64 distributed_depth = 0;
+
     bool empty() const { return query_kind == QueryKind::NO_QUERY; }
 
     /** Serialization and deserialization.
diff --git a/src/Interpreters/Cluster.cpp b/src/Interpreters/Cluster.cpp
index 9c19094b061..bac688fe81e 100644
--- a/src/Interpreters/Cluster.cpp
+++ b/src/Interpreters/Cluster.cpp
@@ -292,7 +292,7 @@ void Clusters::updateClusters(const Poco::Util::AbstractConfiguration & new_conf
 
     std::lock_guard lock(mutex);
 
-    /// If old congig is set, remove deleted clusters from impl, otherwise just clear it.
+    /// If old config is set, remove deleted clusters from impl, otherwise just clear it.
     if (old_config)
     {
         for (const auto & key : deleted_keys)
diff --git a/src/Interpreters/Cluster.h b/src/Interpreters/Cluster.h
index 0fb75211bd2..5976074ec7a 100644
--- a/src/Interpreters/Cluster.h
+++ b/src/Interpreters/Cluster.h
@@ -1,10 +1,12 @@
 #pragma once
 
-#include <map>
 #include <Client/ConnectionPool.h>
 #include <Client/ConnectionPoolWithFailover.h>
+
 #include <Poco/Net/SocketAddress.h>
 
+#include <map>
+
 namespace Poco
 {
     namespace Util
@@ -53,6 +55,8 @@ public:
     static Poco::Timespan saturate(const Poco::Timespan & v, const Poco::Timespan & limit);
 
 public:
+    using SlotToShard = std::vector<UInt64>;
+
     struct Address
     {
         /** In configuration file,
@@ -230,7 +234,6 @@ public:
     bool maybeCrossReplication() const;
 
 private:
-    using SlotToShard = std::vector<UInt64>;
     SlotToShard slot_to_shard;
 
 public:
diff --git a/src/Interpreters/ClusterProxy/IStreamFactory.h b/src/Interpreters/ClusterProxy/IStreamFactory.h
index 3cf100cd85c..f66eee93e0a 100644
--- a/src/Interpreters/ClusterProxy/IStreamFactory.h
+++ b/src/Interpreters/ClusterProxy/IStreamFactory.h
@@ -8,7 +8,6 @@ namespace DB
 {
 
 struct Settings;
-class Context;
 class Cluster;
 class Throttler;
 struct SelectQueryInfo;
@@ -27,12 +26,12 @@ namespace ClusterProxy
 class IStreamFactory
 {
 public:
-    virtual ~IStreamFactory() {}
+    virtual ~IStreamFactory() = default;
 
     virtual void createForShard(
             const Cluster::ShardInfo & shard_info,
-            const String & query, const ASTPtr & query_ast,
-            const std::shared_ptr<Context> & context_ptr, const ThrottlerPtr & throttler,
+            const ASTPtr & query_ast,
+            ContextPtr context, const ThrottlerPtr & throttler,
             const SelectQueryInfo & query_info,
             std::vector<QueryPlanPtr> & res,
             Pipes & remote_pipes,
diff --git a/src/Interpreters/ClusterProxy/SelectStreamFactory.cpp b/src/Interpreters/ClusterProxy/SelectStreamFactory.cpp
index 0b1f964af32..7cb55f32162 100644
--- a/src/Interpreters/ClusterProxy/SelectStreamFactory.cpp
+++ b/src/Interpreters/ClusterProxy/SelectStreamFactory.cpp
@@ -76,7 +76,7 @@ namespace
 std::unique_ptr<QueryPlan> createLocalPlan(
     const ASTPtr & query_ast,
     const Block & header,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum processed_stage)
 {
     checkStackSize();
@@ -115,24 +115,22 @@ String formattedAST(const ASTPtr & ast)
 
 void SelectStreamFactory::createForShard(
     const Cluster::ShardInfo & shard_info,
-    const String &, const ASTPtr & query_ast,
-    const std::shared_ptr<Context> & context_ptr, const ThrottlerPtr & throttler,
+    const ASTPtr & query_ast,
+    ContextPtr context, const ThrottlerPtr & throttler,
     const SelectQueryInfo &,
     std::vector<QueryPlanPtr> & plans,
     Pipes & remote_pipes,
     Pipes & delayed_pipes,
     Poco::Logger * log)
 {
-    const auto & context = *context_ptr;
-
     bool add_agg_info = processed_stage == QueryProcessingStage::WithMergeableState;
     bool add_totals = false;
     bool add_extremes = false;
-    bool async_read = context_ptr->getSettingsRef().async_socket_for_remote;
+    bool async_read = context->getSettingsRef().async_socket_for_remote;
     if (processed_stage == QueryProcessingStage::Complete)
     {
         add_totals = query_ast->as<ASTSelectQuery &>().group_by_with_totals;
-        add_extremes = context.getSettingsRef().extremes;
+        add_extremes = context->getSettingsRef().extremes;
     }
 
     auto modified_query_ast = query_ast->clone();
@@ -157,10 +155,10 @@ void SelectStreamFactory::createForShard(
             remote_query_executor->setMainTable(main_table);
 
         remote_pipes.emplace_back(createRemoteSourcePipe(remote_query_executor, add_agg_info, add_totals, add_extremes, async_read));
-        remote_pipes.back().addInterpreterContext(context_ptr);
+        remote_pipes.back().addInterpreterContext(context);
     };
 
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = context->getSettingsRef();
 
     if (settings.prefer_localhost_replica && shard_info.isLocal())
     {
@@ -173,7 +171,7 @@ void SelectStreamFactory::createForShard(
         }
         else
         {
-            auto resolved_id = context.resolveStorageID(main_table);
+            auto resolved_id = context->resolveStorageID(main_table);
             main_table_storage = DatabaseCatalog::instance().tryGetTable(resolved_id, context);
         }
 
@@ -250,12 +248,12 @@ void SelectStreamFactory::createForShard(
 
         auto lazily_create_stream = [
                 pool = shard_info.pool, shard_num = shard_info.shard_num, modified_query, header = header, modified_query_ast,
-                &context, context_ptr, throttler,
+                context, throttler,
                 main_table = main_table, table_func_ptr = table_func_ptr, scalars = scalars, external_tables = external_tables,
                 stage = processed_stage, local_delay, add_agg_info, add_totals, add_extremes, async_read]()
             -> Pipe
         {
-            auto current_settings = context.getSettingsRef();
+            auto current_settings = context->getSettingsRef();
             auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(
                 current_settings).getSaturated(
                     current_settings.max_execution_time);
@@ -287,8 +285,8 @@ void SelectStreamFactory::createForShard(
             {
                 auto plan = createLocalPlan(modified_query_ast, header, context, stage);
                 return QueryPipeline::getPipe(std::move(*plan->buildQueryPipeline(
-                    QueryPlanOptimizationSettings::fromContext(*context_ptr),
-                    BuildQueryPipelineSettings::fromContext(*context_ptr))));
+                    QueryPlanOptimizationSettings::fromContext(context),
+                    BuildQueryPipelineSettings::fromContext(context))));
             }
             else
             {
@@ -305,7 +303,7 @@ void SelectStreamFactory::createForShard(
         };
 
         delayed_pipes.emplace_back(createDelayedPipe(header, lazily_create_stream, add_totals, add_extremes));
-        delayed_pipes.back().addInterpreterContext(context_ptr);
+        delayed_pipes.back().addInterpreterContext(context);
     }
     else
         emplace_remote_stream();
diff --git a/src/Interpreters/ClusterProxy/SelectStreamFactory.h b/src/Interpreters/ClusterProxy/SelectStreamFactory.h
index 596e99b8a18..0705bcb2903 100644
--- a/src/Interpreters/ClusterProxy/SelectStreamFactory.h
+++ b/src/Interpreters/ClusterProxy/SelectStreamFactory.h
@@ -8,8 +8,6 @@
 namespace DB
 {
 
-using Scalars = std::map<String, Block>;
-
 namespace ClusterProxy
 {
 
@@ -36,8 +34,8 @@ public:
 
     void createForShard(
         const Cluster::ShardInfo & shard_info,
-        const String & query, const ASTPtr & query_ast,
-        const std::shared_ptr<Context> & context_ptr, const ThrottlerPtr & throttler,
+        const ASTPtr & query_ast,
+        ContextPtr context, const ThrottlerPtr & throttler,
         const SelectQueryInfo & query_info,
         std::vector<QueryPlanPtr> & plans,
         Pipes & remote_pipes,
diff --git a/src/Interpreters/ClusterProxy/executeQuery.cpp b/src/Interpreters/ClusterProxy/executeQuery.cpp
index 59cbae67770..5284756a4ff 100644
--- a/src/Interpreters/ClusterProxy/executeQuery.cpp
+++ b/src/Interpreters/ClusterProxy/executeQuery.cpp
@@ -5,7 +5,7 @@
 #include <Interpreters/Cluster.h>
 #include <Interpreters/IInterpreter.h>
 #include <Interpreters/ProcessList.h>
-#include <Parsers/queryToString.h>
+#include <Interpreters/OptimizeShardingKeyRewriteInVisitor.h>
 #include <Processors/Pipe.h>
 #include <Processors/QueryPlan/QueryPlan.h>
 #include <Processors/QueryPlan/ReadFromPreparedSource.h>
@@ -16,10 +16,15 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int TOO_LARGE_DISTRIBUTED_DEPTH;
+}
+
 namespace ClusterProxy
 {
 
-std::shared_ptr<Context> updateSettingsForCluster(const Cluster & cluster, const Context & context, const Settings & settings, Poco::Logger * log)
+ContextPtr updateSettingsForCluster(const Cluster & cluster, ContextPtr context, const Settings & settings, Poco::Logger * log)
 {
     Settings new_settings = settings;
     new_settings.queue_max_wait_ms = Cluster::saturate(new_settings.queue_max_wait_ms, settings.max_execution_time);
@@ -78,7 +83,7 @@ std::shared_ptr<Context> updateSettingsForCluster(const Cluster & cluster, const
         }
     }
 
-    auto new_context = std::make_shared<Context>(context);
+    auto new_context = Context::createCopy(context);
     new_context->setSettings(new_settings);
     return new_context;
 }
@@ -86,22 +91,28 @@ std::shared_ptr<Context> updateSettingsForCluster(const Cluster & cluster, const
 void executeQuery(
     QueryPlan & query_plan,
     IStreamFactory & stream_factory, Poco::Logger * log,
-    const ASTPtr & query_ast, const Context & context, const SelectQueryInfo & query_info)
+    const ASTPtr & query_ast, ContextPtr context, const SelectQueryInfo & query_info,
+    const ExpressionActionsPtr & sharding_key_expr,
+    const std::string & sharding_key_column_name,
+    const ClusterPtr & not_optimized_cluster)
 {
     assert(log);
 
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
+
+    if (settings.max_distributed_depth && context->getClientInfo().distributed_depth > settings.max_distributed_depth)
+        throw Exception("Maximum distributed depth exceeded", ErrorCodes::TOO_LARGE_DISTRIBUTED_DEPTH);
 
     std::vector<QueryPlanPtr> plans;
     Pipes remote_pipes;
     Pipes delayed_pipes;
 
-    const std::string query = queryToString(query_ast);
+    auto new_context = updateSettingsForCluster(*query_info.getCluster(), context, settings, log);
 
-    auto new_context = updateSettingsForCluster(*query_info.cluster, context, settings, log);
+    new_context->getClientInfo().distributed_depth += 1;
 
     ThrottlerPtr user_level_throttler;
-    if (auto * process_list_element = context.getProcessListElement())
+    if (auto * process_list_element = context->getProcessListElement())
         user_level_throttler = process_list_element->getUserNetworkThrottler();
 
     /// Network bandwidth limit, if needed.
@@ -117,9 +128,28 @@ void executeQuery(
     else
         throttler = user_level_throttler;
 
-    for (const auto & shard_info : query_info.cluster->getShardsInfo())
+    size_t shards = query_info.getCluster()->getShardCount();
+    for (const auto & shard_info : query_info.getCluster()->getShardsInfo())
     {
-        stream_factory.createForShard(shard_info, query, query_ast,
+        ASTPtr query_ast_for_shard;
+        if (query_info.optimized_cluster && settings.optimize_skip_unused_shards_rewrite_in && shards > 1)
+        {
+            query_ast_for_shard = query_ast->clone();
+
+            OptimizeShardingKeyRewriteInVisitor::Data visitor_data{
+                sharding_key_expr,
+                sharding_key_column_name,
+                shard_info,
+                not_optimized_cluster->getSlotToShard(),
+            };
+            OptimizeShardingKeyRewriteInVisitor visitor(visitor_data);
+            visitor.visit(query_ast_for_shard);
+        }
+        else
+            query_ast_for_shard = query_ast;
+
+        stream_factory.createForShard(shard_info,
+            query_ast_for_shard,
             new_context, throttler, query_info, plans,
             remote_pipes, delayed_pipes, log);
     }
@@ -156,8 +186,7 @@ void executeQuery(
     for (auto & plan : plans)
         input_streams.emplace_back(plan->getCurrentDataStream());
 
-    auto header = input_streams.front().header;
-    auto union_step = std::make_unique<UnionStep>(std::move(input_streams), header);
+    auto union_step = std::make_unique<UnionStep>(std::move(input_streams));
     query_plan.unitePlans(std::move(union_step), std::move(plans));
 }
 
diff --git a/src/Interpreters/ClusterProxy/executeQuery.h b/src/Interpreters/ClusterProxy/executeQuery.h
index 8840b82d5b2..46525335803 100644
--- a/src/Interpreters/ClusterProxy/executeQuery.h
+++ b/src/Interpreters/ClusterProxy/executeQuery.h
@@ -1,18 +1,22 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
 #include <Parsers/IAST.h>
 
 namespace DB
 {
 
 struct Settings;
-class Context;
 class Cluster;
+using ClusterPtr = std::shared_ptr<Cluster>;
 struct SelectQueryInfo;
 
 class Pipe;
 class QueryPlan;
 
+class ExpressionActions;
+using ExpressionActionsPtr = std::shared_ptr<ExpressionActions>;
+
 namespace ClusterProxy
 {
 
@@ -27,7 +31,7 @@ class IStreamFactory;
 ///   - optimize_skip_unused_shards_nesting
 ///
 /// @return new Context with adjusted settings
-std::shared_ptr<Context> updateSettingsForCluster(const Cluster & cluster, const Context & context, const Settings & settings, Poco::Logger * log = nullptr);
+ContextPtr updateSettingsForCluster(const Cluster & cluster, ContextPtr context, const Settings & settings, Poco::Logger * log = nullptr);
 
 /// Execute a distributed query, creating a vector of BlockInputStreams, from which the result can be read.
 /// `stream_factory` object encapsulates the logic of creating streams for a different type of query
@@ -35,7 +39,10 @@ std::shared_ptr<Context> updateSettingsForCluster(const Cluster & cluster, const
 void executeQuery(
     QueryPlan & query_plan,
     IStreamFactory & stream_factory, Poco::Logger * log,
-    const ASTPtr & query_ast, const Context & context, const SelectQueryInfo & query_info);
+    const ASTPtr & query_ast, ContextPtr context, const SelectQueryInfo & query_info,
+    const ExpressionActionsPtr & sharding_key_expr,
+    const std::string & sharding_key_column_name,
+    const ClusterPtr & not_optimized_cluster);
 
 }
 
diff --git a/src/Interpreters/ColumnAliasesVisitor.h b/src/Interpreters/ColumnAliasesVisitor.h
index 2cd9ad796cd..a1f8e79f64c 100644
--- a/src/Interpreters/ColumnAliasesVisitor.h
+++ b/src/Interpreters/ColumnAliasesVisitor.h
@@ -56,12 +56,12 @@ public:
         /// Do not analyze joined columns.
         /// They may have aliases and come to description as is.
         const NameSet & forbidden_columns;
-        const Context & context;
+        ContextPtr context;
 
         /// private_aliases are from lambda, so these are local names.
         NameSet private_aliases;
 
-        Data(const ColumnsDescription & columns_, const NameSet & forbidden_columns_, const Context & context_)
+        Data(const ColumnsDescription & columns_, const NameSet & forbidden_columns_, ContextPtr context_)
         : columns(columns_)
         , forbidden_columns(forbidden_columns_)
         , context(context_)
diff --git a/src/Interpreters/Context.cpp b/src/Interpreters/Context.cpp
index 8eec5d099e2..187edf8843f 100644
--- a/src/Interpreters/Context.cpp
+++ b/src/Interpreters/Context.cpp
@@ -29,6 +29,7 @@
 #include <Disks/DiskLocal.h>
 #include <TableFunctions/TableFunctionFactory.h>
 #include <Interpreters/ActionLocksManager.h>
+#include <Interpreters/ExternalLoaderXMLConfigRepository.h>
 #include <Core/Settings.h>
 #include <Core/SettingsQuirks.h>
 #include <Access/AccessControlManager.h>
@@ -49,6 +50,7 @@
 #include <Interpreters/ExternalModelsLoader.h>
 #include <Interpreters/ExpressionActions.h>
 #include <Interpreters/ProcessList.h>
+#include <Interpreters/InterserverCredentials.h>
 #include <Interpreters/Cluster.h>
 #include <Interpreters/InterserverIOHandler.h>
 #include <Interpreters/SystemLog.h>
@@ -138,13 +140,13 @@ public:
     /// Find existing session or create a new.
     std::shared_ptr<NamedSession> acquireSession(
         const String & session_id,
-        Context & context,
+        ContextPtr context,
         std::chrono::steady_clock::duration timeout,
         bool throw_if_not_found)
     {
         std::unique_lock lock(mutex);
 
-        auto & user_name = context.client_info.current_user;
+        auto & user_name = context->client_info.current_user;
 
         if (user_name.empty())
             throw Exception("Empty user name.", ErrorCodes::LOGICAL_ERROR);
@@ -160,7 +162,7 @@ public:
             /// Create a new session from current context.
             it = sessions.insert(std::make_pair(key, std::make_shared<NamedSession>(key, context, timeout, *this))).first;
         }
-        else if (it->second->key.first != context.client_info.current_user)
+        else if (it->second->key.first != context->client_info.current_user)
         {
             throw Exception("Session belongs to a different user", ErrorCodes::SESSION_IS_LOCKED);
         }
@@ -171,7 +173,7 @@ public:
         if (!session.unique())
             throw Exception("Session is locked by a concurrent client.", ErrorCodes::SESSION_IS_LOCKED);
 
-        session->context.client_info = context.client_info;
+        session->context->client_info = context->client_info;
 
         return session;
     }
@@ -224,7 +226,6 @@ private:
     void cleanThread()
     {
         setThreadName("SessionCleaner");
-
         std::unique_lock lock{mutex};
 
         while (true)
@@ -292,7 +293,7 @@ void NamedSession::release()
 /** Set of known objects (environment), that could be used in query.
   * Shared (global) part. Order of members (especially, order of destruction) is very important.
   */
-struct ContextShared
+struct ContextSharedPart
 {
     Poco::Logger * log = &Poco::Logger::get("Context");
 
@@ -322,9 +323,8 @@ struct ContextShared
 
     String interserver_io_host;                             /// The host name by which this server is available for other servers.
     UInt16 interserver_io_port = 0;                         /// and port.
-    String interserver_io_user;
-    String interserver_io_password;
     String interserver_scheme;                              /// http or https
+    MultiVersion<InterserverCredentials> interserver_io_credentials;
 
     String path;                                            /// Path to the data directory, with a slash at the end.
     String flags_path;                                      /// Path to the directory with some control flags for server maintenance.
@@ -338,6 +338,9 @@ struct ContextShared
     mutable std::optional<EmbeddedDictionaries> embedded_dictionaries;    /// Metrica's dictionaries. Have lazy initialization.
     mutable std::optional<ExternalDictionariesLoader> external_dictionaries_loader;
     mutable std::optional<ExternalModelsLoader> external_models_loader;
+    ConfigurationPtr external_models_config;
+    ext::scope_guard models_repository_guard;
+
     String default_profile_name;                            /// Default profile name used for default values.
     String system_profile_name;                             /// Profile used by system processes
     String buffer_profile_name;                             /// Profile used by Buffer engine for flushing to the underlying
@@ -395,7 +398,7 @@ struct ContextShared
 
     Context::ConfigReloadCallback config_reload_callback;
 
-    ContextShared()
+    ContextSharedPart()
         : macros(std::make_unique<Macros>())
     {
         /// TODO: make it singleton (?)
@@ -409,7 +412,7 @@ struct ContextShared
     }
 
 
-    ~ContextShared()
+    ~ContextSharedPart()
     {
         try
         {
@@ -445,6 +448,7 @@ struct ContextShared
         system_logs.reset();
         embedded_dictionaries.reset();
         external_dictionaries_loader.reset();
+        models_repository_guard.reset();
         external_models_loader.reset();
         buffer_flush_schedule_pool.reset();
         schedule_pool.reset();
@@ -456,7 +460,6 @@ struct ContextShared
         trace_collector.reset();
         /// Stop zookeeper connection
         zookeeper.reset();
-
     }
 
     bool hasTraceCollector() const
@@ -484,27 +487,48 @@ SharedContextHolder::SharedContextHolder(SharedContextHolder &&) noexcept = defa
 SharedContextHolder & SharedContextHolder::operator=(SharedContextHolder &&) = default;
 SharedContextHolder::SharedContextHolder() = default;
 SharedContextHolder::~SharedContextHolder() = default;
-SharedContextHolder::SharedContextHolder(std::unique_ptr<ContextShared> shared_context)
+SharedContextHolder::SharedContextHolder(std::unique_ptr<ContextSharedPart> shared_context)
     : shared(std::move(shared_context)) {}
 
 void SharedContextHolder::reset() { shared.reset(); }
 
-
-Context Context::createGlobal(ContextShared * shared)
+ContextPtr Context::createGlobal(ContextSharedPart * shared)
 {
-    Context res;
-    res.shared = shared;
+    auto res = std::shared_ptr<Context>(new Context);
+    res->shared = shared;
     return res;
 }
 
 void Context::initGlobal()
 {
-    DatabaseCatalog::init(*this);
+    DatabaseCatalog::init(shared_from_this());
 }
 
 SharedContextHolder Context::createShared()
 {
-    return SharedContextHolder(std::make_unique<ContextShared>());
+    return SharedContextHolder(std::make_unique<ContextSharedPart>());
+}
+
+ContextPtr Context::createCopy(const ContextConstPtr & other)
+{
+    return std::shared_ptr<Context>(new Context(*other));
+}
+
+ContextPtr Context::createCopy(const ContextWeakConstPtr & other)
+{
+    auto ptr = other.lock();
+    if (!ptr) throw Exception("Can't copy an expired context", ErrorCodes::LOGICAL_ERROR);
+    return createCopy(ptr);
+}
+
+ContextPtr Context::createCopy(const ContextPtr & other)
+{
+    return createCopy(std::const_pointer_cast<const Context>(other));
+}
+
+void Context::copyFrom(const ContextPtr & other)
+{
+    *this = *other;
 }
 
 Context::~Context() = default;
@@ -532,12 +556,13 @@ void Context::enableNamedSessions()
     shared->named_sessions.emplace();
 }
 
-std::shared_ptr<NamedSession> Context::acquireNamedSession(const String & session_id, std::chrono::steady_clock::duration timeout, bool session_check)
+std::shared_ptr<NamedSession>
+Context::acquireNamedSession(const String & session_id, std::chrono::steady_clock::duration timeout, bool session_check)
 {
     if (!shared->named_sessions)
         throw Exception("Support for named sessions is not enabled", ErrorCodes::NOT_IMPLEMENTED);
 
-    return shared->named_sessions->acquireSession(session_id, *this, timeout, session_check);
+    return shared->named_sessions->acquireSession(session_id, shared_from_this(), timeout, session_check);
 }
 
 String Context::resolveDatabase(const String & database_name) const
@@ -890,21 +915,23 @@ const Block & Context::getScalar(const String & name) const
 
 Tables Context::getExternalTables() const
 {
-    assert(global_context != this || getApplicationType() == ApplicationType::LOCAL);
+    assert(!isGlobalContext() || getApplicationType() == ApplicationType::LOCAL);
     auto lock = getLock();
 
     Tables res;
     for (const auto & table : external_tables_mapping)
         res[table.first] = table.second->getTable();
 
-    if (query_context && query_context != this)
+    auto query_context_ptr = query_context.lock();
+    auto session_context_ptr = session_context.lock();
+    if (query_context_ptr && query_context_ptr.get() != this)
     {
-        Tables buf = query_context->getExternalTables();
+        Tables buf = query_context_ptr->getExternalTables();
         res.insert(buf.begin(), buf.end());
     }
-    else if (session_context && session_context != this)
+    else if (session_context_ptr && session_context_ptr.get() != this)
     {
-        Tables buf = session_context->getExternalTables();
+        Tables buf = session_context_ptr->getExternalTables();
         res.insert(buf.begin(), buf.end());
     }
     return res;
@@ -913,7 +940,7 @@ Tables Context::getExternalTables() const
 
 void Context::addExternalTable(const String & table_name, TemporaryTableHolder && temporary_table)
 {
-    assert(global_context != this || getApplicationType() == ApplicationType::LOCAL);
+    assert(!isGlobalContext() || getApplicationType() == ApplicationType::LOCAL);
     auto lock = getLock();
     if (external_tables_mapping.end() != external_tables_mapping.find(table_name))
         throw Exception("Temporary table " + backQuoteIfNeed(table_name) + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS);
@@ -923,7 +950,7 @@ void Context::addExternalTable(const String & table_name, TemporaryTableHolder &
 
 std::shared_ptr<TemporaryTableHolder> Context::removeExternalTable(const String & table_name)
 {
-    assert(global_context != this || getApplicationType() == ApplicationType::LOCAL);
+    assert(!isGlobalContext() || getApplicationType() == ApplicationType::LOCAL);
     std::shared_ptr<TemporaryTableHolder> holder;
     {
         auto lock = getLock();
@@ -939,21 +966,21 @@ std::shared_ptr<TemporaryTableHolder> Context::removeExternalTable(const String
 
 void Context::addScalar(const String & name, const Block & block)
 {
-    assert(global_context != this || getApplicationType() == ApplicationType::LOCAL);
+    assert(!isGlobalContext() || getApplicationType() == ApplicationType::LOCAL);
     scalars[name] = block;
 }
 
 
 bool Context::hasScalar(const String & name) const
 {
-    assert(global_context != this || getApplicationType() == ApplicationType::LOCAL);
+    assert(!isGlobalContext() || getApplicationType() == ApplicationType::LOCAL);
     return scalars.count(name);
 }
 
 
 void Context::addQueryAccessInfo(const String & quoted_database_name, const String & full_quoted_table_name, const Names & column_names)
 {
-    assert(global_context != this || getApplicationType() == ApplicationType::LOCAL);
+    assert(!isGlobalContext() || getApplicationType() == ApplicationType::LOCAL);
     std::lock_guard<std::mutex> lock(query_access_info.mutex);
     query_access_info.databases.emplace(quoted_database_name);
     query_access_info.tables.emplace(full_quoted_table_name);
@@ -964,7 +991,7 @@ void Context::addQueryAccessInfo(const String & quoted_database_name, const Stri
 
 void Context::addQueryFactoriesInfo(QueryLogFactories factory_type, const String & created_object) const
 {
-    assert(global_context != this || getApplicationType() == ApplicationType::LOCAL);
+    assert(!isGlobalContext() || getApplicationType() == ApplicationType::LOCAL);
     auto lock = getLock();
 
     switch (factory_type)
@@ -1009,10 +1036,10 @@ StoragePtr Context::executeTableFunction(const ASTPtr & table_expression)
 
     if (!res)
     {
-        TableFunctionPtr table_function_ptr = TableFunctionFactory::instance().get(table_expression, *this);
+        TableFunctionPtr table_function_ptr = TableFunctionFactory::instance().get(table_expression, shared_from_this());
 
         /// Run it and remember the result
-        res = table_function_ptr->execute(table_expression, *this, table_function_ptr->getName());
+        res = table_function_ptr->execute(table_expression, shared_from_this(), table_function_ptr->getName());
     }
 
     return res;
@@ -1153,7 +1180,7 @@ String Context::getInitialQueryId() const
 
 void Context::setCurrentDatabaseNameInGlobalContext(const String & name)
 {
-    if (global_context != this)
+    if (!isGlobalContext())
         throw Exception("Cannot set current database for non global context, this method should be used during server initialization",
                         ErrorCodes::LOGICAL_ERROR);
     auto lock = getLock();
@@ -1262,53 +1289,37 @@ void Context::setMacros(std::unique_ptr<Macros> && macros)
     shared->macros.set(std::move(macros));
 }
 
-const Context & Context::getQueryContext() const
+ContextPtr Context::getQueryContext() const
 {
-    if (!query_context)
-        throw Exception("There is no query", ErrorCodes::THERE_IS_NO_QUERY);
-    return *query_context;
+    auto ptr = query_context.lock();
+    if (!ptr) throw Exception("There is no query or query context has expired", ErrorCodes::THERE_IS_NO_QUERY);
+    return ptr;
 }
 
-Context & Context::getQueryContext()
+bool Context::isInternalSubquery() const
 {
-    if (!query_context)
-        throw Exception("There is no query", ErrorCodes::THERE_IS_NO_QUERY);
-    return *query_context;
+    auto ptr = query_context.lock();
+    return ptr && ptr.get() != this;
 }
 
-const Context & Context::getSessionContext() const
+ContextPtr Context::getSessionContext() const
 {
-    if (!session_context)
-        throw Exception("There is no session", ErrorCodes::THERE_IS_NO_SESSION);
-    return *session_context;
+    auto ptr = session_context.lock();
+    if (!ptr) throw Exception("There is no session or session context has expired", ErrorCodes::THERE_IS_NO_SESSION);
+    return ptr;
 }
 
-Context & Context::getSessionContext()
+ContextPtr Context::getGlobalContext() const
 {
-    if (!session_context)
-        throw Exception("There is no session", ErrorCodes::THERE_IS_NO_SESSION);
-    return *session_context;
+    auto ptr = global_context.lock();
+    if (!ptr) throw Exception("There is no global context or global context has expired", ErrorCodes::LOGICAL_ERROR);
+    return ptr;
 }
 
-const Context & Context::getGlobalContext() const
+ContextPtr Context::getBufferContext() const
 {
-    if (!global_context)
-        throw Exception("Logical error: there is no global context", ErrorCodes::LOGICAL_ERROR);
-    return *global_context;
-}
-
-Context & Context::getGlobalContext()
-{
-    if (!global_context)
-        throw Exception("Logical error: there is no global context", ErrorCodes::LOGICAL_ERROR);
-    return *global_context;
-}
-
-const Context & Context::getBufferContext() const
-{
-    if (!buffer_context)
-        throw Exception("Logical error: there is no buffer context", ErrorCodes::LOGICAL_ERROR);
-    return *buffer_context;
+    if (!buffer_context) throw Exception("There is no buffer context", ErrorCodes::LOGICAL_ERROR);
+    return buffer_context;
 }
 
 
@@ -1325,39 +1336,47 @@ EmbeddedDictionaries & Context::getEmbeddedDictionaries()
 
 const ExternalDictionariesLoader & Context::getExternalDictionariesLoader() const
 {
-    std::lock_guard lock(shared->external_dictionaries_mutex);
-    if (!shared->external_dictionaries_loader)
-    {
-        if (!this->global_context)
-            throw Exception("Logical error: there is no global context", ErrorCodes::LOGICAL_ERROR);
-
-        shared->external_dictionaries_loader.emplace(*this->global_context);
-    }
-    return *shared->external_dictionaries_loader;
+    return const_cast<Context *>(this)->getExternalDictionariesLoader();
 }
 
 ExternalDictionariesLoader & Context::getExternalDictionariesLoader()
 {
-    return const_cast<ExternalDictionariesLoader &>(const_cast<const Context *>(this)->getExternalDictionariesLoader());
+    std::lock_guard lock(shared->external_dictionaries_mutex);
+    if (!shared->external_dictionaries_loader)
+        shared->external_dictionaries_loader.emplace(getGlobalContext());
+    return *shared->external_dictionaries_loader;
 }
 
 
 const ExternalModelsLoader & Context::getExternalModelsLoader() const
 {
-    std::lock_guard lock(shared->external_models_mutex);
-    if (!shared->external_models_loader)
-    {
-        if (!this->global_context)
-            throw Exception("Logical error: there is no global context", ErrorCodes::LOGICAL_ERROR);
-
-        shared->external_models_loader.emplace(*this->global_context);
-    }
-    return *shared->external_models_loader;
+    return const_cast<Context *>(this)->getExternalModelsLoader();
 }
 
 ExternalModelsLoader & Context::getExternalModelsLoader()
 {
-    return const_cast<ExternalModelsLoader &>(const_cast<const Context *>(this)->getExternalModelsLoader());
+    std::lock_guard lock(shared->external_models_mutex);
+    return getExternalModelsLoaderUnlocked();
+}
+
+ExternalModelsLoader & Context::getExternalModelsLoaderUnlocked()
+{
+    if (!shared->external_models_loader)
+        shared->external_models_loader.emplace(getGlobalContext());
+    return *shared->external_models_loader;
+}
+
+void Context::setExternalModelsConfig(const ConfigurationPtr & config, const std::string & config_name)
+{
+    std::lock_guard lock(shared->external_models_mutex);
+
+    if (shared->external_models_config && isSameConfigurationWithMultipleKeys(*config, *shared->external_models_config, "", config_name))
+        return;
+
+    shared->external_models_config = config;
+    shared->models_repository_guard .reset();
+    shared->models_repository_guard = getExternalModelsLoaderUnlocked().addConfigRepository(
+        std::make_unique<ExternalLoaderXMLConfigRepository>(*config, config_name));
 }
 
 
@@ -1371,7 +1390,7 @@ EmbeddedDictionaries & Context::getEmbeddedDictionariesImpl(const bool throw_on_
 
         shared->embedded_dictionaries.emplace(
             std::move(geo_dictionaries_loader),
-            *this->global_context,
+            getGlobalContext(),
             throw_on_error);
     }
 
@@ -1734,6 +1753,17 @@ bool Context::hasAuxiliaryZooKeeper(const String & name) const
     return getConfigRef().has("auxiliary_zookeepers." + name);
 }
 
+InterserverCredentialsPtr Context::getInterserverCredentials()
+{
+    return shared->interserver_io_credentials.get();
+}
+
+void Context::updateInterserverCredentials(const Poco::Util::AbstractConfiguration & config)
+{
+    auto credentials = InterserverCredentials::make(config, "interserver_http_credentials");
+    shared->interserver_io_credentials.set(std::move(credentials));
+}
+
 void Context::setInterserverIOAddress(const String & host, UInt16 port)
 {
     shared->interserver_io_host = host;
@@ -1749,17 +1779,6 @@ std::pair<String, UInt16> Context::getInterserverIOAddress() const
     return { shared->interserver_io_host, shared->interserver_io_port };
 }
 
-void Context::setInterserverCredentials(const String & user_, const String & password)
-{
-    shared->interserver_io_user = user_;
-    shared->interserver_io_password = password;
-}
-
-std::pair<String, String> Context::getInterserverCredentials() const
-{
-    return { shared->interserver_io_user, shared->interserver_io_password };
-}
-
 void Context::setInterserverScheme(const String & scheme)
 {
     shared->interserver_scheme = scheme;
@@ -1891,7 +1910,7 @@ void Context::setCluster(const String & cluster_name, const std::shared_ptr<Clus
 void Context::initializeSystemLogs()
 {
     auto lock = getLock();
-    shared->system_logs.emplace(*global_context, getConfigRef());
+    shared->system_logs.emplace(getGlobalContext(), getConfigRef());
 }
 
 void Context::initializeTraceCollector()
@@ -1978,7 +1997,7 @@ std::shared_ptr<MetricLog> Context::getMetricLog()
 }
 
 
-std::shared_ptr<AsynchronousMetricLog> Context::getAsynchronousMetricLog()
+std::shared_ptr<AsynchronousMetricLog> Context::getAsynchronousMetricLog() const
 {
     auto lock = getLock();
 
@@ -2057,7 +2076,7 @@ DiskSelectorPtr Context::getDiskSelector(std::lock_guard<std::mutex> & /* lock *
         constexpr auto config_name = "storage_configuration.disks";
         const auto & config = getConfigRef();
 
-        shared->merge_tree_disk_selector = std::make_shared<DiskSelector>(config, config_name, *this);
+        shared->merge_tree_disk_selector = std::make_shared<DiskSelector>(config, config_name, shared_from_this());
     }
     return shared->merge_tree_disk_selector;
 }
@@ -2080,17 +2099,20 @@ void Context::updateStorageConfiguration(const Poco::Util::AbstractConfiguration
     std::lock_guard lock(shared->storage_policies_mutex);
 
     if (shared->merge_tree_disk_selector)
-        shared->merge_tree_disk_selector = shared->merge_tree_disk_selector->updateFromConfig(config, "storage_configuration.disks", *this);
+        shared->merge_tree_disk_selector
+            = shared->merge_tree_disk_selector->updateFromConfig(config, "storage_configuration.disks", shared_from_this());
 
     if (shared->merge_tree_storage_policy_selector)
     {
         try
         {
-            shared->merge_tree_storage_policy_selector = shared->merge_tree_storage_policy_selector->updateFromConfig(config, "storage_configuration.policies", shared->merge_tree_disk_selector);
+            shared->merge_tree_storage_policy_selector = shared->merge_tree_storage_policy_selector->updateFromConfig(
+                config, "storage_configuration.policies", shared->merge_tree_disk_selector);
         }
         catch (Exception & e)
         {
-            LOG_ERROR(shared->log, "An error has occurred while reloading storage policies, storage policies were not applied: {}", e.message());
+            LOG_ERROR(
+                shared->log, "An error has occurred while reloading storage policies, storage policies were not applied: {}", e.message());
         }
     }
 
@@ -2223,27 +2245,28 @@ void Context::checkPartitionCanBeDropped(const String & database, const String &
 
 BlockInputStreamPtr Context::getInputFormat(const String & name, ReadBuffer & buf, const Block & sample, UInt64 max_block_size) const
 {
-    return std::make_shared<InputStreamFromInputFormat>(FormatFactory::instance().getInput(name, buf, sample, *this, max_block_size));
+    return std::make_shared<InputStreamFromInputFormat>(
+        FormatFactory::instance().getInput(name, buf, sample, shared_from_this(), max_block_size));
 }
 
 BlockOutputStreamPtr Context::getOutputStreamParallelIfPossible(const String & name, WriteBuffer & buf, const Block & sample) const
 {
-    return FormatFactory::instance().getOutputStreamParallelIfPossible(name, buf, sample, *this);
+    return FormatFactory::instance().getOutputStreamParallelIfPossible(name, buf, sample, shared_from_this());
 }
 
 BlockOutputStreamPtr Context::getOutputStream(const String & name, WriteBuffer & buf, const Block & sample) const
 {
-    return FormatFactory::instance().getOutputStream(name, buf, sample, *this);
+    return FormatFactory::instance().getOutputStream(name, buf, sample, shared_from_this());
 }
 
 OutputFormatPtr Context::getOutputFormatParallelIfPossible(const String & name, WriteBuffer & buf, const Block & sample) const
 {
-    return FormatFactory::instance().getOutputFormatParallelIfPossible(name, buf, sample, *this);
+    return FormatFactory::instance().getOutputFormatParallelIfPossible(name, buf, sample, shared_from_this());
 }
 
 OutputFormatPtr Context::getOutputFormat(const String & name, WriteBuffer & buf, const Block & sample) const
 {
-    return FormatFactory::instance().getOutputFormat(name, buf, sample, *this);
+    return FormatFactory::instance().getOutputFormat(name, buf, sample, shared_from_this());
 }
 
 
@@ -2309,7 +2332,7 @@ void Context::setDefaultProfiles(const Poco::Util::AbstractConfiguration & confi
     applySettingsQuirks(settings, &Poco::Logger::get("SettingsQuirks"));
 
     shared->buffer_profile_name = config.getString("buffer_profile", shared->system_profile_name);
-    buffer_context = std::make_shared<Context>(*this);
+    buffer_context = Context::createCopy(shared_from_this());
     buffer_context->setProfile(shared->buffer_profile_name);
 }
 
@@ -2335,7 +2358,7 @@ void Context::setFormatSchemaPath(const String & path)
 
 Context::SampleBlockCache & Context::getSampleBlockCache() const
 {
-    return getQueryContext().sample_block_cache;
+    return getQueryContext()->sample_block_cache;
 }
 
 
@@ -2358,7 +2381,7 @@ void Context::setQueryParameter(const String & name, const String & value)
 }
 
 
-void Context::addXDBCBridgeCommand(std::unique_ptr<ShellCommand> cmd) const
+void Context::addBridgeCommand(std::unique_ptr<ShellCommand> cmd) const
 {
     auto lock = getLock();
     shared->bridge_commands.emplace_back(std::move(cmd));
@@ -2382,7 +2405,7 @@ std::shared_ptr<ActionLocksManager> Context::getActionLocksManager()
     auto lock = getLock();
 
     if (!shared->action_locks_manager)
-        shared->action_locks_manager = std::make_shared<ActionLocksManager>(*this);
+        shared->action_locks_manager = std::make_shared<ActionLocksManager>(shared_from_this());
 
     return shared->action_locks_manager;
 }
@@ -2400,7 +2423,7 @@ void Context::initializeExternalTablesIfSet()
 {
     if (external_tables_initializer_callback)
     {
-        external_tables_initializer_callback(*this);
+        external_tables_initializer_callback(shared_from_this());
         /// Reset callback
         external_tables_initializer_callback = {};
     }
@@ -2421,7 +2444,7 @@ void Context::initializeInput(const StoragePtr & input_storage)
     if (!input_initializer_callback)
         throw Exception("Input initializer is not set", ErrorCodes::LOGICAL_ERROR);
 
-    input_initializer_callback(*this, input_storage);
+    input_initializer_callback(shared_from_this(), input_storage);
     /// Reset callback
     input_initializer_callback = {};
 }
@@ -2520,12 +2543,12 @@ StorageID Context::resolveStorageIDImpl(StorageID storage_id, StorageNamespace w
     if (look_for_external_table)
     {
         /// Global context should not contain temporary tables
-        assert(global_context != this || getApplicationType() == ApplicationType::LOCAL);
+        assert(!isGlobalContext() || getApplicationType() == ApplicationType::LOCAL);
 
         auto resolved_id = StorageID::createEmpty();
-        auto try_resolve = [&](const Context & context) -> bool
+        auto try_resolve = [&](ContextConstPtr context) -> bool
         {
-            const auto & tables = context.external_tables_mapping;
+            const auto & tables = context->external_tables_mapping;
             auto it = tables.find(storage_id.getTableName());
             if (it == tables.end())
                 return false;
@@ -2534,17 +2557,19 @@ StorageID Context::resolveStorageIDImpl(StorageID storage_id, StorageNamespace w
         };
 
         /// Firstly look for temporary table in current context
-        if (try_resolve(*this))
+        if (try_resolve(shared_from_this()))
             return resolved_id;
 
         /// If not found and current context was created from some query context, look for temporary table in query context
-        bool is_local_context = query_context && query_context != this;
-        if (is_local_context && try_resolve(*query_context))
+        auto query_context_ptr = query_context.lock();
+        bool is_local_context = query_context_ptr && query_context_ptr.get() != this;
+        if (is_local_context && try_resolve(query_context_ptr))
             return resolved_id;
 
         /// If not found and current context was created from some session context, look for temporary table in session context
-        bool is_local_or_query_context = session_context && session_context != this;
-        if (is_local_or_query_context && try_resolve(*session_context))
+        auto session_context_ptr = session_context.lock();
+        bool is_local_or_query_context = session_context_ptr && session_context_ptr.get() != this;
+        if (is_local_or_query_context && try_resolve(session_context_ptr))
             return resolved_id;
     }
 
@@ -2571,7 +2596,7 @@ StorageID Context::resolveStorageIDImpl(StorageID storage_id, StorageNamespace w
 void Context::initZooKeeperMetadataTransaction(ZooKeeperMetadataTransactionPtr txn, [[maybe_unused]] bool attach_existing)
 {
     assert(!metadata_transaction);
-    assert(attach_existing || query_context == this);
+    assert(attach_existing || query_context.lock().get() == this);
     metadata_transaction = std::move(txn);
 }
 
diff --git a/src/Interpreters/Context.h b/src/Interpreters/Context.h
index 5c98a2ba64a..b5912738833 100644
--- a/src/Interpreters/Context.h
+++ b/src/Interpreters/Context.h
@@ -1,19 +1,26 @@
 #pragma once
 
+#include <Access/RowPolicy.h>
 #include <Core/Block.h>
 #include <Core/NamesAndTypes.h>
 #include <Core/Settings.h>
-#include <common/types.h>
 #include <Core/UUID.h>
 #include <DataStreams/IBlockStream_fwd.h>
 #include <Interpreters/ClientInfo.h>
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/DatabaseCatalog.h>
 #include <Parsers/IAST_fwd.h>
-#include <Access/RowPolicy.h>
-#include <Common/MultiVersion.h>
-#include <Common/ThreadPool.h>
-#include <Common/OpenTelemetryTraceContext.h>
 #include <Storages/IStorage_fwd.h>
+#include <Common/MultiVersion.h>
+#include <Common/OpenTelemetryTraceContext.h>
+#include <Common/RemoteHostFilter.h>
+#include <Common/ThreadPool.h>
+#include <common/types.h>
+
+#if !defined(ARCADIA_BUILD)
+#    include "config_core.h"
+#endif
+
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
@@ -22,32 +29,16 @@
 #include <mutex>
 #include <optional>
 #include <thread>
-#include <Common/RemoteHostFilter.h>
-
-#if !defined(ARCADIA_BUILD)
-#    include "config_core.h"
-#endif
 
 
-namespace Poco
-{
-    namespace Net
-    {
-        class IPAddress;
-    }
-}
-
-namespace zkutil
-{
-    class ZooKeeper;
-}
+namespace Poco::Net { class IPAddress; }
+namespace zkutil { class ZooKeeper; }
 
 
 namespace DB
 {
 
-struct ContextShared;
-class Context;
+struct ContextSharedPart;
 class ContextAccess;
 struct User;
 using UserPtr = std::shared_ptr<const User>;
@@ -61,6 +52,8 @@ class AccessRightsElements;
 class EmbeddedDictionaries;
 class ExternalDictionariesLoader;
 class ExternalModelsLoader;
+class InterserverCredentials;
+using InterserverCredentialsPtr = std::shared_ptr<const InterserverCredentials>;
 class InterserverIOHandler;
 class BackgroundSchedulePool;
 class MergeList;
@@ -128,15 +121,12 @@ class CompiledExpressionCache;
 #endif
 
 /// Callback for external tables initializer
-using ExternalTablesInitializer = std::function<void(Context &)>;
+using ExternalTablesInitializer = std::function<void(ContextPtr)>;
 
 /// Callback for initialize input()
-using InputInitializer = std::function<void(Context &, const StoragePtr &)>;
+using InputInitializer = std::function<void(ContextPtr, const StoragePtr &)>;
 /// Callback for reading blocks of data from client for function input()
-using InputBlocksReader = std::function<Block(Context &)>;
-
-/// Scalar results of sub queries
-using Scalars = std::map<String, Block>;
+using InputBlocksReader = std::function<Block(ContextPtr)>;
 
 /// An empty interface for an arbitrary object that may be attached by a shared pointer
 /// to query context, when using ClickHouse as a library.
@@ -153,15 +143,16 @@ struct SharedContextHolder
 {
     ~SharedContextHolder();
     SharedContextHolder();
-    SharedContextHolder(std::unique_ptr<ContextShared> shared_context);
+    explicit SharedContextHolder(std::unique_ptr<ContextSharedPart> shared_context);
     SharedContextHolder(SharedContextHolder &&) noexcept;
 
     SharedContextHolder & operator=(SharedContextHolder &&);
 
-    ContextShared * get() const { return shared.get(); }
+    ContextSharedPart * get() const { return shared.get(); }
     void reset();
+
 private:
-    std::unique_ptr<ContextShared> shared;
+    std::unique_ptr<ContextSharedPart> shared;
 };
 
 /** A set of known objects that can be used in the query.
@@ -170,10 +161,10 @@ private:
   *
   * Everything is encapsulated for all sorts of checks and locks.
   */
-class Context
+class Context: public std::enable_shared_from_this<Context>
 {
 private:
-    ContextShared * shared;
+    ContextSharedPart * shared;
 
     ClientInfo client_info;
     ExternalTablesInitializer external_tables_initializer_callback;
@@ -252,18 +243,19 @@ private:
     /// Needs to be chandged while having const context in factories methods
     mutable QueryFactoriesInfo query_factories_info;
 
-    //TODO maybe replace with temporary tables?
+    /// TODO: maybe replace with temporary tables?
     StoragePtr view_source;                 /// Temporary StorageValues used to generate alias columns for materialized views
     Tables table_function_results;          /// Temporary tables obtained by execution of table functions. Keyed by AST tree id.
 
-    Context * query_context = nullptr;
-    Context * session_context = nullptr;    /// Session context or nullptr. Could be equal to this.
-    Context * global_context = nullptr;     /// Global context. Could be equal to this.
-    std::shared_ptr<Context> buffer_context;/// Buffer context. Could be equal to this.
+    ContextWeakPtr query_context;
+    ContextWeakPtr session_context;  /// Session context or nullptr. Could be equal to this.
+    ContextWeakPtr global_context;   /// Global context. Could be equal to this.
+
+    /// XXX: move this stuff to shared part instead.
+    ContextPtr buffer_context;  /// Buffer context. Could be equal to this.
 
 public:
-    // Top-level OpenTelemetry trace context for the query. Makes sense only for
-    // a query context.
+    // Top-level OpenTelemetry trace context for the query. Makes sense only for a query context.
     OpenTelemetryTraceContext query_trace_context;
 
 private:
@@ -281,7 +273,7 @@ private:
     IHostContextPtr host_context;  /// Arbitrary object that may used to attach some host specific information to query context,
                                    /// when using ClickHouse as a library in some project. For example, it may contain host
                                    /// logger, some query identification information, profiling guards, etc. This field is
-                                   /// to be customized in HTTP and TCP servers by overloading the customizeContext(DB::Context&)
+                                   /// to be customized in HTTP and TCP servers by overloading the customizeContext(DB::ContextPtr)
                                    /// methods.
 
     ZooKeeperMetadataTransactionPtr metadata_transaction;    /// Distributed DDL context. I'm not sure if it's a suitable place for this,
@@ -290,16 +282,20 @@ private:
                                                     /// thousands of signatures.
                                                     /// And I hope it will be replaced with more common Transaction sometime.
 
-    /// Use copy constructor or createGlobal() instead
     Context();
+    Context(const Context &);
+    Context & operator=(const Context &);
 
 public:
     /// Create initial Context with ContextShared and etc.
-    static Context createGlobal(ContextShared * shared);
+    static ContextPtr createGlobal(ContextSharedPart * shared);
+    static ContextPtr createCopy(const ContextWeakConstPtr & other);
+    static ContextPtr createCopy(const ContextConstPtr & other);
+    static ContextPtr createCopy(const ContextPtr & other);
     static SharedContextHolder createShared();
 
-    Context(const Context &);
-    Context & operator=(const Context &);
+    void copyFrom(const ContextPtr & other);
+
     ~Context();
 
     String getPath() const;
@@ -503,8 +499,11 @@ public:
     EmbeddedDictionaries & getEmbeddedDictionaries();
     ExternalDictionariesLoader & getExternalDictionariesLoader();
     ExternalModelsLoader & getExternalModelsLoader();
+    ExternalModelsLoader & getExternalModelsLoaderUnlocked();
     void tryCreateEmbeddedDictionaries() const;
 
+    void setExternalModelsConfig(const ConfigurationPtr & config, const std::string & config_name = "models_config");
+
     /// I/O formats.
     BlockInputStreamPtr getInputFormat(const String & name, ReadBuffer & buf, const Block & sample, UInt64 max_block_size) const;
 
@@ -522,8 +521,8 @@ public:
     std::pair<String, UInt16> getInterserverIOAddress() const;
 
     /// Credentials which server will use to communicate with others
-    void setInterserverCredentials(const String & user, const String & password);
-    std::pair<String, String> getInterserverCredentials() const;
+    void updateInterserverCredentials(const Poco::Util::AbstractConfiguration & config);
+    InterserverCredentialsPtr getInterserverCredentials();
 
     /// Interserver requests scheme (http or https)
     void setInterserverScheme(const String & scheme);
@@ -546,27 +545,29 @@ public:
 
     /// For methods below you may need to acquire the context lock by yourself.
 
-    const Context & getQueryContext() const;
-    Context & getQueryContext();
-    bool hasQueryContext() const { return query_context != nullptr; }
-    bool isInternalSubquery() const { return hasQueryContext() && query_context != this; }
+    ContextPtr getQueryContext() const;
+    bool hasQueryContext() const { return !query_context.expired(); }
+    bool isInternalSubquery() const;
 
-    const Context & getSessionContext() const;
-    Context & getSessionContext();
-    bool hasSessionContext() const { return session_context != nullptr; }
+    ContextPtr getSessionContext() const;
+    bool hasSessionContext() const { return !session_context.expired(); }
 
-    const Context & getGlobalContext() const;
-    Context & getGlobalContext();
-    bool hasGlobalContext() const { return global_context != nullptr; }
+    ContextPtr getGlobalContext() const;
+    bool hasGlobalContext() const { return !global_context.expired(); }
+    bool isGlobalContext() const
+    {
+        auto ptr = global_context.lock();
+        return ptr && ptr.get() == this;
+    }
 
-    const Context & getBufferContext() const;
+    ContextPtr getBufferContext() const;
 
-    void setQueryContext(Context & context_) { query_context = &context_; }
-    void setSessionContext(Context & context_) { session_context = &context_; }
+    void setQueryContext(ContextPtr context_) { query_context = context_; }
+    void setSessionContext(ContextPtr context_) { session_context = context_; }
 
-    void makeQueryContext() { query_context = this; }
-    void makeSessionContext() { session_context = this; }
-    void makeGlobalContext() { initGlobal(); global_context = this; }
+    void makeQueryContext() { query_context = shared_from_this(); }
+    void makeSessionContext() { session_context = shared_from_this(); }
+    void makeGlobalContext() { initGlobal(); global_context = shared_from_this(); }
 
     const Settings & getSettingsRef() const { return settings; }
 
@@ -675,7 +676,7 @@ public:
     std::shared_ptr<TraceLog> getTraceLog();
     std::shared_ptr<TextLog> getTextLog();
     std::shared_ptr<MetricLog> getMetricLog();
-    std::shared_ptr<AsynchronousMetricLog> getAsynchronousMetricLog();
+    std::shared_ptr<AsynchronousMetricLog> getAsynchronousMetricLog() const;
     std::shared_ptr<OpenTelemetrySpanLog> getOpenTelemetrySpanLog();
 
     /// Returns an object used to log operations with parts if it possible.
@@ -747,7 +748,7 @@ public:
     void setQueryParameters(const NameToNameMap & parameters) { query_parameters = parameters; }
 
     /// Add started bridge command. It will be killed after context destruction
-    void addXDBCBridgeCommand(std::unique_ptr<ShellCommand> cmd) const;
+    void addBridgeCommand(std::unique_ptr<ShellCommand> cmd) const;
 
     IHostContextPtr & getHostContext();
     const IHostContextPtr & getHostContext() const;
@@ -788,6 +789,9 @@ private:
     StoragePolicySelectorPtr getStoragePolicySelector(std::lock_guard<std::mutex> & lock) const;
 
     DiskSelectorPtr getDiskSelector(std::lock_guard<std::mutex> & /* lock */) const;
+
+    /// If the password is not set, the password will not be checked
+    void setUserImpl(const String & name, const std::optional<String> & password, const Poco::Net::SocketAddress & address);
 };
 
 
@@ -801,12 +805,12 @@ struct NamedSession
 {
     NamedSessionKey key;
     UInt64 close_cycle = 0;
-    Context context;
+    ContextPtr context;
     std::chrono::steady_clock::duration timeout;
     NamedSessions & parent;
 
-    NamedSession(NamedSessionKey key_, Context & context_, std::chrono::steady_clock::duration timeout_, NamedSessions & parent_)
-        : key(key_), context(context_), timeout(timeout_), parent(parent_)
+    NamedSession(NamedSessionKey key_, ContextPtr context_, std::chrono::steady_clock::duration timeout_, NamedSessions & parent_)
+        : key(key_), context(Context::createCopy(context_)), timeout(timeout_), parent(parent_)
     {
     }
 
diff --git a/src/Interpreters/Context_fwd.h b/src/Interpreters/Context_fwd.h
new file mode 100644
index 00000000000..d7232717bb2
--- /dev/null
+++ b/src/Interpreters/Context_fwd.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <Common/Exception.h>
+
+#include <map>
+#include <memory>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+class Block;
+
+/// Scalar results of subqueries
+using Scalars = std::map<String, Block>;
+
+class Context;
+
+/// Most used types have shorter names
+/// TODO: in the first part of refactoring all the context pointers are non-const.
+using ContextPtr = std::shared_ptr<Context>;
+using ContextConstPtr = std::shared_ptr<const Context>;
+using ContextWeakPtr = std::weak_ptr<Context>;
+using ContextWeakConstPtr = std::weak_ptr<const Context>;
+
+template <class Shared = ContextPtr>
+struct WithContextImpl
+{
+    using Weak = typename Shared::weak_type;
+    using ConstShared = std::shared_ptr<const typename Shared::element_type>;
+    using ConstWeak = typename ConstShared::weak_type;
+
+    WithContextImpl() = default;
+    explicit WithContextImpl(Weak context_) : context(context_) {}
+
+    inline Shared getContext() const
+    {
+        auto ptr = context.lock();
+        if (!ptr) throw Exception("Context has expired", ErrorCodes::LOGICAL_ERROR);
+        return ptr;
+    }
+
+protected:
+    Weak context;
+};
+
+using WithContext = WithContextImpl<>;
+using WithConstContext = WithContextImpl<ContextConstPtr>;
+
+}
diff --git a/src/Interpreters/CrossToInnerJoinVisitor.cpp b/src/Interpreters/CrossToInnerJoinVisitor.cpp
index 2fcd75b1f23..b6f977cd9b5 100644
--- a/src/Interpreters/CrossToInnerJoinVisitor.cpp
+++ b/src/Interpreters/CrossToInnerJoinVisitor.cpp
@@ -81,86 +81,6 @@ private:
     ASTTableJoin * join = nullptr;
 };
 
-/// Collect all identifiers from ast
-class IdentifiersCollector
-{
-public:
-    using ASTIdentPtr = const ASTIdentifier *;
-    using ASTIdentifiers = std::vector<ASTIdentPtr>;
-    struct Data
-    {
-        ASTIdentifiers idents;
-    };
-
-    static void visit(const ASTPtr & node, Data & data)
-    {
-        if (const auto * ident = node->as<ASTIdentifier>())
-            data.idents.push_back(ident);
-    }
-
-    static bool needChildVisit(const ASTPtr &, const ASTPtr &)
-    {
-        return true;
-    }
-
-    static ASTIdentifiers collect(const ASTPtr & node)
-    {
-        IdentifiersCollector::Data ident_data;
-        ConstInDepthNodeVisitor<IdentifiersCollector, true> ident_visitor(ident_data);
-        ident_visitor.visit(node);
-        return ident_data.idents;
-    }
-};
-
-/// Split expression `expr_1 AND expr_2 AND ... AND expr_n` into vector `[expr_1, expr_2, ..., expr_n]`
-void collectConjunctions(const ASTPtr & node, std::vector<ASTPtr> & members)
-{
-    if (const auto * func = node->as<ASTFunction>(); func && func->name == NameAnd::name)
-    {
-        for (const auto & child : func->arguments->children)
-            collectConjunctions(child, members);
-        return;
-    }
-    members.push_back(node);
-}
-
-std::vector<ASTPtr> collectConjunctions(const ASTPtr & node)
-{
-    std::vector<ASTPtr> members;
-    collectConjunctions(node, members);
-    return members;
-}
-
-std::optional<size_t> getIdentMembership(const ASTIdentifier & ident, const std::vector<TableWithColumnNamesAndTypes> & tables)
-{
-    std::optional<size_t> table_pos = IdentifierSemantic::getMembership(ident);
-    if (table_pos)
-        return table_pos;
-    return IdentifierSemantic::chooseTableColumnMatch(ident, tables, true);
-}
-
-std::optional<size_t> getIdentsMembership(const ASTPtr ast,
-                                          const std::vector<TableWithColumnNamesAndTypes> & tables,
-                                          const Aliases & aliases)
-{
-    auto idents = IdentifiersCollector::collect(ast);
-
-    std::optional<size_t> result;
-    for (const auto * ident : idents)
-    {
-        /// Moving expressions that use column aliases is not supported.
-        if (ident->isShort() && aliases.count(ident->shortName()))
-            return {};
-        const auto pos = getIdentMembership(*ident, tables);
-        if (!pos)
-            return {};
-        if (result && *pos != *result)
-            return {};
-        result = pos;
-    }
-    return result;
-}
-
 bool isAllowedToRewriteCrossJoin(const ASTPtr & node, const Aliases & aliases)
 {
     if (node->as<ASTFunction>())
@@ -193,8 +113,8 @@ std::map<size_t, std::vector<ASTPtr>> moveExpressionToJoinOn(
 
             /// Check if the identifiers are from different joined tables.
             /// If it's a self joint, tables should have aliases.
-            auto left_table_pos = getIdentsMembership(func->arguments->children[0], tables, aliases);
-            auto right_table_pos = getIdentsMembership(func->arguments->children[1], tables, aliases);
+            auto left_table_pos = IdentifierSemantic::getIdentsMembership(func->arguments->children[0], tables, aliases);
+            auto right_table_pos = IdentifierSemantic::getIdentsMembership(func->arguments->children[1], tables, aliases);
 
             /// Identifiers from different table move to JOIN ON
             if (left_table_pos && right_table_pos && *left_table_pos != *right_table_pos)
diff --git a/src/Interpreters/DDLTask.cpp b/src/Interpreters/DDLTask.cpp
index d446422124a..087e5504672 100644
--- a/src/Interpreters/DDLTask.cpp
+++ b/src/Interpreters/DDLTask.cpp
@@ -52,11 +52,11 @@ void DDLLogEntry::assertVersion() const
                                                             "Maximum supported version is {}", version, max_version);
 }
 
-void DDLLogEntry::setSettingsIfRequired(const Context & context)
+void DDLLogEntry::setSettingsIfRequired(ContextPtr context)
 {
-    version = context.getSettingsRef().distributed_ddl_entry_format_version;
+    version = context->getSettingsRef().distributed_ddl_entry_format_version;
     if (version == 2)
-        settings.emplace(context.getSettingsRef().changes());
+        settings.emplace(context->getSettingsRef().changes());
 }
 
 String DDLLogEntry::toString() const
@@ -135,19 +135,19 @@ void DDLLogEntry::parse(const String & data)
 }
 
 
-void DDLTaskBase::parseQueryFromEntry(const Context & context)
+void DDLTaskBase::parseQueryFromEntry(ContextPtr context)
 {
     const char * begin = entry.query.data();
     const char * end = begin + entry.query.size();
 
     ParserQuery parser_query(end);
     String description;
-    query = parseQuery(parser_query, begin, end, description, 0, context.getSettingsRef().max_parser_depth);
+    query = parseQuery(parser_query, begin, end, description, 0, context->getSettingsRef().max_parser_depth);
 }
 
-std::unique_ptr<Context> DDLTaskBase::makeQueryContext(Context & from_context, const ZooKeeperPtr & /*zookeeper*/)
+ContextPtr DDLTaskBase::makeQueryContext(ContextPtr from_context, const ZooKeeperPtr & /*zookeeper*/)
 {
-    auto query_context = std::make_unique<Context>(from_context);
+    auto query_context = Context::createCopy(from_context);
     query_context->makeQueryContext();
     query_context->setCurrentQueryId(""); // generate random query_id
     query_context->getClientInfo().query_kind = ClientInfo::QueryKind::SECONDARY_QUERY;
@@ -157,17 +157,17 @@ std::unique_ptr<Context> DDLTaskBase::makeQueryContext(Context & from_context, c
 }
 
 
-bool DDLTask::findCurrentHostID(const Context & global_context, Poco::Logger * log)
+bool DDLTask::findCurrentHostID(ContextPtr global_context, Poco::Logger * log)
 {
     bool host_in_hostlist = false;
 
     for (const HostID & host : entry.hosts)
     {
-        auto maybe_secure_port = global_context.getTCPPortSecure();
+        auto maybe_secure_port = global_context->getTCPPortSecure();
 
         /// The port is considered local if it matches TCP or TCP secure port that the server is listening.
         bool is_local_port = (maybe_secure_port && host.isLocalAddress(*maybe_secure_port))
-                             || host.isLocalAddress(global_context.getTCPPort());
+                             || host.isLocalAddress(global_context->getTCPPort());
 
         if (!is_local_port)
             continue;
@@ -189,14 +189,14 @@ bool DDLTask::findCurrentHostID(const Context & global_context, Poco::Logger * l
     return host_in_hostlist;
 }
 
-void DDLTask::setClusterInfo(const Context & context, Poco::Logger * log)
+void DDLTask::setClusterInfo(ContextPtr context, Poco::Logger * log)
 {
     auto * query_on_cluster = dynamic_cast<ASTQueryWithOnCluster *>(query.get());
     if (!query_on_cluster)
         throw Exception("Received unknown DDL query", ErrorCodes::UNKNOWN_TYPE_OF_QUERY);
 
     cluster_name = query_on_cluster->cluster;
-    cluster = context.tryGetCluster(cluster_name);
+    cluster = context->tryGetCluster(cluster_name);
 
     if (!cluster)
         throw Exception(ErrorCodes::INCONSISTENT_CLUSTER_DEFINITION,
@@ -277,7 +277,7 @@ bool DDLTask::tryFindHostInCluster()
     return found_exact_match;
 }
 
-bool DDLTask::tryFindHostInClusterViaResolving(const Context & context)
+bool DDLTask::tryFindHostInClusterViaResolving(ContextPtr context)
 {
     const auto & shards = cluster->getShardsAddresses();
     bool found_via_resolving = false;
@@ -288,9 +288,9 @@ bool DDLTask::tryFindHostInClusterViaResolving(const Context & context)
         {
             const Cluster::Address & address = shards[shard_num][replica_num];
 
-            if (auto resolved = address.getResolvedAddress();
-                resolved && (isLocalAddress(*resolved, context.getTCPPort())
-                             || (context.getTCPPortSecure() && isLocalAddress(*resolved, *context.getTCPPortSecure()))))
+            if (auto resolved = address.getResolvedAddress(); resolved
+                && (isLocalAddress(*resolved, context->getTCPPort())
+                    || (context->getTCPPortSecure() && isLocalAddress(*resolved, *context->getTCPPortSecure()))))
             {
                 if (found_via_resolving)
                 {
@@ -344,7 +344,7 @@ String DatabaseReplicatedTask::getShardID() const
     return database->shard_name;
 }
 
-void DatabaseReplicatedTask::parseQueryFromEntry(const Context & context)
+void DatabaseReplicatedTask::parseQueryFromEntry(ContextPtr context)
 {
     DDLTaskBase::parseQueryFromEntry(context);
     if (auto * ddl_query = dynamic_cast<ASTQueryWithTableAndOutput *>(query.get()))
@@ -355,7 +355,7 @@ void DatabaseReplicatedTask::parseQueryFromEntry(const Context & context)
     }
 }
 
-std::unique_ptr<Context> DatabaseReplicatedTask::makeQueryContext(Context & from_context, const ZooKeeperPtr & zookeeper)
+ContextPtr DatabaseReplicatedTask::makeQueryContext(ContextPtr from_context, const ZooKeeperPtr & zookeeper)
 {
     auto query_context = DDLTaskBase::makeQueryContext(from_context, zookeeper);
     query_context->getClientInfo().query_kind = ClientInfo::QueryKind::SECONDARY_QUERY;
diff --git a/src/Interpreters/DDLTask.h b/src/Interpreters/DDLTask.h
index a333bb1af45..874a29f051d 100644
--- a/src/Interpreters/DDLTask.h
+++ b/src/Interpreters/DDLTask.h
@@ -1,4 +1,5 @@
 #pragma once
+
 #include <Core/Types.h>
 #include <Interpreters/Cluster.h>
 #include <Common/ZooKeeper/Types.h>
@@ -63,7 +64,7 @@ struct DDLLogEntry
     String initiator; // optional
     std::optional<SettingsChanges> settings;
 
-    void setSettingsIfRequired(const Context & context);
+    void setSettingsIfRequired(ContextPtr context);
     String toString() const;
     void parse(const String & data);
     void assertVersion() const;
@@ -93,11 +94,11 @@ struct DDLTaskBase
     DDLTaskBase(const DDLTaskBase &) = delete;
     virtual ~DDLTaskBase() = default;
 
-    virtual void parseQueryFromEntry(const Context & context);
+    virtual void parseQueryFromEntry(ContextPtr context);
 
     virtual String getShardID() const = 0;
 
-    virtual std::unique_ptr<Context> makeQueryContext(Context & from_context, const ZooKeeperPtr & zookeeper);
+    virtual ContextPtr makeQueryContext(ContextPtr from_context, const ZooKeeperPtr & zookeeper);
 
     inline String getActiveNodePath() const { return entry_path + "/active/" + host_id_str; }
     inline String getFinishedNodePath() const { return entry_path + "/finished/" + host_id_str; }
@@ -111,15 +112,15 @@ struct DDLTask : public DDLTaskBase
 {
     DDLTask(const String & name, const String & path) : DDLTaskBase(name, path) {}
 
-    bool findCurrentHostID(const Context & global_context, Poco::Logger * log);
+    bool findCurrentHostID(ContextPtr global_context, Poco::Logger * log);
 
-    void setClusterInfo(const Context & context, Poco::Logger * log);
+    void setClusterInfo(ContextPtr context, Poco::Logger * log);
 
     String getShardID() const override;
 
 private:
     bool tryFindHostInCluster();
-    bool tryFindHostInClusterViaResolving(const Context & context);
+    bool tryFindHostInClusterViaResolving(ContextPtr context);
 
     HostID host_id;
     String cluster_name;
@@ -134,8 +135,8 @@ struct DatabaseReplicatedTask : public DDLTaskBase
     DatabaseReplicatedTask(const String & name, const String & path, DatabaseReplicated * database_);
 
     String getShardID() const override;
-    void parseQueryFromEntry(const Context & context) override;
-    std::unique_ptr<Context> makeQueryContext(Context & from_context, const ZooKeeperPtr & zookeeper) override;
+    void parseQueryFromEntry(ContextPtr context) override;
+    ContextPtr makeQueryContext(ContextPtr from_context, const ZooKeeperPtr & zookeeper) override;
 
     DatabaseReplicated * database;
 };
diff --git a/src/Interpreters/DDLWorker.cpp b/src/Interpreters/DDLWorker.cpp
index eceb48ae773..6081f06b25f 100644
--- a/src/Interpreters/DDLWorker.cpp
+++ b/src/Interpreters/DDLWorker.cpp
@@ -29,6 +29,7 @@
 #include <common/logger_useful.h>
 #include <random>
 #include <pcg_random.hpp>
+#include <ext/scope_guard_safe.h>
 
 namespace fs = std::filesystem;
 
@@ -148,9 +149,15 @@ std::unique_ptr<ZooKeeperLock> createSimpleZooKeeperLock(
 }
 
 
-DDLWorker::DDLWorker(int pool_size_, const std::string & zk_root_dir, const Context & context_, const Poco::Util::AbstractConfiguration * config, const String & prefix,
-                     const String & logger_name, const CurrentMetrics::Metric * max_entry_metric_)
-    : context(context_)
+DDLWorker::DDLWorker(
+    int pool_size_,
+    const std::string & zk_root_dir,
+    ContextPtr context_,
+    const Poco::Util::AbstractConfiguration * config,
+    const String & prefix,
+    const String & logger_name,
+    const CurrentMetrics::Metric * max_entry_metric_)
+    : context(Context::createCopy(context_))
     , log(&Poco::Logger::get(logger_name))
     , pool_size(pool_size_)
     , max_entry_metric(max_entry_metric_)
@@ -176,16 +183,16 @@ DDLWorker::DDLWorker(int pool_size_, const std::string & zk_root_dir, const Cont
         max_tasks_in_queue = std::max<UInt64>(1, config->getUInt64(prefix + ".max_tasks_in_queue", max_tasks_in_queue));
 
         if (config->has(prefix + ".profile"))
-            context.setSetting("profile", config->getString(prefix + ".profile"));
+            context->setSetting("profile", config->getString(prefix + ".profile"));
     }
 
-    if (context.getSettingsRef().readonly)
+    if (context->getSettingsRef().readonly)
     {
         LOG_WARNING(log, "Distributed DDL worker is run with readonly settings, it will not be able to execute DDL queries Set appropriate system_profile or distributed_ddl.profile to fix this.");
     }
 
     host_fqdn = getFQDNOrHostName();
-    host_fqdn_id = Cluster::Address::toString(host_fqdn, context.getTCPPort());
+    host_fqdn_id = Cluster::Address::toString(host_fqdn, context->getTCPPort());
 }
 
 void DDLWorker::startup()
@@ -224,7 +231,7 @@ ZooKeeperPtr DDLWorker::getAndSetZooKeeper()
     std::lock_guard lock(zookeeper_mutex);
 
     if (!current_zookeeper || current_zookeeper->expired())
-        current_zookeeper = context.getZooKeeper();
+        current_zookeeper = context->getZooKeeper();
 
     return current_zookeeper;
 }
@@ -491,8 +498,8 @@ bool DDLWorker::tryExecuteQuery(const String & query, DDLTaskBase & task, const
     {
         auto query_context = task.makeQueryContext(context, zookeeper);
         if (!task.is_initial_query)
-            query_scope.emplace(*query_context);
-        executeQuery(istr, ostr, !task.is_initial_query, *query_context, {});
+            query_scope.emplace(query_context);
+        executeQuery(istr, ostr, !task.is_initial_query, query_context, {});
 
         if (auto txn = query_context->getZooKeeperMetadataTransaction())
         {
@@ -638,7 +645,7 @@ void DDLWorker::processTask(DDLTaskBase & task, const ZooKeeperPtr & zookeeper)
                 if (!query_with_table->table.empty())
                 {
                     /// It's not CREATE DATABASE
-                    auto table_id = context.tryResolveStorageID(*query_with_table, Context::ResolveOrdinary);
+                    auto table_id = context->tryResolveStorageID(*query_with_table, Context::ResolveOrdinary);
                     storage = DatabaseCatalog::instance().tryGetTable(table_id, context);
                 }
 
@@ -820,7 +827,7 @@ bool DDLWorker::tryExecuteQueryOnLeaderReplica(
             zookeeper->set(tries_to_execute_path, toString(counter + 1));
 
             task.ops.push_back(create_shard_flag);
-            SCOPE_EXIT({ if (!executed_by_us && !task.ops.empty()) task.ops.pop_back(); });
+            SCOPE_EXIT_MEMORY({ if (!executed_by_us && !task.ops.empty()) task.ops.pop_back(); });
 
             /// If the leader will unexpectedly changed this method will return false
             /// and on the next iteration new leader will take lock
diff --git a/src/Interpreters/DDLWorker.h b/src/Interpreters/DDLWorker.h
index 4814f232ce2..e92644f0f99 100644
--- a/src/Interpreters/DDLWorker.h
+++ b/src/Interpreters/DDLWorker.h
@@ -42,7 +42,7 @@ class AccessRightsElements;
 class DDLWorker
 {
 public:
-    DDLWorker(int pool_size_, const std::string & zk_root_dir, const Context & context_, const Poco::Util::AbstractConfiguration * config, const String & prefix,
+    DDLWorker(int pool_size_, const std::string & zk_root_dir, ContextPtr context_, const Poco::Util::AbstractConfiguration * config, const String & prefix,
               const String & logger_name = "DDLWorker", const CurrentMetrics::Metric * max_entry_metric_ = nullptr);
     virtual ~DDLWorker();
 
@@ -110,8 +110,7 @@ protected:
     void runMainThread();
     void runCleanupThread();
 
-protected:
-    Context context;
+    ContextPtr context;
     Poco::Logger * log;
 
     std::string host_fqdn;      /// current host domain name
diff --git a/src/Interpreters/DNSCacheUpdater.cpp b/src/Interpreters/DNSCacheUpdater.cpp
index 723945165e3..27d0c3abd92 100644
--- a/src/Interpreters/DNSCacheUpdater.cpp
+++ b/src/Interpreters/DNSCacheUpdater.cpp
@@ -1,15 +1,16 @@
 #include "DNSCacheUpdater.h"
-#include <Common/DNSResolver.h>
+
 #include <Interpreters/Context.h>
+#include <Common/DNSResolver.h>
 
 
 namespace DB
 {
 
-DNSCacheUpdater::DNSCacheUpdater(Context & context_, Int32 update_period_seconds_)
-    : context(context_),
-    update_period_seconds(update_period_seconds_),
-    pool(context_.getSchedulePool())
+DNSCacheUpdater::DNSCacheUpdater(ContextPtr context_, Int32 update_period_seconds_)
+    : WithContext(context_)
+    , update_period_seconds(update_period_seconds_)
+    , pool(getContext()->getSchedulePool())
 {
     task_handle = pool.createTask("DNSCacheUpdater", [this]{ run(); });
 }
@@ -24,7 +25,7 @@ void DNSCacheUpdater::run()
         LOG_INFO(&Poco::Logger::get("DNSCacheUpdater"), "IPs of some hosts have been changed. Will reload cluster config.");
         try
         {
-            context.reloadClusterConfig();
+            getContext()->reloadClusterConfig();
         }
         catch (...)
         {
diff --git a/src/Interpreters/DNSCacheUpdater.h b/src/Interpreters/DNSCacheUpdater.h
index 2cc0f9f0f21..bbbc2ab3d21 100644
--- a/src/Interpreters/DNSCacheUpdater.h
+++ b/src/Interpreters/DNSCacheUpdater.h
@@ -1,26 +1,24 @@
 #pragma once
 
 #include <Core/BackgroundSchedulePool.h>
+#include <Interpreters/Context_fwd.h>
 #include <Common/Stopwatch.h>
 
 
 namespace DB
 {
 
-class Context;
-
 /// Add a task to BackgroundProcessingPool that resolves all hosts and updates cache with constant period.
-class DNSCacheUpdater
+class DNSCacheUpdater : WithContext
 {
 public:
-    explicit DNSCacheUpdater(Context & context, Int32 update_period_seconds_);
+    DNSCacheUpdater(ContextPtr context, Int32 update_period_seconds_);
     ~DNSCacheUpdater();
     void start();
 
 private:
     void run();
 
-    Context & context;
     Int32 update_period_seconds;
 
     BackgroundSchedulePool & pool;
diff --git a/src/Interpreters/DatabaseAndTableWithAlias.h b/src/Interpreters/DatabaseAndTableWithAlias.h
index b889509c264..d2b1d655de7 100644
--- a/src/Interpreters/DatabaseAndTableWithAlias.h
+++ b/src/Interpreters/DatabaseAndTableWithAlias.h
@@ -16,8 +16,6 @@ namespace DB
 class ASTSelectQuery;
 class ASTIdentifier;
 struct ASTTableExpression;
-class Context;
-
 
 /// Extracts database name (and/or alias) from table expression or identifier
 struct DatabaseAndTableWithAlias
@@ -75,7 +73,7 @@ struct TableWithColumnNamesAndTypes
 
     void addMaterializedColumns(const NamesAndTypesList & addition)
     {
-        addAdditionalColumns(alias_columns, addition);
+        addAdditionalColumns(materialized_columns, addition);
     }
 
 private:
diff --git a/src/Interpreters/DatabaseCatalog.cpp b/src/Interpreters/DatabaseCatalog.cpp
index f398074da09..d88b87a73d4 100644
--- a/src/Interpreters/DatabaseCatalog.cpp
+++ b/src/Interpreters/DatabaseCatalog.cpp
@@ -48,9 +48,8 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
-TemporaryTableHolder::TemporaryTableHolder(const Context & context_,
-                                           const TemporaryTableHolder::Creator & creator, const ASTPtr & query)
-    : global_context(context_.getGlobalContext())
+TemporaryTableHolder::TemporaryTableHolder(ContextPtr context_, const TemporaryTableHolder::Creator & creator, const ASTPtr & query)
+    : WithContext(context_->getGlobalContext())
     , temporary_tables(DatabaseCatalog::instance().getDatabaseForTemporaryTables().get())
 {
     ASTPtr original_create;
@@ -73,13 +72,13 @@ TemporaryTableHolder::TemporaryTableHolder(const Context & context_,
     }
     auto table_id = StorageID(DatabaseCatalog::TEMPORARY_DATABASE, global_name, id);
     auto table = creator(table_id);
-    temporary_tables->createTable(global_context, global_name, table, original_create);
+    temporary_tables->createTable(getContext(), global_name, table, original_create);
     table->startup();
 }
 
 
 TemporaryTableHolder::TemporaryTableHolder(
-    const Context & context_,
+    ContextPtr context_,
     const ColumnsDescription & columns,
     const ConstraintsDescription & constraints,
     const ASTPtr & query,
@@ -103,7 +102,7 @@ TemporaryTableHolder::TemporaryTableHolder(
 }
 
 TemporaryTableHolder::TemporaryTableHolder(TemporaryTableHolder && rhs)
-        : global_context(rhs.global_context), temporary_tables(rhs.temporary_tables), id(rhs.id)
+        : WithContext(rhs.context), temporary_tables(rhs.temporary_tables), id(rhs.id)
 {
     rhs.id = UUIDHelpers::Nil;
 }
@@ -118,7 +117,7 @@ TemporaryTableHolder & TemporaryTableHolder::operator = (TemporaryTableHolder &&
 TemporaryTableHolder::~TemporaryTableHolder()
 {
     if (id != UUIDHelpers::Nil)
-        temporary_tables->dropTable(global_context, "_tmp_" + toString(id));
+        temporary_tables->dropTable(getContext(), "_tmp_" + toString(id));
 }
 
 StorageID TemporaryTableHolder::getGlobalTableID() const
@@ -128,7 +127,7 @@ StorageID TemporaryTableHolder::getGlobalTableID() const
 
 StoragePtr TemporaryTableHolder::getTable() const
 {
-    auto table = temporary_tables->tryGetTable("_tmp_" + toString(id), global_context);
+    auto table = temporary_tables->tryGetTable("_tmp_" + toString(id), getContext());
     if (!table)
         throw Exception("Temporary table " + getGlobalTableID().getNameForLogs() + " not found", ErrorCodes::LOGICAL_ERROR);
     return table;
@@ -137,13 +136,13 @@ StoragePtr TemporaryTableHolder::getTable() const
 
 void DatabaseCatalog::loadDatabases()
 {
-    drop_delay_sec = global_context.getConfigRef().getInt("database_atomic_delay_before_drop_table_sec", default_drop_delay_sec);
+    drop_delay_sec = getContext()->getConfigRef().getInt("database_atomic_delay_before_drop_table_sec", default_drop_delay_sec);
 
-    auto db_for_temporary_and_external_tables = std::make_shared<DatabaseMemory>(TEMPORARY_DATABASE, global_context);
+    auto db_for_temporary_and_external_tables = std::make_shared<DatabaseMemory>(TEMPORARY_DATABASE, getContext());
     attachDatabase(TEMPORARY_DATABASE, db_for_temporary_and_external_tables);
 
     loadMarkedAsDroppedTables();
-    auto task_holder = global_context.getSchedulePool().createTask("DatabaseCatalog", [this](){ this->dropTableDataTask(); });
+    auto task_holder = getContext()->getSchedulePool().createTask("DatabaseCatalog", [this](){ this->dropTableDataTask(); });
     drop_task = std::make_unique<BackgroundSchedulePoolTaskHolder>(std::move(task_holder));
     (*drop_task)->activate();
     std::lock_guard lock{tables_marked_dropped_mutex};
@@ -152,7 +151,7 @@ void DatabaseCatalog::loadDatabases()
 
     /// Another background thread which drops temporary LiveViews.
     /// We should start it after loadMarkedAsDroppedTables() to avoid race condition.
-    TemporaryLiveViewCleaner::instance().startupIfNecessary();
+    TemporaryLiveViewCleaner::instance().startup();
 }
 
 void DatabaseCatalog::shutdownImpl()
@@ -212,7 +211,7 @@ DatabaseAndTable DatabaseCatalog::tryGetByUUID(const UUID & uuid) const
 
 DatabaseAndTable DatabaseCatalog::getTableImpl(
     const StorageID & table_id,
-    const Context & context,
+    ContextPtr context_,
     std::optional<Exception> * exception) const
 {
     if (!table_id)
@@ -268,7 +267,7 @@ DatabaseAndTable DatabaseCatalog::getTableImpl(
         database = it->second;
     }
 
-    auto table = database->tryGetTable(table_id.table_name, context);
+    auto table = database->tryGetTable(table_id.table_name, context_);
     if (!table && exception)
             exception->emplace(ErrorCodes::UNKNOWN_TABLE, "Table {} doesn't exist", table_id.getNameForLogs());
     if (!table)
@@ -351,11 +350,11 @@ DatabasePtr DatabaseCatalog::detachDatabase(const String & database_name, bool d
     if (drop)
     {
         /// Delete the database.
-        db->drop(global_context);
+        db->drop(getContext());
 
         /// Old ClickHouse versions did not store database.sql files
         Poco::File database_metadata_file(
-                global_context.getPath() + "metadata/" + escapeForFileName(database_name) + ".sql");
+                getContext()->getPath() + "metadata/" + escapeForFileName(database_name) + ".sql");
         if (database_metadata_file.exists())
             database_metadata_file.remove(false);
     }
@@ -423,7 +422,7 @@ Databases DatabaseCatalog::getDatabases() const
     return databases;
 }
 
-bool DatabaseCatalog::isTableExist(const DB::StorageID & table_id, const Context & context) const
+bool DatabaseCatalog::isTableExist(const DB::StorageID & table_id, ContextPtr context_) const
 {
     if (table_id.hasUUID())
         return tryGetByUUID(table_id.uuid).second != nullptr;
@@ -435,12 +434,12 @@ bool DatabaseCatalog::isTableExist(const DB::StorageID & table_id, const Context
         if (iter != databases.end())
             db = iter->second;
     }
-    return db && db->isTableExist(table_id.table_name, context);
+    return db && db->isTableExist(table_id.table_name, context_);
 }
 
-void DatabaseCatalog::assertTableDoesntExist(const StorageID & table_id, const Context & context) const
+void DatabaseCatalog::assertTableDoesntExist(const StorageID & table_id, ContextPtr context_) const
 {
-    if (isTableExist(table_id, context))
+    if (isTableExist(table_id, context_))
         throw Exception("Table " + table_id.getNameForLogs() + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS);
 }
 
@@ -528,13 +527,13 @@ void DatabaseCatalog::updateUUIDMapping(const UUID & uuid, DatabasePtr database,
 
 std::unique_ptr<DatabaseCatalog> DatabaseCatalog::database_catalog;
 
-DatabaseCatalog::DatabaseCatalog(Context & global_context_)
-    : global_context(global_context_), log(&Poco::Logger::get("DatabaseCatalog"))
+DatabaseCatalog::DatabaseCatalog(ContextPtr global_context_)
+    : WithContext(global_context_), log(&Poco::Logger::get("DatabaseCatalog"))
 {
-    TemporaryLiveViewCleaner::init(global_context);
+    TemporaryLiveViewCleaner::init(global_context_);
 }
 
-DatabaseCatalog & DatabaseCatalog::init(Context & global_context_)
+DatabaseCatalog & DatabaseCatalog::init(ContextPtr global_context_)
 {
     if (database_catalog)
     {
@@ -568,9 +567,9 @@ void DatabaseCatalog::shutdown()
     }
 }
 
-DatabasePtr DatabaseCatalog::getDatabase(const String & database_name, const Context & local_context) const
+DatabasePtr DatabaseCatalog::getDatabase(const String & database_name, ContextPtr local_context) const
 {
-    String resolved_database = local_context.resolveDatabase(database_name);
+    String resolved_database = local_context->resolveDatabase(database_name);
     return getDatabase(resolved_database);
 }
 
@@ -635,32 +634,32 @@ bool DatabaseCatalog::isDictionaryExist(const StorageID & table_id) const
     return db && db->isDictionaryExist(table_id.getTableName());
 }
 
-StoragePtr DatabaseCatalog::getTable(const StorageID & table_id, const Context & context) const
+StoragePtr DatabaseCatalog::getTable(const StorageID & table_id, ContextPtr local_context) const
 {
     std::optional<Exception> exc;
-    auto res = getTableImpl(table_id, context, &exc);
+    auto res = getTableImpl(table_id, local_context, &exc);
     if (!res.second)
         throw Exception(*exc);
     return res.second;
 }
 
-StoragePtr DatabaseCatalog::tryGetTable(const StorageID & table_id, const Context & context) const
+StoragePtr DatabaseCatalog::tryGetTable(const StorageID & table_id, ContextPtr local_context) const
 {
-    return getTableImpl(table_id, context, nullptr).second;
+    return getTableImpl(table_id, local_context, nullptr).second;
 }
 
-DatabaseAndTable DatabaseCatalog::getDatabaseAndTable(const StorageID & table_id, const Context & context) const
+DatabaseAndTable DatabaseCatalog::getDatabaseAndTable(const StorageID & table_id, ContextPtr local_context) const
 {
     std::optional<Exception> exc;
-    auto res = getTableImpl(table_id, context, &exc);
+    auto res = getTableImpl(table_id, local_context, &exc);
     if (!res.second)
         throw Exception(*exc);
     return res;
 }
 
-DatabaseAndTable DatabaseCatalog::tryGetDatabaseAndTable(const StorageID & table_id, const Context & context) const
+DatabaseAndTable DatabaseCatalog::tryGetDatabaseAndTable(const StorageID & table_id, ContextPtr local_context) const
 {
-    return getTableImpl(table_id, context, nullptr);
+    return getTableImpl(table_id, local_context, nullptr);
 }
 
 void DatabaseCatalog::loadMarkedAsDroppedTables()
@@ -673,7 +672,7 @@ void DatabaseCatalog::loadMarkedAsDroppedTables()
     /// we should load them and enqueue cleanup to remove data from store/ and metadata from ZooKeeper
 
     std::map<String, StorageID> dropped_metadata;
-    String path = global_context.getPath() + "metadata_dropped/";
+    String path = getContext()->getPath() + "metadata_dropped/";
 
     if (!std::filesystem::exists(path))
     {
@@ -728,7 +727,7 @@ void DatabaseCatalog::loadMarkedAsDroppedTables()
 
 String DatabaseCatalog::getPathForDroppedMetadata(const StorageID & table_id) const
 {
-    return global_context.getPath() + "metadata_dropped/" +
+    return getContext()->getPath() + "metadata_dropped/" +
            escapeForFileName(table_id.getDatabaseName()) + "." +
            escapeForFileName(table_id.getTableName()) + "." +
            toString(table_id.uuid) + ".sql";
@@ -751,7 +750,8 @@ void DatabaseCatalog::enqueueDroppedTableCleanup(StorageID table_id, StoragePtr
     {
         /// Try load table from metadata to drop it correctly (e.g. remove metadata from zk or remove data from all volumes)
         LOG_INFO(log, "Trying load partially dropped table {} from {}", table_id.getNameForLogs(), dropped_metadata_path);
-        ASTPtr ast = DatabaseOnDisk::parseQueryFromMetadata(log, global_context, dropped_metadata_path, /*throw_on_error*/ false, /*remove_empty*/false);
+        ASTPtr ast = DatabaseOnDisk::parseQueryFromMetadata(
+            log, getContext(), dropped_metadata_path, /*throw_on_error*/ false, /*remove_empty*/ false);
         auto * create = typeid_cast<ASTCreateQuery *>(ast.get());
         assert(!create || create->uuid == table_id.uuid);
 
@@ -762,7 +762,7 @@ void DatabaseCatalog::enqueueDroppedTableCleanup(StorageID table_id, StoragePtr
             create->table = table_id.table_name;
             try
             {
-                table = createTableFromAST(*create, table_id.getDatabaseName(), data_path, global_context, false).second;
+                table = createTableFromAST(*create, table_id.getDatabaseName(), data_path, getContext(), false).second;
                 table->is_dropped = true;
             }
             catch (...)
@@ -889,7 +889,7 @@ void DatabaseCatalog::dropTableFinally(const TableMarkedAsDropped & table)
 
     /// Even if table is not loaded, try remove its data from disk.
     /// TODO remove data from all volumes
-    String data_path = global_context.getPath() + "store/" + getPathForUUID(table.table_id.uuid);
+    String data_path = getContext()->getPath() + "store/" + getPathForUUID(table.table_id.uuid);
     Poco::File table_data_dir{data_path};
     if (table_data_dir.exists())
     {
diff --git a/src/Interpreters/DatabaseCatalog.h b/src/Interpreters/DatabaseCatalog.h
index dad9846da0b..388079b54f2 100644
--- a/src/Interpreters/DatabaseCatalog.h
+++ b/src/Interpreters/DatabaseCatalog.h
@@ -1,25 +1,28 @@
 #pragma once
-#include <Storages/IStorage_fwd.h>
+
+#include <Core/UUID.h>
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/StorageID.h>
 #include <Parsers/IAST_fwd.h>
-#include <Core/UUID.h>
-#include <Poco/Logger.h>
+#include <Storages/IStorage_fwd.h>
+
 #include <boost/noncopyable.hpp>
-#include <memory>
-#include <map>
-#include <set>
-#include <unordered_map>
-#include <unordered_set>
-#include <mutex>
-#include <shared_mutex>
+#include <Poco/Logger.h>
+
 #include <array>
 #include <list>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <shared_mutex>
+#include <unordered_map>
+#include <unordered_set>
 
 
 namespace DB
 {
 
-class Context;
 class IDatabase;
 class Exception;
 class ColumnsDescription;
@@ -51,7 +54,12 @@ public:
     /// NOTE: using std::map here (and not std::unordered_map) to avoid iterator invalidation on insertion.
     using Map = std::map<String, Entry>;
 
-    DDLGuard(Map & map_, std::shared_mutex & db_mutex_, std::unique_lock<std::mutex> guards_lock_, const String & elem, const String & database_name);
+    DDLGuard(
+        Map & map_,
+        std::shared_mutex & db_mutex_,
+        std::unique_lock<std::mutex> guards_lock_,
+        const String & elem,
+        const String & database_name);
     ~DDLGuard();
 
     /// Unlocks table name, keeps holding read lock for database name
@@ -74,15 +82,15 @@ using DDLGuardPtr = std::unique_ptr<DDLGuard>;
 /// Such table can be accessed from everywhere by its ID.
 /// Removes the table from database on destruction.
 /// TemporaryTableHolder object can be attached to a query or session Context, so table will be accessible through the context.
-struct TemporaryTableHolder : boost::noncopyable
+struct TemporaryTableHolder : boost::noncopyable, WithContext
 {
-    typedef std::function<StoragePtr(const StorageID &)> Creator;
+    using Creator = std::function<StoragePtr (const StorageID &)>;
 
-    TemporaryTableHolder(const Context & context, const Creator & creator, const ASTPtr & query = {});
+    TemporaryTableHolder(ContextPtr context, const Creator & creator, const ASTPtr & query = {});
 
     /// Creates temporary table with Engine=Memory
     TemporaryTableHolder(
-        const Context & context,
+        ContextPtr context,
         const ColumnsDescription & columns,
         const ConstraintsDescription & constraints,
         const ASTPtr & query = {},
@@ -99,7 +107,6 @@ struct TemporaryTableHolder : boost::noncopyable
 
     operator bool () const { return id != UUIDHelpers::Nil; }
 
-    const Context & global_context;
     IDatabase * temporary_tables = nullptr;
     UUID id = UUIDHelpers::Nil;
 };
@@ -109,13 +116,14 @@ using TemporaryTablesMapping = std::map<String, std::shared_ptr<TemporaryTableHo
 
 class BackgroundSchedulePoolTaskHolder;
 
-class DatabaseCatalog : boost::noncopyable
+/// For some reason Context is required to get Storage from Database object
+class DatabaseCatalog : boost::noncopyable, WithContext
 {
 public:
     static constexpr const char * TEMPORARY_DATABASE = "_temporary_and_external_tables";
     static constexpr const char * SYSTEM_DATABASE = "system";
 
-    static DatabaseCatalog & init(Context & global_context_);
+    static DatabaseCatalog & init(ContextPtr global_context_);
     static DatabaseCatalog & instance();
     static void shutdown();
 
@@ -146,19 +154,19 @@ public:
     Databases getDatabases() const;
 
     /// Same as getDatabase(const String & database_name), but if database_name is empty, current database of local_context is used
-    DatabasePtr getDatabase(const String & database_name, const Context & local_context) const;
+    DatabasePtr getDatabase(const String & database_name, ContextPtr local_context) const;
 
     /// For all of the following methods database_name in table_id must be not empty (even for temporary tables).
-    void assertTableDoesntExist(const StorageID & table_id, const Context & context) const;
-    bool isTableExist(const StorageID & table_id, const Context & context) const;
+    void assertTableDoesntExist(const StorageID & table_id, ContextPtr context) const;
+    bool isTableExist(const StorageID & table_id, ContextPtr context) const;
     bool isDictionaryExist(const StorageID & table_id) const;
 
-    StoragePtr getTable(const StorageID & table_id, const Context & context) const;
-    StoragePtr tryGetTable(const StorageID & table_id, const Context & context) const;
-    DatabaseAndTable getDatabaseAndTable(const StorageID & table_id, const Context & context) const;
-    DatabaseAndTable tryGetDatabaseAndTable(const StorageID & table_id, const Context & context) const;
+    StoragePtr getTable(const StorageID & table_id, ContextPtr context) const;
+    StoragePtr tryGetTable(const StorageID & table_id, ContextPtr context) const;
+    DatabaseAndTable getDatabaseAndTable(const StorageID & table_id, ContextPtr context) const;
+    DatabaseAndTable tryGetDatabaseAndTable(const StorageID & table_id, ContextPtr context) const;
     DatabaseAndTable getTableImpl(const StorageID & table_id,
-                                  const Context & context,
+                                  ContextPtr context,
                                   std::optional<Exception> * exception = nullptr) const;
 
     void addDependency(const StorageID & from, const StorageID & where);
@@ -200,7 +208,7 @@ private:
     // make emplace(global_context_) compile with private constructor ¯\_(ツ)_/¯.
     static std::unique_ptr<DatabaseCatalog> database_catalog;
 
-    DatabaseCatalog(Context & global_context_);
+    explicit DatabaseCatalog(ContextPtr global_context_);
     void assertDatabaseExistsUnlocked(const String & database_name) const;
     void assertDatabaseDoesntExistUnlocked(const String & database_name) const;
 
@@ -216,7 +224,7 @@ private:
     static constexpr UInt64 bits_for_first_level = 4;
     using UUIDToStorageMap = std::array<UUIDToStorageMapPart, 1ull << bits_for_first_level>;
 
-    inline size_t getFirstLevelIdx(const UUID & uuid) const
+    static inline size_t getFirstLevelIdx(const UUID & uuid)
     {
         return uuid.toUnderType().low >> (64 - bits_for_first_level);
     }
@@ -237,11 +245,8 @@ private:
     static constexpr size_t reschedule_time_ms = 100;
     static constexpr time_t drop_error_cooldown_sec = 5;
 
-private:
     using UUIDToDatabaseMap = std::unordered_map<UUID, DatabasePtr>;
 
-    /// For some reason Context is required to get Storage from Database object
-    Context & global_context;
     mutable std::mutex databases_mutex;
 
     ViewDependencies view_dependencies;
diff --git a/src/Interpreters/DictionaryReader.cpp b/src/Interpreters/DictionaryReader.cpp
index 1b503bd8313..fc795b9cdfb 100644
--- a/src/Interpreters/DictionaryReader.cpp
+++ b/src/Interpreters/DictionaryReader.cpp
@@ -44,7 +44,7 @@ DictionaryReader::FunctionWrapper::FunctionWrapper(FunctionOverloadResolverPtr r
 static constexpr const size_t key_size = 1;
 
 DictionaryReader::DictionaryReader(const String & dictionary_name, const Names & src_column_names, const NamesAndTypesList & result_columns,
-                                   const Context & context)
+                                   ContextPtr context)
     : result_header(makeResultBlock(result_columns))
     , key_position(key_size + result_header.columns())
 {
diff --git a/src/Interpreters/DictionaryReader.h b/src/Interpreters/DictionaryReader.h
index b49a15debb3..bfb21e2f050 100644
--- a/src/Interpreters/DictionaryReader.h
+++ b/src/Interpreters/DictionaryReader.h
@@ -3,12 +3,11 @@
 #include <Core/Block.h>
 #include <Columns/ColumnVector.h>
 #include <Functions/IFunctionAdaptors.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
 
-class Context;
-
 /// Read block of required columns from Dictionary by UInt64 key column. Rename columns if needed.
 /// Current implementation uses dictHas() + N * dictGet() functions.
 class DictionaryReader
@@ -35,7 +34,7 @@ public:
     };
 
     DictionaryReader(const String & dictionary_name, const Names & src_column_names, const NamesAndTypesList & result_columns,
-                     const Context & context);
+                     ContextPtr context);
     void readKeys(const IColumn & keys, Block & out_block, ColumnVector<UInt8>::Container & found, std::vector<size_t> & positions) const;
 
 private:
diff --git a/src/Interpreters/DuplicateOrderByVisitor.h b/src/Interpreters/DuplicateOrderByVisitor.h
index f5e5763c719..4f95854e17b 100644
--- a/src/Interpreters/DuplicateOrderByVisitor.h
+++ b/src/Interpreters/DuplicateOrderByVisitor.h
@@ -21,7 +21,7 @@ class ASTFunctionStatefulData
 public:
     using TypeToVisit = ASTFunction;
 
-    const Context & context;
+    ContextPtr context;
     bool & is_stateful;
     void visit(ASTFunction & ast_function, ASTPtr &)
     {
@@ -80,7 +80,7 @@ class DuplicateOrderByData
 public:
     using TypeToVisit = ASTSelectQuery;
 
-    const Context & context;
+    ContextPtr context;
 
     void visit(ASTSelectQuery & select_query, ASTPtr &)
     {
diff --git a/src/Interpreters/EmbeddedDictionaries.cpp b/src/Interpreters/EmbeddedDictionaries.cpp
index 58b21fdda52..947768ad3d7 100644
--- a/src/Interpreters/EmbeddedDictionaries.cpp
+++ b/src/Interpreters/EmbeddedDictionaries.cpp
@@ -35,7 +35,7 @@ bool EmbeddedDictionaries::reloadDictionary(
     const bool throw_on_error,
     const bool force_reload)
 {
-    const auto & config = context.getConfigRef();
+    const auto & config = getContext()->getConfigRef();
 
     bool not_initialized = dictionary.get() == nullptr;
 
@@ -122,12 +122,12 @@ void EmbeddedDictionaries::reloadPeriodically()
 
 EmbeddedDictionaries::EmbeddedDictionaries(
     std::unique_ptr<GeoDictionariesLoader> geo_dictionaries_loader_,
-    Context & context_,
+    ContextPtr context_,
     const bool throw_on_error)
-    : log(&Poco::Logger::get("EmbeddedDictionaries"))
-    , context(context_)
+    : WithContext(context_)
+    , log(&Poco::Logger::get("EmbeddedDictionaries"))
     , geo_dictionaries_loader(std::move(geo_dictionaries_loader_))
-    , reload_period(context_.getConfigRef().getInt("builtin_dictionaries_reload_interval", 3600))
+    , reload_period(getContext()->getConfigRef().getInt("builtin_dictionaries_reload_interval", 3600))
 {
     reloadImpl(throw_on_error);
     reloading_thread = ThreadFromGlobalPool([this] { reloadPeriodically(); });
diff --git a/src/Interpreters/EmbeddedDictionaries.h b/src/Interpreters/EmbeddedDictionaries.h
index 69b21d4b39a..674b3a7f01e 100644
--- a/src/Interpreters/EmbeddedDictionaries.h
+++ b/src/Interpreters/EmbeddedDictionaries.h
@@ -1,10 +1,13 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
+#include <Common/MultiVersion.h>
+#include <Common/ThreadPool.h>
+
+#include <Poco/Event.h>
+
 #include <thread>
 #include <functional>
-#include <Common/MultiVersion.h>
-#include <Common/ThreadPool.h>
-#include <Poco/Event.h>
 
 
 namespace Poco { class Logger; namespace Util { class AbstractConfiguration; } }
@@ -17,16 +20,12 @@ class GeoDictionariesLoader;
 namespace DB
 {
 
-class Context;
-
-
 /// Metrica's Dictionaries which can be used in functions.
 
-class EmbeddedDictionaries
+class EmbeddedDictionaries : WithContext
 {
 private:
     Poco::Logger * log;
-    Context & context;
 
     MultiVersion<RegionsHierarchies> regions_hierarchies;
     MultiVersion<RegionsNames> regions_names;
@@ -44,7 +43,7 @@ private:
     Poco::Event destroy;
 
 
-    void handleException(const bool throw_on_error) const;
+    void handleException(bool throw_on_error) const;
 
     /** Updates directories (dictionaries) every reload_period seconds.
      * If all dictionaries are not loaded at least once, try reload them with exponential delay (1, 2, ... reload_period).
@@ -53,7 +52,7 @@ private:
     void reloadPeriodically();
 
     /// Updates dictionaries.
-    bool reloadImpl(const bool throw_on_error, const bool force_reload = false);
+    bool reloadImpl(bool throw_on_error, bool force_reload = false);
 
     template <typename Dictionary>
     using DictionaryReloader = std::function<std::unique_ptr<Dictionary>(const Poco::Util::AbstractConfiguration & config)>;
@@ -62,15 +61,15 @@ private:
     bool reloadDictionary(
         MultiVersion<Dictionary> & dictionary,
         DictionaryReloader<Dictionary> reload_dictionary,
-        const bool throw_on_error,
-        const bool force_reload);
+        bool throw_on_error,
+        bool force_reload);
 
 public:
     /// Every reload_period seconds directories are updated inside a separate thread.
     EmbeddedDictionaries(
         std::unique_ptr<GeoDictionariesLoader> geo_dictionaries_loader,
-        Context & context,
-        const bool throw_on_error);
+        ContextPtr context,
+        bool throw_on_error);
 
     /// Forcibly reloads all dictionaries.
     void reload();
diff --git a/src/Interpreters/ExecuteScalarSubqueriesVisitor.cpp b/src/Interpreters/ExecuteScalarSubqueriesVisitor.cpp
index 94b3a5218b4..97ad191289c 100644
--- a/src/Interpreters/ExecuteScalarSubqueriesVisitor.cpp
+++ b/src/Interpreters/ExecuteScalarSubqueriesVisitor.cpp
@@ -1,26 +1,22 @@
-#include <Parsers/ASTFunction.h>
-#include <Parsers/ASTLiteral.h>
-#include <Parsers/ASTSubquery.h>
-#include <Parsers/ASTSelectQuery.h>
-#include <Parsers/ASTTablesInSelectQuery.h>
-#include <Parsers/ASTExpressionList.h>
-#include <Parsers/ASTWithElement.h>
-
-#include <Interpreters/Context.h>
-#include <Interpreters/misc.h>
-#include <Interpreters/InterpreterSelectWithUnionQuery.h>
 #include <Interpreters/ExecuteScalarSubqueriesVisitor.h>
-#include <Interpreters/addTypeConversionToAST.h>
 
+#include <Columns/ColumnTuple.h>
 #include <DataStreams/IBlockInputStream.h>
 #include <DataStreams/materializeBlock.h>
 #include <DataTypes/DataTypeAggregateFunction.h>
 #include <DataTypes/DataTypeTuple.h>
-
-#include <Columns/ColumnTuple.h>
-
 #include <IO/WriteHelpers.h>
-
+#include <Interpreters/Context.h>
+#include <Interpreters/InterpreterSelectWithUnionQuery.h>
+#include <Interpreters/addTypeConversionToAST.h>
+#include <Interpreters/misc.h>
+#include <Parsers/ASTExpressionList.h>
+#include <Parsers/ASTFunction.h>
+#include <Parsers/ASTLiteral.h>
+#include <Parsers/ASTSelectQuery.h>
+#include <Parsers/ASTSubquery.h>
+#include <Parsers/ASTTablesInSelectQuery.h>
+#include <Parsers/ASTWithElement.h>
 #include <Processors/Executors/PullingAsyncPipelineExecutor.h>
 
 namespace DB
@@ -82,17 +78,17 @@ void ExecuteScalarSubqueriesMatcher::visit(const ASTSubquery & subquery, ASTPtr
     auto scalar_query_hash_str = toString(hash.first) + "_" + toString(hash.second);
 
     Block scalar;
-    if (data.context.hasQueryContext() && data.context.getQueryContext().hasScalar(scalar_query_hash_str))
-        scalar = data.context.getQueryContext().getScalar(scalar_query_hash_str);
+    if (data.getContext()->hasQueryContext() && data.getContext()->getQueryContext()->hasScalar(scalar_query_hash_str))
+        scalar = data.getContext()->getQueryContext()->getScalar(scalar_query_hash_str);
     else if (data.scalars.count(scalar_query_hash_str))
         scalar = data.scalars[scalar_query_hash_str];
     else
     {
-        Context subquery_context = data.context;
-        Settings subquery_settings = data.context.getSettings();
+        auto subquery_context = Context::createCopy(data.getContext());
+        Settings subquery_settings = data.getContext()->getSettings();
         subquery_settings.max_result_rows = 1;
         subquery_settings.extremes = false;
-        subquery_context.setSettings(subquery_settings);
+        subquery_context->setSettings(subquery_settings);
 
         ASTPtr subquery_select = subquery.children.at(0);
 
@@ -167,10 +163,11 @@ void ExecuteScalarSubqueriesMatcher::visit(const ASTSubquery & subquery, ASTPtr
         }
     }
 
-    const Settings & settings = data.context.getSettingsRef();
+    const Settings & settings = data.getContext()->getSettingsRef();
 
     // Always convert to literals when there is no query context.
-    if (data.only_analyze || !settings.enable_scalar_subquery_optimization || worthConvertingToLiteral(scalar) || !data.context.hasQueryContext())
+    if (data.only_analyze || !settings.enable_scalar_subquery_optimization || worthConvertingToLiteral(scalar)
+        || !data.getContext()->hasQueryContext())
     {
         auto lit = std::make_unique<ASTLiteral>((*scalar.safeGetByPosition(0).column)[0]);
         lit->alias = subquery.alias;
diff --git a/src/Interpreters/ExecuteScalarSubqueriesVisitor.h b/src/Interpreters/ExecuteScalarSubqueriesVisitor.h
index 02949ad6d59..c230f346779 100644
--- a/src/Interpreters/ExecuteScalarSubqueriesVisitor.h
+++ b/src/Interpreters/ExecuteScalarSubqueriesVisitor.h
@@ -1,13 +1,13 @@
 #pragma once
 
-#include <Common/typeid_cast.h>
 #include <Core/Block.h>
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/InDepthNodeVisitor.h>
+#include <Common/typeid_cast.h>
 
 namespace DB
 {
 
-class Context;
 class ASTSubquery;
 class ASTFunction;
 struct ASTTableExpression;
@@ -33,9 +33,8 @@ class ExecuteScalarSubqueriesMatcher
 public:
     using Visitor = InDepthNodeVisitor<ExecuteScalarSubqueriesMatcher, true>;
 
-    struct Data
+    struct Data : public WithContext
     {
-        const Context & context;
         size_t subquery_depth;
         Scalars & scalars;
         bool only_analyze;
diff --git a/src/Interpreters/ExpressionActions.cpp b/src/Interpreters/ExpressionActions.cpp
index aa250e800cb..e4d81dbbf94 100644
--- a/src/Interpreters/ExpressionActions.cpp
+++ b/src/Interpreters/ExpressionActions.cpp
@@ -522,6 +522,10 @@ std::string ExpressionActions::getSmallestColumn(const NamesAndTypesList & colum
 
     for (const auto & column : columns)
     {
+        /// Skip .sizeX and similar meta information
+        if (!column.getSubcolumnName().empty())
+            continue;
+
         /// @todo resolve evil constant
         size_t size = column.type->haveMaximumSizeOfValue() ? column.type->getMaximumSizeOfValueInMemory() : 100;
 
diff --git a/src/Interpreters/ExpressionActions.h b/src/Interpreters/ExpressionActions.h
index 5d48ed84b7c..40a4cdcbc02 100644
--- a/src/Interpreters/ExpressionActions.h
+++ b/src/Interpreters/ExpressionActions.h
@@ -133,9 +133,9 @@ private:
   *     2) calculate the expression in the SELECT section,
   * and between the two steps do the filtering by value in the WHERE clause.
   */
-struct ExpressionActionsChain
+struct ExpressionActionsChain : WithContext
 {
-    explicit ExpressionActionsChain(const Context & context_) : context(context_) {}
+    explicit ExpressionActionsChain(ContextPtr context_) : WithContext(context_) {}
 
 
     struct Step
@@ -241,7 +241,6 @@ struct ExpressionActionsChain
     using StepPtr = std::unique_ptr<Step>;
     using Steps = std::vector<StepPtr>;
 
-    const Context & context;
     Steps steps;
 
     void addStep(NameSet non_constant_inputs = {});
diff --git a/src/Interpreters/ExpressionActionsSettings.cpp b/src/Interpreters/ExpressionActionsSettings.cpp
index e23a2a14cc7..a9495628d6f 100644
--- a/src/Interpreters/ExpressionActionsSettings.cpp
+++ b/src/Interpreters/ExpressionActionsSettings.cpp
@@ -1,4 +1,5 @@
 #include <Interpreters/ExpressionActionsSettings.h>
+
 #include <Core/Settings.h>
 #include <Interpreters/Context.h>
 
@@ -16,9 +17,9 @@ ExpressionActionsSettings ExpressionActionsSettings::fromSettings(const Settings
     return settings;
 }
 
-ExpressionActionsSettings ExpressionActionsSettings::fromContext(const Context & from)
+ExpressionActionsSettings ExpressionActionsSettings::fromContext(ContextPtr from)
 {
-    return fromSettings(from.getSettingsRef());
+    return fromSettings(from->getSettingsRef());
 }
 
 }
diff --git a/src/Interpreters/ExpressionActionsSettings.h b/src/Interpreters/ExpressionActionsSettings.h
index f424445e7a4..06351136a9a 100644
--- a/src/Interpreters/ExpressionActionsSettings.h
+++ b/src/Interpreters/ExpressionActionsSettings.h
@@ -1,12 +1,13 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
+
 #include <cstddef>
 
 namespace DB
 {
 
 struct Settings;
-class Context;
 
 struct ExpressionActionsSettings
 {
@@ -17,7 +18,7 @@ struct ExpressionActionsSettings
     size_t max_temporary_non_const_columns = 0;
 
     static ExpressionActionsSettings fromSettings(const Settings & from);
-    static ExpressionActionsSettings fromContext(const Context & from);
+    static ExpressionActionsSettings fromContext(ContextPtr from);
 };
 
 }
diff --git a/src/Interpreters/ExpressionAnalyzer.cpp b/src/Interpreters/ExpressionAnalyzer.cpp
index 4d2cebc9900..0a281436183 100644
--- a/src/Interpreters/ExpressionAnalyzer.cpp
+++ b/src/Interpreters/ExpressionAnalyzer.cpp
@@ -128,11 +128,12 @@ ExpressionAnalyzer::ExtractedSettings::ExtractedSettings(const Settings & settin
 ExpressionAnalyzer::ExpressionAnalyzer(
     const ASTPtr & query_,
     const TreeRewriterResultPtr & syntax_analyzer_result_,
-    const Context & context_,
+    ContextPtr context_,
     size_t subquery_depth_,
     bool do_global,
     SubqueriesForSets subqueries_for_sets_)
-    : query(query_), context(context_), settings(context.getSettings())
+    : WithContext(context_)
+    , query(query_), settings(getContext()->getSettings())
     , subquery_depth(subquery_depth_)
     , syntax(syntax_analyzer_result_)
 {
@@ -292,7 +293,7 @@ void ExpressionAnalyzer::initGlobalSubqueriesAndExternalTables(bool do_global)
 {
     if (do_global)
     {
-        GlobalSubqueriesVisitor::Data subqueries_data(context, subquery_depth, isRemoteStorage(),
+        GlobalSubqueriesVisitor::Data subqueries_data(getContext(), subquery_depth, isRemoteStorage(),
                                                    external_tables, subqueries_for_sets, has_global_subqueries);
         GlobalSubqueriesVisitor(subqueries_data).visit(query);
     }
@@ -312,11 +313,11 @@ void ExpressionAnalyzer::tryMakeSetForIndexFromSubquery(const ASTPtr & subquery_
         return;
     }
 
-    auto interpreter_subquery = interpretSubquery(subquery_or_table_name, context, {}, query_options);
+    auto interpreter_subquery = interpretSubquery(subquery_or_table_name, getContext(), {}, query_options);
     auto io = interpreter_subquery->execute();
     PullingAsyncPipelineExecutor executor(io.pipeline);
 
-    SetPtr set = std::make_shared<Set>(settings.size_limits_for_set, true, context.getSettingsRef().transform_null_in);
+    SetPtr set = std::make_shared<Set>(settings.size_limits_for_set, true, getContext()->getSettingsRef().transform_null_in);
     set->setHeader(executor.getHeader());
 
     Block block;
@@ -340,8 +341,8 @@ SetPtr ExpressionAnalyzer::isPlainStorageSetInSubquery(const ASTPtr & subquery_o
     const auto * table = subquery_or_table_name->as<ASTIdentifier>();
     if (!table)
         return nullptr;
-    auto table_id = context.resolveStorageID(subquery_or_table_name);
-    const auto storage = DatabaseCatalog::instance().getTable(table_id, context);
+    auto table_id = getContext()->resolveStorageID(subquery_or_table_name);
+    const auto storage = DatabaseCatalog::instance().getTable(table_id, getContext());
     if (storage->getName() != "Set")
         return nullptr;
     const auto storage_set = std::dynamic_pointer_cast<StorageSet>(storage);
@@ -375,7 +376,7 @@ void SelectQueryExpressionAnalyzer::makeSetsForIndex(const ASTPtr & node)
         const IAST & args = *func->arguments;
         const ASTPtr & left_in_operand = args.children.at(0);
 
-        if (storage()->mayBenefitFromIndexForIn(left_in_operand, context, metadata_snapshot))
+        if (storage()->mayBenefitFromIndexForIn(left_in_operand, getContext(), metadata_snapshot))
         {
             const ASTPtr & arg = args.children.at(1);
             if (arg->as<ASTSubquery>() || arg->as<ASTIdentifier>())
@@ -389,7 +390,7 @@ void SelectQueryExpressionAnalyzer::makeSetsForIndex(const ASTPtr & node)
                 getRootActions(left_in_operand, true, temp_actions);
 
                 if (temp_actions->tryFindInIndex(left_in_operand->getColumnName()))
-                    makeExplicitSet(func, *temp_actions, true, context,
+                    makeExplicitSet(func, *temp_actions, true, getContext(),
                         settings.size_limits_for_set, prepared_sets);
             }
         }
@@ -400,7 +401,7 @@ void SelectQueryExpressionAnalyzer::makeSetsForIndex(const ASTPtr & node)
 void ExpressionAnalyzer::getRootActions(const ASTPtr & ast, bool no_subqueries, ActionsDAGPtr & actions, bool only_consts)
 {
     LogAST log;
-    ActionsVisitor::Data visitor_data(context, settings.size_limits_for_set, subquery_depth,
+    ActionsVisitor::Data visitor_data(getContext(), settings.size_limits_for_set, subquery_depth,
                                    sourceColumns(), std::move(actions), prepared_sets, subqueries_for_sets,
                                    no_subqueries, false, only_consts, !isRemoteStorage());
     ActionsVisitor(visitor_data, log.stream()).visit(ast);
@@ -411,7 +412,7 @@ void ExpressionAnalyzer::getRootActions(const ASTPtr & ast, bool no_subqueries,
 void ExpressionAnalyzer::getRootActionsNoMakeSet(const ASTPtr & ast, bool no_subqueries, ActionsDAGPtr & actions, bool only_consts)
 {
     LogAST log;
-    ActionsVisitor::Data visitor_data(context, settings.size_limits_for_set, subquery_depth,
+    ActionsVisitor::Data visitor_data(getContext(), settings.size_limits_for_set, subquery_depth,
                                    sourceColumns(), std::move(actions), prepared_sets, subqueries_for_sets,
                                    no_subqueries, true, only_consts, !isRemoteStorage());
     ActionsVisitor(visitor_data, log.stream()).visit(ast);
@@ -421,7 +422,7 @@ void ExpressionAnalyzer::getRootActionsNoMakeSet(const ASTPtr & ast, bool no_sub
 void ExpressionAnalyzer::getRootActionsForHaving(const ASTPtr & ast, bool no_subqueries, ActionsDAGPtr & actions, bool only_consts)
 {
     LogAST log;
-    ActionsVisitor::Data visitor_data(context, settings.size_limits_for_set, subquery_depth,
+    ActionsVisitor::Data visitor_data(getContext(), settings.size_limits_for_set, subquery_depth,
                                    sourceColumns(), std::move(actions), prepared_sets, subqueries_for_sets,
                                    no_subqueries, false, only_consts, true);
     ActionsVisitor(visitor_data, log.stream()).visit(ast);
@@ -532,7 +533,7 @@ void ExpressionAnalyzer::makeWindowDescriptions(ActionsDAGPtr actions)
 {
     // Convenient to check here because at least we have the Context.
     if (!syntax->window_function_asts.empty() &&
-        !context.getSettingsRef().allow_experimental_window_functions)
+        !getContext()->getSettingsRef().allow_experimental_window_functions)
     {
         throw Exception(ErrorCodes::NOT_IMPLEMENTED,
             "The support for window functions is experimental and will change"
@@ -685,7 +686,7 @@ ArrayJoinActionPtr ExpressionAnalyzer::addMultipleArrayJoinAction(ActionsDAGPtr
         result_columns.insert(result_source.first);
     }
 
-    return std::make_shared<ArrayJoinAction>(result_columns, array_join_is_left, context);
+    return std::make_shared<ArrayJoinAction>(result_columns, array_join_is_left, getContext());
 }
 
 ArrayJoinActionPtr SelectQueryExpressionAnalyzer::appendArrayJoin(ExpressionActionsChain & chain, ActionsDAGPtr & before_array_join, bool only_types)
@@ -745,21 +746,21 @@ static JoinPtr tryGetStorageJoin(std::shared_ptr<TableJoin> analyzed_join)
     return {};
 }
 
-static ExpressionActionsPtr createJoinedBlockActions(const Context & context, const TableJoin & analyzed_join)
+static ExpressionActionsPtr createJoinedBlockActions(ContextPtr context, const TableJoin & analyzed_join)
 {
     ASTPtr expression_list = analyzed_join.rightKeysList();
     auto syntax_result = TreeRewriter(context).analyze(expression_list, analyzed_join.columnsFromJoinedTable());
     return ExpressionAnalyzer(expression_list, syntax_result, context).getActions(true, false);
 }
 
-static bool allowDictJoin(StoragePtr joined_storage, const Context & context, String & dict_name, String & key_name)
+static bool allowDictJoin(StoragePtr joined_storage, ContextPtr context, String & dict_name, String & key_name)
 {
     const auto * dict = dynamic_cast<const StorageDictionary *>(joined_storage.get());
     if (!dict)
         return false;
 
     dict_name = dict->dictionaryName();
-    auto dictionary = context.getExternalDictionariesLoader().getDictionary(dict_name, context);
+    auto dictionary = context->getExternalDictionariesLoader().getDictionary(dict_name, context);
     if (!dictionary)
         return false;
 
@@ -772,7 +773,7 @@ static bool allowDictJoin(StoragePtr joined_storage, const Context & context, St
     return false;
 }
 
-static std::shared_ptr<IJoin> makeJoin(std::shared_ptr<TableJoin> analyzed_join, const Block & sample_block, const Context & context)
+static std::shared_ptr<IJoin> makeJoin(std::shared_ptr<TableJoin> analyzed_join, const Block & sample_block, ContextPtr context)
 {
     bool allow_merge_join = analyzed_join->allowMergeJoin();
 
@@ -813,7 +814,7 @@ JoinPtr SelectQueryExpressionAnalyzer::makeTableJoin(
     if (!subquery_for_join.join)
     {
         /// Actions which need to be calculated on joined block.
-        ExpressionActionsPtr joined_block_actions = createJoinedBlockActions(context, analyzedJoin());
+        ExpressionActionsPtr joined_block_actions = createJoinedBlockActions(getContext(), analyzedJoin());
 
         Names original_right_columns;
         if (!subquery_for_join.source)
@@ -828,7 +829,7 @@ JoinPtr SelectQueryExpressionAnalyzer::makeTableJoin(
                 *   in the subquery_for_set object this subquery is exposed as source and the temporary table _data1 as the `table`.
                 * - this function shows the expression JOIN _data1.
                 */
-            auto interpreter = interpretSubquery(join_element.table_expression, context, original_right_columns, query_options);
+            auto interpreter = interpretSubquery(join_element.table_expression, getContext(), original_right_columns, query_options);
 
             subquery_for_join.makeSource(interpreter, std::move(required_columns_with_aliases));
         }
@@ -841,9 +842,9 @@ JoinPtr SelectQueryExpressionAnalyzer::makeTableJoin(
         if (need_convert)
             subquery_for_join.addJoinActions(std::make_shared<ExpressionActions>(
                 syntax->analyzed_join->rightConvertingActions(),
-                ExpressionActionsSettings::fromContext(context)));
+                ExpressionActionsSettings::fromContext(getContext())));
 
-        subquery_for_join.join = makeJoin(syntax->analyzed_join, subquery_for_join.sample_block, context);
+        subquery_for_join.join = makeJoin(syntax->analyzed_join, subquery_for_join.sample_block, getContext());
 
         /// Do not make subquery for join over dictionary.
         if (syntax->analyzed_join->dictionary_reader)
@@ -893,7 +894,7 @@ ActionsDAGPtr SelectQueryExpressionAnalyzer::appendPrewhere(
         auto tmp_actions_dag = std::make_shared<ActionsDAG>(sourceColumns());
         getRootActions(select_query->prewhere(), only_types, tmp_actions_dag);
         tmp_actions_dag->removeUnusedActions(NameSet{prewhere_column_name});
-        auto tmp_actions = std::make_shared<ExpressionActions>(tmp_actions_dag, ExpressionActionsSettings::fromContext(context));
+        auto tmp_actions = std::make_shared<ExpressionActions>(tmp_actions_dag, ExpressionActionsSettings::fromContext(getContext()));
         auto required_columns = tmp_actions->getRequiredColumns();
         NameSet required_source_columns(required_columns.begin(), required_columns.end());
         required_source_columns.insert(first_action_names.begin(), first_action_names.end());
@@ -1011,7 +1012,8 @@ bool SelectQueryExpressionAnalyzer::appendGroupBy(ExpressionActionsChain & chain
         {
             auto actions_dag = std::make_shared<ActionsDAG>(columns_after_join);
             getRootActions(child, only_types, actions_dag);
-            group_by_elements_actions.emplace_back(std::make_shared<ExpressionActions>(actions_dag, ExpressionActionsSettings::fromContext(context)));
+            group_by_elements_actions.emplace_back(
+                std::make_shared<ExpressionActions>(actions_dag, ExpressionActionsSettings::fromContext(getContext())));
         }
     }
 
@@ -1170,7 +1172,7 @@ ActionsDAGPtr SelectQueryExpressionAnalyzer::appendOrderBy(ExpressionActionsChai
             auto actions_dag = std::make_shared<ActionsDAG>(columns_after_join);
             getRootActions(child, only_types, actions_dag);
             order_by_elements_actions.emplace_back(
-                std::make_shared<ExpressionActions>(actions_dag, ExpressionActionsSettings::fromContext(context)));
+                std::make_shared<ExpressionActions>(actions_dag, ExpressionActionsSettings::fromContext(getContext())));
         }
     }
 
@@ -1330,7 +1332,8 @@ ActionsDAGPtr ExpressionAnalyzer::getActionsDAG(bool add_aliases, bool project_r
 
 ExpressionActionsPtr ExpressionAnalyzer::getActions(bool add_aliases, bool project_result)
 {
-    return std::make_shared<ExpressionActions>(getActionsDAG(add_aliases, project_result), ExpressionActionsSettings::fromContext(context));
+    return std::make_shared<ExpressionActions>(
+        getActionsDAG(add_aliases, project_result), ExpressionActionsSettings::fromContext(getContext()));
 }
 
 
@@ -1339,12 +1342,12 @@ ExpressionActionsPtr ExpressionAnalyzer::getConstActions(const ColumnsWithTypeAn
     auto actions = std::make_shared<ActionsDAG>(constant_inputs);
 
     getRootActions(query, true, actions, true);
-    return std::make_shared<ExpressionActions>(actions, ExpressionActionsSettings::fromContext(context));
+    return std::make_shared<ExpressionActions>(actions, ExpressionActionsSettings::fromContext(getContext()));
 }
 
 ActionsDAGPtr SelectQueryExpressionAnalyzer::simpleSelectActions()
 {
-    ExpressionActionsChain new_chain(context);
+    ExpressionActionsChain new_chain(getContext());
     appendSelect(new_chain, false);
     return new_chain.getLastActions();
 }
@@ -1371,8 +1374,8 @@ ExpressionAnalysisResult::ExpressionAnalysisResult(
         */
 
     const ASTSelectQuery & query = *query_analyzer.getSelectQuery();
-    const Context & context = query_analyzer.context;
-    const Settings & settings = context.getSettingsRef();
+    auto context = query_analyzer.getContext();
+    const Settings & settings = context->getSettingsRef();
     const ConstStoragePtr & storage = query_analyzer.storage();
 
     bool finalized = false;
@@ -1432,7 +1435,7 @@ ExpressionAnalysisResult::ExpressionAnalysisResult(
                 {
                     ExpressionActions(
                         prewhere_info->prewhere_actions,
-                        ExpressionActionsSettings::fromSettings(context.getSettingsRef())).execute(before_prewhere_sample);
+                        ExpressionActionsSettings::fromSettings(context->getSettingsRef())).execute(before_prewhere_sample);
                     auto & column_elem = before_prewhere_sample.getByName(query.prewhere()->getColumnName());
                     /// If the filter column is a constant, record it.
                     if (column_elem.column)
@@ -1467,7 +1470,7 @@ ExpressionAnalysisResult::ExpressionAnalysisResult(
                 {
                     ExpressionActions(
                         before_where,
-                        ExpressionActionsSettings::fromSettings(context.getSettingsRef())).execute(before_where_sample);
+                        ExpressionActionsSettings::fromSettings(context->getSettingsRef())).execute(before_where_sample);
                     auto & column_elem = before_where_sample.getByName(query.where()->getColumnName());
                     /// If the filter column is a constant, record it.
                     if (column_elem.column)
@@ -1481,7 +1484,7 @@ ExpressionAnalysisResult::ExpressionAnalysisResult(
         {
             /// TODO correct conditions
             optimize_aggregation_in_order =
-                    context.getSettingsRef().optimize_aggregation_in_order
+                    context->getSettingsRef().optimize_aggregation_in_order
                     && storage && query.groupBy();
 
             query_analyzer.appendGroupBy(chain, only_types || !first_stage, optimize_aggregation_in_order, group_by_elements_actions);
diff --git a/src/Interpreters/ExpressionAnalyzer.h b/src/Interpreters/ExpressionAnalyzer.h
index 58893091882..fe53b44690e 100644
--- a/src/Interpreters/ExpressionAnalyzer.h
+++ b/src/Interpreters/ExpressionAnalyzer.h
@@ -16,7 +16,6 @@ namespace DB
 {
 
 class Block;
-class Context;
 struct Settings;
 
 struct ExpressionActionsChain;
@@ -78,7 +77,7 @@ struct ExpressionAnalyzerData
   *
   * NOTE: if `ast` is a SELECT query from a table, the structure of this table should not change during the lifetime of ExpressionAnalyzer.
   */
-class ExpressionAnalyzer : protected ExpressionAnalyzerData, private boost::noncopyable
+class ExpressionAnalyzer : protected ExpressionAnalyzerData, private boost::noncopyable, protected WithContext
 {
 private:
     /// Extracts settings to enlight which are used (and avoid copy of others).
@@ -96,7 +95,7 @@ public:
     ExpressionAnalyzer(
         const ASTPtr & query_,
         const TreeRewriterResultPtr & syntax_analyzer_result_,
-        const Context & context_)
+        ContextPtr context_)
     :   ExpressionAnalyzer(query_, syntax_analyzer_result_, context_, 0, false, {})
     {}
 
@@ -145,13 +144,12 @@ protected:
     ExpressionAnalyzer(
         const ASTPtr & query_,
         const TreeRewriterResultPtr & syntax_analyzer_result_,
-        const Context & context_,
+        ContextPtr context_,
         size_t subquery_depth_,
         bool do_global_,
         SubqueriesForSets subqueries_for_sets_);
 
     ASTPtr query;
-    const Context & context;
     const ExtractedSettings settings;
     size_t subquery_depth;
 
@@ -272,7 +270,7 @@ public:
     SelectQueryExpressionAnalyzer(
         const ASTPtr & query_,
         const TreeRewriterResultPtr & syntax_analyzer_result_,
-        const Context & context_,
+        ContextPtr context_,
         const StorageMetadataPtr & metadata_snapshot_,
         const NameSet & required_result_columns_ = {},
         bool do_global_ = false,
diff --git a/src/Interpreters/ExternalDictionariesLoader.cpp b/src/Interpreters/ExternalDictionariesLoader.cpp
index 8df29459b72..1fc0f95c846 100644
--- a/src/Interpreters/ExternalDictionariesLoader.cpp
+++ b/src/Interpreters/ExternalDictionariesLoader.cpp
@@ -23,9 +23,9 @@ namespace ErrorCodes
 }
 
 /// Must not acquire Context lock in constructor to avoid possibility of deadlocks.
-ExternalDictionariesLoader::ExternalDictionariesLoader(Context & global_context_)
+ExternalDictionariesLoader::ExternalDictionariesLoader(ContextPtr global_context_)
     : ExternalLoader("external dictionary", &Poco::Logger::get("ExternalDictionariesLoader"))
-    , global_context(global_context_)
+    , WithContext(global_context_)
 {
     setConfigSettings({"dictionary", "name", "database", "uuid"});
     enableAsyncLoading(true);
@@ -40,31 +40,31 @@ ExternalLoader::LoadablePtr ExternalDictionariesLoader::create(
     /// For dictionaries from databases (created with DDL queries) we have to perform
     /// additional checks, so we identify them here.
     bool dictionary_from_database = !repository_name.empty();
-    return DictionaryFactory::instance().create(name, config, key_in_config, global_context, dictionary_from_database);
+    return DictionaryFactory::instance().create(name, config, key_in_config, getContext(), dictionary_from_database);
 }
 
-ExternalDictionariesLoader::DictPtr ExternalDictionariesLoader::getDictionary(const std::string & dictionary_name, const Context & context) const
+ExternalDictionariesLoader::DictPtr ExternalDictionariesLoader::getDictionary(const std::string & dictionary_name, ContextPtr local_context) const
 {
-    std::string resolved_dictionary_name = resolveDictionaryName(dictionary_name, context.getCurrentDatabase());
+    std::string resolved_dictionary_name = resolveDictionaryName(dictionary_name, local_context->getCurrentDatabase());
     return std::static_pointer_cast<const IDictionary>(load(resolved_dictionary_name));
 }
 
-ExternalDictionariesLoader::DictPtr ExternalDictionariesLoader::tryGetDictionary(const std::string & dictionary_name, const Context & context) const
+ExternalDictionariesLoader::DictPtr ExternalDictionariesLoader::tryGetDictionary(const std::string & dictionary_name, ContextPtr local_context) const
 {
-    std::string resolved_dictionary_name = resolveDictionaryName(dictionary_name, context.getCurrentDatabase());
+    std::string resolved_dictionary_name = resolveDictionaryName(dictionary_name, local_context->getCurrentDatabase());
     return std::static_pointer_cast<const IDictionary>(tryLoad(resolved_dictionary_name));
 }
 
 
-void ExternalDictionariesLoader::reloadDictionary(const std::string & dictionary_name, const Context & context) const
+void ExternalDictionariesLoader::reloadDictionary(const std::string & dictionary_name, ContextPtr local_context) const
 {
-    std::string resolved_dictionary_name = resolveDictionaryName(dictionary_name, context.getCurrentDatabase());
+    std::string resolved_dictionary_name = resolveDictionaryName(dictionary_name, local_context->getCurrentDatabase());
     loadOrReload(resolved_dictionary_name);
 }
 
-DictionaryStructure ExternalDictionariesLoader::getDictionaryStructure(const std::string & dictionary_name, const Context & query_context) const
+DictionaryStructure ExternalDictionariesLoader::getDictionaryStructure(const std::string & dictionary_name, ContextPtr query_context) const
 {
-    std::string resolved_name = resolveDictionaryName(dictionary_name, query_context.getCurrentDatabase());
+    std::string resolved_name = resolveDictionaryName(dictionary_name, query_context->getCurrentDatabase());
 
     auto load_result = getLoadResult(resolved_name);
     if (!load_result.config)
@@ -110,7 +110,7 @@ std::string ExternalDictionariesLoader::resolveDictionaryNameFromDatabaseCatalog
     std::string maybe_database_name = name.substr(0, pos);
     std::string maybe_table_name = name.substr(pos + 1);
 
-    auto [db, table] = DatabaseCatalog::instance().tryGetDatabaseAndTable({maybe_database_name, maybe_table_name}, global_context);
+    auto [db, table] = DatabaseCatalog::instance().tryGetDatabaseAndTable({maybe_database_name, maybe_table_name}, getContext());
     if (!db)
         return name;
     assert(table);
diff --git a/src/Interpreters/ExternalDictionariesLoader.h b/src/Interpreters/ExternalDictionariesLoader.h
index ce5b2512741..06f64ef30c5 100644
--- a/src/Interpreters/ExternalDictionariesLoader.h
+++ b/src/Interpreters/ExternalDictionariesLoader.h
@@ -1,32 +1,33 @@
 #pragma once
 
+#include <Dictionaries/IDictionary.h>
+#include <Interpreters/Context_fwd.h>
+#include <Interpreters/ExternalLoader.h>
+#include <Common/quoteString.h>
+
 #include <memory>
 
-#include <Common/quoteString.h>
-#include <Interpreters/ExternalLoader.h>
-#include <Dictionaries/IDictionary.h>
-
 namespace DB
 {
-class Context;
+
 class IExternalLoaderConfigRepository;
 
 /// Manages user-defined dictionaries.
-class ExternalDictionariesLoader : public ExternalLoader
+class ExternalDictionariesLoader : public ExternalLoader, WithContext
 {
 public:
     using DictPtr = std::shared_ptr<const IDictionary>;
 
     /// Dictionaries will be loaded immediately and then will be updated in separate thread, each 'reload_period' seconds.
-    explicit ExternalDictionariesLoader(Context & global_context_);
+    explicit ExternalDictionariesLoader(ContextPtr global_context_);
 
-    DictPtr getDictionary(const std::string & dictionary_name, const Context & context) const;
+    DictPtr getDictionary(const std::string & dictionary_name, ContextPtr context) const;
 
-    DictPtr tryGetDictionary(const std::string & dictionary_name, const Context & context) const;
+    DictPtr tryGetDictionary(const std::string & dictionary_name, ContextPtr context) const;
 
-    void reloadDictionary(const std::string & dictionary_name, const Context & context) const;
+    void reloadDictionary(const std::string & dictionary_name, ContextPtr context) const;
 
-    DictionaryStructure getDictionaryStructure(const std::string & dictionary_name, const Context & context) const;
+    DictionaryStructure getDictionaryStructure(const std::string & dictionary_name, ContextPtr context) const;
 
     static DictionaryStructure getDictionaryStructure(const Poco::Util::AbstractConfiguration & config, const std::string & key_in_config = "dictionary");
 
@@ -45,9 +46,6 @@ protected:
 
     friend class StorageSystemDictionaries;
     friend class DatabaseDictionary;
-
-private:
-    Context & global_context;
 };
 
 }
diff --git a/src/Interpreters/ExternalLoaderDatabaseConfigRepository.cpp b/src/Interpreters/ExternalLoaderDatabaseConfigRepository.cpp
index 41269b91b5f..a8b65a18983 100644
--- a/src/Interpreters/ExternalLoaderDatabaseConfigRepository.cpp
+++ b/src/Interpreters/ExternalLoaderDatabaseConfigRepository.cpp
@@ -17,7 +17,7 @@ namespace ErrorCodes
 namespace
 {
     String trimDatabaseName(const std::string & loadable_definition_name, const String & database_name,
-                            const IDatabase & database, const Context & global_context)
+                            const IDatabase & database, ContextPtr global_context)
     {
         bool is_atomic_database = database.getUUID() != UUIDHelpers::Nil;
         if (is_atomic_database)
@@ -42,8 +42,8 @@ namespace
 }
 
 
-ExternalLoaderDatabaseConfigRepository::ExternalLoaderDatabaseConfigRepository(IDatabase & database_, const Context & context_)
-    : global_context(context_.getGlobalContext())
+ExternalLoaderDatabaseConfigRepository::ExternalLoaderDatabaseConfigRepository(IDatabase & database_, ContextPtr context_)
+    : WithContext(context_->getGlobalContext())
     , database_name(database_.getDatabaseName())
     , database(database_)
 {
@@ -51,19 +51,19 @@ ExternalLoaderDatabaseConfigRepository::ExternalLoaderDatabaseConfigRepository(I
 
 LoadablesConfigurationPtr ExternalLoaderDatabaseConfigRepository::load(const std::string & loadable_definition_name)
 {
-    auto dict_name = trimDatabaseName(loadable_definition_name, database_name, database, global_context);
+    auto dict_name = trimDatabaseName(loadable_definition_name, database_name, database, getContext());
     return database.getDictionaryConfiguration(dict_name);
 }
 
 bool ExternalLoaderDatabaseConfigRepository::exists(const std::string & loadable_definition_name)
 {
-    auto dict_name = trimDatabaseName(loadable_definition_name, database_name, database, global_context);
+    auto dict_name = trimDatabaseName(loadable_definition_name, database_name, database, getContext());
     return database.isDictionaryExist(dict_name);
 }
 
 Poco::Timestamp ExternalLoaderDatabaseConfigRepository::getUpdateTime(const std::string & loadable_definition_name)
 {
-    auto dict_name = trimDatabaseName(loadable_definition_name, database_name, database, global_context);
+    auto dict_name = trimDatabaseName(loadable_definition_name, database_name, database, getContext());
     return database.getObjectMetadataModificationTime(dict_name);
 }
 
diff --git a/src/Interpreters/ExternalLoaderDatabaseConfigRepository.h b/src/Interpreters/ExternalLoaderDatabaseConfigRepository.h
index 59dad1274e0..baa99bc5610 100644
--- a/src/Interpreters/ExternalLoaderDatabaseConfigRepository.h
+++ b/src/Interpreters/ExternalLoaderDatabaseConfigRepository.h
@@ -9,10 +9,10 @@ namespace DB
 
 /// Repository from database, which stores dictionary definitions on disk.
 /// Tracks update time and existence of .sql files through IDatabase.
-class ExternalLoaderDatabaseConfigRepository : public IExternalLoaderConfigRepository
+class ExternalLoaderDatabaseConfigRepository : public IExternalLoaderConfigRepository, WithContext
 {
 public:
-    ExternalLoaderDatabaseConfigRepository(IDatabase & database_, const Context & global_context_);
+    ExternalLoaderDatabaseConfigRepository(IDatabase & database_, ContextPtr global_context_);
 
     const std::string & getName() const override { return database_name; }
 
@@ -25,7 +25,6 @@ public:
     LoadablesConfigurationPtr load(const std::string & loadable_definition_name) override;
 
 private:
-    const Context & global_context;
     const String database_name;
     IDatabase & database;
 };
diff --git a/src/Interpreters/ExternalModelsLoader.cpp b/src/Interpreters/ExternalModelsLoader.cpp
index 4e9ddb78241..317cf0bf1c9 100644
--- a/src/Interpreters/ExternalModelsLoader.cpp
+++ b/src/Interpreters/ExternalModelsLoader.cpp
@@ -10,9 +10,8 @@ namespace ErrorCodes
 }
 
 
-ExternalModelsLoader::ExternalModelsLoader(Context & context_)
-    : ExternalLoader("external model", &Poco::Logger::get("ExternalModelsLoader"))
-    , context(context_)
+ExternalModelsLoader::ExternalModelsLoader(ContextPtr context_)
+    : ExternalLoader("external model", &Poco::Logger::get("ExternalModelsLoader")), WithContext(context_)
 {
     setConfigSettings({"model", "name", {}, {}});
     enablePeriodicUpdates(true);
@@ -30,7 +29,7 @@ std::shared_ptr<const IExternalLoadable> ExternalModelsLoader::create(
     {
         return std::make_unique<CatBoostModel>(
                 name, config.getString(config_prefix + ".path"),
-                context.getConfigRef().getString("catboost_dynamic_library_path"),
+                getContext()->getConfigRef().getString("catboost_dynamic_library_path"),
                 lifetime
         );
     }
diff --git a/src/Interpreters/ExternalModelsLoader.h b/src/Interpreters/ExternalModelsLoader.h
index 3f09512338d..ebf6de67540 100644
--- a/src/Interpreters/ExternalModelsLoader.h
+++ b/src/Interpreters/ExternalModelsLoader.h
@@ -1,24 +1,24 @@
 #pragma once
 
 #include <Interpreters/CatBoostModel.h>
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/ExternalLoader.h>
 #include <common/logger_useful.h>
+
 #include <memory>
 
 
 namespace DB
 {
 
-class Context;
-
 /// Manages user-defined models.
-class ExternalModelsLoader : public ExternalLoader
+class ExternalModelsLoader : public ExternalLoader, WithContext
 {
 public:
     using ModelPtr = std::shared_ptr<const IModel>;
 
     /// Models will be loaded immediately and then will be updated in separate thread, each 'reload_period' seconds.
-    ExternalModelsLoader(Context & context_);
+    explicit ExternalModelsLoader(ContextPtr context_);
 
     ModelPtr getModel(const std::string & name) const
     {
@@ -30,9 +30,6 @@ protected:
             const std::string & config_prefix, const std::string & repository_name) const override;
 
     friend class StorageSystemModels;
-private:
-
-    Context & context;
 };
 
 }
diff --git a/src/Interpreters/ExtractExpressionInfoVisitor.cpp b/src/Interpreters/ExtractExpressionInfoVisitor.cpp
index 64c23cd4fd1..2d46fe08e95 100644
--- a/src/Interpreters/ExtractExpressionInfoVisitor.cpp
+++ b/src/Interpreters/ExtractExpressionInfoVisitor.cpp
@@ -40,7 +40,7 @@ void ExpressionInfoMatcher::visit(const ASTFunction & ast_function, const ASTPtr
     }
     else
     {
-        const auto & function = FunctionFactory::instance().tryGet(ast_function.name, data.context);
+        const auto & function = FunctionFactory::instance().tryGet(ast_function.name, data.getContext());
 
         /// Skip lambda, tuple and other special functions
         if (function)
@@ -82,11 +82,12 @@ bool ExpressionInfoMatcher::needChildVisit(const ASTPtr & node, const ASTPtr &)
     return !node->as<ASTSubquery>();
 }
 
-bool hasNonRewritableFunction(const ASTPtr & node, const Context & context)
+bool hasNonRewritableFunction(const ASTPtr & node, ContextPtr context)
 {
     for (const auto & select_expression : node->children)
     {
-        ExpressionInfoVisitor::Data expression_info{.context = context, .tables = {}};
+        TablesWithColumns tables;
+        ExpressionInfoVisitor::Data expression_info{WithContext{context}, tables};
         ExpressionInfoVisitor(expression_info).visit(select_expression);
 
         if (expression_info.is_stateful_function
diff --git a/src/Interpreters/ExtractExpressionInfoVisitor.h b/src/Interpreters/ExtractExpressionInfoVisitor.h
index d05415490e6..c84e243ce2e 100644
--- a/src/Interpreters/ExtractExpressionInfoVisitor.h
+++ b/src/Interpreters/ExtractExpressionInfoVisitor.h
@@ -1,21 +1,20 @@
 #pragma once
 
-#include <Parsers/IAST_fwd.h>
+#include <Interpreters/Context_fwd.h>
+#include <Interpreters/DatabaseAndTableWithAlias.h>
+#include <Interpreters/InDepthNodeVisitor.h>
 #include <Parsers/ASTFunction.h>
 #include <Parsers/ASTIdentifier.h>
-#include <Interpreters/InDepthNodeVisitor.h>
-#include <Interpreters/DatabaseAndTableWithAlias.h>
+#include <Parsers/IAST_fwd.h>
 
 namespace DB
 {
 
-class Context;
 
 struct ExpressionInfoMatcher
 {
-    struct Data
+    struct Data : public WithContext
     {
-        const Context & context;
         const TablesWithColumns & tables;
 
         bool is_array_join = false;
@@ -37,6 +36,6 @@ struct ExpressionInfoMatcher
 
 using ExpressionInfoVisitor = ConstInDepthNodeVisitor<ExpressionInfoMatcher, true>;
 
-bool hasNonRewritableFunction(const ASTPtr & node, const Context & context);
+bool hasNonRewritableFunction(const ASTPtr & node, ContextPtr context);
 
 }
diff --git a/src/Interpreters/GlobalSubqueriesVisitor.h b/src/Interpreters/GlobalSubqueriesVisitor.h
index 80d133ebea6..1aac27396ed 100644
--- a/src/Interpreters/GlobalSubqueriesVisitor.h
+++ b/src/Interpreters/GlobalSubqueriesVisitor.h
@@ -1,37 +1,36 @@
 #pragma once
 
-#include <Parsers/IAST.h>
-#include <Parsers/ASTSubquery.h>
-#include <Parsers/ASTLiteral.h>
-#include <Parsers/ASTFunction.h>
-#include <Parsers/ASTTablesInSelectQuery.h>
-#include <Parsers/ASTSelectQuery.h>
-#include <Parsers/ASTIdentifier.h>
-#include <Interpreters/interpretSubquery.h>
-#include <Common/typeid_cast.h>
 #include <Core/Block.h>
 #include <Core/NamesAndTypes.h>
 #include <Databases/IDatabase.h>
 #include <IO/WriteHelpers.h>
-#include <Interpreters/InDepthNodeVisitor.h>
-#include <Interpreters/IdentifierSemantic.h>
 #include <Interpreters/Context.h>
+#include <Interpreters/IdentifierSemantic.h>
+#include <Interpreters/InDepthNodeVisitor.h>
+#include <Interpreters/interpretSubquery.h>
+#include <Parsers/ASTFunction.h>
+#include <Parsers/ASTIdentifier.h>
+#include <Parsers/ASTLiteral.h>
+#include <Parsers/ASTSelectQuery.h>
+#include <Parsers/ASTSubquery.h>
+#include <Parsers/ASTTablesInSelectQuery.h>
+#include <Parsers/IAST.h>
 #include <Processors/Executors/PullingPipelineExecutor.h>
+#include <Common/typeid_cast.h>
 
 namespace DB
 {
+
 namespace ErrorCodes
 {
     extern const int WRONG_GLOBAL_SUBQUERY;
 }
 
-
 class GlobalSubqueriesMatcher
 {
 public:
-    struct Data
+    struct Data : WithContext
     {
-        const Context & context;
         size_t subquery_depth;
         bool is_remote;
         size_t external_table_id;
@@ -39,16 +38,22 @@ public:
         SubqueriesForSets & subqueries_for_sets;
         bool & has_global_subqueries;
 
-        Data(const Context & context_, size_t subquery_depth_, bool is_remote_,
-             TemporaryTablesMapping & tables, SubqueriesForSets & subqueries_for_sets_, bool & has_global_subqueries_)
-        :   context(context_),
-            subquery_depth(subquery_depth_),
-            is_remote(is_remote_),
-            external_table_id(1),
-            external_tables(tables),
-            subqueries_for_sets(subqueries_for_sets_),
-            has_global_subqueries(has_global_subqueries_)
-        {}
+        Data(
+            ContextPtr context_,
+            size_t subquery_depth_,
+            bool is_remote_,
+            TemporaryTablesMapping & tables,
+            SubqueriesForSets & subqueries_for_sets_,
+            bool & has_global_subqueries_)
+            : WithContext(context_)
+            , subquery_depth(subquery_depth_)
+            , is_remote(is_remote_)
+            , external_table_id(1)
+            , external_tables(tables)
+            , subqueries_for_sets(subqueries_for_sets_)
+            , has_global_subqueries(has_global_subqueries_)
+        {
+        }
 
         void addExternalStorage(ASTPtr & ast, bool set_alias = false)
         {
@@ -80,7 +85,7 @@ public:
                 /// If this is already an external table, you do not need to add anything. Just remember its presence.
                 auto temporary_table_name = getIdentifierName(subquery_or_table_name);
                 bool exists_in_local_map = external_tables.end() != external_tables.find(temporary_table_name);
-                bool exists_in_context = context.tryResolveStorageID(StorageID("", temporary_table_name), Context::ResolveExternal);
+                bool exists_in_context = getContext()->tryResolveStorageID(StorageID("", temporary_table_name), Context::ResolveExternal);
                 if (exists_in_local_map || exists_in_context)
                     return;
             }
@@ -97,14 +102,17 @@ public:
                 }
             }
 
-            auto interpreter = interpretSubquery(subquery_or_table_name, context, subquery_depth, {});
+            auto interpreter = interpretSubquery(subquery_or_table_name, getContext(), subquery_depth, {});
 
             Block sample = interpreter->getSampleBlock();
             NamesAndTypesList columns = sample.getNamesAndTypesList();
 
             auto external_storage_holder = std::make_shared<TemporaryTableHolder>(
-                    context, ColumnsDescription{columns}, ConstraintsDescription{}, nullptr,
-                    /*create_for_global_subquery*/ true);
+                getContext(),
+                ColumnsDescription{columns},
+                ConstraintsDescription{},
+                nullptr,
+                /*create_for_global_subquery*/ true);
             StoragePtr external_storage = external_storage_holder->getTable();
 
             /** We replace the subquery with the name of the temporary table.
@@ -136,10 +144,10 @@ public:
 
             external_tables[external_table_name] = external_storage_holder;
 
-            if (context.getSettingsRef().use_index_for_in_with_subqueries)
+            if (getContext()->getSettingsRef().use_index_for_in_with_subqueries)
             {
                 auto external_table = external_storage_holder->getTable();
-                auto table_out = external_table->write({}, external_table->getInMemoryMetadataPtr(), context);
+                auto table_out = external_table->write({}, external_table->getInMemoryMetadataPtr(), getContext());
                 auto io = interpreter->execute();
                 PullingPipelineExecutor executor(io.pipeline);
 
@@ -176,9 +184,7 @@ public:
     static bool needChildVisit(ASTPtr &, const ASTPtr & child)
     {
         /// We do not go into subqueries.
-        if (child->as<ASTSelectQuery>())
-            return false;
-        return true;
+        return !child->as<ASTSelectQuery>();
     }
 
 private:
diff --git a/src/Interpreters/HashJoin.h b/src/Interpreters/HashJoin.h
index b726de44f3a..7f70c397db9 100644
--- a/src/Interpreters/HashJoin.h
+++ b/src/Interpreters/HashJoin.h
@@ -134,6 +134,8 @@ class HashJoin : public IJoin
 public:
     HashJoin(std::shared_ptr<TableJoin> table_join_, const Block & right_sample_block, bool any_take_last_row_ = false);
 
+    const TableJoin & getTableJoin() const override { return *table_join; }
+
     /** Add block of data from right hand of JOIN to the map.
       * Returns false, if some limit was exceeded and you should not insert more data.
       */
diff --git a/src/Interpreters/IInterpreter.cpp b/src/Interpreters/IInterpreter.cpp
index b219a9cd923..1b0e9738429 100644
--- a/src/Interpreters/IInterpreter.cpp
+++ b/src/Interpreters/IInterpreter.cpp
@@ -4,7 +4,7 @@
 namespace DB
 {
 void IInterpreter::extendQueryLogElem(
-    QueryLogElement & elem, const ASTPtr & ast, const Context & context, const String & query_database, const String & query_table) const
+    QueryLogElement & elem, const ASTPtr & ast, ContextPtr context, const String & query_database, const String & query_table) const
 {
     if (!query_database.empty() && query_table.empty())
     {
@@ -12,7 +12,8 @@ void IInterpreter::extendQueryLogElem(
     }
     else if (!query_table.empty())
     {
-        auto quoted_database = query_database.empty() ? backQuoteIfNeed(context.getCurrentDatabase()) : backQuoteIfNeed(query_database);
+        auto quoted_database = query_database.empty() ? backQuoteIfNeed(context->getCurrentDatabase())
+                                                      : backQuoteIfNeed(query_database);
         elem.query_databases.insert(quoted_database);
         elem.query_tables.insert(quoted_database + "." + backQuoteIfNeed(query_table));
     }
diff --git a/src/Interpreters/IInterpreter.h b/src/Interpreters/IInterpreter.h
index aaecf735e60..1b4eada3c9f 100644
--- a/src/Interpreters/IInterpreter.h
+++ b/src/Interpreters/IInterpreter.h
@@ -1,13 +1,13 @@
 #pragma once
 
 #include <DataStreams/BlockIO.h>
+#include <Interpreters/Context_fwd.h>
 #include <Parsers/IAST_fwd.h>
 
 namespace DB
 {
 
 struct QueryLogElement;
-class Context;
 
 /** Interpreters interface for different queries.
   */
@@ -27,11 +27,11 @@ public:
     void extendQueryLogElem(
         QueryLogElement & elem,
         const ASTPtr & ast,
-        const Context & context,
+        ContextPtr context,
         const String & query_database,
         const String & query_table) const;
 
-    virtual void extendQueryLogElemImpl(QueryLogElement &, const ASTPtr &, const Context &) const {}
+    virtual void extendQueryLogElemImpl(QueryLogElement &, const ASTPtr &, ContextPtr) const {}
 
     virtual ~IInterpreter() = default;
 };
diff --git a/src/Interpreters/IInterpreterUnionOrSelectQuery.cpp b/src/Interpreters/IInterpreterUnionOrSelectQuery.cpp
index 833625a6f3e..7233ab332dd 100644
--- a/src/Interpreters/IInterpreterUnionOrSelectQuery.cpp
+++ b/src/Interpreters/IInterpreterUnionOrSelectQuery.cpp
@@ -4,7 +4,7 @@
 namespace DB
 {
 
-void IInterpreterUnionOrSelectQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, const Context &) const
+void IInterpreterUnionOrSelectQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, ContextPtr) const
 {
     elem.query_kind = "Select";
 }
diff --git a/src/Interpreters/IInterpreterUnionOrSelectQuery.h b/src/Interpreters/IInterpreterUnionOrSelectQuery.h
index 128072fb103..72723d68161 100644
--- a/src/Interpreters/IInterpreterUnionOrSelectQuery.h
+++ b/src/Interpreters/IInterpreterUnionOrSelectQuery.h
@@ -10,9 +10,9 @@ namespace DB
 class IInterpreterUnionOrSelectQuery : public IInterpreter
 {
 public:
-    IInterpreterUnionOrSelectQuery(const ASTPtr & query_ptr_, const Context & context_, const SelectQueryOptions & options_)
+    IInterpreterUnionOrSelectQuery(const ASTPtr & query_ptr_, ContextPtr context_, const SelectQueryOptions & options_)
         : query_ptr(query_ptr_)
-        , context(std::make_shared<Context>(context_))
+        , context(Context::createCopy(context_))
         , options(options_)
         , max_streams(context->getSettingsRef().max_threads)
     {
@@ -28,11 +28,11 @@ public:
 
     size_t getMaxStreams() const { return max_streams; }
 
-    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, const Context &) const override;
+    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, ContextPtr) const override;
 
 protected:
     ASTPtr query_ptr;
-    std::shared_ptr<Context> context;
+    ContextPtr context;
     Block result_header;
     SelectQueryOptions options;
     size_t max_streams = 1;
diff --git a/src/Interpreters/IJoin.h b/src/Interpreters/IJoin.h
index ade6eaa0cc9..b326f06fa7e 100644
--- a/src/Interpreters/IJoin.h
+++ b/src/Interpreters/IJoin.h
@@ -14,11 +14,15 @@ class Block;
 struct ExtraBlock;
 using ExtraBlockPtr = std::shared_ptr<ExtraBlock>;
 
+class TableJoin;
+
 class IJoin
 {
 public:
     virtual ~IJoin() = default;
 
+    virtual const TableJoin & getTableJoin() const = 0;
+
     /// Add block of data from right hand of JOIN.
     /// @returns false, if some limit was exceeded and you should not insert more data.
     virtual bool addJoinedBlock(const Block & block, bool check_limits = true) = 0;
diff --git a/src/Interpreters/IdentifierSemantic.cpp b/src/Interpreters/IdentifierSemantic.cpp
index 81bd499ea2e..8b8eab219ba 100644
--- a/src/Interpreters/IdentifierSemantic.cpp
+++ b/src/Interpreters/IdentifierSemantic.cpp
@@ -3,6 +3,8 @@
 #include <Interpreters/IdentifierSemantic.h>
 #include <Interpreters/StorageID.h>
 
+#include <Parsers/ASTFunction.h>
+
 namespace DB
 {
 
@@ -249,4 +251,86 @@ void IdentifierSemantic::setColumnLongName(ASTIdentifier & identifier, const Dat
     }
 }
 
+std::optional<size_t> IdentifierSemantic::getIdentMembership(const ASTIdentifier & ident, const std::vector<TableWithColumnNamesAndTypes> & tables)
+{
+    std::optional<size_t> table_pos = IdentifierSemantic::getMembership(ident);
+    if (table_pos)
+        return table_pos;
+    return IdentifierSemantic::chooseTableColumnMatch(ident, tables, true);
+}
+
+std::optional<size_t>
+IdentifierSemantic::getIdentsMembership(ASTPtr ast, const std::vector<TableWithColumnNamesAndTypes> & tables, const Aliases & aliases)
+{
+    auto idents = IdentifiersCollector::collect(ast);
+
+    std::optional<size_t> result;
+    for (const auto * ident : idents)
+    {
+        /// short name clashes with alias, ambiguous
+        if (ident->isShort() && aliases.count(ident->shortName()))
+            return {};
+        const auto pos = getIdentMembership(*ident, tables);
+        if (!pos)
+            return {};
+        /// identifiers from different tables
+        if (result && *pos != *result)
+            return {};
+        result = pos;
+    }
+    return result;
+}
+
+IdentifiersCollector::ASTIdentifiers IdentifiersCollector::collect(const ASTPtr & node)
+{
+    IdentifiersCollector::Data ident_data;
+    ConstInDepthNodeVisitor<IdentifiersCollector, true> ident_visitor(ident_data);
+    ident_visitor.visit(node);
+    return ident_data.idents;
+}
+
+bool IdentifiersCollector::needChildVisit(const ASTPtr &, const ASTPtr &)
+{
+    return true;
+}
+
+void IdentifiersCollector::visit(const ASTPtr & node, IdentifiersCollector::Data & data)
+{
+    if (const auto * ident = node->as<ASTIdentifier>())
+        data.idents.push_back(ident);
+}
+
+
+IdentifierMembershipCollector::IdentifierMembershipCollector(const ASTSelectQuery & select, ContextPtr context)
+{
+    if (ASTPtr with = select.with())
+        QueryAliasesNoSubqueriesVisitor(aliases).visit(with);
+    QueryAliasesNoSubqueriesVisitor(aliases).visit(select.select());
+
+    tables = getDatabaseAndTablesWithColumns(getTableExpressions(select), context);
+}
+
+std::optional<size_t> IdentifierMembershipCollector::getIdentsMembership(ASTPtr ast) const
+{
+    return IdentifierSemantic::getIdentsMembership(ast, tables, aliases);
+}
+
+static void collectConjunctions(const ASTPtr & node, std::vector<ASTPtr> & members)
+{
+    if (const auto * func = node->as<ASTFunction>(); func && func->name == "and")
+    {
+        for (const auto & child : func->arguments->children)
+            collectConjunctions(child, members);
+        return;
+    }
+    members.push_back(node);
+}
+
+std::vector<ASTPtr> collectConjunctions(const ASTPtr & node)
+{
+    std::vector<ASTPtr> members;
+    collectConjunctions(node, members);
+    return members;
+}
+
 }
diff --git a/src/Interpreters/IdentifierSemantic.h b/src/Interpreters/IdentifierSemantic.h
index 80b55ba0537..20ef3248f7c 100644
--- a/src/Interpreters/IdentifierSemantic.h
+++ b/src/Interpreters/IdentifierSemantic.h
@@ -2,8 +2,15 @@
 
 #include <optional>
 
-#include <Parsers/ASTIdentifier.h>
+#include <Interpreters/Aliases.h>
 #include <Interpreters/DatabaseAndTableWithAlias.h>
+#include <Interpreters/InDepthNodeVisitor.h>
+#include <Interpreters/QueryAliasesVisitor.h>
+#include <Interpreters/getHeaderForProcessingStage.h>
+#include <Interpreters/getTableExpressions.h>
+
+#include <Parsers/ASTIdentifier.h>
+#include <Parsers/ASTSelectQuery.h>
 
 namespace DB
 {
@@ -59,9 +66,48 @@ struct IdentifierSemantic
     static std::optional<size_t> chooseTableColumnMatch(const ASTIdentifier &, const TablesWithColumns & tables,
                             bool allow_ambiguous = false);
 
+    static std::optional<size_t> getIdentMembership(const ASTIdentifier & ident, const std::vector<TableWithColumnNamesAndTypes> & tables);
+
+    /// Collect common table membership for identifiers in expression
+    /// If membership cannot be established or there are several identifies from different tables, return empty optional
+    static std::optional<size_t>
+    getIdentsMembership(ASTPtr ast, const std::vector<TableWithColumnNamesAndTypes> & tables, const Aliases & aliases);
+
 private:
     static bool doesIdentifierBelongTo(const ASTIdentifier & identifier, const String & database, const String & table);
     static bool doesIdentifierBelongTo(const ASTIdentifier & identifier, const String & table);
 };
 
+
+/// Collect all identifies from AST recursively
+class IdentifiersCollector
+{
+public:
+    using ASTIdentPtr = const ASTIdentifier *;
+    using ASTIdentifiers = std::vector<ASTIdentPtr>;
+    struct Data
+    {
+        ASTIdentifiers idents;
+    };
+
+    static void visit(const ASTPtr & node, Data & data);
+    static bool needChildVisit(const ASTPtr &, const ASTPtr &);
+    static ASTIdentifiers collect(const ASTPtr & node);
+};
+
+/// Collect identifier table membership considering aliases
+class IdentifierMembershipCollector
+{
+public:
+    IdentifierMembershipCollector(const ASTSelectQuery & select, ContextPtr context);
+    std::optional<size_t> getIdentsMembership(ASTPtr ast) const;
+
+private:
+    std::vector<TableWithColumnNamesAndTypes> tables;
+    Aliases aliases;
+};
+
+/// Split expression `expr_1 AND expr_2 AND ... AND expr_n` into vector `[expr_1, expr_2, ..., expr_n]`
+std::vector<ASTPtr> collectConjunctions(const ASTPtr & node);
+
 }
diff --git a/src/Interpreters/InJoinSubqueriesPreprocessor.cpp b/src/Interpreters/InJoinSubqueriesPreprocessor.cpp
index 2e922393131..8dc5d95bd89 100644
--- a/src/Interpreters/InJoinSubqueriesPreprocessor.cpp
+++ b/src/Interpreters/InJoinSubqueriesPreprocessor.cpp
@@ -25,9 +25,9 @@ namespace ErrorCodes
 namespace
 {
 
-StoragePtr tryGetTable(const ASTPtr & database_and_table, const Context & context)
+StoragePtr tryGetTable(const ASTPtr & database_and_table, ContextPtr context)
 {
-    auto table_id = context.tryResolveStorageID(database_and_table);
+    auto table_id = context->tryResolveStorageID(database_and_table);
     if (!table_id)
         return {};
     return DatabaseCatalog::instance().tryGetTable(table_id, context);
@@ -35,12 +35,21 @@ StoragePtr tryGetTable(const ASTPtr & database_and_table, const Context & contex
 
 using CheckShardsAndTables = InJoinSubqueriesPreprocessor::CheckShardsAndTables;
 
-struct NonGlobalTableData
+struct NonGlobalTableData : public WithContext
 {
     using TypeToVisit = ASTTableExpression;
 
+    NonGlobalTableData(
+        ContextPtr context_,
+        const CheckShardsAndTables & checker_,
+        std::vector<ASTPtr> & renamed_tables_,
+        ASTFunction * function_,
+        ASTTableJoin * table_join_)
+        : WithContext(context_), checker(checker_), renamed_tables(renamed_tables_), function(function_), table_join(table_join_)
+    {
+    }
+
     const CheckShardsAndTables & checker;
-    const Context & context;
     std::vector<ASTPtr> & renamed_tables;
     ASTFunction * function = nullptr;
     ASTTableJoin * table_join = nullptr;
@@ -55,9 +64,9 @@ struct NonGlobalTableData
 private:
     void renameIfNeeded(ASTPtr & database_and_table)
     {
-        const DistributedProductMode distributed_product_mode = context.getSettingsRef().distributed_product_mode;
+        const DistributedProductMode distributed_product_mode = getContext()->getSettingsRef().distributed_product_mode;
 
-        StoragePtr storage = tryGetTable(database_and_table, context);
+        StoragePtr storage = tryGetTable(database_and_table, getContext());
         if (!storage || !checker.hasAtLeastTwoShards(*storage))
             return;
 
@@ -119,11 +128,17 @@ using NonGlobalTableVisitor = InDepthNodeVisitor<NonGlobalTableMatcher, true>;
 class NonGlobalSubqueryMatcher
 {
 public:
-    struct Data
+    struct Data : public WithContext
     {
+        using RenamedTables = std::vector<std::pair<ASTPtr, std::vector<ASTPtr>>>;
+
+        Data(ContextPtr context_, const CheckShardsAndTables & checker_, RenamedTables & renamed_tables_)
+        : WithContext(context_), checker(checker_), renamed_tables(renamed_tables_)
+        {
+        }
+
         const CheckShardsAndTables & checker;
-        const Context & context;
-        std::vector<std::pair<ASTPtr, std::vector<ASTPtr>>> & renamed_tables;
+        RenamedTables & renamed_tables;
     };
 
     static void visit(ASTPtr & node, Data & data)
@@ -161,7 +176,7 @@ private:
             }
             auto & subquery = node.arguments->children.at(1);
             std::vector<ASTPtr> renamed;
-            NonGlobalTableVisitor::Data table_data{data.checker, data.context, renamed, &node, nullptr};
+            NonGlobalTableVisitor::Data table_data(data.getContext(), data.checker, renamed, &node, nullptr);
             NonGlobalTableVisitor(table_data).visit(subquery);
             if (!renamed.empty())
                 data.renamed_tables.emplace_back(subquery, std::move(renamed));
@@ -179,7 +194,7 @@ private:
             if (auto & subquery = node.table_expression->as<ASTTableExpression>()->subquery)
             {
                 std::vector<ASTPtr> renamed;
-                NonGlobalTableVisitor::Data table_data{data.checker, data.context, renamed, nullptr, table_join};
+                NonGlobalTableVisitor::Data table_data(data.getContext(), data.checker, renamed, nullptr, table_join);
                 NonGlobalTableVisitor(table_data).visit(subquery);
                 if (!renamed.empty())
                     data.renamed_tables.emplace_back(subquery, std::move(renamed));
@@ -202,7 +217,7 @@ void InJoinSubqueriesPreprocessor::visit(ASTPtr & ast) const
     if (!query || !query->tables())
         return;
 
-    if (context.getSettingsRef().distributed_product_mode == DistributedProductMode::ALLOW)
+    if (getContext()->getSettingsRef().distributed_product_mode == DistributedProductMode::ALLOW)
         return;
 
     const auto & tables_in_select_query = query->tables()->as<ASTTablesInSelectQuery &>();
@@ -221,12 +236,12 @@ void InJoinSubqueriesPreprocessor::visit(ASTPtr & ast) const
 
     /// If not really distributed table, skip it.
     {
-        StoragePtr storage = tryGetTable(table_expression->database_and_table_name, context);
+        StoragePtr storage = tryGetTable(table_expression->database_and_table_name, getContext());
         if (!storage || !checker->hasAtLeastTwoShards(*storage))
             return;
     }
 
-    NonGlobalSubqueryVisitor::Data visitor_data{*checker, context, renamed_tables};
+    NonGlobalSubqueryVisitor::Data visitor_data{getContext(), *checker, renamed_tables};
     NonGlobalSubqueryVisitor(visitor_data).visit(ast);
 }
 
diff --git a/src/Interpreters/InJoinSubqueriesPreprocessor.h b/src/Interpreters/InJoinSubqueriesPreprocessor.h
index 4d46fabfd99..92a408e7ae3 100644
--- a/src/Interpreters/InJoinSubqueriesPreprocessor.h
+++ b/src/Interpreters/InJoinSubqueriesPreprocessor.h
@@ -1,19 +1,18 @@
 #pragma once
 
-#include <common/types.h>
+#include <Interpreters/Context_fwd.h>
 #include <Parsers/IAST_fwd.h>
 #include <Storages/IStorage_fwd.h>
+#include <common/types.h>
 
-#include <string>
 #include <memory>
+#include <string>
 
 
 namespace DB
 {
 
 class ASTSelectQuery;
-class Context;
-
 
 /** Scheme of operation:
   *
@@ -32,7 +31,7 @@ class Context;
   * Do not recursively preprocess subqueries, as it will be done by calling code.
   */
 
-class InJoinSubqueriesPreprocessor
+class InJoinSubqueriesPreprocessor : WithContext
 {
 public:
     using SubqueryTables = std::vector<std::pair<ASTPtr, std::vector<ASTPtr>>>;  /// {subquery, renamed_tables}
@@ -47,17 +46,17 @@ public:
         virtual ~CheckShardsAndTables() {}
     };
 
-    InJoinSubqueriesPreprocessor(const Context & context_, SubqueryTables & renamed_tables_,
-                                 CheckShardsAndTables::Ptr _checker = std::make_unique<CheckShardsAndTables>())
-        : context(context_)
-        , renamed_tables(renamed_tables_)
-        , checker(std::move(_checker))
-    {}
+    InJoinSubqueriesPreprocessor(
+        ContextPtr context_,
+        SubqueryTables & renamed_tables_,
+        CheckShardsAndTables::Ptr _checker = std::make_unique<CheckShardsAndTables>())
+        : WithContext(context_), renamed_tables(renamed_tables_), checker(std::move(_checker))
+    {
+    }
 
     void visit(ASTPtr & ast) const;
 
 private:
-    const Context & context;
     SubqueryTables & renamed_tables;
     CheckShardsAndTables::Ptr checker;
 };
diff --git a/src/Interpreters/InterpreterAlterQuery.cpp b/src/Interpreters/InterpreterAlterQuery.cpp
index 4a8aef414e4..9553dc87c31 100644
--- a/src/Interpreters/InterpreterAlterQuery.cpp
+++ b/src/Interpreters/InterpreterAlterQuery.cpp
@@ -1,24 +1,27 @@
 #include <Interpreters/InterpreterAlterQuery.h>
-#include <Interpreters/executeDDLQueryOnCluster.h>
-#include <Interpreters/MutationsInterpreter.h>
+
+#include <Access/AccessRightsElement.h>
+#include <Databases/DatabaseFactory.h>
+#include <Databases/DatabaseReplicated.h>
+#include <Databases/IDatabase.h>
 #include <Interpreters/AddDefaultDatabaseVisitor.h>
 #include <Interpreters/Context.h>
+#include <Interpreters/MutationsInterpreter.h>
 #include <Interpreters/QueryLog.h>
+#include <Interpreters/executeDDLQueryOnCluster.h>
 #include <Parsers/ASTAlterQuery.h>
 #include <Parsers/ASTAssignment.h>
-#include <Storages/IStorage.h>
 #include <Storages/AlterCommands.h>
-#include <Storages/MutationCommands.h>
-#include <Storages/PartitionCommands.h>
+#include <Storages/IStorage.h>
 #include <Storages/LiveView/LiveViewCommands.h>
 #include <Storages/LiveView/StorageLiveView.h>
-#include <Access/AccessRightsElement.h>
+#include <Storages/MutationCommands.h>
+#include <Storages/PartitionCommands.h>
 #include <Common/typeid_cast.h>
+
 #include <boost/range/algorithm_ext/push_back.hpp>
+
 #include <algorithm>
-#include <Databases/IDatabase.h>
-#include <Databases/DatabaseReplicated.h>
-#include <Databases/DatabaseFactory.h>
 
 
 namespace DB
@@ -32,8 +35,7 @@ namespace ErrorCodes
 }
 
 
-InterpreterAlterQuery::InterpreterAlterQuery(const ASTPtr & query_ptr_, const Context & context_)
-    : query_ptr(query_ptr_), context(context_)
+InterpreterAlterQuery::InterpreterAlterQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_)
 {
 }
 
@@ -44,22 +46,23 @@ BlockIO InterpreterAlterQuery::execute()
 
 
     if (!alter.cluster.empty())
-        return executeDDLQueryOnCluster(query_ptr, context, getRequiredAccess());
+        return executeDDLQueryOnCluster(query_ptr, getContext(), getRequiredAccess());
 
-    context.checkAccess(getRequiredAccess());
-    auto table_id = context.resolveStorageID(alter, Context::ResolveOrdinary);
+    getContext()->checkAccess(getRequiredAccess());
+    auto table_id = getContext()->resolveStorageID(alter, Context::ResolveOrdinary);
     query_ptr->as<ASTAlterQuery &>().database = table_id.database_name;
 
     DatabasePtr database = DatabaseCatalog::instance().getDatabase(table_id.database_name);
-    if (typeid_cast<DatabaseReplicated *>(database.get()) && context.getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
+    if (typeid_cast<DatabaseReplicated *>(database.get())
+        && getContext()->getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
     {
         auto guard = DatabaseCatalog::instance().getDDLGuard(table_id.database_name, table_id.table_name);
         guard->releaseTableLock();
-        return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, context);
+        return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, getContext());
     }
 
-    StoragePtr table = DatabaseCatalog::instance().getTable(table_id, context);
-    auto alter_lock = table->lockForAlter(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+    StoragePtr table = DatabaseCatalog::instance().getTable(table_id, getContext());
+    auto alter_lock = table->lockForAlter(getContext()->getCurrentQueryId(), getContext()->getSettingsRef().lock_acquire_timeout);
     auto metadata_snapshot = table->getInMemoryMetadataPtr();
 
     /// Add default database to table identifiers that we can encounter in e.g. default expressions,
@@ -105,15 +108,15 @@ BlockIO InterpreterAlterQuery::execute()
 
     if (!mutation_commands.empty())
     {
-        table->checkMutationIsPossible(mutation_commands, context.getSettingsRef());
-        MutationsInterpreter(table, metadata_snapshot, mutation_commands, context, false).validate();
-        table->mutate(mutation_commands, context);
+        table->checkMutationIsPossible(mutation_commands, getContext()->getSettingsRef());
+        MutationsInterpreter(table, metadata_snapshot, mutation_commands, getContext(), false).validate();
+        table->mutate(mutation_commands, getContext());
     }
 
     if (!partition_commands.empty())
     {
-        table->checkAlterPartitionIsPossible(partition_commands, metadata_snapshot, context.getSettingsRef());
-        auto partition_commands_pipe = table->alterPartition(metadata_snapshot, partition_commands, context);
+        table->checkAlterPartitionIsPossible(partition_commands, metadata_snapshot, getContext()->getSettingsRef());
+        auto partition_commands_pipe = table->alterPartition(metadata_snapshot, partition_commands, getContext());
         if (!partition_commands_pipe.empty())
             res.pipeline.init(std::move(partition_commands_pipe));
     }
@@ -136,10 +139,10 @@ BlockIO InterpreterAlterQuery::execute()
     if (!alter_commands.empty())
     {
         StorageInMemoryMetadata metadata = table->getInMemoryMetadata();
-        alter_commands.validate(metadata, context);
+        alter_commands.validate(metadata, getContext());
         alter_commands.prepare(metadata);
-        table->checkAlterIsPossible(alter_commands, context);
-        table->alter(alter_commands, context, alter_lock);
+        table->checkAlterIsPossible(alter_commands, getContext());
+        table->alter(alter_commands, getContext(), alter_lock);
     }
 
     return res;
@@ -328,7 +331,7 @@ AccessRightsElements InterpreterAlterQuery::getRequiredAccessForCommand(const AS
     return required_access;
 }
 
-void InterpreterAlterQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, const Context &) const
+void InterpreterAlterQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, ContextPtr) const
 {
     const auto & alter = ast->as<const ASTAlterQuery &>();
 
@@ -358,14 +361,14 @@ void InterpreterAlterQuery::extendQueryLogElemImpl(QueryLogElement & elem, const
 
             if (!command->from_table.empty())
             {
-                String database = command->from_database.empty() ? context.getCurrentDatabase() : command->from_database;
+                String database = command->from_database.empty() ? getContext()->getCurrentDatabase() : command->from_database;
                 elem.query_databases.insert(database);
                 elem.query_tables.insert(database + "." + command->from_table);
             }
 
             if (!command->to_table.empty())
             {
-                String database = command->to_database.empty() ? context.getCurrentDatabase() : command->to_database;
+                String database = command->to_database.empty() ? getContext()->getCurrentDatabase() : command->to_database;
                 elem.query_databases.insert(database);
                 elem.query_tables.insert(database + "." + command->to_table);
             }
diff --git a/src/Interpreters/InterpreterAlterQuery.h b/src/Interpreters/InterpreterAlterQuery.h
index 37084844f6c..ae9750b0b62 100644
--- a/src/Interpreters/InterpreterAlterQuery.h
+++ b/src/Interpreters/InterpreterAlterQuery.h
@@ -6,7 +6,7 @@
 
 namespace DB
 {
-class Context;
+
 class AccessRightsElements;
 class ASTAlterCommand;
 
@@ -14,23 +14,21 @@ class ASTAlterCommand;
 /** Allows you add or remove a column in the table.
   * It also allows you to manipulate the partitions of the MergeTree family tables.
   */
-class InterpreterAlterQuery : public IInterpreter
+class InterpreterAlterQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterAlterQuery(const ASTPtr & query_ptr_, const Context & context_);
+    InterpreterAlterQuery(const ASTPtr & query_ptr_, ContextPtr context_);
 
     BlockIO execute() override;
 
     static AccessRightsElements getRequiredAccessForCommand(const ASTAlterCommand & command, const String & database, const String & table);
 
-    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, const Context & context) const override;
+    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, ContextPtr context) const override;
 
 private:
     AccessRightsElements getRequiredAccess() const;
 
     ASTPtr query_ptr;
-
-    const Context & context;
 };
 
 }
diff --git a/src/Interpreters/InterpreterCheckQuery.cpp b/src/Interpreters/InterpreterCheckQuery.cpp
index b3cd807abe5..e8a4f884dd0 100644
--- a/src/Interpreters/InterpreterCheckQuery.cpp
+++ b/src/Interpreters/InterpreterCheckQuery.cpp
@@ -29,8 +29,7 @@ NamesAndTypes getBlockStructure()
 }
 
 
-InterpreterCheckQuery::InterpreterCheckQuery(const ASTPtr & query_ptr_, const Context & context_)
-    : query_ptr(query_ptr_), context(context_)
+InterpreterCheckQuery::InterpreterCheckQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_)
 {
 }
 
@@ -38,14 +37,14 @@ InterpreterCheckQuery::InterpreterCheckQuery(const ASTPtr & query_ptr_, const Co
 BlockIO InterpreterCheckQuery::execute()
 {
     const auto & check = query_ptr->as<ASTCheckQuery &>();
-    auto table_id = context.resolveStorageID(check, Context::ResolveOrdinary);
+    auto table_id = getContext()->resolveStorageID(check, Context::ResolveOrdinary);
 
-    context.checkAccess(AccessType::SHOW_TABLES, table_id);
-    StoragePtr table = DatabaseCatalog::instance().getTable(table_id, context);
-    auto check_results = table->checkData(query_ptr, context);
+    getContext()->checkAccess(AccessType::SHOW_TABLES, table_id);
+    StoragePtr table = DatabaseCatalog::instance().getTable(table_id, getContext());
+    auto check_results = table->checkData(query_ptr, getContext());
 
     Block block;
-    if (context.getSettingsRef().check_query_single_value_result)
+    if (getContext()->getSettingsRef().check_query_single_value_result)
     {
         bool result = std::all_of(check_results.begin(), check_results.end(), [] (const CheckResult & res) { return res.success; });
         auto column = ColumnUInt8::create();
diff --git a/src/Interpreters/InterpreterCheckQuery.h b/src/Interpreters/InterpreterCheckQuery.h
index c667ca74c22..557faddfe9c 100644
--- a/src/Interpreters/InterpreterCheckQuery.h
+++ b/src/Interpreters/InterpreterCheckQuery.h
@@ -7,20 +7,17 @@
 namespace DB
 {
 
-class Context;
 class Cluster;
 
-class InterpreterCheckQuery : public IInterpreter
+class InterpreterCheckQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterCheckQuery(const ASTPtr & query_ptr_, const Context & context_);
+    InterpreterCheckQuery(const ASTPtr & query_ptr_, ContextPtr context_);
 
     BlockIO execute() override;
 
 private:
     ASTPtr query_ptr;
-
-    const Context & context;
 };
 
 }
diff --git a/src/Interpreters/InterpreterCreateQuery.cpp b/src/Interpreters/InterpreterCreateQuery.cpp
index 8cd93546ad0..5d58d19ffaa 100644
--- a/src/Interpreters/InterpreterCreateQuery.cpp
+++ b/src/Interpreters/InterpreterCreateQuery.cpp
@@ -90,8 +90,8 @@ namespace ErrorCodes
 
 namespace fs = std::filesystem;
 
-InterpreterCreateQuery::InterpreterCreateQuery(const ASTPtr & query_ptr_, Context & context_)
-    : query_ptr(query_ptr_), context(context_)
+InterpreterCreateQuery::InterpreterCreateQuery(const ASTPtr & query_ptr_, ContextPtr context_)
+    : WithContext(context_), query_ptr(query_ptr_)
 {
 }
 
@@ -113,7 +113,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
 
     /// Will write file with database metadata, if needed.
     String database_name_escaped = escapeForFileName(database_name);
-    fs::path metadata_path = fs::canonical(context.getPath());
+    fs::path metadata_path = fs::canonical(getContext()->getPath());
     fs::path metadata_file_tmp_path = metadata_path / "metadata" / (database_name_escaped + ".sql.tmp");
     fs::path metadata_file_path = metadata_path / "metadata" / (database_name_escaped + ".sql");
 
@@ -122,7 +122,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
         if (!fs::exists(metadata_file_path))
             throw Exception("Database engine must be specified for ATTACH DATABASE query", ErrorCodes::UNKNOWN_DATABASE_ENGINE);
         /// Short syntax: try read database definition from file
-        auto ast = DatabaseOnDisk::parseQueryFromMetadata(nullptr, context, metadata_file_path);
+        auto ast = DatabaseOnDisk::parseQueryFromMetadata(nullptr, getContext(), metadata_file_path);
         create = ast->as<ASTCreateQuery &>();
         if (!create.table.empty() || !create.storage)
             throw Exception(ErrorCodes::INCORRECT_QUERY, "Metadata file {} contains incorrect CREATE DATABASE query", metadata_file_path.string());
@@ -136,7 +136,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
         /// When attaching old-style database during server startup, we must always use Ordinary engine
         if (create.attach)
             throw Exception("Database engine must be specified for ATTACH DATABASE query", ErrorCodes::UNKNOWN_DATABASE_ENGINE);
-        bool old_style_database = context.getSettingsRef().default_database_engine.value == DefaultDatabaseEngine::Ordinary;
+        bool old_style_database = getContext()->getSettingsRef().default_database_engine.value == DefaultDatabaseEngine::Ordinary;
         auto engine = std::make_shared<ASTFunction>();
         auto storage = std::make_shared<ASTStorage>();
         engine->name = old_style_database ? "Ordinary" : "Atomic";
@@ -174,7 +174,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
 
         if (create_from_user)
         {
-            const auto & default_engine = context.getSettingsRef().default_database_engine.value;
+            const auto & default_engine = getContext()->getSettingsRef().default_database_engine.value;
             if (create.uuid == UUIDHelpers::Nil && default_engine == DefaultDatabaseEngine::Atomic)
                 create.uuid = UUIDHelpers::generateV4();    /// Will enable Atomic engine for nested database
         }
@@ -194,7 +194,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
     }
     else
     {
-        bool is_on_cluster = context.getClientInfo().query_kind == ClientInfo::QueryKind::SECONDARY_QUERY;
+        bool is_on_cluster = getContext()->getClientInfo().query_kind == ClientInfo::QueryKind::SECONDARY_QUERY;
         if (create.uuid != UUIDHelpers::Nil && !is_on_cluster)
             throw Exception("Ordinary database engine does not support UUID", ErrorCodes::INCORRECT_QUERY);
 
@@ -203,19 +203,20 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
         metadata_path = metadata_path / "metadata" / database_name_escaped;
     }
 
-    if (create.storage->engine->name == "MaterializeMySQL" && !context.getSettingsRef().allow_experimental_database_materialize_mysql && !internal)
+    if (create.storage->engine->name == "MaterializeMySQL" && !getContext()->getSettingsRef().allow_experimental_database_materialize_mysql
+        && !internal)
     {
         throw Exception("MaterializeMySQL is an experimental database engine. "
                         "Enable allow_experimental_database_materialize_mysql to use it.", ErrorCodes::UNKNOWN_DATABASE_ENGINE);
     }
 
-    if (create.storage->engine->name == "Replicated" && !context.getSettingsRef().allow_experimental_database_replicated && !internal)
+    if (create.storage->engine->name == "Replicated" && !getContext()->getSettingsRef().allow_experimental_database_replicated && !internal)
     {
         throw Exception("Replicated is an experimental database engine. "
                         "Enable allow_experimental_database_replicated to use it.", ErrorCodes::UNKNOWN_DATABASE_ENGINE);
     }
 
-    DatabasePtr database = DatabaseFactory::get(create, metadata_path / "", context);
+    DatabasePtr database = DatabaseFactory::get(create, metadata_path / "", getContext());
 
     if (create.uuid != UUIDHelpers::Nil)
         create.database = TABLE_WITH_UUID_NAME_PLACEHOLDER;
@@ -237,7 +238,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
         writeString(statement, out);
 
         out.next();
-        if (context.getSettingsRef().fsync_metadata)
+        if (getContext()->getSettingsRef().fsync_metadata)
             out.sync();
         out.close();
     }
@@ -261,7 +262,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
         }
 
         /// We use global context here, because storages lifetime is bigger than query context lifetime
-        database->loadStoredObjects(context.getGlobalContext(), has_force_restore_data_flag, create.attach && force_attach);
+        database->loadStoredObjects(getContext()->getGlobalContext(), has_force_restore_data_flag, create.attach && force_attach);
     }
     catch (...)
     {
@@ -361,7 +362,7 @@ ASTPtr InterpreterCreateQuery::formatConstraints(const ConstraintsDescription &
 }
 
 ColumnsDescription InterpreterCreateQuery::getColumnsDescription(
-    const ASTExpressionList & columns_ast, const Context & context, bool sanity_check_compression_codecs)
+    const ASTExpressionList & columns_ast, ContextPtr context_, bool sanity_check_compression_codecs)
 {
     /// First, deduce implicit types.
 
@@ -388,7 +389,8 @@ ColumnsDescription InterpreterCreateQuery::getColumnsDescription(
                 if (*col_decl.null_modifier)
                     column_type = makeNullable(column_type);
             }
-            else if (context.getSettingsRef().data_type_default_nullable)
+            /// XXX: context_ or context ?
+            else if (context_->getSettingsRef().data_type_default_nullable)
             {
                 column_type = makeNullable(column_type);
             }
@@ -431,7 +433,7 @@ ColumnsDescription InterpreterCreateQuery::getColumnsDescription(
     Block defaults_sample_block;
     /// set missing types and wrap default_expression's in a conversion-function if necessary
     if (!default_expr_list->children.empty())
-        defaults_sample_block = validateColumnsDefaultsAndGetSampleBlock(default_expr_list, column_names_and_types, context);
+        defaults_sample_block = validateColumnsDefaultsAndGetSampleBlock(default_expr_list, column_names_and_types, context_);
 
     ColumnsDescription res;
     auto name_type_it = column_names_and_types.begin();
@@ -476,7 +478,7 @@ ColumnsDescription InterpreterCreateQuery::getColumnsDescription(
         res.add(std::move(column));
     }
 
-    if (context.getSettingsRef().flatten_nested)
+    if (context_->getSettingsRef().flatten_nested)
         res.flattenNested();
 
     if (res.getAllPhysical().empty())
@@ -508,24 +510,24 @@ InterpreterCreateQuery::TableProperties InterpreterCreateQuery::setProperties(AS
 
         if (create.columns_list->columns)
         {
-            bool sanity_check_compression_codecs = !create.attach && !context.getSettingsRef().allow_suspicious_codecs;
-            properties.columns = getColumnsDescription(*create.columns_list->columns, context, sanity_check_compression_codecs);
+            bool sanity_check_compression_codecs = !create.attach && !getContext()->getSettingsRef().allow_suspicious_codecs;
+            properties.columns = getColumnsDescription(*create.columns_list->columns, getContext(), sanity_check_compression_codecs);
         }
 
         if (create.columns_list->indices)
             for (const auto & index : create.columns_list->indices->children)
                 properties.indices.push_back(
-                    IndexDescription::getIndexFromAST(index->clone(), properties.columns, context));
+                    IndexDescription::getIndexFromAST(index->clone(), properties.columns, getContext()));
 
         properties.constraints = getConstraintsDescription(create.columns_list->constraints);
     }
     else if (!create.as_table.empty())
     {
-        String as_database_name = context.resolveDatabase(create.as_database);
-        StoragePtr as_storage = DatabaseCatalog::instance().getTable({as_database_name, create.as_table}, context);
+        String as_database_name = getContext()->resolveDatabase(create.as_database);
+        StoragePtr as_storage = DatabaseCatalog::instance().getTable({as_database_name, create.as_table}, getContext());
 
         /// as_storage->getColumns() and setEngine(...) must be called under structure lock of other_table for CREATE ... AS other_table.
-        as_storage_lock = as_storage->lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+        as_storage_lock = as_storage->lockForShare(getContext()->getCurrentQueryId(), getContext()->getSettingsRef().lock_acquire_timeout);
         auto as_storage_metadata = as_storage->getInMemoryMetadataPtr();
         properties.columns = as_storage_metadata->getColumns();
 
@@ -538,14 +540,14 @@ InterpreterCreateQuery::TableProperties InterpreterCreateQuery::setProperties(AS
     }
     else if (create.select)
     {
-        Block as_select_sample = InterpreterSelectWithUnionQuery::getSampleBlock(create.select->clone(), context);
+        Block as_select_sample = InterpreterSelectWithUnionQuery::getSampleBlock(create.select->clone(), getContext());
         properties.columns = ColumnsDescription(as_select_sample.getNamesAndTypesList());
     }
     else if (create.as_table_function)
     {
         /// Table function without columns list.
-        auto table_function = TableFunctionFactory::instance().get(create.as_table_function, context);
-        properties.columns = table_function->getActualTableStructure(context);
+        auto table_function = TableFunctionFactory::instance().get(create.as_table_function, getContext());
+        properties.columns = table_function->getActualTableStructure(getContext());
         assert(!properties.columns.empty());
     }
     else
@@ -586,7 +588,7 @@ void InterpreterCreateQuery::validateTableStructure(const ASTCreateQuery & creat
             throw Exception("Column " + backQuoteIfNeed(column.name) + " already exists", ErrorCodes::DUPLICATE_COLUMN);
     }
 
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = getContext()->getSettingsRef();
 
     /// Check low cardinality types in creating table if it was not allowed in setting
     if (!create.attach && !settings.allow_suspicious_low_cardinality_types && !create.is_materialized_view)
@@ -681,10 +683,10 @@ void InterpreterCreateQuery::setEngine(ASTCreateQuery & create) const
     {
         /// NOTE Getting the structure from the table specified in the AS is done not atomically with the creation of the table.
 
-        String as_database_name = context.resolveDatabase(create.as_database);
+        String as_database_name = getContext()->resolveDatabase(create.as_database);
         String as_table_name = create.as_table;
 
-        ASTPtr as_create_ptr = DatabaseCatalog::instance().getDatabase(as_database_name)->getCreateTableQuery(as_table_name, context);
+        ASTPtr as_create_ptr = DatabaseCatalog::instance().getDatabase(as_database_name)->getCreateTableQuery(as_table_name, getContext());
         const auto & as_create = as_create_ptr->as<ASTCreateQuery &>();
 
         const String qualified_name = backQuoteIfNeed(as_database_name) + "." + backQuoteIfNeed(as_table_name);
@@ -731,7 +733,8 @@ void InterpreterCreateQuery::assertOrSetUUID(ASTCreateQuery & create, const Data
     const auto * kind = create.is_dictionary ? "Dictionary" : "Table";
     const auto * kind_upper = create.is_dictionary ? "DICTIONARY" : "TABLE";
 
-    if (database->getEngineName() == "Replicated" && context.getClientInfo().query_kind == ClientInfo::QueryKind::SECONDARY_QUERY && !internal)
+    if (database->getEngineName() == "Replicated" && getContext()->getClientInfo().query_kind == ClientInfo::QueryKind::SECONDARY_QUERY
+        && !internal)
     {
         if (create.uuid == UUIDHelpers::Nil)
             throw Exception("Table UUID is not specified in DDL log", ErrorCodes::LOGICAL_ERROR);
@@ -761,7 +764,7 @@ void InterpreterCreateQuery::assertOrSetUUID(ASTCreateQuery & create, const Data
     }
     else
     {
-        bool is_on_cluster = context.getClientInfo().query_kind == ClientInfo::QueryKind::SECONDARY_QUERY;
+        bool is_on_cluster = getContext()->getClientInfo().query_kind == ClientInfo::QueryKind::SECONDARY_QUERY;
         bool has_uuid = create.uuid != UUIDHelpers::Nil || create.to_inner_uuid != UUIDHelpers::Nil;
         if (has_uuid && !is_on_cluster)
             throw Exception(ErrorCodes::INCORRECT_QUERY,
@@ -782,19 +785,19 @@ void InterpreterCreateQuery::assertOrSetUUID(ASTCreateQuery & create, const Data
         UUID uuid_of_table_to_replace;
         if (create.create_or_replace)
         {
-            uuid_of_table_to_replace = context.tryResolveStorageID(StorageID(create.database, create.table)).uuid;
+            uuid_of_table_to_replace = getContext()->tryResolveStorageID(StorageID(create.database, create.table)).uuid;
             if (uuid_of_table_to_replace == UUIDHelpers::Nil)
             {
                 /// Convert to usual CREATE
                 create.replace_table = false;
-                assert(!database->isTableExist(create.table, context));
+                assert(!database->isTableExist(create.table, getContext()));
             }
             else
                 create.table = "_tmp_replace_" + toString(uuid_of_table_to_replace);
         }
         else
         {
-            uuid_of_table_to_replace = context.resolveStorageID(StorageID(create.database, create.table)).uuid;
+            uuid_of_table_to_replace = getContext()->resolveStorageID(StorageID(create.database, create.table)).uuid;
             if (uuid_of_table_to_replace == UUIDHelpers::Nil)
                 throw Exception(ErrorCodes::UNKNOWN_TABLE, "Table {}.{} doesn't exist",
                                 backQuoteIfNeed(create.database), backQuoteIfNeed(create.table));
@@ -811,7 +814,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
         throw Exception("Temporary tables cannot be inside a database. You should not specify a database for a temporary table.",
             ErrorCodes::BAD_DATABASE_FOR_TEMPORARY_TABLE);
 
-    String current_database = context.getCurrentDatabase();
+    String current_database = getContext()->getCurrentDatabase();
     auto database_name = create.database.empty() ? current_database : create.database;
 
     // If this is a stub ATTACH query, read the query definition from the database
@@ -821,18 +824,18 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
         if (database->getEngineName() == "Replicated")
         {
             auto guard = DatabaseCatalog::instance().getDDLGuard(database_name, create.table);
-            if (typeid_cast<DatabaseReplicated *>(database.get()) && context.getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
+            if (typeid_cast<DatabaseReplicated *>(database.get()) && getContext()->getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
             {
                 create.database = database_name;
                 guard->releaseTableLock();
-                return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, context);
+                return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, getContext());
             }
         }
 
         bool if_not_exists = create.if_not_exists;
 
         // Table SQL definition is available even if the table is detached (even permanently)
-        auto query = database->getCreateTableQuery(create.table, context);
+        auto query = database->getCreateTableQuery(create.table, getContext());
         create = query->as<ASTCreateQuery &>(); // Copy the saved create query, but use ATTACH instead of CREATE
         if (create.is_dictionary)
             throw Exception(ErrorCodes::INCORRECT_QUERY,
@@ -847,10 +850,10 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
 
     if (create.attach_from_path)
     {
-        fs::path user_files = fs::path(context.getUserFilesPath()).lexically_normal();
-        fs::path root_path = fs::path(context.getPath()).lexically_normal();
+        fs::path user_files = fs::path(getContext()->getUserFilesPath()).lexically_normal();
+        fs::path root_path = fs::path(getContext()->getPath()).lexically_normal();
 
-        if (context.getClientInfo().query_kind == ClientInfo::QueryKind::INITIAL_QUERY)
+        if (getContext()->getClientInfo().query_kind == ClientInfo::QueryKind::INITIAL_QUERY)
         {
             fs::path data_path = fs::path(*create.attach_from_path).lexically_normal();
             if (data_path.is_relative())
@@ -870,7 +873,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
                                 "Data directory {} must be inside {} to attach it", String(data_path), String(user_files));
         }
     }
-    else if (create.attach && !create.attach_short_syntax && context.getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
+    else if (create.attach && !create.attach_short_syntax && getContext()->getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
     {
         auto * log = &Poco::Logger::get("InterpreterCreateQuery");
         LOG_WARNING(log, "ATTACH TABLE query with full table definition is not recommended: "
@@ -902,11 +905,11 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
     if (need_add_to_database && database->getEngineName() == "Replicated")
     {
         auto guard = DatabaseCatalog::instance().getDDLGuard(create.database, create.table);
-        if (typeid_cast<DatabaseReplicated *>(database.get()) && context.getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
+        if (typeid_cast<DatabaseReplicated *>(database.get()) && getContext()->getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
         {
             assertOrSetUUID(create, database);
             guard->releaseTableLock();
-            return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, context);
+            return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, getContext());
         }
     }
 
@@ -942,7 +945,7 @@ bool InterpreterCreateQuery::doCreateTable(ASTCreateQuery & create,
         assertOrSetUUID(create, database);
 
         /// Table can be created before or it can be created concurrently in another thread, while we were waiting in DDLGuard.
-        if (database->isTableExist(create.table, context))
+        if (database->isTableExist(create.table, getContext()))
         {
             /// TODO Check structure of table
             if (create.if_not_exists)
@@ -955,7 +958,7 @@ bool InterpreterCreateQuery::doCreateTable(ASTCreateQuery & create,
                 drop_ast->table = create.table;
                 drop_ast->no_ddl_lock = true;
 
-                Context drop_context = context;
+                auto drop_context = Context::createCopy(context);
                 InterpreterDropQuery interpreter(drop_ast, drop_context);
                 interpreter.execute();
             }
@@ -964,17 +967,17 @@ bool InterpreterCreateQuery::doCreateTable(ASTCreateQuery & create,
         }
 
         data_path = database->getTableDataPath(create);
-        if (!create.attach && !data_path.empty() && fs::exists(fs::path{context.getPath()} / data_path))
+        if (!create.attach && !data_path.empty() && fs::exists(fs::path{getContext()->getPath()} / data_path))
             throw Exception(ErrorCodes::TABLE_ALREADY_EXISTS, "Directory for table data {} already exists", String(data_path));
     }
     else
     {
-        if (create.if_not_exists && context.tryResolveStorageID({"", create.table}, Context::ResolveExternal))
+        if (create.if_not_exists && getContext()->tryResolveStorageID({"", create.table}, Context::ResolveExternal))
             return false;
 
         String temporary_table_name = create.table;
-        auto temporary_table = TemporaryTableHolder(context, properties.columns, properties.constraints, query_ptr);
-        context.getSessionContext().addExternalTable(temporary_table_name, std::move(temporary_table));
+        auto temporary_table = TemporaryTableHolder(getContext(), properties.columns, properties.constraints, query_ptr);
+        getContext()->getSessionContext()->addExternalTable(temporary_table_name, std::move(temporary_table));
         return true;
     }
 
@@ -995,16 +998,16 @@ bool InterpreterCreateQuery::doCreateTable(ASTCreateQuery & create,
     if (create.as_table_function)
     {
         const auto & factory = TableFunctionFactory::instance();
-        auto table_func = factory.get(create.as_table_function, context);
-        res = table_func->execute(create.as_table_function, context, create.table, properties.columns);
+        auto table_func = factory.get(create.as_table_function, getContext());
+        res = table_func->execute(create.as_table_function, getContext(), create.table, properties.columns);
         res->renameInMemory({create.database, create.table, create.uuid});
     }
     else
     {
         res = StorageFactory::instance().get(create,
             data_path,
-            context,
-            context.getGlobalContext(),
+            getContext(),
+            getContext()->getGlobalContext(),
             properties.columns,
             properties.constraints,
             false);
@@ -1015,7 +1018,7 @@ bool InterpreterCreateQuery::doCreateTable(ASTCreateQuery & create,
                         "ATTACH ... FROM ... query is not supported for {} table engine, "
                         "because such tables do not store any data on disk. Use CREATE instead.", res->getName());
 
-    database->createTable(context, create.table, res, query_ptr);
+    database->createTable(getContext(), create.table, res, query_ptr);
 
     /// Move table data to the proper place. Wo do not move data earlier to avoid situations
     /// when data directory moved, but table has not been created due to some error.
@@ -1067,10 +1070,10 @@ BlockIO InterpreterCreateQuery::doCreateOrReplaceTable(ASTCreateQuery & create,
         };
         ast_rename->elements.push_back(std::move(elem));
         ast_rename->exchange = true;
-        InterpreterRenameQuery(ast_rename, context).execute();
+        InterpreterRenameQuery(ast_rename, getContext()).execute();
         replaced = true;
 
-        InterpreterDropQuery(ast_drop, context).execute();
+        InterpreterDropQuery(ast_drop, getContext()).execute();
 
         create.table = table_to_replace_name;
         return fillTableIfNeeded(create);
@@ -1078,7 +1081,7 @@ BlockIO InterpreterCreateQuery::doCreateOrReplaceTable(ASTCreateQuery & create,
     catch (...)
     {
         if (created && create.replace_table && !replaced)
-            InterpreterDropQuery(ast_drop, context).execute();
+            InterpreterDropQuery(ast_drop, getContext()).execute();
         throw;
     }
 }
@@ -1093,12 +1096,12 @@ BlockIO InterpreterCreateQuery::fillTableIfNeeded(const ASTCreateQuery & create)
         insert->table_id = {create.database, create.table, create.uuid};
         insert->select = create.select->clone();
 
-        if (create.temporary && !context.getSessionContext().hasQueryContext())
-            context.getSessionContext().makeQueryContext();
+        if (create.temporary && !getContext()->getSessionContext()->hasQueryContext())
+            getContext()->getSessionContext()->makeQueryContext();
 
         return InterpreterInsertQuery(insert,
-            create.temporary ? context.getSessionContext() : context,
-            context.getSettingsRef().insert_allow_materialized_columns).execute();
+            create.temporary ? getContext()->getSessionContext() : getContext(),
+            getContext()->getSettingsRef().insert_allow_materialized_columns).execute();
     }
 
     return {};
@@ -1108,18 +1111,19 @@ BlockIO InterpreterCreateQuery::createDictionary(ASTCreateQuery & create)
 {
     String dictionary_name = create.table;
 
-    create.database = context.resolveDatabase(create.database);
+    create.database = getContext()->resolveDatabase(create.database);
     const String & database_name = create.database;
 
     auto guard = DatabaseCatalog::instance().getDDLGuard(database_name, dictionary_name);
     DatabasePtr database = DatabaseCatalog::instance().getDatabase(database_name);
 
-    if (typeid_cast<DatabaseReplicated *>(database.get()) && context.getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
+    if (typeid_cast<DatabaseReplicated *>(database.get())
+        && getContext()->getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
     {
         if (!create.attach)
             assertOrSetUUID(create, database);
         guard->releaseTableLock();
-        return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, context);
+        return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, getContext());
     }
 
     if (database->isDictionaryExist(dictionary_name))
@@ -1143,17 +1147,17 @@ BlockIO InterpreterCreateQuery::createDictionary(ASTCreateQuery & create)
 
     if (create.attach)
     {
-        auto config = getDictionaryConfigurationFromAST(create, context);
+        auto config = getDictionaryConfigurationFromAST(create, getContext());
         auto modification_time = database->getObjectMetadataModificationTime(dictionary_name);
         database->attachDictionary(dictionary_name, DictionaryAttachInfo{query_ptr, config, modification_time});
     }
     else
-        database->createDictionary(context, dictionary_name, query_ptr);
+        database->createDictionary(getContext(), dictionary_name, query_ptr);
 
     return {};
 }
 
-void InterpreterCreateQuery::prepareOnClusterQuery(ASTCreateQuery & create, const Context & context, const String & cluster_name)
+void InterpreterCreateQuery::prepareOnClusterQuery(ASTCreateQuery & create, ContextPtr local_context, const String & cluster_name)
 {
     if (create.attach)
         return;
@@ -1163,8 +1167,8 @@ void InterpreterCreateQuery::prepareOnClusterQuery(ASTCreateQuery & create, cons
     generateUUIDForTable(create);
 
     /// For cross-replication cluster we cannot use UUID in replica path.
-    String cluster_name_expanded = context.getMacros()->expand(cluster_name);
-    ClusterPtr cluster = context.getCluster(cluster_name_expanded);
+    String cluster_name_expanded = local_context->getMacros()->expand(cluster_name);
+    ClusterPtr cluster = local_context->getCluster(cluster_name_expanded);
 
     if (cluster->maybeCrossReplication())
     {
@@ -1188,7 +1192,7 @@ void InterpreterCreateQuery::prepareOnClusterQuery(ASTCreateQuery & create, cons
             Macros::MacroExpansionInfo info;
             info.table_id.uuid = create.uuid;
             info.ignore_unknown = true;
-            context.getMacros()->expand(zk_path, info);
+            local_context->getMacros()->expand(zk_path, info);
             if (!info.expanded_uuid)
                 return;
         }
@@ -1206,11 +1210,11 @@ BlockIO InterpreterCreateQuery::execute()
     auto & create = query_ptr->as<ASTCreateQuery &>();
     if (!create.cluster.empty())
     {
-        prepareOnClusterQuery(create, context, create.cluster);
-        return executeDDLQueryOnCluster(query_ptr, context, getRequiredAccess());
+        prepareOnClusterQuery(create, getContext(), create.cluster);
+        return executeDDLQueryOnCluster(query_ptr, getContext(), getRequiredAccess());
     }
 
-    context.checkAccess(getRequiredAccess());
+    getContext()->checkAccess(getRequiredAccess());
 
     ASTQueryWithOutput::resetOutputASTIfExist(create);
 
@@ -1274,12 +1278,12 @@ AccessRightsElements InterpreterCreateQuery::getRequiredAccess() const
     return required_access;
 }
 
-void InterpreterCreateQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, const Context &) const
+void InterpreterCreateQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, ContextPtr) const
 {
     elem.query_kind = "Create";
     if (!as_table_saved.empty())
     {
-        String database = backQuoteIfNeed(as_database_saved.empty() ? context.getCurrentDatabase() : as_database_saved);
+        String database = backQuoteIfNeed(as_database_saved.empty() ? getContext()->getCurrentDatabase() : as_database_saved);
         elem.query_databases.insert(database);
         elem.query_tables.insert(database + "." + backQuoteIfNeed(as_table_saved));
     }
diff --git a/src/Interpreters/InterpreterCreateQuery.h b/src/Interpreters/InterpreterCreateQuery.h
index d88357fe412..30db7dbdc8e 100644
--- a/src/Interpreters/InterpreterCreateQuery.h
+++ b/src/Interpreters/InterpreterCreateQuery.h
@@ -1,18 +1,17 @@
 #pragma once
 
+#include <Access/AccessRightsElement.h>
 #include <Interpreters/IInterpreter.h>
 #include <Storages/ColumnsDescription.h>
+#include <Storages/ConstraintsDescription.h>
 #include <Storages/IStorage_fwd.h>
 #include <Storages/StorageInMemoryMetadata.h>
-#include <Storages/ConstraintsDescription.h>
 #include <Common/ThreadPool.h>
-#include <Access/AccessRightsElement.h>
 
 
 namespace DB
 {
 
-class Context;
 class ASTCreateQuery;
 class ASTExpressionList;
 class ASTConstraintDeclaration;
@@ -23,10 +22,10 @@ using DatabasePtr = std::shared_ptr<IDatabase>;
 /** Allows to create new table or database,
   *  or create an object for existing table or database.
   */
-class InterpreterCreateQuery : public IInterpreter
+class InterpreterCreateQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterCreateQuery(const ASTPtr & query_ptr_, Context & context_);
+    InterpreterCreateQuery(const ASTPtr & query_ptr_, ContextPtr context_);
 
     BlockIO execute() override;
 
@@ -54,12 +53,12 @@ public:
 
     /// Obtain information about columns, their types, default values and column comments,
     ///  for case when columns in CREATE query is specified explicitly.
-    static ColumnsDescription getColumnsDescription(const ASTExpressionList & columns, const Context & context, bool sanity_check_compression_codecs);
+    static ColumnsDescription getColumnsDescription(const ASTExpressionList & columns, ContextPtr context, bool sanity_check_compression_codecs);
     static ConstraintsDescription getConstraintsDescription(const ASTExpressionList * constraints);
 
-    static void prepareOnClusterQuery(ASTCreateQuery & create, const Context & context, const String & cluster_name);
+    static void prepareOnClusterQuery(ASTCreateQuery & create, ContextPtr context, const String & cluster_name);
 
-    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, const Context &) const override;
+    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, ContextPtr) const override;
 
 private:
     struct TableProperties
@@ -88,7 +87,6 @@ private:
     void assertOrSetUUID(ASTCreateQuery & create, const DatabasePtr & database) const;
 
     ASTPtr query_ptr;
-    Context & context;
 
     /// Skip safety threshold when loading tables.
     bool has_force_restore_data_flag = false;
diff --git a/src/Interpreters/InterpreterCreateQuotaQuery.cpp b/src/Interpreters/InterpreterCreateQuotaQuery.cpp
index 4c35aaf573b..223215624b3 100644
--- a/src/Interpreters/InterpreterCreateQuotaQuery.cpp
+++ b/src/Interpreters/InterpreterCreateQuotaQuery.cpp
@@ -73,18 +73,18 @@ namespace
 BlockIO InterpreterCreateQuotaQuery::execute()
 {
     auto & query = query_ptr->as<ASTCreateQuotaQuery &>();
-    auto & access_control = context.getAccessControlManager();
-    context.checkAccess(query.alter ? AccessType::ALTER_QUOTA : AccessType::CREATE_QUOTA);
+    auto & access_control = getContext()->getAccessControlManager();
+    getContext()->checkAccess(query.alter ? AccessType::ALTER_QUOTA : AccessType::CREATE_QUOTA);
 
     if (!query.cluster.empty())
     {
-        query.replaceCurrentUserTag(context.getUserName());
-        return executeDDLQueryOnCluster(query_ptr, context);
+        query.replaceCurrentUserTag(getContext()->getUserName());
+        return executeDDLQueryOnCluster(query_ptr, getContext());
     }
 
     std::optional<RolesOrUsersSet> roles_from_query;
     if (query.roles)
-        roles_from_query = RolesOrUsersSet{*query.roles, access_control, context.getUserID()};
+        roles_from_query = RolesOrUsersSet{*query.roles, access_control, getContext()->getUserID()};
 
     if (query.alter)
     {
diff --git a/src/Interpreters/InterpreterCreateQuotaQuery.h b/src/Interpreters/InterpreterCreateQuotaQuery.h
index ca0e7b44713..d8edd24b2d9 100644
--- a/src/Interpreters/InterpreterCreateQuotaQuery.h
+++ b/src/Interpreters/InterpreterCreateQuotaQuery.h
@@ -2,19 +2,18 @@
 
 #include <Interpreters/IInterpreter.h>
 #include <Parsers/IAST_fwd.h>
-#include <optional>
 
 
 namespace DB
 {
+
 class ASTCreateQuotaQuery;
 struct Quota;
 
-
-class InterpreterCreateQuotaQuery : public IInterpreter
+class InterpreterCreateQuotaQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterCreateQuotaQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+    InterpreterCreateQuotaQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -25,6 +24,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    Context & context;
 };
+
 }
diff --git a/src/Interpreters/InterpreterCreateRoleQuery.cpp b/src/Interpreters/InterpreterCreateRoleQuery.cpp
index 72ad3234b95..b9debc259be 100644
--- a/src/Interpreters/InterpreterCreateRoleQuery.cpp
+++ b/src/Interpreters/InterpreterCreateRoleQuery.cpp
@@ -34,14 +34,14 @@ namespace
 BlockIO InterpreterCreateRoleQuery::execute()
 {
     const auto & query = query_ptr->as<const ASTCreateRoleQuery &>();
-    auto & access_control = context.getAccessControlManager();
+    auto & access_control = getContext()->getAccessControlManager();
     if (query.alter)
-        context.checkAccess(AccessType::ALTER_ROLE);
+        getContext()->checkAccess(AccessType::ALTER_ROLE);
     else
-        context.checkAccess(AccessType::CREATE_ROLE);
+        getContext()->checkAccess(AccessType::CREATE_ROLE);
 
     if (!query.cluster.empty())
-        return executeDDLQueryOnCluster(query_ptr, context);
+        return executeDDLQueryOnCluster(query_ptr, getContext());
 
     std::optional<SettingsProfileElements> settings_from_query;
     if (query.settings)
diff --git a/src/Interpreters/InterpreterCreateRoleQuery.h b/src/Interpreters/InterpreterCreateRoleQuery.h
index 768fd6d1d6b..18b3f946837 100644
--- a/src/Interpreters/InterpreterCreateRoleQuery.h
+++ b/src/Interpreters/InterpreterCreateRoleQuery.h
@@ -6,14 +6,14 @@
 
 namespace DB
 {
+
 class ASTCreateRoleQuery;
 struct Role;
 
-
-class InterpreterCreateRoleQuery : public IInterpreter
+class InterpreterCreateRoleQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterCreateRoleQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+    InterpreterCreateRoleQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -21,6 +21,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    Context & context;
 };
+
 }
diff --git a/src/Interpreters/InterpreterCreateRowPolicyQuery.cpp b/src/Interpreters/InterpreterCreateRowPolicyQuery.cpp
index 0932f74cdc5..5e4b9b30e66 100644
--- a/src/Interpreters/InterpreterCreateRowPolicyQuery.cpp
+++ b/src/Interpreters/InterpreterCreateRowPolicyQuery.cpp
@@ -44,21 +44,21 @@ namespace
 BlockIO InterpreterCreateRowPolicyQuery::execute()
 {
     auto & query = query_ptr->as<ASTCreateRowPolicyQuery &>();
-    auto & access_control = context.getAccessControlManager();
-    context.checkAccess(query.alter ? AccessType::ALTER_ROW_POLICY : AccessType::CREATE_ROW_POLICY);
+    auto & access_control = getContext()->getAccessControlManager();
+    getContext()->checkAccess(query.alter ? AccessType::ALTER_ROW_POLICY : AccessType::CREATE_ROW_POLICY);
 
     if (!query.cluster.empty())
     {
-        query.replaceCurrentUserTag(context.getUserName());
-        return executeDDLQueryOnCluster(query_ptr, context);
+        query.replaceCurrentUserTag(getContext()->getUserName());
+        return executeDDLQueryOnCluster(query_ptr, getContext());
     }
 
     assert(query.names->cluster.empty());
     std::optional<RolesOrUsersSet> roles_from_query;
     if (query.roles)
-        roles_from_query = RolesOrUsersSet{*query.roles, access_control, context.getUserID()};
+        roles_from_query = RolesOrUsersSet{*query.roles, access_control, getContext()->getUserID()};
 
-    query.replaceEmptyDatabase(context.getCurrentDatabase());
+    query.replaceEmptyDatabase(getContext()->getCurrentDatabase());
 
     if (query.alter)
     {
diff --git a/src/Interpreters/InterpreterCreateRowPolicyQuery.h b/src/Interpreters/InterpreterCreateRowPolicyQuery.h
index feb583310c0..10167bac669 100644
--- a/src/Interpreters/InterpreterCreateRowPolicyQuery.h
+++ b/src/Interpreters/InterpreterCreateRowPolicyQuery.h
@@ -2,19 +2,18 @@
 
 #include <Interpreters/IInterpreter.h>
 #include <Parsers/IAST_fwd.h>
-#include <optional>
 
 
 namespace DB
 {
+
 class ASTCreateRowPolicyQuery;
 struct RowPolicy;
 
-
-class InterpreterCreateRowPolicyQuery : public IInterpreter
+class InterpreterCreateRowPolicyQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterCreateRowPolicyQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+    InterpreterCreateRowPolicyQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -22,6 +21,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    Context & context;
 };
+
 }
diff --git a/src/Interpreters/InterpreterCreateSettingsProfileQuery.cpp b/src/Interpreters/InterpreterCreateSettingsProfileQuery.cpp
index 0931b48e723..fb5fb258b10 100644
--- a/src/Interpreters/InterpreterCreateSettingsProfileQuery.cpp
+++ b/src/Interpreters/InterpreterCreateSettingsProfileQuery.cpp
@@ -42,16 +42,16 @@ namespace
 BlockIO InterpreterCreateSettingsProfileQuery::execute()
 {
     auto & query = query_ptr->as<ASTCreateSettingsProfileQuery &>();
-    auto & access_control = context.getAccessControlManager();
+    auto & access_control = getContext()->getAccessControlManager();
     if (query.alter)
-        context.checkAccess(AccessType::ALTER_SETTINGS_PROFILE);
+        getContext()->checkAccess(AccessType::ALTER_SETTINGS_PROFILE);
     else
-        context.checkAccess(AccessType::CREATE_SETTINGS_PROFILE);
+        getContext()->checkAccess(AccessType::CREATE_SETTINGS_PROFILE);
 
     if (!query.cluster.empty())
     {
-        query.replaceCurrentUserTag(context.getUserName());
-        return executeDDLQueryOnCluster(query_ptr, context);
+        query.replaceCurrentUserTag(getContext()->getUserName());
+        return executeDDLQueryOnCluster(query_ptr, getContext());
     }
 
     std::optional<SettingsProfileElements> settings_from_query;
@@ -60,7 +60,7 @@ BlockIO InterpreterCreateSettingsProfileQuery::execute()
 
     std::optional<RolesOrUsersSet> roles_from_query;
     if (query.to_roles)
-        roles_from_query = RolesOrUsersSet{*query.to_roles, access_control, context.getUserID()};
+        roles_from_query = RolesOrUsersSet{*query.to_roles, access_control, getContext()->getUserID()};
 
     if (query.alter)
     {
diff --git a/src/Interpreters/InterpreterCreateSettingsProfileQuery.h b/src/Interpreters/InterpreterCreateSettingsProfileQuery.h
index fd420779cf4..9ef1f0354a9 100644
--- a/src/Interpreters/InterpreterCreateSettingsProfileQuery.h
+++ b/src/Interpreters/InterpreterCreateSettingsProfileQuery.h
@@ -6,14 +6,14 @@
 
 namespace DB
 {
+
 class ASTCreateSettingsProfileQuery;
 struct SettingsProfile;
 
-
-class InterpreterCreateSettingsProfileQuery : public IInterpreter
+class InterpreterCreateSettingsProfileQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterCreateSettingsProfileQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+    InterpreterCreateSettingsProfileQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -21,6 +21,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    Context & context;
 };
+
 }
diff --git a/src/Interpreters/InterpreterCreateUserQuery.cpp b/src/Interpreters/InterpreterCreateUserQuery.cpp
index 777cf7de297..7f4969ff9ef 100644
--- a/src/Interpreters/InterpreterCreateUserQuery.cpp
+++ b/src/Interpreters/InterpreterCreateUserQuery.cpp
@@ -75,8 +75,8 @@ namespace
 BlockIO InterpreterCreateUserQuery::execute()
 {
     const auto & query = query_ptr->as<const ASTCreateUserQuery &>();
-    auto & access_control = context.getAccessControlManager();
-    auto access = context.getAccess();
+    auto & access_control = getContext()->getAccessControlManager();
+    auto access = getContext()->getAccess();
     access->checkAccess(query.alter ? AccessType::ALTER_USER : AccessType::CREATE_USER);
 
     std::optional<RolesOrUsersSet> default_roles_from_query;
@@ -91,7 +91,7 @@ BlockIO InterpreterCreateUserQuery::execute()
     }
 
     if (!query.cluster.empty())
-        return executeDDLQueryOnCluster(query_ptr, context);
+        return executeDDLQueryOnCluster(query_ptr, getContext());
 
     std::optional<SettingsProfileElements> settings_from_query;
     if (query.settings)
diff --git a/src/Interpreters/InterpreterCreateUserQuery.h b/src/Interpreters/InterpreterCreateUserQuery.h
index e5b614b5cbb..e9f4e82e767 100644
--- a/src/Interpreters/InterpreterCreateUserQuery.h
+++ b/src/Interpreters/InterpreterCreateUserQuery.h
@@ -6,14 +6,14 @@
 
 namespace DB
 {
+
 class ASTCreateUserQuery;
 struct User;
 
-
-class InterpreterCreateUserQuery : public IInterpreter
+class InterpreterCreateUserQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterCreateUserQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+    InterpreterCreateUserQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -21,6 +21,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    Context & context;
 };
+
 }
diff --git a/src/Interpreters/InterpreterDescribeQuery.cpp b/src/Interpreters/InterpreterDescribeQuery.cpp
index 27d8ac48bc8..705e52da72c 100644
--- a/src/Interpreters/InterpreterDescribeQuery.cpp
+++ b/src/Interpreters/InterpreterDescribeQuery.cpp
@@ -69,20 +69,20 @@ BlockInputStreamPtr InterpreterDescribeQuery::executeImpl()
     if (table_expression.subquery)
     {
         auto names_and_types = InterpreterSelectWithUnionQuery::getSampleBlock(
-            table_expression.subquery->children.at(0), context).getNamesAndTypesList();
+            table_expression.subquery->children.at(0), getContext()).getNamesAndTypesList();
         columns = ColumnsDescription(std::move(names_and_types));
     }
     else if (table_expression.table_function)
     {
-        TableFunctionPtr table_function_ptr = TableFunctionFactory::instance().get(table_expression.table_function, context);
-        columns = table_function_ptr->getActualTableStructure(context);
+        TableFunctionPtr table_function_ptr = TableFunctionFactory::instance().get(table_expression.table_function, getContext());
+        columns = table_function_ptr->getActualTableStructure(getContext());
     }
     else
     {
-        auto table_id = context.resolveStorageID(table_expression.database_and_table_name);
-        context.checkAccess(AccessType::SHOW_COLUMNS, table_id);
-        auto table = DatabaseCatalog::instance().getTable(table_id, context);
-        auto table_lock = table->lockForShare(context.getInitialQueryId(), context.getSettingsRef().lock_acquire_timeout);
+        auto table_id = getContext()->resolveStorageID(table_expression.database_and_table_name);
+        getContext()->checkAccess(AccessType::SHOW_COLUMNS, table_id);
+        auto table = DatabaseCatalog::instance().getTable(table_id, getContext());
+        auto table_lock = table->lockForShare(getContext()->getInitialQueryId(), getContext()->getSettingsRef().lock_acquire_timeout);
         auto metadata_snapshot = table->getInMemoryMetadataPtr();
         columns = metadata_snapshot->getColumns();
     }
diff --git a/src/Interpreters/InterpreterDescribeQuery.h b/src/Interpreters/InterpreterDescribeQuery.h
index 4fafe61f229..627d1ca0353 100644
--- a/src/Interpreters/InterpreterDescribeQuery.h
+++ b/src/Interpreters/InterpreterDescribeQuery.h
@@ -7,16 +7,12 @@
 namespace DB
 {
 
-class Context;
-
-
 /** Return names, types and other information about columns in specified table.
   */
-class InterpreterDescribeQuery : public IInterpreter
+class InterpreterDescribeQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterDescribeQuery(const ASTPtr & query_ptr_, const Context & context_)
-        : query_ptr(query_ptr_), context(context_) {}
+    InterpreterDescribeQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -24,7 +20,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    const Context & context;
 
     BlockInputStreamPtr executeImpl();
 };
diff --git a/src/Interpreters/InterpreterDropAccessEntityQuery.cpp b/src/Interpreters/InterpreterDropAccessEntityQuery.cpp
index e02c047e75d..a9b8db6d74e 100644
--- a/src/Interpreters/InterpreterDropAccessEntityQuery.cpp
+++ b/src/Interpreters/InterpreterDropAccessEntityQuery.cpp
@@ -25,13 +25,13 @@ using EntityType = IAccessEntity::Type;
 BlockIO InterpreterDropAccessEntityQuery::execute()
 {
     auto & query = query_ptr->as<ASTDropAccessEntityQuery &>();
-    auto & access_control = context.getAccessControlManager();
-    context.checkAccess(getRequiredAccess());
+    auto & access_control = getContext()->getAccessControlManager();
+    getContext()->checkAccess(getRequiredAccess());
 
     if (!query.cluster.empty())
-        return executeDDLQueryOnCluster(query_ptr, context);
+        return executeDDLQueryOnCluster(query_ptr, getContext());
 
-    query.replaceEmptyDatabase(context.getCurrentDatabase());
+    query.replaceEmptyDatabase(getContext()->getCurrentDatabase());
 
     auto do_drop = [&](const Strings & names)
     {
diff --git a/src/Interpreters/InterpreterDropAccessEntityQuery.h b/src/Interpreters/InterpreterDropAccessEntityQuery.h
index 0db68a0ad78..7f0f6348610 100644
--- a/src/Interpreters/InterpreterDropAccessEntityQuery.h
+++ b/src/Interpreters/InterpreterDropAccessEntityQuery.h
@@ -6,12 +6,13 @@
 
 namespace DB
 {
+
 class AccessRightsElements;
 
-class InterpreterDropAccessEntityQuery : public IInterpreter
+class InterpreterDropAccessEntityQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterDropAccessEntityQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+    InterpreterDropAccessEntityQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -19,6 +20,6 @@ private:
     AccessRightsElements getRequiredAccess() const;
 
     ASTPtr query_ptr;
-    Context & context;
 };
+
 }
diff --git a/src/Interpreters/InterpreterDropQuery.cpp b/src/Interpreters/InterpreterDropQuery.cpp
index 276f61d244a..8ac6a0ae3a8 100644
--- a/src/Interpreters/InterpreterDropQuery.cpp
+++ b/src/Interpreters/InterpreterDropQuery.cpp
@@ -43,16 +43,18 @@ static DatabasePtr tryGetDatabase(const String & database_name, bool if_exists)
 }
 
 
-InterpreterDropQuery::InterpreterDropQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+InterpreterDropQuery::InterpreterDropQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_)
+{
+}
 
 
 BlockIO InterpreterDropQuery::execute()
 {
     auto & drop = query_ptr->as<ASTDropQuery &>();
     if (!drop.cluster.empty())
-        return executeDDLQueryOnCluster(query_ptr, context, getRequiredAccessForDDLOnCluster());
+        return executeDDLQueryOnCluster(query_ptr, getContext(), getRequiredAccessForDDLOnCluster());
 
-    if (context.getSettingsRef().database_atomic_wait_for_drop_and_detach_synchronously)
+    if (getContext()->getSettingsRef().database_atomic_wait_for_drop_and_detach_synchronously)
         drop.no_delay = true;
 
     if (!drop.table.empty())
@@ -98,10 +100,10 @@ BlockIO InterpreterDropQuery::executeToTableImpl(ASTDropQuery & query, DatabaseP
     auto table_id = StorageID(query);
     if (query.temporary || table_id.database_name.empty())
     {
-        if (context.tryResolveStorageID(table_id, Context::ResolveExternal))
+        if (getContext()->tryResolveStorageID(table_id, Context::ResolveExternal))
             return executeToTemporaryTable(table_id.getTableName(), query.kind);
         else
-            query.database = table_id.database_name = context.getCurrentDatabase();
+            query.database = table_id.database_name = getContext()->getCurrentDatabase();
     }
 
     if (query.temporary)
@@ -115,8 +117,8 @@ BlockIO InterpreterDropQuery::executeToTableImpl(ASTDropQuery & query, DatabaseP
     auto ddl_guard = (!query.no_ddl_lock ? DatabaseCatalog::instance().getDDLGuard(table_id.database_name, table_id.table_name) : nullptr);
 
     /// If table was already dropped by anyone, an exception will be thrown
-    auto [database, table] = query.if_exists ? DatabaseCatalog::instance().tryGetDatabaseAndTable(table_id, context)
-                                             : DatabaseCatalog::instance().getDatabaseAndTable(table_id, context);
+    auto [database, table] = query.if_exists ? DatabaseCatalog::instance().tryGetDatabaseAndTable(table_id, getContext())
+                                             : DatabaseCatalog::instance().getDatabaseAndTable(table_id, getContext());
 
     if (database && table)
     {
@@ -129,36 +131,36 @@ BlockIO InterpreterDropQuery::executeToTableImpl(ASTDropQuery & query, DatabaseP
         /// Prevents recursive drop from drop database query. The original query must specify a table.
         bool is_drop_or_detach_database = query_ptr->as<ASTDropQuery>()->table.empty();
         bool is_replicated_ddl_query = typeid_cast<DatabaseReplicated *>(database.get()) &&
-                                       context.getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY &&
+                                       getContext()->getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY &&
                                        !is_drop_or_detach_database;
         if (is_replicated_ddl_query)
         {
             if (query.kind == ASTDropQuery::Kind::Detach)
-                context.checkAccess(table->isView() ? AccessType::DROP_VIEW : AccessType::DROP_TABLE, table_id);
+                getContext()->checkAccess(table->isView() ? AccessType::DROP_VIEW : AccessType::DROP_TABLE, table_id);
             else if (query.kind == ASTDropQuery::Kind::Truncate)
-                context.checkAccess(AccessType::TRUNCATE, table_id);
+                getContext()->checkAccess(AccessType::TRUNCATE, table_id);
             else if (query.kind == ASTDropQuery::Kind::Drop)
-                context.checkAccess(table->isView() ? AccessType::DROP_VIEW : AccessType::DROP_TABLE, table_id);
+                getContext()->checkAccess(table->isView() ? AccessType::DROP_VIEW : AccessType::DROP_TABLE, table_id);
 
             ddl_guard->releaseTableLock();
             table.reset();
-            return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query.clone(), context);
+            return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query.clone(), getContext());
         }
 
         if (query.kind == ASTDropQuery::Kind::Detach)
         {
-            context.checkAccess(table->isView() ? AccessType::DROP_VIEW : AccessType::DROP_TABLE, table_id);
+            getContext()->checkAccess(table->isView() ? AccessType::DROP_VIEW : AccessType::DROP_TABLE, table_id);
             table->checkTableCanBeDetached();
             table->shutdown();
             TableExclusiveLockHolder table_lock;
 
             if (database->getUUID() == UUIDHelpers::Nil)
-                table_lock = table->lockExclusively(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+                table_lock = table->lockExclusively(getContext()->getCurrentQueryId(), getContext()->getSettingsRef().lock_acquire_timeout);
 
             if (query.permanently)
             {
                 /// Drop table from memory, don't touch data, metadata file renamed and will be skipped during server restart
-                database->detachTablePermanently(context, table_id.table_name);
+                database->detachTablePermanently(getContext(), table_id.table_name);
             }
             else
             {
@@ -168,26 +170,26 @@ BlockIO InterpreterDropQuery::executeToTableImpl(ASTDropQuery & query, DatabaseP
         }
         else if (query.kind == ASTDropQuery::Kind::Truncate)
         {
-            context.checkAccess(AccessType::TRUNCATE, table_id);
+            getContext()->checkAccess(AccessType::TRUNCATE, table_id);
             table->checkTableCanBeDropped();
 
-            auto table_lock = table->lockExclusively(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+            auto table_lock = table->lockExclusively(getContext()->getCurrentQueryId(), getContext()->getSettingsRef().lock_acquire_timeout);
             auto metadata_snapshot = table->getInMemoryMetadataPtr();
             /// Drop table data, don't touch metadata
-            table->truncate(query_ptr, metadata_snapshot, context, table_lock);
+            table->truncate(query_ptr, metadata_snapshot, getContext(), table_lock);
         }
         else if (query.kind == ASTDropQuery::Kind::Drop)
         {
-            context.checkAccess(table->isView() ? AccessType::DROP_VIEW : AccessType::DROP_TABLE, table_id);
+            getContext()->checkAccess(table->isView() ? AccessType::DROP_VIEW : AccessType::DROP_TABLE, table_id);
             table->checkTableCanBeDropped();
 
             table->shutdown();
 
             TableExclusiveLockHolder table_lock;
             if (database->getUUID() == UUIDHelpers::Nil)
-                table_lock = table->lockExclusively(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+                table_lock = table->lockExclusively(getContext()->getCurrentQueryId(), getContext()->getSettingsRef().lock_acquire_timeout);
 
-            database->dropTable(context, table_id.table_name, query.no_delay);
+            database->dropTable(getContext(), table_id.table_name, query.no_delay);
         }
 
         db = database;
@@ -209,7 +211,7 @@ BlockIO InterpreterDropQuery::executeToDictionary(
     if (is_temporary)
         throw Exception("Temporary dictionaries are not possible.", ErrorCodes::SYNTAX_ERROR);
 
-    String database_name = context.resolveDatabase(database_name_);
+    String database_name = getContext()->resolveDatabase(database_name_);
 
     auto ddl_guard = (!no_ddl_lock ? DatabaseCatalog::instance().getDDLGuard(database_name, dictionary_name) : nullptr);
     query_ptr->as<ASTDropQuery>()->database = database_name;
@@ -217,17 +219,17 @@ BlockIO InterpreterDropQuery::executeToDictionary(
 
     bool is_drop_or_detach_database = query_ptr->as<ASTDropQuery>()->table.empty();
     bool is_replicated_ddl_query = typeid_cast<DatabaseReplicated *>(database.get()) &&
-                                   context.getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY &&
+                                   getContext()->getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY &&
                                    !is_drop_or_detach_database;
     if (is_replicated_ddl_query)
     {
         if (kind == ASTDropQuery::Kind::Detach)
             throw Exception(ErrorCodes::INCORRECT_QUERY, "DETACH DICTIONARY is not allowed for Replicated databases.");
 
-        context.checkAccess(AccessType::DROP_DICTIONARY, database_name, dictionary_name);
+        getContext()->checkAccess(AccessType::DROP_DICTIONARY, database_name, dictionary_name);
 
         ddl_guard->releaseTableLock();
-        return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, context);
+        return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, getContext());
     }
 
     if (!database || !database->isDictionaryExist(dictionary_name))
@@ -243,7 +245,7 @@ BlockIO InterpreterDropQuery::executeToDictionary(
     if (kind == ASTDropQuery::Kind::Detach)
     {
         /// Drop dictionary from memory, don't touch data and metadata
-        context.checkAccess(AccessType::DROP_DICTIONARY, database_name, dictionary_name);
+        getContext()->checkAccess(AccessType::DROP_DICTIONARY, database_name, dictionary_name);
         database->detachDictionary(dictionary_name);
     }
     else if (kind == ASTDropQuery::Kind::Truncate)
@@ -252,8 +254,8 @@ BlockIO InterpreterDropQuery::executeToDictionary(
     }
     else if (kind == ASTDropQuery::Kind::Drop)
     {
-        context.checkAccess(AccessType::DROP_DICTIONARY, database_name, dictionary_name);
-        database->removeDictionary(context, dictionary_name);
+        getContext()->checkAccess(AccessType::DROP_DICTIONARY, database_name, dictionary_name);
+        database->removeDictionary(getContext(), dictionary_name);
     }
     return {};
 }
@@ -264,23 +266,24 @@ BlockIO InterpreterDropQuery::executeToTemporaryTable(const String & table_name,
         throw Exception("Unable to detach temporary table.", ErrorCodes::SYNTAX_ERROR);
     else
     {
-        auto & context_handle = context.hasSessionContext() ? context.getSessionContext() : context;
-        auto resolved_id = context_handle.tryResolveStorageID(StorageID("", table_name), Context::ResolveExternal);
+        auto context_handle = getContext()->hasSessionContext() ? getContext()->getSessionContext() : getContext();
+        auto resolved_id = context_handle->tryResolveStorageID(StorageID("", table_name), Context::ResolveExternal);
         if (resolved_id)
         {
-            StoragePtr table = DatabaseCatalog::instance().getTable(resolved_id, context);
+            StoragePtr table = DatabaseCatalog::instance().getTable(resolved_id, getContext());
             if (kind == ASTDropQuery::Kind::Truncate)
             {
-                auto table_lock = table->lockExclusively(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+                auto table_lock
+                    = table->lockExclusively(getContext()->getCurrentQueryId(), getContext()->getSettingsRef().lock_acquire_timeout);
                 /// Drop table data, don't touch metadata
                 auto metadata_snapshot = table->getInMemoryMetadataPtr();
-                table->truncate(query_ptr, metadata_snapshot, context, table_lock);
+                table->truncate(query_ptr, metadata_snapshot, getContext(), table_lock);
             }
             else if (kind == ASTDropQuery::Kind::Drop)
             {
-                context_handle.removeExternalTable(table_name);
+                context_handle->removeExternalTable(table_name);
                 table->shutdown();
-                auto table_lock = table->lockExclusively(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+                auto table_lock = table->lockExclusively(getContext()->getCurrentQueryId(), getContext()->getSettingsRef().lock_acquire_timeout);
                 /// Delete table data
                 table->drop();
                 table->is_dropped = true;
@@ -334,7 +337,7 @@ BlockIO InterpreterDropQuery::executeToDatabaseImpl(const ASTDropQuery & query,
         else if (query.kind == ASTDropQuery::Kind::Detach || query.kind == ASTDropQuery::Kind::Drop)
         {
             bool drop = query.kind == ASTDropQuery::Kind::Drop;
-            context.checkAccess(AccessType::DROP_DATABASE, database_name);
+            getContext()->checkAccess(AccessType::DROP_DATABASE, database_name);
 
             if (query.kind == ASTDropQuery::Kind::Detach && query.permanently)
                 throw Exception("DETACH PERMANENTLY is not implemented for databases", ErrorCodes::NOT_IMPLEMENTED);
@@ -363,7 +366,7 @@ BlockIO InterpreterDropQuery::executeToDatabaseImpl(const ASTDropQuery & query,
                 query_for_table.database = database_name;
                 query_for_table.no_delay = query.no_delay;
 
-                for (auto iterator = database->getTablesIterator(context); iterator->isValid(); iterator->next())
+                for (auto iterator = database->getTablesIterator(getContext()); iterator->isValid(); iterator->next())
                 {
                     DatabasePtr db;
                     UUID table_to_wait = UUIDHelpers::Nil;
@@ -421,7 +424,7 @@ AccessRightsElements InterpreterDropQuery::getRequiredAccessForDDLOnCluster() co
     return required_access;
 }
 
-void InterpreterDropQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, const Context &) const
+void InterpreterDropQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, ContextPtr) const
 {
     elem.query_kind = "Drop";
 }
diff --git a/src/Interpreters/InterpreterDropQuery.h b/src/Interpreters/InterpreterDropQuery.h
index 4a67857767f..8e8d577deec 100644
--- a/src/Interpreters/InterpreterDropQuery.h
+++ b/src/Interpreters/InterpreterDropQuery.h
@@ -16,20 +16,19 @@ class AccessRightsElements;
   * or remove information about table (just forget) from server (DETACH),
   * or just clear all data in table (TRUNCATE).
   */
-class InterpreterDropQuery : public IInterpreter
+class InterpreterDropQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterDropQuery(const ASTPtr & query_ptr_, Context & context_);
+    InterpreterDropQuery(const ASTPtr & query_ptr_, ContextPtr context_);
 
     /// Drop table or database.
     BlockIO execute() override;
 
-    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, const Context &) const override;
+    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, ContextPtr) const override;
 
 private:
     AccessRightsElements getRequiredAccessForDDLOnCluster() const;
     ASTPtr query_ptr;
-    Context & context;
 
     BlockIO executeToDatabase(const ASTDropQuery & query);
     BlockIO executeToDatabaseImpl(const ASTDropQuery & query, DatabasePtr & database, std::vector<UUID> & uuids_to_wait);
diff --git a/src/Interpreters/InterpreterExistsQuery.cpp b/src/Interpreters/InterpreterExistsQuery.cpp
index 335ee452e39..cbdb8561920 100644
--- a/src/Interpreters/InterpreterExistsQuery.cpp
+++ b/src/Interpreters/InterpreterExistsQuery.cpp
@@ -44,34 +44,34 @@ BlockInputStreamPtr InterpreterExistsQuery::executeImpl()
     {
         if (exists_query->temporary)
         {
-            result = context.tryResolveStorageID({"", exists_query->table}, Context::ResolveExternal);
+            result = getContext()->tryResolveStorageID({"", exists_query->table}, Context::ResolveExternal);
         }
         else
         {
-            String database = context.resolveDatabase(exists_query->database);
-            context.checkAccess(AccessType::SHOW_TABLES, database, exists_query->table);
-            result = DatabaseCatalog::instance().isTableExist({database, exists_query->table}, context);
+            String database = getContext()->resolveDatabase(exists_query->database);
+            getContext()->checkAccess(AccessType::SHOW_TABLES, database, exists_query->table);
+            result = DatabaseCatalog::instance().isTableExist({database, exists_query->table}, getContext());
         }
     }
     else if ((exists_query = query_ptr->as<ASTExistsViewQuery>()))
     {
-        String database = context.resolveDatabase(exists_query->database);
-        context.checkAccess(AccessType::SHOW_TABLES, database, exists_query->table);
-        auto table = DatabaseCatalog::instance().tryGetTable({database, exists_query->table}, context);
+        String database = getContext()->resolveDatabase(exists_query->database);
+        getContext()->checkAccess(AccessType::SHOW_TABLES, database, exists_query->table);
+        auto table = DatabaseCatalog::instance().tryGetTable({database, exists_query->table}, getContext());
         result = table && table->isView();
     }
     else if ((exists_query = query_ptr->as<ASTExistsDatabaseQuery>()))
     {
-        String database = context.resolveDatabase(exists_query->database);
-        context.checkAccess(AccessType::SHOW_DATABASES, database);
+        String database = getContext()->resolveDatabase(exists_query->database);
+        getContext()->checkAccess(AccessType::SHOW_DATABASES, database);
         result = DatabaseCatalog::instance().isDatabaseExist(database);
     }
     else if ((exists_query = query_ptr->as<ASTExistsDictionaryQuery>()))
     {
         if (exists_query->temporary)
             throw Exception("Temporary dictionaries are not possible.", ErrorCodes::SYNTAX_ERROR);
-        String database = context.resolveDatabase(exists_query->database);
-        context.checkAccess(AccessType::SHOW_DICTIONARIES, database, exists_query->table);
+        String database = getContext()->resolveDatabase(exists_query->database);
+        getContext()->checkAccess(AccessType::SHOW_DICTIONARIES, database, exists_query->table);
         result = DatabaseCatalog::instance().isDictionaryExist({database, exists_query->table});
     }
 
diff --git a/src/Interpreters/InterpreterExistsQuery.h b/src/Interpreters/InterpreterExistsQuery.h
index 1860e1d0aa9..efc664f07c3 100644
--- a/src/Interpreters/InterpreterExistsQuery.h
+++ b/src/Interpreters/InterpreterExistsQuery.h
@@ -7,16 +7,12 @@
 namespace DB
 {
 
-class Context;
-
-
 /** Check that table exists. Return single row with single column "result" of type UInt8 and value 0 or 1.
   */
-class InterpreterExistsQuery : public IInterpreter
+class InterpreterExistsQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterExistsQuery(const ASTPtr & query_ptr_, const Context & context_)
-        : query_ptr(query_ptr_), context(context_) {}
+    InterpreterExistsQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) { }
 
     BlockIO execute() override;
 
@@ -24,7 +20,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    const Context & context;
 
     BlockInputStreamPtr executeImpl();
 };
diff --git a/src/Interpreters/InterpreterExplainQuery.cpp b/src/Interpreters/InterpreterExplainQuery.cpp
index 4eff8b8456d..a0195ec85e6 100644
--- a/src/Interpreters/InterpreterExplainQuery.cpp
+++ b/src/Interpreters/InterpreterExplainQuery.cpp
@@ -33,9 +33,9 @@ namespace
 {
     struct ExplainAnalyzedSyntaxMatcher
     {
-        struct Data
+        struct Data : public WithContext
         {
-            const Context & context;
+            explicit Data(ContextPtr context_) : WithContext(context_) {}
         };
 
         static bool needChildVisit(ASTPtr & node, ASTPtr &)
@@ -52,7 +52,7 @@ namespace
         static void visit(ASTSelectQuery & select, ASTPtr & node, Data & data)
         {
             InterpreterSelectQuery interpreter(
-                node, data.context, SelectQueryOptions(QueryProcessingStage::FetchColumns).analyze().modify());
+                node, data.getContext(), SelectQueryOptions(QueryProcessingStage::FetchColumns).analyze().modify());
 
             const SelectQueryInfo & query_info = interpreter.getQueryInfo();
             if (query_info.view_query)
@@ -236,7 +236,7 @@ BlockInputStreamPtr InterpreterExplainQuery::executeImpl()
         if (ast.getSettings())
             throw Exception("Settings are not supported for EXPLAIN SYNTAX query.", ErrorCodes::UNKNOWN_SETTING);
 
-        ExplainAnalyzedSyntaxVisitor::Data data{.context = context};
+        ExplainAnalyzedSyntaxVisitor::Data data(getContext());
         ExplainAnalyzedSyntaxVisitor(data).visit(query);
 
         ast.getExplainedQuery()->format(IAST::FormatSettings(buf, false));
@@ -249,11 +249,11 @@ BlockInputStreamPtr InterpreterExplainQuery::executeImpl()
         auto settings = checkAndGetSettings<QueryPlanSettings>(ast.getSettings());
         QueryPlan plan;
 
-        InterpreterSelectWithUnionQuery interpreter(ast.getExplainedQuery(), context, SelectQueryOptions());
+        InterpreterSelectWithUnionQuery interpreter(ast.getExplainedQuery(), getContext(), SelectQueryOptions());
         interpreter.buildQueryPlan(plan);
 
         if (settings.optimize)
-            plan.optimize(QueryPlanOptimizationSettings::fromContext(context));
+            plan.optimize(QueryPlanOptimizationSettings::fromContext(getContext()));
 
         plan.explainPlan(buf, settings.query_plan_options);
     }
@@ -265,11 +265,11 @@ BlockInputStreamPtr InterpreterExplainQuery::executeImpl()
         auto settings = checkAndGetSettings<QueryPipelineSettings>(ast.getSettings());
         QueryPlan plan;
 
-        InterpreterSelectWithUnionQuery interpreter(ast.getExplainedQuery(), context, SelectQueryOptions());
+        InterpreterSelectWithUnionQuery interpreter(ast.getExplainedQuery(), getContext(), SelectQueryOptions());
         interpreter.buildQueryPlan(plan);
         auto pipeline = plan.buildQueryPipeline(
-            QueryPlanOptimizationSettings::fromContext(context),
-            BuildQueryPipelineSettings::fromContext(context));
+            QueryPlanOptimizationSettings::fromContext(getContext()),
+            BuildQueryPipelineSettings::fromContext(getContext()));
 
         if (settings.graph)
         {
diff --git a/src/Interpreters/InterpreterExplainQuery.h b/src/Interpreters/InterpreterExplainQuery.h
index fbc8a998f2c..f16b1a8f69d 100644
--- a/src/Interpreters/InterpreterExplainQuery.h
+++ b/src/Interpreters/InterpreterExplainQuery.h
@@ -7,15 +7,11 @@
 namespace DB
 {
 
-class Context;
-
 /// Returns single row with explain results
-class InterpreterExplainQuery : public IInterpreter
+class InterpreterExplainQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterExplainQuery(const ASTPtr & query_, const Context & context_)
-        : query(query_), context(context_)
-    {}
+    InterpreterExplainQuery(const ASTPtr & query_, ContextPtr context_) : WithContext(context_), query(query_) { }
 
     BlockIO execute() override;
 
@@ -23,7 +19,6 @@ public:
 
 private:
     ASTPtr query;
-    const Context & context;
 
     BlockInputStreamPtr executeImpl();
 };
diff --git a/src/Interpreters/InterpreterExternalDDLQuery.cpp b/src/Interpreters/InterpreterExternalDDLQuery.cpp
index 4a93c0fa753..8f9f0cf9ddb 100644
--- a/src/Interpreters/InterpreterExternalDDLQuery.cpp
+++ b/src/Interpreters/InterpreterExternalDDLQuery.cpp
@@ -26,8 +26,8 @@ namespace ErrorCodes
     extern const int BAD_ARGUMENTS;
 }
 
-InterpreterExternalDDLQuery::InterpreterExternalDDLQuery(const ASTPtr & query_, Context & context_)
-    : query(query_), context(context_)
+InterpreterExternalDDLQuery::InterpreterExternalDDLQuery(const ASTPtr & query_, ContextPtr context_)
+    : WithContext(context_), query(query_)
 {
 }
 
@@ -35,7 +35,7 @@ BlockIO InterpreterExternalDDLQuery::execute()
 {
     const ASTExternalDDLQuery & external_ddl_query = query->as<ASTExternalDDLQuery &>();
 
-    if (context.getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
+    if (getContext()->getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
         throw Exception("Cannot parse and execute EXTERNAL DDL FROM.", ErrorCodes::SYNTAX_ERROR);
 
     if (external_ddl_query.from->name == "MySQL")
@@ -48,19 +48,19 @@ BlockIO InterpreterExternalDDLQuery::execute()
 
         if (external_ddl_query.external_ddl->as<ASTDropQuery>())
             return MySQLInterpreter::InterpreterMySQLDropQuery(
-                external_ddl_query.external_ddl, context, getIdentifierName(arguments[0]),
+                external_ddl_query.external_ddl, getContext(), getIdentifierName(arguments[0]),
                 getIdentifierName(arguments[1])).execute();
         else if (external_ddl_query.external_ddl->as<ASTRenameQuery>())
             return MySQLInterpreter::InterpreterMySQLRenameQuery(
-                external_ddl_query.external_ddl, context, getIdentifierName(arguments[0]),
+                external_ddl_query.external_ddl, getContext(), getIdentifierName(arguments[0]),
                 getIdentifierName(arguments[1])).execute();
         else if (external_ddl_query.external_ddl->as<MySQLParser::ASTAlterQuery>())
             return MySQLInterpreter::InterpreterMySQLAlterQuery(
-                external_ddl_query.external_ddl, context, getIdentifierName(arguments[0]),
+                external_ddl_query.external_ddl, getContext(), getIdentifierName(arguments[0]),
                 getIdentifierName(arguments[1])).execute();
         else if (external_ddl_query.external_ddl->as<MySQLParser::ASTCreateQuery>())
             return MySQLInterpreter::InterpreterMySQLCreateQuery(
-                external_ddl_query.external_ddl, context, getIdentifierName(arguments[0]),
+                external_ddl_query.external_ddl, getContext(), getIdentifierName(arguments[0]),
                 getIdentifierName(arguments[1])).execute();
 #endif
     }
diff --git a/src/Interpreters/InterpreterExternalDDLQuery.h b/src/Interpreters/InterpreterExternalDDLQuery.h
index f6b29c20c70..15a842a2611 100644
--- a/src/Interpreters/InterpreterExternalDDLQuery.h
+++ b/src/Interpreters/InterpreterExternalDDLQuery.h
@@ -6,15 +6,15 @@
 namespace DB
 {
 
-class InterpreterExternalDDLQuery : public IInterpreter
+class InterpreterExternalDDLQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterExternalDDLQuery(const ASTPtr & query_, Context & context_);
+    InterpreterExternalDDLQuery(const ASTPtr & query_, ContextPtr context_);
 
     BlockIO execute() override;
+
 private:
     const ASTPtr query;
-    Context & context;
 
 };
 
diff --git a/src/Interpreters/InterpreterFactory.cpp b/src/Interpreters/InterpreterFactory.cpp
index 15e4c52f040..4af8b6ffa7d 100644
--- a/src/Interpreters/InterpreterFactory.cpp
+++ b/src/Interpreters/InterpreterFactory.cpp
@@ -92,7 +92,7 @@ namespace ErrorCodes
 }
 
 
-std::unique_ptr<IInterpreter> InterpreterFactory::get(ASTPtr & query, Context & context, const SelectQueryOptions & options)
+std::unique_ptr<IInterpreter> InterpreterFactory::get(ASTPtr & query, ContextPtr context, const SelectQueryOptions & options)
 {
     OpenTelemetrySpanHolder span("InterpreterFactory::get()");
 
@@ -112,7 +112,7 @@ std::unique_ptr<IInterpreter> InterpreterFactory::get(ASTPtr & query, Context &
     else if (query->as<ASTInsertQuery>())
     {
         ProfileEvents::increment(ProfileEvents::InsertQuery);
-        bool allow_materialized = static_cast<bool>(context.getSettingsRef().insert_allow_materialized_columns);
+        bool allow_materialized = static_cast<bool>(context->getSettingsRef().insert_allow_materialized_columns);
         return std::make_unique<InterpreterInsertQuery>(query, context, allow_materialized);
     }
     else if (query->as<ASTCreateQuery>())
diff --git a/src/Interpreters/InterpreterFactory.h b/src/Interpreters/InterpreterFactory.h
index 22a6ab7e8f3..c122fe11b7d 100644
--- a/src/Interpreters/InterpreterFactory.h
+++ b/src/Interpreters/InterpreterFactory.h
@@ -16,7 +16,7 @@ class InterpreterFactory
 public:
     static std::unique_ptr<IInterpreter> get(
         ASTPtr & query,
-        Context & context,
+        ContextPtr context,
         const SelectQueryOptions & options = {});
 };
 
diff --git a/src/Interpreters/InterpreterGrantQuery.cpp b/src/Interpreters/InterpreterGrantQuery.cpp
index b518178f6d0..7487ca79bde 100644
--- a/src/Interpreters/InterpreterGrantQuery.cpp
+++ b/src/Interpreters/InterpreterGrantQuery.cpp
@@ -225,7 +225,7 @@ BlockIO InterpreterGrantQuery::execute()
 {
     auto & query = query_ptr->as<ASTGrantQuery &>();
 
-    query.replaceCurrentUserTag(context.getUserName());
+    query.replaceCurrentUserTag(getContext()->getUserName());
     query.access_rights_elements.eraseNonGrantable();
 
     if (!query.access_rights_elements.sameOptions())
@@ -233,32 +233,32 @@ BlockIO InterpreterGrantQuery::execute()
     if (!query.access_rights_elements.empty() && query.access_rights_elements[0].is_partial_revoke && !query.is_revoke)
         throw Exception("A partial revoke should be revoked, not granted", ErrorCodes::LOGICAL_ERROR);
 
-    auto & access_control = context.getAccessControlManager();
+    auto & access_control = getContext()->getAccessControlManager();
     std::optional<RolesOrUsersSet> roles_set;
     if (query.roles)
         roles_set = RolesOrUsersSet{*query.roles, access_control};
 
-    std::vector<UUID> grantees = RolesOrUsersSet{*query.grantees, access_control, context.getUserID()}.getMatchingIDs(access_control);
+    std::vector<UUID> grantees = RolesOrUsersSet{*query.grantees, access_control, getContext()->getUserID()}.getMatchingIDs(access_control);
 
     /// Check if the current user has corresponding roles granted with admin option.
     std::vector<UUID> roles;
     if (roles_set)
-        roles = getRoleIDsAndCheckAdminOption(access_control, *context.getAccess(), query, *roles_set, grantees);
+        roles = getRoleIDsAndCheckAdminOption(access_control, *getContext()->getAccess(), query, *roles_set, grantees);
 
     if (!query.cluster.empty())
     {
         /// To execute the command GRANT the current user needs to have the access granted with GRANT OPTION.
         auto required_access = query.access_rights_elements;
         std::for_each(required_access.begin(), required_access.end(), [&](AccessRightsElement & element) { element.grant_option = true; });
-        checkGranteesAreAllowed(access_control, *context.getAccess(), grantees);
-        return executeDDLQueryOnCluster(query_ptr, context, std::move(required_access));
+        checkGranteesAreAllowed(access_control, *getContext()->getAccess(), grantees);
+        return executeDDLQueryOnCluster(query_ptr, getContext(), std::move(required_access));
     }
 
-    query.replaceEmptyDatabase(context.getCurrentDatabase());
+    query.replaceEmptyDatabase(getContext()->getCurrentDatabase());
 
     /// Check if the current user has corresponding access rights with grant option.
     if (!query.access_rights_elements.empty())
-        checkGrantOption(access_control, *context.getAccess(), query, grantees);
+        checkGrantOption(access_control, *getContext()->getAccess(), query, grantees);
 
     /// Update roles and users listed in `grantees`.
     auto update_func = [&](const AccessEntityPtr & entity) -> AccessEntityPtr
@@ -291,7 +291,7 @@ void InterpreterGrantQuery::updateRoleFromQuery(Role & role, const ASTGrantQuery
     updateFromQueryImpl(role, query, roles_to_grant_or_revoke);
 }
 
-void InterpreterGrantQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & /*ast*/, const Context &) const
+void InterpreterGrantQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & /*ast*/, ContextPtr) const
 {
     auto & query = query_ptr->as<ASTGrantQuery &>();
     if (query.is_revoke)
diff --git a/src/Interpreters/InterpreterGrantQuery.h b/src/Interpreters/InterpreterGrantQuery.h
index 645b33346c3..f5939ff3cb7 100644
--- a/src/Interpreters/InterpreterGrantQuery.h
+++ b/src/Interpreters/InterpreterGrantQuery.h
@@ -1,30 +1,30 @@
 #pragma once
 
+#include <Core/UUID.h>
 #include <Interpreters/IInterpreter.h>
 #include <Parsers/IAST_fwd.h>
-#include <Core/UUID.h>
 
 
 namespace DB
 {
+
 class ASTGrantQuery;
 struct User;
 struct Role;
 
-
-class InterpreterGrantQuery : public IInterpreter
+class InterpreterGrantQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterGrantQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+    InterpreterGrantQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
     static void updateUserFromQuery(User & user, const ASTGrantQuery & query);
     static void updateRoleFromQuery(Role & role, const ASTGrantQuery & query);
-    void extendQueryLogElemImpl(QueryLogElement &, const ASTPtr &, const Context &) const override;
+    void extendQueryLogElemImpl(QueryLogElement &, const ASTPtr &, ContextPtr) const override;
 
 private:
     ASTPtr query_ptr;
-    Context & context;
 };
+
 }
diff --git a/src/Interpreters/InterpreterInsertQuery.cpp b/src/Interpreters/InterpreterInsertQuery.cpp
index b4ed7a2fd6e..33cfe4bf7a2 100644
--- a/src/Interpreters/InterpreterInsertQuery.cpp
+++ b/src/Interpreters/InterpreterInsertQuery.cpp
@@ -9,21 +9,17 @@
 #include <DataStreams/NullAndDoCopyBlockInputStream.h>
 #include <DataStreams/NullBlockOutputStream.h>
 #include <DataStreams/PushingToViewsBlockOutputStream.h>
-#include <DataStreams/RemoteBlockInputStream.h>
 #include <DataStreams/SquashingBlockOutputStream.h>
 #include <DataStreams/copyData.h>
 #include <IO/ConnectionTimeoutsContext.h>
 #include <Interpreters/InterpreterSelectWithUnionQuery.h>
 #include <Interpreters/InterpreterWatchQuery.h>
-#include <Interpreters/JoinedTables.h>
 #include <Parsers/ASTFunction.h>
 #include <Parsers/ASTIdentifier.h>
 #include <Parsers/ASTInsertQuery.h>
 #include <Parsers/ASTSelectQuery.h>
 #include <Parsers/ASTSelectWithUnionQuery.h>
 #include <Parsers/ASTTablesInSelectQuery.h>
-#include <Parsers/queryToString.h>
-#include <Processors/NullSink.h>
 #include <Processors/Sources/SinkToOutputStream.h>
 #include <Processors/Sources/SourceFromInputStream.h>
 #include <Processors/Transforms/ExpressionTransform.h>
@@ -36,11 +32,6 @@
 #include <Interpreters/getTableExpressions.h>
 #include <Interpreters/processColumnTransformers.h>
 
-namespace
-{
-const UInt64 PARALLEL_DISTRIBUTED_INSERT_SELECT_ALL = 2;
-}
-
 
 namespace DB
 {
@@ -50,13 +41,12 @@ namespace ErrorCodes
     extern const int NO_SUCH_COLUMN_IN_TABLE;
     extern const int ILLEGAL_COLUMN;
     extern const int DUPLICATE_COLUMN;
-    extern const int LOGICAL_ERROR;
 }
 
 InterpreterInsertQuery::InterpreterInsertQuery(
-    const ASTPtr & query_ptr_, const Context & context_, bool allow_materialized_, bool no_squash_, bool no_destination_)
-    : query_ptr(query_ptr_)
-    , context(context_)
+    const ASTPtr & query_ptr_, ContextPtr context_, bool allow_materialized_, bool no_squash_, bool no_destination_)
+    : WithContext(context_)
+    , query_ptr(query_ptr_)
     , allow_materialized(allow_materialized_)
     , no_squash(no_squash_)
     , no_destination(no_destination_)
@@ -70,12 +60,12 @@ StoragePtr InterpreterInsertQuery::getTable(ASTInsertQuery & query)
     if (query.table_function)
     {
         const auto & factory = TableFunctionFactory::instance();
-        TableFunctionPtr table_function_ptr = factory.get(query.table_function, context);
-        return table_function_ptr->execute(query.table_function, context, table_function_ptr->getName());
+        TableFunctionPtr table_function_ptr = factory.get(query.table_function, getContext());
+        return table_function_ptr->execute(query.table_function, getContext(), table_function_ptr->getName());
     }
 
-    query.table_id = context.resolveStorageID(query.table_id);
-    return DatabaseCatalog::instance().getTable(query.table_id, context);
+    query.table_id = getContext()->resolveStorageID(query.table_id);
+    return DatabaseCatalog::instance().getTable(query.table_id, getContext());
 }
 
 Block InterpreterInsertQuery::getSampleBlock(
@@ -95,7 +85,7 @@ Block InterpreterInsertQuery::getSampleBlock(
 
     Block table_sample = metadata_snapshot->getSampleBlock();
 
-    const auto columns_ast = processColumnTransformers(context.getCurrentDatabase(), table, metadata_snapshot, query.columns);
+    const auto columns_ast = processColumnTransformers(getContext()->getCurrentDatabase(), table, metadata_snapshot, query.columns);
 
     /// Form the block based on the column names from the query
     Block res;
@@ -160,97 +150,28 @@ static bool isTrivialSelect(const ASTPtr & select)
 
 BlockIO InterpreterInsertQuery::execute()
 {
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = getContext()->getSettingsRef();
     auto & query = query_ptr->as<ASTInsertQuery &>();
 
     BlockIO res;
 
     StoragePtr table = getTable(query);
-    auto table_lock = table->lockForShare(context.getInitialQueryId(), settings.lock_acquire_timeout);
+    auto table_lock = table->lockForShare(getContext()->getInitialQueryId(), settings.lock_acquire_timeout);
     auto metadata_snapshot = table->getInMemoryMetadataPtr();
 
     auto query_sample_block = getSampleBlock(query, table, metadata_snapshot);
     if (!query.table_function)
-        context.checkAccess(AccessType::INSERT, query.table_id, query_sample_block.getNames());
+        getContext()->checkAccess(AccessType::INSERT, query.table_id, query_sample_block.getNames());
 
     bool is_distributed_insert_select = false;
 
     if (query.select && table->isRemote() && settings.parallel_distributed_insert_select)
     {
         // Distributed INSERT SELECT
-        std::shared_ptr<StorageDistributed> storage_src;
-        auto & select = query.select->as<ASTSelectWithUnionQuery &>();
-        auto new_query = std::dynamic_pointer_cast<ASTInsertQuery>(query.clone());
-        if (select.list_of_selects->children.size() == 1)
-        {
-            if (auto * select_query = select.list_of_selects->children.at(0)->as<ASTSelectQuery>())
-            {
-                JoinedTables joined_tables(Context(context), *select_query);
-
-                if (joined_tables.tablesCount() == 1)
-                {
-                    storage_src = std::dynamic_pointer_cast<StorageDistributed>(joined_tables.getLeftTableStorage());
-                    if (storage_src)
-                    {
-                        const auto select_with_union_query = std::make_shared<ASTSelectWithUnionQuery>();
-                        select_with_union_query->list_of_selects = std::make_shared<ASTExpressionList>();
-
-                        auto new_select_query = std::dynamic_pointer_cast<ASTSelectQuery>(select_query->clone());
-                        select_with_union_query->list_of_selects->children.push_back(new_select_query);
-
-                        new_select_query->replaceDatabaseAndTable(storage_src->getRemoteDatabaseName(), storage_src->getRemoteTableName());
-
-                        new_query->select = select_with_union_query;
-                    }
-                }
-            }
-        }
-
-        auto storage_dst = std::dynamic_pointer_cast<StorageDistributed>(table);
-
-        if (storage_src && storage_dst && storage_src->getClusterName() == storage_dst->getClusterName())
+        if (auto maybe_pipeline = table->distributedWrite(query, getContext()))
         {
+            res.pipeline = std::move(*maybe_pipeline);
             is_distributed_insert_select = true;
-
-            if (settings.parallel_distributed_insert_select == PARALLEL_DISTRIBUTED_INSERT_SELECT_ALL)
-            {
-                new_query->table_id = StorageID(storage_dst->getRemoteDatabaseName(), storage_dst->getRemoteTableName());
-            }
-
-            const auto & cluster = storage_src->getCluster();
-            const auto & shards_info = cluster->getShardsInfo();
-
-            std::vector<std::unique_ptr<QueryPipeline>> pipelines;
-
-            String new_query_str = queryToString(new_query);
-            for (size_t shard_index : ext::range(0, shards_info.size()))
-            {
-                const auto & shard_info = shards_info[shard_index];
-                if (shard_info.isLocal())
-                {
-                    InterpreterInsertQuery interpreter(new_query, context);
-                    pipelines.emplace_back(std::make_unique<QueryPipeline>(interpreter.execute().pipeline));
-                }
-                else
-                {
-                    auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(settings);
-                    auto connections = shard_info.pool->getMany(timeouts, &settings, PoolMode::GET_ONE);
-                    if (connections.empty() || connections.front().isNull())
-                        throw Exception(
-                            "Expected exactly one connection for shard " + toString(shard_info.shard_num), ErrorCodes::LOGICAL_ERROR);
-
-                    ///  INSERT SELECT query returns empty block
-                    auto in_stream = std::make_shared<RemoteBlockInputStream>(std::move(connections), new_query_str, Block{}, context);
-                    pipelines.emplace_back(std::make_unique<QueryPipeline>());
-                    pipelines.back()->init(Pipe(std::make_shared<SourceFromInputStream>(std::move(in_stream))));
-                    pipelines.back()->setSinks([](const Block & header, QueryPipeline::StreamType) -> ProcessorPtr
-                    {
-                        return std::make_shared<EmptySink>(header);
-                    });
-                }
-            }
-
-            res.pipeline = QueryPipeline::unitePipelines(std::move(pipelines), {}, ExpressionActionsSettings::fromContext(context));
         }
     }
 
@@ -285,15 +206,15 @@ BlockIO InterpreterInsertQuery::execute()
                   * to avoid unnecessary squashing.
                   */
 
-                Settings new_settings = context.getSettings();
+                Settings new_settings = getContext()->getSettings();
 
                 new_settings.max_threads = std::max<UInt64>(1, settings.max_insert_threads);
 
                 if (settings.min_insert_block_size_rows && table->prefersLargeBlocks())
                     new_settings.max_block_size = settings.min_insert_block_size_rows;
 
-                Context new_context = context;
-                new_context.setSettings(new_settings);
+                auto new_context = Context::createCopy(context);
+                new_context->setSettings(new_settings);
 
                 InterpreterSelectWithUnionQuery interpreter_select{
                     query.select, new_context, SelectQueryOptions(QueryProcessingStage::Complete, 1)};
@@ -303,7 +224,7 @@ BlockIO InterpreterInsertQuery::execute()
             {
                 /// Passing 1 as subquery_depth will disable limiting size of intermediate result.
                 InterpreterSelectWithUnionQuery interpreter_select{
-                    query.select, context, SelectQueryOptions(QueryProcessingStage::Complete, 1)};
+                    query.select, getContext(), SelectQueryOptions(QueryProcessingStage::Complete, 1)};
                 res = interpreter_select.execute();
             }
 
@@ -314,7 +235,7 @@ BlockIO InterpreterInsertQuery::execute()
         }
         else if (query.watch)
         {
-            InterpreterWatchQuery interpreter_watch{ query.watch, context };
+            InterpreterWatchQuery interpreter_watch{ query.watch, getContext() };
             res = interpreter_watch.execute();
             res.pipeline.init(Pipe(std::make_shared<SourceFromInputStream>(std::move(res.in))));
         }
@@ -327,21 +248,21 @@ BlockIO InterpreterInsertQuery::execute()
             /// NOTE: we explicitly ignore bound materialized views when inserting into Kafka Storage.
             ///       Otherwise we'll get duplicates when MV reads same rows again from Kafka.
             if (table->noPushingToViews() && !no_destination)
-                out = table->write(query_ptr, metadata_snapshot, context);
+                out = table->write(query_ptr, metadata_snapshot, getContext());
             else
-                out = std::make_shared<PushingToViewsBlockOutputStream>(table, metadata_snapshot, context, query_ptr, no_destination);
+                out = std::make_shared<PushingToViewsBlockOutputStream>(table, metadata_snapshot, getContext(), query_ptr, no_destination);
 
             /// Note that we wrap transforms one on top of another, so we write them in reverse of data processing order.
 
             /// Checking constraints. It must be done after calculation of all defaults, so we can check them on calculated columns.
             if (const auto & constraints = metadata_snapshot->getConstraints(); !constraints.empty())
                 out = std::make_shared<CheckConstraintsBlockOutputStream>(
-                    query.table_id, out, out->getHeader(), metadata_snapshot->getConstraints(), context);
+                    query.table_id, out, out->getHeader(), metadata_snapshot->getConstraints(), getContext());
 
             /// Actually we don't know structure of input blocks from query/table,
             /// because some clients break insertion protocol (columns != header)
             out = std::make_shared<AddingDefaultBlockOutputStream>(
-                out, query_sample_block, metadata_snapshot->getColumns(), context);
+                out, query_sample_block, metadata_snapshot->getColumns(), getContext());
 
             /// It's important to squash blocks as early as possible (before other transforms),
             ///  because other transforms may work inefficient if block size is small.
@@ -360,7 +281,7 @@ BlockIO InterpreterInsertQuery::execute()
             }
 
             auto out_wrapper = std::make_shared<CountingBlockOutputStream>(out);
-            out_wrapper->setProcessListElement(context.getProcessListElement());
+            out_wrapper->setProcessListElement(getContext()->getProcessListElement());
             out = std::move(out_wrapper);
             out_streams.emplace_back(std::move(out));
         }
@@ -378,7 +299,7 @@ BlockIO InterpreterInsertQuery::execute()
                 res.pipeline.getHeader().getColumnsWithTypeAndName(),
                 header.getColumnsWithTypeAndName(),
                 ActionsDAG::MatchColumnsMode::Position);
-        auto actions = std::make_shared<ExpressionActions>(actions_dag, ExpressionActionsSettings::fromContext(context));
+        auto actions = std::make_shared<ExpressionActions>(actions_dag, ExpressionActionsSettings::fromContext(getContext()));
 
         res.pipeline.addSimpleTransform([&](const Block & in_header) -> ProcessorPtr
         {
@@ -406,7 +327,7 @@ BlockIO InterpreterInsertQuery::execute()
     else if (query.data && !query.has_tail) /// can execute without additional data
     {
         // res.out = std::move(out_streams.at(0));
-        res.in = std::make_shared<InputStreamFromASTInsertQuery>(query_ptr, nullptr, query_sample_block, context, nullptr);
+        res.in = std::make_shared<InputStreamFromASTInsertQuery>(query_ptr, nullptr, query_sample_block, getContext(), nullptr);
         res.in = std::make_shared<NullAndDoCopyBlockInputStream>(res.in, out_streams.at(0));
     }
     else
@@ -429,10 +350,10 @@ StorageID InterpreterInsertQuery::getDatabaseTable() const
 }
 
 
-void InterpreterInsertQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, const Context & context_) const
+void InterpreterInsertQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr &, ContextPtr context_) const
 {
     elem.query_kind = "Insert";
-    const auto & insert_table = context_.getInsertionTable();
+    const auto & insert_table = context_->getInsertionTable();
     if (!insert_table.empty())
     {
         elem.query_databases.insert(insert_table.getDatabaseName());
diff --git a/src/Interpreters/InterpreterInsertQuery.h b/src/Interpreters/InterpreterInsertQuery.h
index 85178bc73ad..71b8c827702 100644
--- a/src/Interpreters/InterpreterInsertQuery.h
+++ b/src/Interpreters/InterpreterInsertQuery.h
@@ -9,17 +9,14 @@
 namespace DB
 {
 
-class Context;
-
-
 /** Interprets the INSERT query.
   */
-class InterpreterInsertQuery : public IInterpreter
+class InterpreterInsertQuery : public IInterpreter, WithContext
 {
 public:
     InterpreterInsertQuery(
         const ASTPtr & query_ptr_,
-        const Context & context_,
+        ContextPtr context_,
         bool allow_materialized_ = false,
         bool no_squash_ = false,
         bool no_destination_ = false);
@@ -33,14 +30,13 @@ public:
 
     StorageID getDatabaseTable() const;
 
-    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, const Context & context_) const override;
+    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, ContextPtr context_) const override;
 
 private:
     StoragePtr getTable(ASTInsertQuery & query);
     Block getSampleBlock(const ASTInsertQuery & query, const StoragePtr & table, const StorageMetadataPtr & metadata_snapshot) const;
 
     ASTPtr query_ptr;
-    const Context & context;
     const bool allow_materialized;
     const bool no_squash;
     const bool no_destination;
diff --git a/src/Interpreters/InterpreterKillQueryQuery.cpp b/src/Interpreters/InterpreterKillQueryQuery.cpp
index c50659c6c45..88ddfefef63 100644
--- a/src/Interpreters/InterpreterKillQueryQuery.cpp
+++ b/src/Interpreters/InterpreterKillQueryQuery.cpp
@@ -74,7 +74,7 @@ static void insertResultRow(size_t n, CancellationCode code, const Block & sourc
         columns[col_num]->insertFrom(*source.getByName(header.getByPosition(col_num).name).column, n);
 }
 
-static QueryDescriptors extractQueriesExceptMeAndCheckAccess(const Block & processes_block, Context & context)
+static QueryDescriptors extractQueriesExceptMeAndCheckAccess(const Block & processes_block, ContextPtr context)
 {
     QueryDescriptors res;
     size_t num_processes = processes_block.rows();
@@ -82,7 +82,7 @@ static QueryDescriptors extractQueriesExceptMeAndCheckAccess(const Block & proce
 
     const ColumnString & query_id_col = typeid_cast<const ColumnString &>(*processes_block.getByName("query_id").column);
     const ColumnString & user_col = typeid_cast<const ColumnString &>(*processes_block.getByName("user").column);
-    const ClientInfo & my_client = context.getProcessListElement()->getClientInfo();
+    const ClientInfo & my_client = context->getProcessListElement()->getClientInfo();
 
     bool access_denied = false;
     std::optional<bool> is_kill_query_granted_value;
@@ -90,7 +90,7 @@ static QueryDescriptors extractQueriesExceptMeAndCheckAccess(const Block & proce
     {
         if (!is_kill_query_granted_value)
         {
-            is_kill_query_granted_value = context.getAccess()->isGranted(AccessType::KILL_QUERY);
+            is_kill_query_granted_value = context->getAccess()->isGranted(AccessType::KILL_QUERY);
             if (!*is_kill_query_granted_value)
                 access_denied = true;
         }
@@ -195,7 +195,7 @@ BlockIO InterpreterKillQueryQuery::execute()
     const auto & query = query_ptr->as<ASTKillQueryQuery &>();
 
     if (!query.cluster.empty())
-        return executeDDLQueryOnCluster(query_ptr, context, getRequiredAccessForDDLOnCluster());
+        return executeDDLQueryOnCluster(query_ptr, getContext(), getRequiredAccessForDDLOnCluster());
 
     BlockIO res_io;
     switch (query.type)
@@ -206,8 +206,8 @@ BlockIO InterpreterKillQueryQuery::execute()
         if (!processes_block)
             return res_io;
 
-        ProcessList & process_list = context.getProcessList();
-        QueryDescriptors queries_to_stop = extractQueriesExceptMeAndCheckAccess(processes_block, context);
+        ProcessList & process_list = getContext()->getProcessList();
+        QueryDescriptors queries_to_stop = extractQueriesExceptMeAndCheckAccess(processes_block, getContext());
 
         auto header = processes_block.cloneEmpty();
         header.insert(0, {ColumnString::create(), std::make_shared<DataTypeString>(), "kill_status"});
@@ -248,7 +248,7 @@ BlockIO InterpreterKillQueryQuery::execute()
         MutableColumns res_columns = header.cloneEmptyColumns();
         auto table_id = StorageID::createEmpty();
         AccessRightsElements required_access_rights;
-        auto access = context.getAccess();
+        auto access = getContext()->getAccess();
         bool access_denied = false;
 
         for (size_t i = 0; i < mutations_block.rows(); ++i)
@@ -259,14 +259,16 @@ BlockIO InterpreterKillQueryQuery::execute()
             CancellationCode code = CancellationCode::Unknown;
             if (!query.test)
             {
-                auto storage = DatabaseCatalog::instance().tryGetTable(table_id, context);
+                auto storage = DatabaseCatalog::instance().tryGetTable(table_id, getContext());
                 if (!storage)
                     code = CancellationCode::NotFound;
                 else
                 {
                     ParserAlterCommand parser;
-                    auto command_ast = parseQuery(parser, command_col.getDataAt(i).toString(), 0, context.getSettingsRef().max_parser_depth);
-                    required_access_rights = InterpreterAlterQuery::getRequiredAccessForCommand(command_ast->as<const ASTAlterCommand &>(), table_id.database_name, table_id.table_name);
+                    auto command_ast
+                        = parseQuery(parser, command_col.getDataAt(i).toString(), 0, getContext()->getSettingsRef().max_parser_depth);
+                    required_access_rights = InterpreterAlterQuery::getRequiredAccessForCommand(
+                        command_ast->as<const ASTAlterCommand &>(), table_id.database_name, table_id.table_name);
                     if (!access->isGranted(required_access_rights))
                     {
                         access_denied = true;
@@ -300,7 +302,7 @@ Block InterpreterKillQueryQuery::getSelectResult(const String & columns, const S
     if (where_expression)
         select_query += " WHERE " + queryToString(where_expression);
 
-    auto stream = executeQuery(select_query, context.getGlobalContext(), true).getInputStream();
+    auto stream = executeQuery(select_query, getContext()->getGlobalContext(), true).getInputStream();
     Block res = stream->read();
 
     if (res && stream->read())
diff --git a/src/Interpreters/InterpreterKillQueryQuery.h b/src/Interpreters/InterpreterKillQueryQuery.h
index 788703f8e6d..5ffd9a525a2 100644
--- a/src/Interpreters/InterpreterKillQueryQuery.h
+++ b/src/Interpreters/InterpreterKillQueryQuery.h
@@ -8,15 +8,12 @@
 namespace DB
 {
 
-class Context;
 class AccessRightsElements;
 
-
-class InterpreterKillQueryQuery final : public IInterpreter
+class InterpreterKillQueryQuery final : public IInterpreter, WithContext
 {
 public:
-    InterpreterKillQueryQuery(const ASTPtr & query_ptr_, Context & context_)
-        : query_ptr(query_ptr_), context(context_) {}
+    InterpreterKillQueryQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) { }
 
     BlockIO execute() override;
 
@@ -25,8 +22,6 @@ private:
     Block getSelectResult(const String & columns, const String & table);
 
     ASTPtr query_ptr;
-    Context & context;
 };
 
-
 }
diff --git a/src/Interpreters/InterpreterOptimizeQuery.cpp b/src/Interpreters/InterpreterOptimizeQuery.cpp
index d8e9013e397..64de5ee0479 100644
--- a/src/Interpreters/InterpreterOptimizeQuery.cpp
+++ b/src/Interpreters/InterpreterOptimizeQuery.cpp
@@ -25,12 +25,12 @@ BlockIO InterpreterOptimizeQuery::execute()
     const auto & ast = query_ptr->as<ASTOptimizeQuery &>();
 
     if (!ast.cluster.empty())
-        return executeDDLQueryOnCluster(query_ptr, context, getRequiredAccess());
+        return executeDDLQueryOnCluster(query_ptr, getContext(), getRequiredAccess());
 
-    context.checkAccess(getRequiredAccess());
+    getContext()->checkAccess(getRequiredAccess());
 
-    auto table_id = context.resolveStorageID(ast, Context::ResolveOrdinary);
-    StoragePtr table = DatabaseCatalog::instance().getTable(table_id, context);
+    auto table_id = getContext()->resolveStorageID(ast, Context::ResolveOrdinary);
+    StoragePtr table = DatabaseCatalog::instance().getTable(table_id, getContext());
     auto metadata_snapshot = table->getInMemoryMetadataPtr();
 
     // Empty list of names means we deduplicate by all columns, but user can explicitly state which columns to use.
@@ -40,7 +40,8 @@ BlockIO InterpreterOptimizeQuery::execute()
         // User requested custom set of columns for deduplication, possibly with Column Transformer expression.
         {
             // Expand asterisk, column transformers, etc into list of column names.
-            const auto cols = processColumnTransformers(context.getCurrentDatabase(), table, metadata_snapshot, ast.deduplicate_by_columns);
+            const auto cols
+                = processColumnTransformers(getContext()->getCurrentDatabase(), table, metadata_snapshot, ast.deduplicate_by_columns);
             for (const auto & col : cols->children)
                 column_names.emplace_back(col->getColumnName());
         }
@@ -68,7 +69,7 @@ BlockIO InterpreterOptimizeQuery::execute()
         }
     }
 
-    table->optimize(query_ptr, metadata_snapshot, ast.partition, ast.final, ast.deduplicate, column_names, context);
+    table->optimize(query_ptr, metadata_snapshot, ast.partition, ast.final, ast.deduplicate, column_names, getContext());
 
     return {};
 }
diff --git a/src/Interpreters/InterpreterOptimizeQuery.h b/src/Interpreters/InterpreterOptimizeQuery.h
index faf336a0e98..8491fe8df49 100644
--- a/src/Interpreters/InterpreterOptimizeQuery.h
+++ b/src/Interpreters/InterpreterOptimizeQuery.h
@@ -6,19 +6,15 @@
 
 namespace DB
 {
-class Context;
-class AccessRightsElements;
 
+class AccessRightsElements;
 
 /** Just call method "optimize" for table.
   */
-class InterpreterOptimizeQuery : public IInterpreter
+class InterpreterOptimizeQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterOptimizeQuery(const ASTPtr & query_ptr_, Context & context_)
-        : query_ptr(query_ptr_), context(context_)
-    {
-    }
+    InterpreterOptimizeQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -26,7 +22,6 @@ private:
     AccessRightsElements getRequiredAccess() const;
 
     ASTPtr query_ptr;
-    Context & context;
 };
 
 }
diff --git a/src/Interpreters/InterpreterRenameQuery.cpp b/src/Interpreters/InterpreterRenameQuery.cpp
index 923a342d9ea..515559ad903 100644
--- a/src/Interpreters/InterpreterRenameQuery.cpp
+++ b/src/Interpreters/InterpreterRenameQuery.cpp
@@ -18,8 +18,8 @@ namespace ErrorCodes
     extern const int NOT_IMPLEMENTED;
 }
 
-InterpreterRenameQuery::InterpreterRenameQuery(const ASTPtr & query_ptr_, Context & context_)
-    : query_ptr(query_ptr_), context(context_)
+InterpreterRenameQuery::InterpreterRenameQuery(const ASTPtr & query_ptr_, ContextPtr context_)
+    : WithContext(context_), query_ptr(query_ptr_)
 {
 }
 
@@ -29,12 +29,12 @@ BlockIO InterpreterRenameQuery::execute()
     const auto & rename = query_ptr->as<const ASTRenameQuery &>();
 
     if (!rename.cluster.empty())
-        return executeDDLQueryOnCluster(query_ptr, context, getRequiredAccess());
+        return executeDDLQueryOnCluster(query_ptr, getContext(), getRequiredAccess());
 
-    context.checkAccess(getRequiredAccess());
+    getContext()->checkAccess(getRequiredAccess());
 
-    String path = context.getPath();
-    String current_database = context.getCurrentDatabase();
+    String path = getContext()->getPath();
+    String current_database = getContext()->getCurrentDatabase();
 
     /** In case of error while renaming, it is possible that only part of tables was renamed
       *  or we will be in inconsistent state. (It is worth to be fixed.)
@@ -77,10 +77,11 @@ BlockIO InterpreterRenameQuery::executeToTables(const ASTRenameQuery & rename, c
     for (const auto & elem : descriptions)
     {
         if (!rename.exchange)
-            database_catalog.assertTableDoesntExist(StorageID(elem.to_database_name, elem.to_table_name), context);
+            database_catalog.assertTableDoesntExist(StorageID(elem.to_database_name, elem.to_table_name), getContext());
 
         DatabasePtr database = database_catalog.getDatabase(elem.from_database_name);
-        if (typeid_cast<DatabaseReplicated *>(database.get()) && context.getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
+        if (typeid_cast<DatabaseReplicated *>(database.get())
+            && getContext()->getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
         {
             if (1 < descriptions.size())
                 throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Database {} is Replicated, "
@@ -90,12 +91,12 @@ BlockIO InterpreterRenameQuery::executeToTables(const ASTRenameQuery & rename, c
             UniqueTableName to(elem.to_database_name, elem.to_table_name);
             ddl_guards[from]->releaseTableLock();
             ddl_guards[to]->releaseTableLock();
-            return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, context);
+            return typeid_cast<DatabaseReplicated *>(database.get())->tryEnqueueReplicatedDDL(query_ptr, getContext());
         }
         else
         {
             database->renameTable(
-                context,
+                getContext(),
                 elem.from_table_name,
                 *database_catalog.getDatabase(elem.to_database_name),
                 elem.to_table_name,
@@ -140,19 +141,19 @@ AccessRightsElements InterpreterRenameQuery::getRequiredAccess() const
     return required_access;
 }
 
-void InterpreterRenameQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, const Context &) const
+void InterpreterRenameQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, ContextPtr) const
 {
     elem.query_kind = "Rename";
     const auto & rename = ast->as<const ASTRenameQuery &>();
     for (const auto & element : rename.elements)
     {
         {
-            String database = backQuoteIfNeed(element.from.database.empty() ? context.getCurrentDatabase() : element.from.database);
+            String database = backQuoteIfNeed(element.from.database.empty() ? getContext()->getCurrentDatabase() : element.from.database);
             elem.query_databases.insert(database);
             elem.query_tables.insert(database + "." + backQuoteIfNeed(element.from.table));
         }
         {
-            String database = backQuoteIfNeed(element.to.database.empty() ? context.getCurrentDatabase() : element.to.database);
+            String database = backQuoteIfNeed(element.to.database.empty() ? getContext()->getCurrentDatabase() : element.to.database);
             elem.query_databases.insert(database);
             elem.query_tables.insert(database + "." + backQuoteIfNeed(element.to.table));
         }
diff --git a/src/Interpreters/InterpreterRenameQuery.h b/src/Interpreters/InterpreterRenameQuery.h
index 0da25f63e8d..49fdd50f52d 100644
--- a/src/Interpreters/InterpreterRenameQuery.h
+++ b/src/Interpreters/InterpreterRenameQuery.h
@@ -7,7 +7,6 @@
 namespace DB
 {
 
-class Context;
 class AccessRightsElements;
 class DDLGuard;
 
@@ -49,12 +48,12 @@ using TableGuards = std::map<UniqueTableName, std::unique_ptr<DDLGuard>>;
 /** Rename one table
   *  or rename many tables at once.
   */
-class InterpreterRenameQuery : public IInterpreter
+class InterpreterRenameQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterRenameQuery(const ASTPtr & query_ptr_, Context & context_);
+    InterpreterRenameQuery(const ASTPtr & query_ptr_, ContextPtr context_);
     BlockIO execute() override;
-    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, const Context &) const override;
+    void extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & ast, ContextPtr) const override;
 
 private:
     BlockIO executeToTables(const ASTRenameQuery & rename, const RenameDescriptions & descriptions, TableGuards & ddl_guards);
@@ -63,7 +62,6 @@ private:
     AccessRightsElements getRequiredAccess() const;
 
     ASTPtr query_ptr;
-    Context & context;
 };
 
 }
diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp
index 1f6b0c37437..f44e55a3df9 100644
--- a/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/src/Interpreters/InterpreterSelectQuery.cpp
@@ -37,7 +37,6 @@
 #include <Interpreters/replaceAliasColumnsInQuery.h>
 
 #include <Processors/Pipe.h>
-#include <Processors/QueryPlan/AddingDelayedSourceStep.h>
 #include <Processors/QueryPlan/AggregatingStep.h>
 #include <Processors/QueryPlan/ArrayJoinStep.h>
 #include <Processors/QueryPlan/CreatingSetsStep.h>
@@ -82,7 +81,7 @@
 #include <Common/typeid_cast.h>
 #include <Common/checkStackSize.h>
 #include <ext/map.h>
-#include <ext/scope_guard.h>
+#include <ext/scope_guard_safe.h>
 #include <memory>
 
 
@@ -138,8 +137,8 @@ String InterpreterSelectQuery::generateFilterActions(ActionsDAGPtr & actions, co
     table_expr->children.push_back(table_expr->database_and_table_name);
 
     /// Using separate expression analyzer to prevent any possible alias injection
-    auto syntax_result = TreeRewriter(*context).analyzeSelect(query_ast, TreeRewriterResult({}, storage, metadata_snapshot));
-    SelectQueryExpressionAnalyzer analyzer(query_ast, syntax_result, *context, metadata_snapshot);
+    auto syntax_result = TreeRewriter(context).analyzeSelect(query_ast, TreeRewriterResult({}, storage, metadata_snapshot));
+    SelectQueryExpressionAnalyzer analyzer(query_ast, syntax_result, context, metadata_snapshot);
     actions = analyzer.simpleSelectActions();
 
     auto column_name = expr_list->children.at(0)->getColumnName();
@@ -154,7 +153,7 @@ String InterpreterSelectQuery::generateFilterActions(ActionsDAGPtr & actions, co
 
 InterpreterSelectQuery::InterpreterSelectQuery(
     const ASTPtr & query_ptr_,
-    const Context & context_,
+    ContextPtr context_,
     const SelectQueryOptions & options_,
     const Names & required_result_column_names_)
     : InterpreterSelectQuery(query_ptr_, context_, nullptr, std::nullopt, nullptr, options_, required_result_column_names_)
@@ -163,7 +162,7 @@ InterpreterSelectQuery::InterpreterSelectQuery(
 
 InterpreterSelectQuery::InterpreterSelectQuery(
     const ASTPtr & query_ptr_,
-    const Context & context_,
+    ContextPtr context_,
     const BlockInputStreamPtr & input_,
     const SelectQueryOptions & options_)
     : InterpreterSelectQuery(query_ptr_, context_, input_, std::nullopt, nullptr, options_.copy().noSubquery())
@@ -171,7 +170,7 @@ InterpreterSelectQuery::InterpreterSelectQuery(
 
 InterpreterSelectQuery::InterpreterSelectQuery(
         const ASTPtr & query_ptr_,
-        const Context & context_,
+        ContextPtr context_,
         Pipe input_pipe_,
         const SelectQueryOptions & options_)
         : InterpreterSelectQuery(query_ptr_, context_, nullptr, std::move(input_pipe_), nullptr, options_.copy().noSubquery())
@@ -179,7 +178,7 @@ InterpreterSelectQuery::InterpreterSelectQuery(
 
 InterpreterSelectQuery::InterpreterSelectQuery(
     const ASTPtr & query_ptr_,
-    const Context & context_,
+    ContextPtr context_,
     const StoragePtr & storage_,
     const StorageMetadataPtr & metadata_snapshot_,
     const SelectQueryOptions & options_)
@@ -192,15 +191,15 @@ InterpreterSelectQuery::~InterpreterSelectQuery() = default;
 /** There are no limits on the maximum size of the result for the subquery.
   *  Since the result of the query is not the result of the entire query.
   */
-static Context getSubqueryContext(const Context & context)
+static ContextPtr getSubqueryContext(ContextPtr context)
 {
-    Context subquery_context = context;
-    Settings subquery_settings = context.getSettings();
+    auto subquery_context = Context::createCopy(context);
+    Settings subquery_settings = context->getSettings();
     subquery_settings.max_result_rows = 0;
     subquery_settings.max_result_bytes = 0;
     /// The calculation of extremes does not make sense and is not necessary (if you do it, then the extremes of the subquery can be taken for whole query).
     subquery_settings.extremes = false;
-    subquery_context.setSettings(subquery_settings);
+    subquery_context->setSettings(subquery_settings);
     return subquery_context;
 }
 
@@ -223,7 +222,7 @@ static void rewriteMultipleJoins(ASTPtr & query, const TablesWithColumns & table
 
 /// Checks that the current user has the SELECT privilege.
 static void checkAccessRightsForSelect(
-    const Context & context,
+    ContextPtr context,
     const StorageID & table_id,
     const StorageMetadataPtr & table_metadata,
     const Strings & required_columns,
@@ -236,19 +235,19 @@ static void checkAccessRightsForSelect(
         /// In this case just checking access for `required_columns` doesn't work correctly
         /// because `required_columns` will contain the name of a column of minimum size (see TreeRewriterResult::collectUsedColumns())
         /// which is probably not the same column as the column the current user has access to.
-        auto access = context.getAccess();
+        auto access = context->getAccess();
         for (const auto & column : table_metadata->getColumns())
         {
             if (access->isGranted(AccessType::SELECT, table_id.database_name, table_id.table_name, column.name))
                 return;
         }
-        throw Exception(context.getUserName() + ": Not enough privileges. "
+        throw Exception(context->getUserName() + ": Not enough privileges. "
                         "To execute this query it's necessary to have grant SELECT for at least one column on " + table_id.getFullTableName(),
                         ErrorCodes::ACCESS_DENIED);
     }
 
     /// General check.
-    context.checkAccess(AccessType::SELECT, table_id, required_columns);
+    context->checkAccess(AccessType::SELECT, table_id, required_columns);
 }
 
 /// Returns true if we should ignore quotas and limits for a specified table in the system database.
@@ -265,7 +264,7 @@ static bool shouldIgnoreQuotaAndLimits(const StorageID & table_id)
 
 InterpreterSelectQuery::InterpreterSelectQuery(
     const ASTPtr & query_ptr_,
-    const Context & context_,
+    ContextPtr context_,
     const BlockInputStreamPtr & input_,
     std::optional<Pipe> input_pipe_,
     const StoragePtr & storage_,
@@ -309,7 +308,7 @@ InterpreterSelectQuery::InterpreterSelectQuery(
         ApplyWithSubqueryVisitor().visit(query_ptr);
     }
 
-    JoinedTables joined_tables(getSubqueryContext(*context), getSelectQuery());
+    JoinedTables joined_tables(getSubqueryContext(context), getSelectQuery());
 
     bool got_storage_from_query = false;
     if (!has_input && !storage)
@@ -376,7 +375,7 @@ InterpreterSelectQuery::InterpreterSelectQuery(
         if (view)
             view->replaceWithSubquery(getSelectQuery(), view_table, metadata_snapshot);
 
-        syntax_analyzer_result = TreeRewriter(*context).analyzeSelect(
+        syntax_analyzer_result = TreeRewriter(context).analyzeSelect(
             query_ptr,
             TreeRewriterResult(source_header.getNamesAndTypesList(), storage, metadata_snapshot),
             options, joined_tables.tablesWithColumns(), required_result_column_names, table_join);
@@ -384,7 +383,7 @@ InterpreterSelectQuery::InterpreterSelectQuery(
         /// Save scalar sub queries's results in the query context
         if (!options.only_analyze && context->hasQueryContext())
             for (const auto & it : syntax_analyzer_result->getScalars())
-                context->getQueryContext().addScalar(it.first, it.second);
+                context->getQueryContext()->addScalar(it.first, it.second);
 
         if (view)
         {
@@ -407,12 +406,18 @@ InterpreterSelectQuery::InterpreterSelectQuery(
                 current_info.query = query_ptr;
                 current_info.syntax_analyzer_result = syntax_analyzer_result;
 
-                MergeTreeWhereOptimizer{current_info, *context, std::move(column_compressed_sizes), metadata_snapshot, syntax_analyzer_result->requiredSourceColumns(), log};
+                MergeTreeWhereOptimizer{
+                    current_info,
+                    context,
+                    std::move(column_compressed_sizes),
+                    metadata_snapshot,
+                    syntax_analyzer_result->requiredSourceColumns(),
+                    log};
             }
         }
 
         query_analyzer = std::make_unique<SelectQueryExpressionAnalyzer>(
-                query_ptr, syntax_analyzer_result, *context, metadata_snapshot,
+                query_ptr, syntax_analyzer_result, context, metadata_snapshot,
                 NameSet(required_result_column_names.begin(), required_result_column_names.end()),
                 !options.only_analyze, options, std::move(subquery_for_sets));
 
@@ -520,7 +525,7 @@ InterpreterSelectQuery::InterpreterSelectQuery(
     {
         /// The current user should have the SELECT privilege.
         /// If this table_id is for a table function we don't check access rights here because in this case they have been already checked in ITableFunction::execute().
-        checkAccessRightsForSelect(*context, table_id, metadata_snapshot, required_columns, *syntax_analyzer_result);
+        checkAccessRightsForSelect(context, table_id, metadata_snapshot, required_columns, *syntax_analyzer_result);
 
         /// Remove limits for some tables in the `system` database.
         if (shouldIgnoreQuotaAndLimits(table_id) && (joined_tables.tablesCount() <= 1))
@@ -562,8 +567,8 @@ BlockIO InterpreterSelectQuery::execute()
     buildQueryPlan(query_plan);
 
     res.pipeline = std::move(*query_plan.buildQueryPipeline(
-        QueryPlanOptimizationSettings::fromContext(*context),
-        BuildQueryPipelineSettings::fromContext(*context)));
+        QueryPlanOptimizationSettings::fromContext(context),
+        BuildQueryPipelineSettings::fromContext(context)));
     return res;
 }
 
@@ -574,7 +579,7 @@ Block InterpreterSelectQuery::getSampleBlockImpl()
     query_info.query = query_ptr;
 
     if (storage && !options.only_analyze)
-        from_stage = storage->getQueryProcessingStage(*context, options.to_stage, query_info);
+        from_stage = storage->getQueryProcessingStage(context, options.to_stage, query_info);
 
     /// Do I need to perform the first part of the pipeline?
     /// Running on remote servers during distributed processing or if query is not distributed.
@@ -610,7 +615,7 @@ Block InterpreterSelectQuery::getSampleBlockImpl()
         {
             ExpressionActions(
                 analysis_result.prewhere_info->prewhere_actions,
-                ExpressionActionsSettings::fromContext(*context)).execute(header);
+                ExpressionActionsSettings::fromContext(context)).execute(header);
             if (analysis_result.prewhere_info->remove_prewhere_column)
                 header.erase(analysis_result.prewhere_info->prewhere_column_name);
         }
@@ -656,7 +661,7 @@ Block InterpreterSelectQuery::getSampleBlockImpl()
     return analysis_result.final_projection->getResultColumns();
 }
 
-static Field getWithFillFieldValue(const ASTPtr & node, const Context & context)
+static Field getWithFillFieldValue(const ASTPtr & node, ContextPtr context)
 {
     const auto & [field, type] = evaluateConstantExpression(node, context);
 
@@ -666,7 +671,7 @@ static Field getWithFillFieldValue(const ASTPtr & node, const Context & context)
     return field;
 }
 
-static FillColumnDescription getWithFillDescription(const ASTOrderByElement & order_by_elem, const Context & context)
+static FillColumnDescription getWithFillDescription(const ASTOrderByElement & order_by_elem, ContextPtr context)
 {
     FillColumnDescription descr;
     if (order_by_elem.fill_from)
@@ -711,7 +716,7 @@ static FillColumnDescription getWithFillDescription(const ASTOrderByElement & or
     return descr;
 }
 
-static SortDescription getSortDescription(const ASTSelectQuery & query, const Context & context)
+static SortDescription getSortDescription(const ASTSelectQuery & query, ContextPtr context)
 {
     SortDescription order_descr;
     order_descr.reserve(query.orderBy()->children.size());
@@ -751,7 +756,7 @@ static SortDescription getSortDescriptionFromGroupBy(const ASTSelectQuery & quer
     return order_descr;
 }
 
-static UInt64 getLimitUIntValue(const ASTPtr & node, const Context & context, const std::string & expr)
+static UInt64 getLimitUIntValue(const ASTPtr & node, ContextPtr context, const std::string & expr)
 {
     const auto & [field, type] = evaluateConstantExpression(node, context);
 
@@ -766,7 +771,7 @@ static UInt64 getLimitUIntValue(const ASTPtr & node, const Context & context, co
 }
 
 
-static std::pair<UInt64, UInt64> getLimitLengthAndOffset(const ASTSelectQuery & query, const Context & context)
+static std::pair<UInt64, UInt64> getLimitLengthAndOffset(const ASTSelectQuery & query, ContextPtr context)
 {
     UInt64 length = 0;
     UInt64 offset = 0;
@@ -783,7 +788,7 @@ static std::pair<UInt64, UInt64> getLimitLengthAndOffset(const ASTSelectQuery &
 }
 
 
-static UInt64 getLimitForSorting(const ASTSelectQuery & query, const Context & context)
+static UInt64 getLimitForSorting(const ASTSelectQuery & query, ContextPtr context)
 {
     /// Partial sort can be done if there is LIMIT but no DISTINCT or LIMIT BY, neither ARRAY JOIN.
     if (!query.distinct && !query.limitBy() && !query.limit_with_ties && !query.arrayJoinExpressionList() && query.limitLength())
@@ -1081,26 +1086,14 @@ void InterpreterSelectQuery::executeImpl(QueryPlan & query_plan, const BlockInpu
 
             if (expressions.hasJoin())
             {
-                JoinPtr join = expressions.join;
-
                 QueryPlanStepPtr join_step = std::make_unique<JoinStep>(
                     query_plan.getCurrentDataStream(),
-                    expressions.join);
+                    expressions.join,
+                    expressions.join_has_delayed_stream,
+                    settings.max_block_size);
 
                 join_step->setStepDescription("JOIN");
                 query_plan.addStep(std::move(join_step));
-
-                if (expressions.join_has_delayed_stream)
-                {
-                    const Block & join_result_sample = query_plan.getCurrentDataStream().header;
-                    auto stream = std::make_shared<LazyNonJoinedBlockInputStream>(*join, join_result_sample, settings.max_block_size);
-                    auto source = std::make_shared<SourceFromInputStream>(std::move(stream));
-                    auto add_non_joined_rows_step = std::make_unique<AddingDelayedSourceStep>(
-                            query_plan.getCurrentDataStream(), std::move(source));
-
-                    add_non_joined_rows_step->setStepDescription("Add non-joined rows after JOIN");
-                    query_plan.addStep(std::move(add_non_joined_rows_step));
-                }
             }
 
             if (expressions.hasWhere())
@@ -1197,7 +1190,7 @@ void InterpreterSelectQuery::executeImpl(QueryPlan & query_plan, const BlockInpu
             bool has_withfill = false;
             if (query.orderBy())
             {
-                SortDescription order_descr = getSortDescription(query, *context);
+                SortDescription order_descr = getSortDescription(query, context);
                 for (auto & desc : order_descr)
                     if (desc.with_fill)
                     {
@@ -1389,7 +1382,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
             temp_query_info.syntax_analyzer_result = syntax_analyzer_result;
             temp_query_info.sets = query_analyzer->getPreparedSets();
 
-            num_rows = storage->totalRowsByPartitionPredicate(temp_query_info, *context);
+            num_rows = storage->totalRowsByPartitionPredicate(temp_query_info, context);
         }
 
         if (num_rows)
@@ -1401,7 +1394,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
             AggregateDataPtr place = state.data();
 
             agg_count.create(place);
-            SCOPE_EXIT(agg_count.destroy(place));
+            SCOPE_EXIT_MEMORY_SAFE(agg_count.destroy(place));
 
             agg_count.set(place, *num_rows);
 
@@ -1488,9 +1481,9 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
                     auto column_decl = storage_columns.get(column);
                     column_expr = column_default->expression->clone();
                     // recursive visit for alias to alias
-                    replaceAliasColumnsInQuery(column_expr, metadata_snapshot->getColumns(), syntax_analyzer_result->getArrayJoinSourceNameSet(), *context);
+                    replaceAliasColumnsInQuery(column_expr, metadata_snapshot->getColumns(), syntax_analyzer_result->getArrayJoinSourceNameSet(), context);
 
-                    column_expr = addTypeConversionToAST(std::move(column_expr), column_decl.type->getName(), metadata_snapshot->getColumns().getAll(), *context);
+                    column_expr = addTypeConversionToAST(std::move(column_expr), column_decl.type->getName(), metadata_snapshot->getColumns().getAll(), context);
                     column_expr = setAlias(column_expr, column);
                 }
                 else
@@ -1535,8 +1528,8 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
                     = ext::map<NameSet>(required_columns_after_prewhere, [](const auto & it) { return it.name; });
             }
 
-            auto syntax_result = TreeRewriter(*context).analyze(required_columns_all_expr, required_columns_after_prewhere, storage, metadata_snapshot);
-            alias_actions = ExpressionAnalyzer(required_columns_all_expr, syntax_result, *context).getActionsDAG(true);
+            auto syntax_result = TreeRewriter(context).analyze(required_columns_all_expr, required_columns_after_prewhere, storage, metadata_snapshot);
+            alias_actions = ExpressionAnalyzer(required_columns_all_expr, syntax_result, context).getActionsDAG(true);
 
             /// The set of required columns could be added as a result of adding an action to calculate ALIAS.
             required_columns = alias_actions->getRequiredColumns().getNames();
@@ -1560,9 +1553,9 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
                     prewhere_info->prewhere_actions->tryRestoreColumn(name);
 
                 auto analyzed_result
-                    = TreeRewriter(*context).analyze(required_columns_from_prewhere_expr, metadata_snapshot->getColumns().getAllPhysical());
+                    = TreeRewriter(context).analyze(required_columns_from_prewhere_expr, metadata_snapshot->getColumns().getAllPhysical());
                 prewhere_info->alias_actions
-                    = ExpressionAnalyzer(required_columns_from_prewhere_expr, analyzed_result, *context).getActionsDAG(true, false);
+                    = ExpressionAnalyzer(required_columns_from_prewhere_expr, analyzed_result, context).getActionsDAG(true, false);
 
                 /// Add (physical?) columns required by alias actions.
                 auto required_columns_from_alias = prewhere_info->alias_actions->getRequiredColumns();
@@ -1608,7 +1601,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
 
     UInt64 max_block_size = settings.max_block_size;
 
-    auto [limit_length, limit_offset] = getLimitLengthAndOffset(query, *context);
+    auto [limit_length, limit_offset] = getLimitLengthAndOffset(query, context);
 
     /** Optimization - if not specified DISTINCT, WHERE, GROUP, HAVING, ORDER, LIMIT BY, WITH TIES but LIMIT is specified, and limit + offset < max_block_size,
      *  then as the block size we will use limit + offset (not to read more from the table than requested),
@@ -1624,6 +1617,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
         && !query.limitBy()
         && query.limitLength()
         && !query_analyzer->hasAggregation()
+        && !query_analyzer->hasWindow()
         && limit_length <= std::numeric_limits<UInt64>::max() - limit_offset
         && limit_length + limit_offset < max_block_size)
     {
@@ -1650,7 +1644,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
                 throw Exception("Subquery expected", ErrorCodes::LOGICAL_ERROR);
 
             interpreter_subquery = std::make_unique<InterpreterSelectWithUnionQuery>(
-                subquery, getSubqueryContext(*context),
+                subquery, getSubqueryContext(context),
                 options.copy().subquery().noModify(), required_columns);
 
             if (query_analyzer->hasAggregation())
@@ -1672,7 +1666,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
 
         query_info.syntax_analyzer_result = syntax_analyzer_result;
         query_info.sets = query_analyzer->getPreparedSets();
-        auto actions_settings = ExpressionActionsSettings::fromContext(*context);
+        auto actions_settings = ExpressionActionsSettings::fromContext(context);
 
         if (prewhere_info)
         {
@@ -1699,7 +1693,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
             if (analysis_result.optimize_read_in_order)
                 query_info.order_optimizer = std::make_shared<ReadInOrderOptimizer>(
                     analysis_result.order_by_elements_actions,
-                    getSortDescription(query, *context),
+                    getSortDescription(query, context),
                     query_info.syntax_analyzer_result);
             else
                 query_info.order_optimizer = std::make_shared<ReadInOrderOptimizer>(
@@ -1707,7 +1701,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
                     getSortDescriptionFromGroupBy(query),
                     query_info.syntax_analyzer_result);
 
-            query_info.input_order_info = query_info.order_optimizer->getInputOrder(metadata_snapshot, *context);
+            query_info.input_order_info = query_info.order_optimizer->getInputOrder(metadata_snapshot, context);
         }
 
         StreamLocalLimits limits;
@@ -1727,12 +1721,12 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc
             quota = context->getQuota();
 
         storage->read(query_plan, required_columns, metadata_snapshot,
-                      query_info, *context, processing_stage, max_block_size, max_streams);
+                      query_info, context, processing_stage, max_block_size, max_streams);
 
         if (context->hasQueryContext() && !options.is_internal)
         {
             auto local_storage_id = storage->getStorageID();
-            context->getQueryContext().addQueryAccessInfo(
+            context->getQueryContext()->addQueryAccessInfo(
                 backQuoteIfNeed(local_storage_id.getDatabaseName()), local_storage_id.getFullTableName(), required_columns);
         }
 
@@ -2114,8 +2108,8 @@ void InterpreterSelectQuery::executeOrderOptimized(QueryPlan & query_plan, Input
 void InterpreterSelectQuery::executeOrder(QueryPlan & query_plan, InputOrderInfoPtr input_sorting_info)
 {
     auto & query = getSelectQuery();
-    SortDescription output_order_descr = getSortDescription(query, *context);
-    UInt64 limit = getLimitForSorting(query, *context);
+    SortDescription output_order_descr = getSortDescription(query, context);
+    UInt64 limit = getLimitForSorting(query, context);
 
     if (input_sorting_info)
     {
@@ -2163,8 +2157,8 @@ void InterpreterSelectQuery::executeOrder(QueryPlan & query_plan, InputOrderInfo
 void InterpreterSelectQuery::executeMergeSorted(QueryPlan & query_plan, const std::string & description)
 {
     auto & query = getSelectQuery();
-    SortDescription order_descr = getSortDescription(query, *context);
-    UInt64 limit = getLimitForSorting(query, *context);
+    SortDescription order_descr = getSortDescription(query, context);
+    UInt64 limit = getLimitForSorting(query, context);
 
     executeMergeSorted(query_plan, order_descr, limit, description);
 }
@@ -2198,7 +2192,7 @@ void InterpreterSelectQuery::executeDistinct(QueryPlan & query_plan, bool before
     {
         const Settings & settings = context->getSettingsRef();
 
-        auto [limit_length, limit_offset] = getLimitLengthAndOffset(query, *context);
+        auto [limit_length, limit_offset] = getLimitLengthAndOffset(query, context);
         UInt64 limit_for_distinct = 0;
 
         /// If after this stage of DISTINCT ORDER BY is not executed,
@@ -2227,7 +2221,7 @@ void InterpreterSelectQuery::executePreLimit(QueryPlan & query_plan, bool do_not
     /// If there is LIMIT
     if (query.limitLength())
     {
-        auto [limit_length, limit_offset] = getLimitLengthAndOffset(query, *context);
+        auto [limit_length, limit_offset] = getLimitLengthAndOffset(query, context);
 
         if (do_not_skip_offset)
         {
@@ -2255,8 +2249,8 @@ void InterpreterSelectQuery::executeLimitBy(QueryPlan & query_plan)
     for (const auto & elem : query.limitBy()->children)
         columns.emplace_back(elem->getColumnName());
 
-    UInt64 length = getLimitUIntValue(query.limitByLength(), *context, "LIMIT");
-    UInt64 offset = (query.limitByOffset() ? getLimitUIntValue(query.limitByOffset(), *context, "OFFSET") : 0);
+    UInt64 length = getLimitUIntValue(query.limitByLength(), context, "LIMIT");
+    UInt64 offset = (query.limitByOffset() ? getLimitUIntValue(query.limitByOffset(), context, "OFFSET") : 0);
 
     auto limit_by = std::make_unique<LimitByStep>(query_plan.getCurrentDataStream(), length, offset, columns);
     query_plan.addStep(std::move(limit_by));
@@ -2267,7 +2261,7 @@ void InterpreterSelectQuery::executeWithFill(QueryPlan & query_plan)
     auto & query = getSelectQuery();
     if (query.orderBy())
     {
-        SortDescription order_descr = getSortDescription(query, *context);
+        SortDescription order_descr = getSortDescription(query, context);
         SortDescription fill_descr;
         for (auto & desc : order_descr)
         {
@@ -2309,14 +2303,14 @@ void InterpreterSelectQuery::executeLimit(QueryPlan & query_plan)
 
         UInt64 limit_length;
         UInt64 limit_offset;
-        std::tie(limit_length, limit_offset) = getLimitLengthAndOffset(query, *context);
+        std::tie(limit_length, limit_offset) = getLimitLengthAndOffset(query, context);
 
         SortDescription order_descr;
         if (query.limit_with_ties)
         {
             if (!query.orderBy())
                 throw Exception("LIMIT WITH TIES without ORDER BY", ErrorCodes::LOGICAL_ERROR);
-            order_descr = getSortDescription(query, *context);
+            order_descr = getSortDescription(query, context);
         }
 
         auto limit = std::make_unique<LimitStep>(
@@ -2339,7 +2333,7 @@ void InterpreterSelectQuery::executeOffset(QueryPlan & query_plan)
     {
         UInt64 limit_length;
         UInt64 limit_offset;
-        std::tie(limit_length, limit_offset) = getLimitLengthAndOffset(query, *context);
+        std::tie(limit_length, limit_offset) = getLimitLengthAndOffset(query, context);
 
         auto offsets_step = std::make_unique<OffsetStep>(query_plan.getCurrentDataStream(), limit_offset);
         query_plan.addStep(std::move(offsets_step));
@@ -2363,7 +2357,7 @@ void InterpreterSelectQuery::executeSubqueriesInSetsAndJoins(QueryPlan & query_p
     const Settings & settings = context->getSettingsRef();
 
     SizeLimits limits(settings.max_rows_to_transfer, settings.max_bytes_to_transfer, settings.transfer_overflow_mode);
-    addCreatingSetsStep(query_plan, std::move(subqueries_for_sets), limits, *context);
+    addCreatingSetsStep(query_plan, std::move(subqueries_for_sets), limits, context);
 }
 
 
@@ -2377,7 +2371,7 @@ void InterpreterSelectQuery::initSettings()
 {
     auto & query = getSelectQuery();
     if (query.settings())
-        InterpreterSetQuery(query.settings(), *context).executeForCurrentContext();
+        InterpreterSetQuery(query.settings(), context).executeForCurrentContext();
 }
 
 }
diff --git a/src/Interpreters/InterpreterSelectQuery.h b/src/Interpreters/InterpreterSelectQuery.h
index 13f4755d431..66b3fc65eff 100644
--- a/src/Interpreters/InterpreterSelectQuery.h
+++ b/src/Interpreters/InterpreterSelectQuery.h
@@ -46,28 +46,28 @@ public:
 
     InterpreterSelectQuery(
         const ASTPtr & query_ptr_,
-        const Context & context_,
+        ContextPtr context_,
         const SelectQueryOptions &,
         const Names & required_result_column_names_ = Names{});
 
     /// Read data not from the table specified in the query, but from the prepared source `input`.
     InterpreterSelectQuery(
         const ASTPtr & query_ptr_,
-        const Context & context_,
+        ContextPtr context_,
         const BlockInputStreamPtr & input_,
         const SelectQueryOptions & = {});
 
     /// Read data not from the table specified in the query, but from the prepared pipe `input`.
     InterpreterSelectQuery(
             const ASTPtr & query_ptr_,
-            const Context & context_,
+            ContextPtr context_,
             Pipe input_pipe_,
             const SelectQueryOptions & = {});
 
     /// Read data not from the table specified in the query, but from the specified `storage_`.
     InterpreterSelectQuery(
         const ASTPtr & query_ptr_,
-        const Context & context_,
+        ContextPtr context_,
         const StoragePtr & storage_,
         const StorageMetadataPtr & metadata_snapshot_ = nullptr,
         const SelectQueryOptions & = {});
@@ -94,7 +94,7 @@ public:
 private:
     InterpreterSelectQuery(
         const ASTPtr & query_ptr_,
-        const Context & context_,
+        ContextPtr context_,
         const BlockInputStreamPtr & input_,
         std::optional<Pipe> input_pipe,
         const StoragePtr & storage_,
diff --git a/src/Interpreters/InterpreterSelectWithUnionQuery.cpp b/src/Interpreters/InterpreterSelectWithUnionQuery.cpp
index 21737bbb57e..3cf4a905d38 100644
--- a/src/Interpreters/InterpreterSelectWithUnionQuery.cpp
+++ b/src/Interpreters/InterpreterSelectWithUnionQuery.cpp
@@ -6,6 +6,7 @@
 #include <Parsers/ASTSelectWithUnionQuery.h>
 #include <Parsers/queryToString.h>
 #include <Processors/QueryPlan/DistinctStep.h>
+#include <Processors/QueryPlan/ExpressionStep.h>
 #include <Processors/QueryPlan/IQueryPlanStep.h>
 #include <Processors/QueryPlan/QueryPlan.h>
 #include <Processors/QueryPlan/UnionStep.h>
@@ -28,7 +29,7 @@ namespace ErrorCodes
 }
 
 InterpreterSelectWithUnionQuery::InterpreterSelectWithUnionQuery(
-    const ASTPtr & query_ptr_, const Context & context_, const SelectQueryOptions & options_, const Names & required_result_column_names)
+    const ASTPtr & query_ptr_, ContextPtr context_, const SelectQueryOptions & options_, const Names & required_result_column_names)
     : IInterpreterUnionOrSelectQuery(query_ptr_, context_, options_)
 {
     ASTSelectWithUnionQuery * ast = query_ptr->as<ASTSelectWithUnionQuery>();
@@ -196,26 +197,26 @@ Block InterpreterSelectWithUnionQuery::getCommonHeaderForUnion(const Blocks & he
 Block InterpreterSelectWithUnionQuery::getCurrentChildResultHeader(const ASTPtr & ast_ptr_, const Names & required_result_column_names)
 {
     if (ast_ptr_->as<ASTSelectWithUnionQuery>())
-        return InterpreterSelectWithUnionQuery(ast_ptr_, *context, options.copy().analyze().noModify(), required_result_column_names)
+        return InterpreterSelectWithUnionQuery(ast_ptr_, context, options.copy().analyze().noModify(), required_result_column_names)
             .getSampleBlock();
     else
-        return InterpreterSelectQuery(ast_ptr_, *context, options.copy().analyze().noModify()).getSampleBlock();
+        return InterpreterSelectQuery(ast_ptr_, context, options.copy().analyze().noModify()).getSampleBlock();
 }
 
 std::unique_ptr<IInterpreterUnionOrSelectQuery>
 InterpreterSelectWithUnionQuery::buildCurrentChildInterpreter(const ASTPtr & ast_ptr_, const Names & current_required_result_column_names)
 {
     if (ast_ptr_->as<ASTSelectWithUnionQuery>())
-        return std::make_unique<InterpreterSelectWithUnionQuery>(ast_ptr_, *context, options, current_required_result_column_names);
+        return std::make_unique<InterpreterSelectWithUnionQuery>(ast_ptr_, context, options, current_required_result_column_names);
     else
-        return std::make_unique<InterpreterSelectQuery>(ast_ptr_, *context, options, current_required_result_column_names);
+        return std::make_unique<InterpreterSelectQuery>(ast_ptr_, context, options, current_required_result_column_names);
 }
 
 InterpreterSelectWithUnionQuery::~InterpreterSelectWithUnionQuery() = default;
 
-Block InterpreterSelectWithUnionQuery::getSampleBlock(const ASTPtr & query_ptr_, const Context & context_, bool is_subquery)
+Block InterpreterSelectWithUnionQuery::getSampleBlock(const ASTPtr & query_ptr_, ContextPtr context_, bool is_subquery)
 {
-    auto & cache = context_.getSampleBlockCache();
+    auto & cache = context_->getSampleBlockCache();
     /// Using query string because query_ptr changes for every internal SELECT
     auto key = queryToString(query_ptr_);
     if (cache.find(key) != cache.end())
@@ -251,11 +252,23 @@ void InterpreterSelectWithUnionQuery::buildQueryPlan(QueryPlan & query_plan)
         {
             plans[i] = std::make_unique<QueryPlan>();
             nested_interpreters[i]->buildQueryPlan(*plans[i]);
+
+            if (!blocksHaveEqualStructure(plans[i]->getCurrentDataStream().header, result_header))
+            {
+                auto actions_dag = ActionsDAG::makeConvertingActions(
+                        plans[i]->getCurrentDataStream().header.getColumnsWithTypeAndName(),
+                        result_header.getColumnsWithTypeAndName(),
+                        ActionsDAG::MatchColumnsMode::Position);
+                auto converting_step = std::make_unique<ExpressionStep>(plans[i]->getCurrentDataStream(), std::move(actions_dag));
+                converting_step->setStepDescription("Conversion before UNION");
+                plans[i]->addStep(std::move(converting_step));
+            }
+
             data_streams[i] = plans[i]->getCurrentDataStream();
         }
 
         auto max_threads = context->getSettingsRef().max_threads;
-        auto union_step = std::make_unique<UnionStep>(std::move(data_streams), result_header, max_threads);
+        auto union_step = std::make_unique<UnionStep>(std::move(data_streams), max_threads);
 
         query_plan.unitePlans(std::move(union_step), std::move(plans));
 
@@ -298,8 +311,8 @@ BlockIO InterpreterSelectWithUnionQuery::execute()
     buildQueryPlan(query_plan);
 
     auto pipeline = query_plan.buildQueryPipeline(
-        QueryPlanOptimizationSettings::fromContext(*context),
-        BuildQueryPipelineSettings::fromContext(*context));
+        QueryPlanOptimizationSettings::fromContext(context),
+        BuildQueryPipelineSettings::fromContext(context));
 
     res.pipeline = std::move(*pipeline);
     res.pipeline.addInterpreterContext(context);
diff --git a/src/Interpreters/InterpreterSelectWithUnionQuery.h b/src/Interpreters/InterpreterSelectWithUnionQuery.h
index f4062b2005e..bd18b8e7907 100644
--- a/src/Interpreters/InterpreterSelectWithUnionQuery.h
+++ b/src/Interpreters/InterpreterSelectWithUnionQuery.h
@@ -6,7 +6,6 @@
 namespace DB
 {
 
-class Context;
 class InterpreterSelectQuery;
 class QueryPlan;
 
@@ -19,7 +18,7 @@ public:
 
     InterpreterSelectWithUnionQuery(
         const ASTPtr & query_ptr_,
-        const Context & context_,
+        ContextPtr context_,
         const SelectQueryOptions &,
         const Names & required_result_column_names = {});
 
@@ -35,7 +34,7 @@ public:
 
     static Block getSampleBlock(
         const ASTPtr & query_ptr_,
-        const Context & context_,
+        ContextPtr context_,
         bool is_subquery = false);
 
     virtual void ignoreWithTotals() override;
diff --git a/src/Interpreters/InterpreterSetQuery.cpp b/src/Interpreters/InterpreterSetQuery.cpp
index f92e9638822..1c6a4236bf6 100644
--- a/src/Interpreters/InterpreterSetQuery.cpp
+++ b/src/Interpreters/InterpreterSetQuery.cpp
@@ -9,8 +9,8 @@ namespace DB
 BlockIO InterpreterSetQuery::execute()
 {
     const auto & ast = query_ptr->as<ASTSetQuery &>();
-    context.checkSettingsConstraints(ast.changes);
-    context.getSessionContext().applySettingsChanges(ast.changes);
+    getContext()->checkSettingsConstraints(ast.changes);
+    getContext()->getSessionContext()->applySettingsChanges(ast.changes);
     return {};
 }
 
@@ -18,8 +18,8 @@ BlockIO InterpreterSetQuery::execute()
 void InterpreterSetQuery::executeForCurrentContext()
 {
     const auto & ast = query_ptr->as<ASTSetQuery &>();
-    context.checkSettingsConstraints(ast.changes);
-    context.applySettingsChanges(ast.changes);
+    getContext()->checkSettingsConstraints(ast.changes);
+    getContext()->applySettingsChanges(ast.changes);
 }
 
 }
diff --git a/src/Interpreters/InterpreterSetQuery.h b/src/Interpreters/InterpreterSetQuery.h
index 6e8e8b8b733..31519be6f29 100644
--- a/src/Interpreters/InterpreterSetQuery.h
+++ b/src/Interpreters/InterpreterSetQuery.h
@@ -7,17 +7,14 @@
 namespace DB
 {
 
-class Context;
 class ASTSetQuery;
 
-
 /** Change one or several settings for the session or just for the current context.
   */
-class InterpreterSetQuery : public IInterpreter
+class InterpreterSetQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterSetQuery(const ASTPtr & query_ptr_, Context & context_)
-        : query_ptr(query_ptr_), context(context_) {}
+    InterpreterSetQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     /** Usual SET query. Set setting for the session.
       */
@@ -30,8 +27,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    Context & context;
 };
 
-
 }
diff --git a/src/Interpreters/InterpreterSetRoleQuery.cpp b/src/Interpreters/InterpreterSetRoleQuery.cpp
index 8d314606329..057ccd447ef 100644
--- a/src/Interpreters/InterpreterSetRoleQuery.cpp
+++ b/src/Interpreters/InterpreterSetRoleQuery.cpp
@@ -28,13 +28,13 @@ BlockIO InterpreterSetRoleQuery::execute()
 
 void InterpreterSetRoleQuery::setRole(const ASTSetRoleQuery & query)
 {
-    auto & access_control = context.getAccessControlManager();
-    auto & session_context = context.getSessionContext();
-    auto user = session_context.getUser();
+    auto & access_control = getContext()->getAccessControlManager();
+    auto session_context = getContext()->getSessionContext();
+    auto user = session_context->getUser();
 
     if (query.kind == ASTSetRoleQuery::Kind::SET_ROLE_DEFAULT)
     {
-        session_context.setCurrentRolesDefault();
+        session_context->setCurrentRolesDefault();
     }
     else
     {
@@ -53,17 +53,17 @@ void InterpreterSetRoleQuery::setRole(const ASTSetRoleQuery & query)
                 new_current_roles.emplace_back(id);
             }
         }
-        session_context.setCurrentRoles(new_current_roles);
+        session_context->setCurrentRoles(new_current_roles);
     }
 }
 
 
 void InterpreterSetRoleQuery::setDefaultRole(const ASTSetRoleQuery & query)
 {
-    context.checkAccess(AccessType::ALTER_USER);
+    getContext()->checkAccess(AccessType::ALTER_USER);
 
-    auto & access_control = context.getAccessControlManager();
-    std::vector<UUID> to_users = RolesOrUsersSet{*query.to_users, access_control, context.getUserID()}.getMatchingIDs(access_control);
+    auto & access_control = getContext()->getAccessControlManager();
+    std::vector<UUID> to_users = RolesOrUsersSet{*query.to_users, access_control, getContext()->getUserID()}.getMatchingIDs(access_control);
     RolesOrUsersSet roles_from_query{*query.roles, access_control};
 
     auto update_func = [&](const AccessEntityPtr & entity) -> AccessEntityPtr
diff --git a/src/Interpreters/InterpreterSetRoleQuery.h b/src/Interpreters/InterpreterSetRoleQuery.h
index 0919b0f23f9..70ba3c381ab 100644
--- a/src/Interpreters/InterpreterSetRoleQuery.h
+++ b/src/Interpreters/InterpreterSetRoleQuery.h
@@ -7,16 +7,14 @@
 namespace DB
 {
 
-class Context;
 class ASTSetRoleQuery;
 struct RolesOrUsersSet;
 struct User;
 
-
-class InterpreterSetRoleQuery : public IInterpreter
+class InterpreterSetRoleQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterSetRoleQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+    InterpreterSetRoleQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -27,6 +25,6 @@ private:
     void setDefaultRole(const ASTSetRoleQuery & query);
 
     ASTPtr query_ptr;
-    Context & context;
 };
+
 }
diff --git a/src/Interpreters/InterpreterShowAccessEntitiesQuery.cpp b/src/Interpreters/InterpreterShowAccessEntitiesQuery.cpp
index 31c1ef874df..afd685ea983 100644
--- a/src/Interpreters/InterpreterShowAccessEntitiesQuery.cpp
+++ b/src/Interpreters/InterpreterShowAccessEntitiesQuery.cpp
@@ -17,22 +17,22 @@ namespace ErrorCodes
 using EntityType = IAccessEntity::Type;
 
 
-InterpreterShowAccessEntitiesQuery::InterpreterShowAccessEntitiesQuery(const ASTPtr & query_ptr_, Context & context_)
-    : query_ptr(query_ptr_), context(context_)
+InterpreterShowAccessEntitiesQuery::InterpreterShowAccessEntitiesQuery(const ASTPtr & query_ptr_, ContextPtr context_)
+    : WithContext(context_), query_ptr(query_ptr_)
 {
 }
 
 
 BlockIO InterpreterShowAccessEntitiesQuery::execute()
 {
-    return executeQuery(getRewrittenQuery(), context, true);
+    return executeQuery(getRewrittenQuery(), getContext(), true);
 }
 
 
 String InterpreterShowAccessEntitiesQuery::getRewrittenQuery() const
 {
     auto & query = query_ptr->as<ASTShowAccessEntitiesQuery &>();
-    query.replaceEmptyDatabase(context.getCurrentDatabase());
+    query.replaceEmptyDatabase(getContext()->getCurrentDatabase());
     String origin;
     String expr = "*";
     String filter, order;
diff --git a/src/Interpreters/InterpreterShowAccessEntitiesQuery.h b/src/Interpreters/InterpreterShowAccessEntitiesQuery.h
index 8fcd70919ba..7224f0d593b 100644
--- a/src/Interpreters/InterpreterShowAccessEntitiesQuery.h
+++ b/src/Interpreters/InterpreterShowAccessEntitiesQuery.h
@@ -6,12 +6,11 @@
 
 namespace DB
 {
-class Context;
 
-class InterpreterShowAccessEntitiesQuery : public IInterpreter
+class InterpreterShowAccessEntitiesQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterShowAccessEntitiesQuery(const ASTPtr & query_ptr_, Context & context_);
+    InterpreterShowAccessEntitiesQuery(const ASTPtr & query_ptr_, ContextPtr context_);
 
     BlockIO execute() override;
 
@@ -22,7 +21,6 @@ private:
     String getRewrittenQuery() const;
 
     ASTPtr query_ptr;
-    Context & context;
 };
 
 }
diff --git a/src/Interpreters/InterpreterShowAccessQuery.cpp b/src/Interpreters/InterpreterShowAccessQuery.cpp
index a1f8b5ed656..d2e21b71ae5 100644
--- a/src/Interpreters/InterpreterShowAccessQuery.cpp
+++ b/src/Interpreters/InterpreterShowAccessQuery.cpp
@@ -49,8 +49,8 @@ BlockInputStreamPtr InterpreterShowAccessQuery::executeImpl() const
 
 std::vector<AccessEntityPtr> InterpreterShowAccessQuery::getEntities() const
 {
-    const auto & access_control = context.getAccessControlManager();
-    context.checkAccess(AccessType::SHOW_ACCESS);
+    const auto & access_control = getContext()->getAccessControlManager();
+    getContext()->checkAccess(AccessType::SHOW_ACCESS);
 
     std::vector<AccessEntityPtr> entities;
     for (auto type : ext::range(EntityType::MAX))
@@ -71,7 +71,7 @@ std::vector<AccessEntityPtr> InterpreterShowAccessQuery::getEntities() const
 ASTs InterpreterShowAccessQuery::getCreateAndGrantQueries() const
 {
     auto entities = getEntities();
-    const auto & access_control = context.getAccessControlManager();
+    const auto & access_control = getContext()->getAccessControlManager();
 
     ASTs create_queries, grant_queries;
     for (const auto & entity : entities)
diff --git a/src/Interpreters/InterpreterShowAccessQuery.h b/src/Interpreters/InterpreterShowAccessQuery.h
index eb548c56241..d08d8962abc 100644
--- a/src/Interpreters/InterpreterShowAccessQuery.h
+++ b/src/Interpreters/InterpreterShowAccessQuery.h
@@ -6,17 +6,16 @@
 
 namespace DB
 {
-class Context;
+
 struct IAccessEntity;
 using AccessEntityPtr = std::shared_ptr<const IAccessEntity>;
 
 /** Return all queries for creating access entities and grants.
   */
-class InterpreterShowAccessQuery : public IInterpreter
+class InterpreterShowAccessQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterShowAccessQuery(const ASTPtr & query_ptr_, Context & context_)
-        : query_ptr(query_ptr_), context(context_) {}
+    InterpreterShowAccessQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -29,8 +28,6 @@ private:
     std::vector<AccessEntityPtr> getEntities() const;
 
     ASTPtr query_ptr;
-    Context & context;
 };
 
-
 }
diff --git a/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp b/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp
index c39fed8fb62..33e29d2b7bd 100644
--- a/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp
+++ b/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp
@@ -225,8 +225,8 @@ namespace
 }
 
 
-InterpreterShowCreateAccessEntityQuery::InterpreterShowCreateAccessEntityQuery(const ASTPtr & query_ptr_, const Context & context_)
-    : query_ptr(query_ptr_), context(context_)
+InterpreterShowCreateAccessEntityQuery::InterpreterShowCreateAccessEntityQuery(const ASTPtr & query_ptr_, ContextPtr context_)
+    : WithContext(context_), query_ptr(query_ptr_)
 {
 }
 
@@ -270,9 +270,9 @@ BlockInputStreamPtr InterpreterShowCreateAccessEntityQuery::executeImpl()
 std::vector<AccessEntityPtr> InterpreterShowCreateAccessEntityQuery::getEntities() const
 {
     auto & show_query = query_ptr->as<ASTShowCreateAccessEntityQuery &>();
-    const auto & access_control = context.getAccessControlManager();
-    context.checkAccess(getRequiredAccess());
-    show_query.replaceEmptyDatabase(context.getCurrentDatabase());
+    const auto & access_control = getContext()->getAccessControlManager();
+    getContext()->checkAccess(getRequiredAccess());
+    show_query.replaceEmptyDatabase(getContext()->getCurrentDatabase());
     std::vector<AccessEntityPtr> entities;
 
     if (show_query.all)
@@ -286,12 +286,12 @@ std::vector<AccessEntityPtr> InterpreterShowCreateAccessEntityQuery::getEntities
     }
     else if (show_query.current_user)
     {
-        if (auto user = context.getUser())
+        if (auto user = getContext()->getUser())
             entities.push_back(user);
     }
     else if (show_query.current_quota)
     {
-        auto usage = context.getQuotaUsage();
+        auto usage = getContext()->getQuotaUsage();
         if (usage)
             entities.push_back(access_control.read<Quota>(usage->quota_id));
     }
@@ -341,7 +341,7 @@ ASTs InterpreterShowCreateAccessEntityQuery::getCreateQueries() const
     auto entities = getEntities();
 
     ASTs list;
-    const auto & access_control = context.getAccessControlManager();
+    const auto & access_control = getContext()->getAccessControlManager();
     for (const auto & entity : entities)
         list.push_back(getCreateQuery(*entity, access_control));
 
diff --git a/src/Interpreters/InterpreterShowCreateAccessEntityQuery.h b/src/Interpreters/InterpreterShowCreateAccessEntityQuery.h
index 5bacbd42988..6d026d2b81b 100644
--- a/src/Interpreters/InterpreterShowCreateAccessEntityQuery.h
+++ b/src/Interpreters/InterpreterShowCreateAccessEntityQuery.h
@@ -16,10 +16,10 @@ using AccessEntityPtr = std::shared_ptr<const IAccessEntity>;
 
 /** Returns a single item containing a statement which could be used to create a specified role.
   */
-class InterpreterShowCreateAccessEntityQuery : public IInterpreter
+class InterpreterShowCreateAccessEntityQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterShowCreateAccessEntityQuery(const ASTPtr & query_ptr_, const Context & context_);
+    InterpreterShowCreateAccessEntityQuery(const ASTPtr & query_ptr_, ContextPtr context_);
 
     BlockIO execute() override;
 
@@ -36,7 +36,6 @@ private:
     AccessRightsElements getRequiredAccess() const;
 
     ASTPtr query_ptr;
-    const Context & context;
 };
 
 
diff --git a/src/Interpreters/InterpreterShowCreateQuery.cpp b/src/Interpreters/InterpreterShowCreateQuery.cpp
index a853c4b9a9b..1a247dbf6e6 100644
--- a/src/Interpreters/InterpreterShowCreateQuery.cpp
+++ b/src/Interpreters/InterpreterShowCreateQuery.cpp
@@ -48,9 +48,9 @@ BlockInputStreamPtr InterpreterShowCreateQuery::executeImpl()
         (show_query = query_ptr->as<ASTShowCreateViewQuery>()))
     {
         auto resolve_table_type = show_query->temporary ? Context::ResolveExternal : Context::ResolveOrdinary;
-        auto table_id = context.resolveStorageID(*show_query, resolve_table_type);
-        context.checkAccess(AccessType::SHOW_COLUMNS, table_id);
-        create_query = DatabaseCatalog::instance().getDatabase(table_id.database_name)->getCreateTableQuery(table_id.table_name, context);
+        auto table_id = getContext()->resolveStorageID(*show_query, resolve_table_type);
+        getContext()->checkAccess(AccessType::SHOW_COLUMNS, table_id);
+        create_query = DatabaseCatalog::instance().getDatabase(table_id.database_name)->getCreateTableQuery(table_id.table_name, getContext());
         if (query_ptr->as<ASTShowCreateViewQuery>())
         {
             auto & ast_create_query = create_query->as<ASTCreateQuery &>();
@@ -62,23 +62,23 @@ BlockInputStreamPtr InterpreterShowCreateQuery::executeImpl()
     {
         if (show_query->temporary)
             throw Exception("Temporary databases are not possible.", ErrorCodes::SYNTAX_ERROR);
-        show_query->database = context.resolveDatabase(show_query->database);
-        context.checkAccess(AccessType::SHOW_DATABASES, show_query->database);
+        show_query->database = getContext()->resolveDatabase(show_query->database);
+        getContext()->checkAccess(AccessType::SHOW_DATABASES, show_query->database);
         create_query = DatabaseCatalog::instance().getDatabase(show_query->database)->getCreateDatabaseQuery();
     }
     else if ((show_query = query_ptr->as<ASTShowCreateDictionaryQuery>()))
     {
         if (show_query->temporary)
             throw Exception("Temporary dictionaries are not possible.", ErrorCodes::SYNTAX_ERROR);
-        show_query->database = context.resolveDatabase(show_query->database);
-        context.checkAccess(AccessType::SHOW_DICTIONARIES, show_query->database, show_query->table);
+        show_query->database = getContext()->resolveDatabase(show_query->database);
+        getContext()->checkAccess(AccessType::SHOW_DICTIONARIES, show_query->database, show_query->table);
         create_query = DatabaseCatalog::instance().getDatabase(show_query->database)->getCreateDictionaryQuery(show_query->table);
     }
 
     if (!create_query)
         throw Exception("Unable to show the create query of " + show_query->table + ". Maybe it was created by the system.", ErrorCodes::THERE_IS_NO_QUERY);
 
-    if (!context.getSettingsRef().show_table_uuid_in_table_create_query_if_not_nil)
+    if (!getContext()->getSettingsRef().show_table_uuid_in_table_create_query_if_not_nil)
     {
         auto & create = create_query->as<ASTCreateQuery &>();
         create.uuid = UUIDHelpers::Nil;
diff --git a/src/Interpreters/InterpreterShowCreateQuery.h b/src/Interpreters/InterpreterShowCreateQuery.h
index 5ac98509b23..53f587d3e7d 100644
--- a/src/Interpreters/InterpreterShowCreateQuery.h
+++ b/src/Interpreters/InterpreterShowCreateQuery.h
@@ -7,16 +7,12 @@
 namespace DB
 {
 
-class Context;
-
-
 /** Return single row with single column "statement" of type String with text of query to CREATE specified table.
   */
-class InterpreterShowCreateQuery : public IInterpreter
+class InterpreterShowCreateQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterShowCreateQuery(const ASTPtr & query_ptr_, const Context & context_)
-        : query_ptr(query_ptr_), context(context_) {}
+    InterpreterShowCreateQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -24,7 +20,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    const Context & context;
 
     BlockInputStreamPtr executeImpl();
 };
diff --git a/src/Interpreters/InterpreterShowGrantsQuery.cpp b/src/Interpreters/InterpreterShowGrantsQuery.cpp
index bda5ef0f8b1..f3e554122e1 100644
--- a/src/Interpreters/InterpreterShowGrantsQuery.cpp
+++ b/src/Interpreters/InterpreterShowGrantsQuery.cpp
@@ -136,8 +136,8 @@ BlockInputStreamPtr InterpreterShowGrantsQuery::executeImpl()
 std::vector<AccessEntityPtr> InterpreterShowGrantsQuery::getEntities() const
 {
     const auto & show_query = query_ptr->as<ASTShowGrantsQuery &>();
-    const auto & access_control = context.getAccessControlManager();
-    auto ids = RolesOrUsersSet{*show_query.for_roles, access_control, context.getUserID()}.getMatchingIDs(access_control);
+    const auto & access_control = getContext()->getAccessControlManager();
+    auto ids = RolesOrUsersSet{*show_query.for_roles, access_control, getContext()->getUserID()}.getMatchingIDs(access_control);
 
     std::vector<AccessEntityPtr> entities;
     for (const auto & id : ids)
@@ -155,7 +155,7 @@ std::vector<AccessEntityPtr> InterpreterShowGrantsQuery::getEntities() const
 ASTs InterpreterShowGrantsQuery::getGrantQueries() const
 {
     auto entities = getEntities();
-    const auto & access_control = context.getAccessControlManager();
+    const auto & access_control = getContext()->getAccessControlManager();
 
     ASTs grant_queries;
     for (const auto & entity : entities)
diff --git a/src/Interpreters/InterpreterShowGrantsQuery.h b/src/Interpreters/InterpreterShowGrantsQuery.h
index f5dbd110fd0..c23aa1e3b94 100644
--- a/src/Interpreters/InterpreterShowGrantsQuery.h
+++ b/src/Interpreters/InterpreterShowGrantsQuery.h
@@ -1,22 +1,22 @@
 #pragma once
 
+#include <Core/UUID.h>
 #include <Interpreters/IInterpreter.h>
 #include <Parsers/IAST_fwd.h>
-#include <Core/UUID.h>
 
 
 namespace DB
 {
+
 class AccessControlManager;
 class ASTShowGrantsQuery;
 struct IAccessEntity;
 using AccessEntityPtr = std::shared_ptr<const IAccessEntity>;
 
-
-class InterpreterShowGrantsQuery : public IInterpreter
+class InterpreterShowGrantsQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterShowGrantsQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+    InterpreterShowGrantsQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -32,6 +32,6 @@ private:
     std::vector<AccessEntityPtr> getEntities() const;
 
     ASTPtr query_ptr;
-    Context & context;
 };
+
 }
diff --git a/src/Interpreters/InterpreterShowPrivilegesQuery.cpp b/src/Interpreters/InterpreterShowPrivilegesQuery.cpp
index e88b97d8671..c566d31e2fc 100644
--- a/src/Interpreters/InterpreterShowPrivilegesQuery.cpp
+++ b/src/Interpreters/InterpreterShowPrivilegesQuery.cpp
@@ -4,7 +4,7 @@
 
 namespace DB
 {
-InterpreterShowPrivilegesQuery::InterpreterShowPrivilegesQuery(const ASTPtr & query_ptr_, Context & context_)
+InterpreterShowPrivilegesQuery::InterpreterShowPrivilegesQuery(const ASTPtr & query_ptr_, ContextPtr context_)
     : query_ptr(query_ptr_), context(context_)
 {
 }
diff --git a/src/Interpreters/InterpreterShowPrivilegesQuery.h b/src/Interpreters/InterpreterShowPrivilegesQuery.h
index 0c1a30107c0..75989263405 100644
--- a/src/Interpreters/InterpreterShowPrivilegesQuery.h
+++ b/src/Interpreters/InterpreterShowPrivilegesQuery.h
@@ -11,7 +11,7 @@ class Context;
 class InterpreterShowPrivilegesQuery : public IInterpreter
 {
 public:
-    InterpreterShowPrivilegesQuery(const ASTPtr & query_ptr_, Context & context_);
+    InterpreterShowPrivilegesQuery(const ASTPtr & query_ptr_, ContextPtr context_);
 
     BlockIO execute() override;
 
@@ -20,7 +20,7 @@ public:
 
 private:
     ASTPtr query_ptr;
-    Context & context;
+    ContextPtr context;
 };
 
 }
diff --git a/src/Interpreters/InterpreterShowProcesslistQuery.cpp b/src/Interpreters/InterpreterShowProcesslistQuery.cpp
index 697b286fe75..780ba688a89 100644
--- a/src/Interpreters/InterpreterShowProcesslistQuery.cpp
+++ b/src/Interpreters/InterpreterShowProcesslistQuery.cpp
@@ -12,7 +12,7 @@ namespace DB
 
 BlockIO InterpreterShowProcesslistQuery::execute()
 {
-    return executeQuery("SELECT * FROM system.processes", context, true);
+    return executeQuery("SELECT * FROM system.processes", getContext(), true);
 }
 
 }
diff --git a/src/Interpreters/InterpreterShowProcesslistQuery.h b/src/Interpreters/InterpreterShowProcesslistQuery.h
index fa0bbf075bd..5eedb67595e 100644
--- a/src/Interpreters/InterpreterShowProcesslistQuery.h
+++ b/src/Interpreters/InterpreterShowProcesslistQuery.h
@@ -7,16 +7,13 @@
 namespace DB
 {
 
-class Context;
-
-
 /** Return list of currently executing queries.
   */
-class InterpreterShowProcesslistQuery : public IInterpreter
+class InterpreterShowProcesslistQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterShowProcesslistQuery(const ASTPtr & query_ptr_, Context & context_)
-        : query_ptr(query_ptr_), context(context_) {}
+    InterpreterShowProcesslistQuery(const ASTPtr & query_ptr_, ContextPtr context_)
+        : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
@@ -27,8 +24,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    Context & context;
 };
 
-
 }
diff --git a/src/Interpreters/InterpreterShowTablesQuery.cpp b/src/Interpreters/InterpreterShowTablesQuery.cpp
index 49c55fa3a93..901999f004f 100644
--- a/src/Interpreters/InterpreterShowTablesQuery.cpp
+++ b/src/Interpreters/InterpreterShowTablesQuery.cpp
@@ -18,8 +18,8 @@ namespace ErrorCodes
 }
 
 
-InterpreterShowTablesQuery::InterpreterShowTablesQuery(const ASTPtr & query_ptr_, Context & context_)
-    : query_ptr(query_ptr_), context(context_)
+InterpreterShowTablesQuery::InterpreterShowTablesQuery(const ASTPtr & query_ptr_, ContextPtr context_)
+    : WithContext(context_), query_ptr(query_ptr_)
 {
 }
 
@@ -102,7 +102,7 @@ String InterpreterShowTablesQuery::getRewrittenQuery()
     if (query.temporary && !query.from.empty())
         throw Exception("The `FROM` and `TEMPORARY` cannot be used together in `SHOW TABLES`", ErrorCodes::SYNTAX_ERROR);
 
-    String database = context.resolveDatabase(query.from);
+    String database = getContext()->resolveDatabase(query.from);
     DatabaseCatalog::instance().assertDatabaseExists(database);
 
     WriteBufferFromOwnString rewritten_query;
@@ -142,7 +142,7 @@ String InterpreterShowTablesQuery::getRewrittenQuery()
 
 BlockIO InterpreterShowTablesQuery::execute()
 {
-    return executeQuery(getRewrittenQuery(), context, true);
+    return executeQuery(getRewrittenQuery(), getContext(), true);
 }
 
 
diff --git a/src/Interpreters/InterpreterShowTablesQuery.h b/src/Interpreters/InterpreterShowTablesQuery.h
index 4f720e68622..b61be568e35 100644
--- a/src/Interpreters/InterpreterShowTablesQuery.h
+++ b/src/Interpreters/InterpreterShowTablesQuery.h
@@ -13,10 +13,10 @@ class Context;
 /** Return a list of tables or databases meets specified conditions.
   * Interprets a query through replacing it to SELECT query from system.tables or system.databases.
   */
-class InterpreterShowTablesQuery : public IInterpreter
+class InterpreterShowTablesQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterShowTablesQuery(const ASTPtr & query_ptr_, Context & context_);
+    InterpreterShowTablesQuery(const ASTPtr & query_ptr_, ContextPtr context_);
 
     BlockIO execute() override;
 
@@ -27,7 +27,6 @@ public:
 
 private:
     ASTPtr query_ptr;
-    Context & context;
 
     String getRewrittenQuery();
 };
diff --git a/src/Interpreters/InterpreterSystemQuery.cpp b/src/Interpreters/InterpreterSystemQuery.cpp
index 67576836d52..c13b9d97037 100644
--- a/src/Interpreters/InterpreterSystemQuery.cpp
+++ b/src/Interpreters/InterpreterSystemQuery.cpp
@@ -134,7 +134,7 @@ AccessType getRequiredAccessType(StorageActionBlockType action_type)
 /// Implements SYSTEM [START|STOP] <something action from ActionLocks>
 void InterpreterSystemQuery::startStopAction(StorageActionBlockType action_type, bool start)
 {
-    auto manager = context.getActionLocksManager();
+    auto manager = getContext()->getActionLocksManager();
     manager->cleanExpired();
 
     if (volume_ptr && action_type == ActionLocks::PartsMerge)
@@ -143,7 +143,7 @@ void InterpreterSystemQuery::startStopAction(StorageActionBlockType action_type,
     }
     else if (table_id)
     {
-        auto table = DatabaseCatalog::instance().tryGetTable(table_id, context);
+        auto table = DatabaseCatalog::instance().tryGetTable(table_id, getContext());
         if (table)
         {
             if (start)
@@ -157,10 +157,10 @@ void InterpreterSystemQuery::startStopAction(StorageActionBlockType action_type,
     }
     else
     {
-        auto access = context.getAccess();
+        auto access = getContext()->getAccess();
         for (auto & elem : DatabaseCatalog::instance().getDatabases())
         {
-            for (auto iterator = elem.second->getTablesIterator(context); iterator->isValid(); iterator->next())
+            for (auto iterator = elem.second->getTablesIterator(getContext()); iterator->isValid(); iterator->next())
             {
                 StoragePtr table = iterator->table();
                 if (!table)
@@ -190,8 +190,8 @@ void InterpreterSystemQuery::startStopAction(StorageActionBlockType action_type,
 }
 
 
-InterpreterSystemQuery::InterpreterSystemQuery(const ASTPtr & query_ptr_, Context & context_)
-        : query_ptr(query_ptr_->clone()), context(context_), log(&Poco::Logger::get("InterpreterSystemQuery"))
+InterpreterSystemQuery::InterpreterSystemQuery(const ASTPtr & query_ptr_, ContextPtr context_)
+        : WithContext(context_), query_ptr(query_ptr_->clone()), log(&Poco::Logger::get("InterpreterSystemQuery"))
 {
 }
 
@@ -201,37 +201,37 @@ BlockIO InterpreterSystemQuery::execute()
     auto & query = query_ptr->as<ASTSystemQuery &>();
 
     if (!query.cluster.empty())
-        return executeDDLQueryOnCluster(query_ptr, context, getRequiredAccessForDDLOnCluster());
+        return executeDDLQueryOnCluster(query_ptr, getContext(), getRequiredAccessForDDLOnCluster());
 
     using Type = ASTSystemQuery::Type;
 
     /// Use global context with fresh system profile settings
-    Context system_context = context.getGlobalContext();
-    system_context.setSetting("profile", context.getSystemProfileName());
+    auto system_context = Context::createCopy(getContext()->getGlobalContext());
+    system_context->setSetting("profile", getContext()->getSystemProfileName());
 
     /// Make canonical query for simpler processing
     if (!query.table.empty())
-        table_id = context.resolveStorageID(StorageID(query.database, query.table), Context::ResolveOrdinary);
+        table_id = getContext()->resolveStorageID(StorageID(query.database, query.table), Context::ResolveOrdinary);
 
     if (!query.target_dictionary.empty() && !query.database.empty())
         query.target_dictionary = query.database + "." + query.target_dictionary;
 
     volume_ptr = {};
     if (!query.storage_policy.empty() && !query.volume.empty())
-        volume_ptr = context.getStoragePolicy(query.storage_policy)->getVolumeByName(query.volume);
+        volume_ptr = getContext()->getStoragePolicy(query.storage_policy)->getVolumeByName(query.volume);
 
     switch (query.type)
     {
         case Type::SHUTDOWN:
         {
-            context.checkAccess(AccessType::SYSTEM_SHUTDOWN);
+            getContext()->checkAccess(AccessType::SYSTEM_SHUTDOWN);
             if (kill(0, SIGTERM))
                 throwFromErrno("System call kill(0, SIGTERM) failed", ErrorCodes::CANNOT_KILL);
             break;
         }
         case Type::KILL:
         {
-            context.checkAccess(AccessType::SYSTEM_SHUTDOWN);
+            getContext()->checkAccess(AccessType::SYSTEM_SHUTDOWN);
             /// Exit with the same code as it is usually set by shell when process is terminated by SIGKILL.
             /// It's better than doing 'raise' or 'kill', because they have no effect for 'init' process (with pid = 0, usually in Docker).
             LOG_INFO(log, "Exit immediately as the SYSTEM KILL command has been issued.");
@@ -254,63 +254,63 @@ BlockIO InterpreterSystemQuery::execute()
         }
         case Type::DROP_DNS_CACHE:
         {
-            context.checkAccess(AccessType::SYSTEM_DROP_DNS_CACHE);
+            getContext()->checkAccess(AccessType::SYSTEM_DROP_DNS_CACHE);
             DNSResolver::instance().dropCache();
             /// Reinitialize clusters to update their resolved_addresses
-            system_context.reloadClusterConfig();
+            system_context->reloadClusterConfig();
             break;
         }
         case Type::DROP_MARK_CACHE:
-            context.checkAccess(AccessType::SYSTEM_DROP_MARK_CACHE);
-            system_context.dropMarkCache();
+            getContext()->checkAccess(AccessType::SYSTEM_DROP_MARK_CACHE);
+            system_context->dropMarkCache();
             break;
         case Type::DROP_UNCOMPRESSED_CACHE:
-            context.checkAccess(AccessType::SYSTEM_DROP_UNCOMPRESSED_CACHE);
-            system_context.dropUncompressedCache();
+            getContext()->checkAccess(AccessType::SYSTEM_DROP_UNCOMPRESSED_CACHE);
+            system_context->dropUncompressedCache();
             break;
         case Type::DROP_MMAP_CACHE:
-            context.checkAccess(AccessType::SYSTEM_DROP_MMAP_CACHE);
-            system_context.dropMMappedFileCache();
+            getContext()->checkAccess(AccessType::SYSTEM_DROP_MMAP_CACHE);
+            system_context->dropMMappedFileCache();
             break;
 #if USE_EMBEDDED_COMPILER
         case Type::DROP_COMPILED_EXPRESSION_CACHE:
-            context.checkAccess(AccessType::SYSTEM_DROP_COMPILED_EXPRESSION_CACHE);
+            getContext()->checkAccess(AccessType::SYSTEM_DROP_COMPILED_EXPRESSION_CACHE);
             if (auto * cache = CompiledExpressionCacheFactory::instance().tryGetCache())
                 cache->reset();
             break;
 #endif
         case Type::RELOAD_DICTIONARY:
         {
-            context.checkAccess(AccessType::SYSTEM_RELOAD_DICTIONARY);
+            getContext()->checkAccess(AccessType::SYSTEM_RELOAD_DICTIONARY);
 
-            auto & external_dictionaries_loader = system_context.getExternalDictionariesLoader();
-            external_dictionaries_loader.reloadDictionary(query.target_dictionary, context);
+            auto & external_dictionaries_loader = system_context->getExternalDictionariesLoader();
+            external_dictionaries_loader.reloadDictionary(query.target_dictionary, getContext());
 
             ExternalDictionariesLoader::resetAll();
             break;
         }
         case Type::RELOAD_DICTIONARIES:
         {
-            context.checkAccess(AccessType::SYSTEM_RELOAD_DICTIONARY);
+            getContext()->checkAccess(AccessType::SYSTEM_RELOAD_DICTIONARY);
             executeCommandsAndThrowIfError(
-                    [&] () { system_context.getExternalDictionariesLoader().reloadAllTriedToLoad(); },
-                    [&] () { system_context.getEmbeddedDictionaries().reload(); }
+                    [&] () { system_context->getExternalDictionariesLoader().reloadAllTriedToLoad(); },
+                    [&] () { system_context->getEmbeddedDictionaries().reload(); }
             );
             ExternalDictionariesLoader::resetAll();
             break;
         }
         case Type::RELOAD_EMBEDDED_DICTIONARIES:
-            context.checkAccess(AccessType::SYSTEM_RELOAD_EMBEDDED_DICTIONARIES);
-            system_context.getEmbeddedDictionaries().reload();
+            getContext()->checkAccess(AccessType::SYSTEM_RELOAD_EMBEDDED_DICTIONARIES);
+            system_context->getEmbeddedDictionaries().reload();
             break;
         case Type::RELOAD_CONFIG:
-            context.checkAccess(AccessType::SYSTEM_RELOAD_CONFIG);
-            system_context.reloadConfig();
+            getContext()->checkAccess(AccessType::SYSTEM_RELOAD_CONFIG);
+            system_context->reloadConfig();
             break;
         case Type::RELOAD_SYMBOLS:
         {
 #if defined(__ELF__) && !defined(__FreeBSD__)
-            context.checkAccess(AccessType::SYSTEM_RELOAD_SYMBOLS);
+            getContext()->checkAccess(AccessType::SYSTEM_RELOAD_SYMBOLS);
             (void)SymbolIndex::instance(true);
             break;
 #else
@@ -378,16 +378,16 @@ BlockIO InterpreterSystemQuery::execute()
             break;
         case Type::FLUSH_LOGS:
         {
-            context.checkAccess(AccessType::SYSTEM_FLUSH_LOGS);
+            getContext()->checkAccess(AccessType::SYSTEM_FLUSH_LOGS);
             executeCommandsAndThrowIfError(
-                    [&] () { if (auto query_log = context.getQueryLog()) query_log->flush(true); },
-                    [&] () { if (auto part_log = context.getPartLog("")) part_log->flush(true); },
-                    [&] () { if (auto query_thread_log = context.getQueryThreadLog()) query_thread_log->flush(true); },
-                    [&] () { if (auto trace_log = context.getTraceLog()) trace_log->flush(true); },
-                    [&] () { if (auto text_log = context.getTextLog()) text_log->flush(true); },
-                    [&] () { if (auto metric_log = context.getMetricLog()) metric_log->flush(true); },
-                    [&] () { if (auto asynchronous_metric_log = context.getAsynchronousMetricLog()) asynchronous_metric_log->flush(true); },
-                    [&] () { if (auto opentelemetry_span_log = context.getOpenTelemetrySpanLog()) opentelemetry_span_log->flush(true); }
+                    [&] () { if (auto query_log = getContext()->getQueryLog()) query_log->flush(true); },
+                    [&] () { if (auto part_log = getContext()->getPartLog("")) part_log->flush(true); },
+                    [&] () { if (auto query_thread_log = getContext()->getQueryThreadLog()) query_thread_log->flush(true); },
+                    [&] () { if (auto trace_log = getContext()->getTraceLog()) trace_log->flush(true); },
+                    [&] () { if (auto text_log = getContext()->getTextLog()) text_log->flush(true); },
+                    [&] () { if (auto metric_log = getContext()->getMetricLog()) metric_log->flush(true); },
+                    [&] () { if (auto asynchronous_metric_log = getContext()->getAsynchronousMetricLog()) asynchronous_metric_log->flush(true); },
+                    [&] () { if (auto opentelemetry_span_log = getContext()->getOpenTelemetrySpanLog()) opentelemetry_span_log->flush(true); }
             );
             break;
         }
@@ -402,12 +402,12 @@ BlockIO InterpreterSystemQuery::execute()
 }
 
 
-StoragePtr InterpreterSystemQuery::tryRestartReplica(const StorageID & replica, Context & system_context, bool need_ddl_guard)
+StoragePtr InterpreterSystemQuery::tryRestartReplica(const StorageID & replica, ContextPtr system_context, bool need_ddl_guard)
 {
-    context.checkAccess(AccessType::SYSTEM_RESTART_REPLICA, replica);
+    getContext()->checkAccess(AccessType::SYSTEM_RESTART_REPLICA, replica);
 
     auto table_ddl_guard = need_ddl_guard ? DatabaseCatalog::instance().getDDLGuard(replica.getDatabaseName(), replica.getTableName()) : nullptr;
-    auto [database, table] = DatabaseCatalog::instance().tryGetDatabaseAndTable(replica, context);
+    auto [database, table] = DatabaseCatalog::instance().tryGetDatabaseAndTable(replica, getContext());
     ASTPtr create_ast;
 
     /// Detach actions
@@ -417,8 +417,8 @@ StoragePtr InterpreterSystemQuery::tryRestartReplica(const StorageID & replica,
     table->shutdown();
     {
         /// If table was already dropped by anyone, an exception will be thrown
-        auto table_lock = table->lockExclusively(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
-        create_ast = database->getCreateTableQuery(replica.table_name, context);
+        auto table_lock = table->lockExclusively(getContext()->getCurrentQueryId(), getContext()->getSettingsRef().lock_acquire_timeout);
+        create_ast = database->getCreateTableQuery(replica.table_name, getContext());
 
         database->detachTable(replica.table_name);
     }
@@ -436,7 +436,7 @@ StoragePtr InterpreterSystemQuery::tryRestartReplica(const StorageID & replica,
     table = StorageFactory::instance().get(create,
         data_path,
         system_context,
-        system_context.getGlobalContext(),
+        system_context->getGlobalContext(),
         columns,
         constraints,
         false);
@@ -447,7 +447,7 @@ StoragePtr InterpreterSystemQuery::tryRestartReplica(const StorageID & replica,
     return table;
 }
 
-void InterpreterSystemQuery::restartReplicas(Context & system_context)
+void InterpreterSystemQuery::restartReplicas(ContextPtr system_context)
 {
     std::vector<StorageID> replica_names;
     auto & catalog = DatabaseCatalog::instance();
@@ -455,7 +455,7 @@ void InterpreterSystemQuery::restartReplicas(Context & system_context)
     for (auto & elem : catalog.getDatabases())
     {
         DatabasePtr & database = elem.second;
-        for (auto iterator = database->getTablesIterator(context); iterator->isValid(); iterator->next())
+        for (auto iterator = database->getTablesIterator(getContext()); iterator->isValid(); iterator->next())
         {
             if (auto table = iterator->table())
             {
@@ -490,43 +490,43 @@ void InterpreterSystemQuery::dropReplica(ASTSystemQuery & query)
 
     if (!table_id.empty())
     {
-        context.checkAccess(AccessType::SYSTEM_DROP_REPLICA, table_id);
-        StoragePtr table = DatabaseCatalog::instance().getTable(table_id, context);
+        getContext()->checkAccess(AccessType::SYSTEM_DROP_REPLICA, table_id);
+        StoragePtr table = DatabaseCatalog::instance().getTable(table_id, getContext());
 
         if (!dropReplicaImpl(query, table))
             throw Exception("Table " + table_id.getNameForLogs() + " is not replicated", ErrorCodes::BAD_ARGUMENTS);
     }
     else if (!query.database.empty())
     {
-        context.checkAccess(AccessType::SYSTEM_DROP_REPLICA, query.database);
+        getContext()->checkAccess(AccessType::SYSTEM_DROP_REPLICA, query.database);
         DatabasePtr database = DatabaseCatalog::instance().getDatabase(query.database);
-        for (auto iterator = database->getTablesIterator(context); iterator->isValid(); iterator->next())
+        for (auto iterator = database->getTablesIterator(getContext()); iterator->isValid(); iterator->next())
             dropReplicaImpl(query, iterator->table());
         LOG_TRACE(log, "Dropped replica {} from database {}", query.replica, backQuoteIfNeed(database->getDatabaseName()));
     }
     else if (query.is_drop_whole_replica)
     {
-        context.checkAccess(AccessType::SYSTEM_DROP_REPLICA);
+        getContext()->checkAccess(AccessType::SYSTEM_DROP_REPLICA);
         auto databases = DatabaseCatalog::instance().getDatabases();
 
         for (auto & elem : databases)
         {
             DatabasePtr & database = elem.second;
-            for (auto iterator = database->getTablesIterator(context); iterator->isValid(); iterator->next())
+            for (auto iterator = database->getTablesIterator(getContext()); iterator->isValid(); iterator->next())
                 dropReplicaImpl(query, iterator->table());
             LOG_TRACE(log, "Dropped replica {} from database {}", query.replica, backQuoteIfNeed(database->getDatabaseName()));
         }
     }
     else if (!query.replica_zk_path.empty())
     {
-        context.checkAccess(AccessType::SYSTEM_DROP_REPLICA);
+        getContext()->checkAccess(AccessType::SYSTEM_DROP_REPLICA);
         auto remote_replica_path = query.replica_zk_path  + "/replicas/" + query.replica;
 
         /// This check is actually redundant, but it may prevent from some user mistakes
         for (auto & elem : DatabaseCatalog::instance().getDatabases())
         {
             DatabasePtr & database = elem.second;
-            for (auto iterator = database->getTablesIterator(context); iterator->isValid(); iterator->next())
+            for (auto iterator = database->getTablesIterator(getContext()); iterator->isValid(); iterator->next())
             {
                 if (auto * storage_replicated = dynamic_cast<StorageReplicatedMergeTree *>(iterator->table().get()))
                 {
@@ -541,7 +541,7 @@ void InterpreterSystemQuery::dropReplica(ASTSystemQuery & query)
             }
         }
 
-        auto zookeeper = context.getZooKeeper();
+        auto zookeeper = getContext()->getZooKeeper();
 
         bool looks_like_table_path = zookeeper->exists(query.replica_zk_path + "/replicas") ||
                                      zookeeper->exists(query.replica_zk_path + "/dropped");
@@ -567,7 +567,7 @@ bool InterpreterSystemQuery::dropReplicaImpl(ASTSystemQuery & query, const Stora
         return false;
 
     StorageReplicatedMergeTree::Status status;
-    auto zookeeper = context.getZooKeeper();
+    auto zookeeper = getContext()->getZooKeeper();
     storage_replicated->getStatus(status);
 
     /// Do not allow to drop local replicas and active remote replicas
@@ -590,13 +590,13 @@ bool InterpreterSystemQuery::dropReplicaImpl(ASTSystemQuery & query, const Stora
 
 void InterpreterSystemQuery::syncReplica(ASTSystemQuery &)
 {
-    context.checkAccess(AccessType::SYSTEM_SYNC_REPLICA, table_id);
-    StoragePtr table = DatabaseCatalog::instance().getTable(table_id, context);
+    getContext()->checkAccess(AccessType::SYSTEM_SYNC_REPLICA, table_id);
+    StoragePtr table = DatabaseCatalog::instance().getTable(table_id, getContext());
 
     if (auto * storage_replicated = dynamic_cast<StorageReplicatedMergeTree *>(table.get()))
     {
         LOG_TRACE(log, "Synchronizing entries in replica's queue with table's log and waiting for it to become empty");
-        if (!storage_replicated->waitForShrinkingQueueSize(0, context.getSettingsRef().receive_timeout.totalMilliseconds()))
+        if (!storage_replicated->waitForShrinkingQueueSize(0, getContext()->getSettingsRef().receive_timeout.totalMilliseconds()))
         {
             LOG_ERROR(log, "SYNC REPLICA {}: Timed out!", table_id.getNameForLogs());
             throw Exception(
@@ -611,10 +611,10 @@ void InterpreterSystemQuery::syncReplica(ASTSystemQuery &)
 
 void InterpreterSystemQuery::flushDistributed(ASTSystemQuery &)
 {
-    context.checkAccess(AccessType::SYSTEM_FLUSH_DISTRIBUTED, table_id);
+    getContext()->checkAccess(AccessType::SYSTEM_FLUSH_DISTRIBUTED, table_id);
 
-    if (auto * storage_distributed = dynamic_cast<StorageDistributed *>(DatabaseCatalog::instance().getTable(table_id, context).get()))
-        storage_distributed->flushClusterNodesAllData(context);
+    if (auto * storage_distributed = dynamic_cast<StorageDistributed *>(DatabaseCatalog::instance().getTable(table_id, getContext()).get()))
+        storage_distributed->flushClusterNodesAllData(getContext());
     else
         throw Exception("Table " + table_id.getNameForLogs() + " is not distributed", ErrorCodes::BAD_ARGUMENTS);
 }
@@ -763,7 +763,7 @@ AccessRightsElements InterpreterSystemQuery::getRequiredAccessForDDLOnCluster()
     return required_access;
 }
 
-void InterpreterSystemQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & /*ast*/, const Context &) const
+void InterpreterSystemQuery::extendQueryLogElemImpl(QueryLogElement & elem, const ASTPtr & /*ast*/, ContextPtr) const
 {
     elem.query_kind = "System";
 }
diff --git a/src/Interpreters/InterpreterSystemQuery.h b/src/Interpreters/InterpreterSystemQuery.h
index 39f8bf69a6e..d9f9e6c5d96 100644
--- a/src/Interpreters/InterpreterSystemQuery.h
+++ b/src/Interpreters/InterpreterSystemQuery.h
@@ -30,25 +30,24 @@ class ASTSystemQuery;
   * - start/stop actions for all existing tables.
   * Note that the actions for tables that will be created after this query will not be affected.
   */
-class InterpreterSystemQuery : public IInterpreter
+class InterpreterSystemQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterSystemQuery(const ASTPtr & query_ptr_, Context & context_);
+    InterpreterSystemQuery(const ASTPtr & query_ptr_, ContextPtr context_);
 
     BlockIO execute() override;
 
 private:
     ASTPtr query_ptr;
-    Context & context;
     Poco::Logger * log = nullptr;
     StorageID table_id = StorageID::createEmpty();      /// Will be set up if query contains table name
     VolumePtr volume_ptr;
 
     /// Tries to get a replicated table and restart it
     /// Returns pointer to a newly created table if the restart was successful
-    StoragePtr tryRestartReplica(const StorageID & replica, Context & context, bool need_ddl_guard = true);
+    StoragePtr tryRestartReplica(const StorageID & replica, ContextPtr context, bool need_ddl_guard = true);
 
-    void restartReplicas(Context & system_context);
+    void restartReplicas(ContextPtr system_context);
     void syncReplica(ASTSystemQuery & query);
     void dropReplica(ASTSystemQuery & query);
     bool dropReplicaImpl(ASTSystemQuery & query, const StoragePtr & table);
@@ -57,7 +56,7 @@ private:
     AccessRightsElements getRequiredAccessForDDLOnCluster() const;
     void startStopAction(StorageActionBlockType action_type, bool start);
 
-    void extendQueryLogElemImpl(QueryLogElement &, const ASTPtr &, const Context &) const override;
+    void extendQueryLogElemImpl(QueryLogElement &, const ASTPtr &, ContextPtr) const override;
 };
 
 
diff --git a/src/Interpreters/InterpreterUseQuery.cpp b/src/Interpreters/InterpreterUseQuery.cpp
index 58f5b6c9a32..626d2f499c7 100644
--- a/src/Interpreters/InterpreterUseQuery.cpp
+++ b/src/Interpreters/InterpreterUseQuery.cpp
@@ -11,8 +11,8 @@ namespace DB
 BlockIO InterpreterUseQuery::execute()
 {
     const String & new_database = query_ptr->as<ASTUseQuery &>().database;
-    context.checkAccess(AccessType::SHOW_DATABASES, new_database);
-    context.getSessionContext().setCurrentDatabase(new_database);
+    getContext()->checkAccess(AccessType::SHOW_DATABASES, new_database);
+    getContext()->getSessionContext()->setCurrentDatabase(new_database);
     return {};
 }
 
diff --git a/src/Interpreters/InterpreterUseQuery.h b/src/Interpreters/InterpreterUseQuery.h
index ae409117afd..d1ce57dc64a 100644
--- a/src/Interpreters/InterpreterUseQuery.h
+++ b/src/Interpreters/InterpreterUseQuery.h
@@ -7,23 +7,17 @@
 namespace DB
 {
 
-class Context;
-
-
 /** Change default database for session.
   */
-class InterpreterUseQuery : public IInterpreter
+class InterpreterUseQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterUseQuery(const ASTPtr & query_ptr_, Context & context_)
-        : query_ptr(query_ptr_), context(context_) {}
+    InterpreterUseQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
 private:
     ASTPtr query_ptr;
-    Context & context;
 };
 
-
 }
diff --git a/src/Interpreters/InterpreterWatchQuery.cpp b/src/Interpreters/InterpreterWatchQuery.cpp
index 757a2d1738b..84959f2f624 100644
--- a/src/Interpreters/InterpreterWatchQuery.cpp
+++ b/src/Interpreters/InterpreterWatchQuery.cpp
@@ -32,15 +32,15 @@ namespace ErrorCodes
 
 BlockIO InterpreterWatchQuery::execute()
 {
-    if (!context.getSettingsRef().allow_experimental_live_view)
+    if (!getContext()->getSettingsRef().allow_experimental_live_view)
         throw Exception("Experimental LIVE VIEW feature is not enabled (the setting 'allow_experimental_live_view')", ErrorCodes::SUPPORT_IS_DISABLED);
 
     BlockIO res;
     const ASTWatchQuery & query = typeid_cast<const ASTWatchQuery &>(*query_ptr);
-    auto table_id = context.resolveStorageID(query, Context::ResolveOrdinary);
+    auto table_id = getContext()->resolveStorageID(query, Context::ResolveOrdinary);
 
     /// Get storage
-    storage = DatabaseCatalog::instance().tryGetTable(table_id, context);
+    storage = DatabaseCatalog::instance().tryGetTable(table_id, getContext());
 
     if (!storage)
         throw Exception("Table " + table_id.getNameForLogs() + " doesn't exist.",
@@ -48,10 +48,10 @@ BlockIO InterpreterWatchQuery::execute()
 
     /// List of columns to read to execute the query.
     Names required_columns = storage->getInMemoryMetadataPtr()->getColumns().getNamesOfPhysical();
-    context.checkAccess(AccessType::SELECT, table_id, required_columns);
+    getContext()->checkAccess(AccessType::SELECT, table_id, required_columns);
 
     /// Get context settings for this query
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = getContext()->getSettingsRef();
 
     /// Limitation on the number of columns to read.
     if (settings.max_columns_to_read && required_columns.size() > settings.max_columns_to_read)
@@ -71,7 +71,7 @@ BlockIO InterpreterWatchQuery::execute()
     QueryProcessingStage::Enum from_stage = QueryProcessingStage::FetchColumns;
 
     /// Watch storage
-    streams = storage->watch(required_columns, query_info, context, from_stage, max_block_size, max_streams);
+    streams = storage->watch(required_columns, query_info, getContext(), from_stage, max_block_size, max_streams);
 
     /// Constraints on the result, the quota on the result, and also callback for progress.
     if (IBlockInputStream * stream = dynamic_cast<IBlockInputStream *>(streams[0].get()))
@@ -83,7 +83,7 @@ BlockIO InterpreterWatchQuery::execute()
         limits.size_limits.overflow_mode = settings.result_overflow_mode;
 
         stream->setLimits(limits);
-        stream->setQuota(context.getQuota());
+        stream->setQuota(getContext()->getQuota());
     }
 
     res.in = streams[0];
diff --git a/src/Interpreters/InterpreterWatchQuery.h b/src/Interpreters/InterpreterWatchQuery.h
index c4aa5b9ca99..45b61a18b66 100644
--- a/src/Interpreters/InterpreterWatchQuery.h
+++ b/src/Interpreters/InterpreterWatchQuery.h
@@ -14,30 +14,27 @@ limitations under the License. */
 #include <Core/QueryProcessingStage.h>
 #include <DataStreams/BlockIO.h>
 #include <DataStreams/IBlockInputStream.h>
-#include <Parsers/IAST_fwd.h>
 #include <Interpreters/IInterpreter.h>
-#include <Storages/SelectQueryInfo.h>
+#include <Parsers/IAST_fwd.h>
 #include <Storages/IStorage.h>
+#include <Storages/SelectQueryInfo.h>
 
 namespace DB
 {
 
-class Context;
 class IAST;
 using ASTPtr = std::shared_ptr<IAST>;
 using StoragePtr = std::shared_ptr<IStorage>;
 
-class InterpreterWatchQuery : public IInterpreter
+class InterpreterWatchQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterWatchQuery(const ASTPtr & query_ptr_, const Context & context_)
-        : query_ptr(query_ptr_), context(context_) {}
+    InterpreterWatchQuery(const ASTPtr & query_ptr_, ContextPtr context_) : WithContext(context_), query_ptr(query_ptr_) {}
 
     BlockIO execute() override;
 
 private:
     ASTPtr query_ptr;
-    const Context & context;
 
     /// Table from where to read data, if not subquery.
     StoragePtr storage;
@@ -45,5 +42,4 @@ private:
     BlockInputStreams streams;
 };
 
-
 }
diff --git a/src/Interpreters/InterserverCredentials.cpp b/src/Interpreters/InterserverCredentials.cpp
new file mode 100644
index 00000000000..e60d397eb02
--- /dev/null
+++ b/src/Interpreters/InterserverCredentials.cpp
@@ -0,0 +1,87 @@
+#include <Interpreters/InterserverCredentials.h>
+#include <common/logger_useful.h>
+#include <Common/StringUtils/StringUtils.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int NO_ELEMENTS_IN_CONFIG;
+}
+
+std::unique_ptr<InterserverCredentials>
+InterserverCredentials::make(const Poco::Util::AbstractConfiguration & config, const std::string & root_tag)
+{
+    if (config.has("user") && !config.has("password"))
+        throw Exception("Configuration parameter interserver_http_credentials.password can't be empty", ErrorCodes::NO_ELEMENTS_IN_CONFIG);
+
+    if (!config.has("user") && config.has("password"))
+        throw Exception("Configuration parameter interserver_http_credentials.user can't be empty if user specified", ErrorCodes::NO_ELEMENTS_IN_CONFIG);
+
+    /// They both can be empty
+    auto user = config.getString(root_tag + ".user", "");
+    auto password = config.getString(root_tag + ".password", "");
+
+    auto store = parseCredentialsFromConfig(user, password, config, root_tag);
+
+    return std::make_unique<InterserverCredentials>(user, password, store);
+}
+
+InterserverCredentials::CurrentCredentials InterserverCredentials::parseCredentialsFromConfig(
+    const std::string & current_user_,
+    const std::string & current_password_,
+    const Poco::Util::AbstractConfiguration & config,
+    const std::string & root_tag)
+{
+    auto * log = &Poco::Logger::get("InterserverCredentials");
+    CurrentCredentials store;
+    store.emplace_back(current_user_, current_password_);
+    if (config.getBool(root_tag + ".allow_empty", false))
+    {
+        LOG_DEBUG(log, "Allowing empty credentials");
+        /// Allow empty credential to support migrating from no auth
+        store.emplace_back("", "");
+    }
+
+    Poco::Util::AbstractConfiguration::Keys old_users;
+    config.keys(root_tag, old_users);
+
+    for (const auto & user_key : old_users)
+    {
+        if (startsWith(user_key, "old"))
+        {
+            std::string full_prefix = root_tag + "." + user_key;
+            std::string old_user_name = config.getString(full_prefix + ".user");
+            LOG_DEBUG(log, "Adding credentials for old user {}", old_user_name);
+
+            std::string old_user_password =  config.getString(full_prefix + ".password");
+
+            store.emplace_back(old_user_name, old_user_password);
+        }
+    }
+
+    return store;
+}
+
+InterserverCredentials::CheckResult InterserverCredentials::isValidUser(const UserWithPassword & credentials) const
+{
+    auto itr = std::find(all_users_store.begin(), all_users_store.end(), credentials);
+
+    if (itr == all_users_store.end())
+    {
+        if (credentials.first.empty())
+            return {"Server requires HTTP Basic authentication, but client doesn't provide it", false};
+
+        return {"Incorrect user or password in HTTP basic authentication: " + credentials.first, false};
+    }
+
+    return {"", true};
+}
+
+InterserverCredentials::CheckResult InterserverCredentials::isValidUser(const std::string & user, const std::string & password) const
+{
+    return isValidUser(std::make_pair(user, password));
+}
+
+}
diff --git a/src/Interpreters/InterserverCredentials.h b/src/Interpreters/InterserverCredentials.h
new file mode 100644
index 00000000000..ffe568868dd
--- /dev/null
+++ b/src/Interpreters/InterserverCredentials.h
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <Poco/Util/AbstractConfiguration.h>
+#include <Common/Exception.h>
+#include <common/logger_useful.h>
+#include <unordered_set>
+
+namespace DB
+{
+
+/// InterserverCredentials implements authentication using a CurrentCredentials, which
+/// is configured, e.g.
+///    <interserver_http_credentials>
+///        <user>admin</user>
+///        <password>222</password>
+///        <!-- To support mix of un/authenticated clients -->
+///        <!-- <allow_empty>true</allow_empty> -->
+///        <old>
+///            <!-- Allow authentication using previous passwords during rotation -->
+///            <user>admin</user>
+///            <password>qqq</password>
+///        </old>
+///        <old>
+///            <!-- Allow authentication using previous users during rotation -->
+///            <user>johny</user>
+///            <password>333</password>
+///        </old>
+///    </interserver_http_credentials>
+class InterserverCredentials
+{
+public:
+    using UserWithPassword = std::pair<std::string, std::string>;
+    using CheckResult = std::pair<std::string, bool>;
+    using CurrentCredentials = std::vector<UserWithPassword>;
+
+    InterserverCredentials(const InterserverCredentials &) = delete;
+
+    static std::unique_ptr<InterserverCredentials> make(const Poco::Util::AbstractConfiguration & config, const std::string & root_tag);
+
+    InterserverCredentials(const std::string & current_user_, const std::string & current_password_, const CurrentCredentials & all_users_store_)
+        : current_user(current_user_)
+        , current_password(current_password_)
+        , all_users_store(all_users_store_)
+    {}
+
+    CheckResult isValidUser(const UserWithPassword & credentials) const;
+    CheckResult isValidUser(const std::string & user, const std::string & password) const;
+
+    std::string getUser() const { return current_user; }
+
+    std::string getPassword() const { return current_password; }
+
+
+private:
+    std::string current_user;
+    std::string current_password;
+
+    /// In common situation this store contains one record
+    CurrentCredentials all_users_store;
+
+    static CurrentCredentials parseCredentialsFromConfig(
+        const std::string & current_user_,
+        const std::string & current_password_,
+        const Poco::Util::AbstractConfiguration & config,
+        const std::string & root_tag);
+};
+
+using InterserverCredentialsPtr = std::shared_ptr<const InterserverCredentials>;
+
+}
diff --git a/src/Interpreters/JoinSwitcher.h b/src/Interpreters/JoinSwitcher.h
index 1fd719cd5dc..75ff7bb9b2c 100644
--- a/src/Interpreters/JoinSwitcher.h
+++ b/src/Interpreters/JoinSwitcher.h
@@ -19,6 +19,8 @@ class JoinSwitcher : public IJoin
 public:
     JoinSwitcher(std::shared_ptr<TableJoin> table_join_, const Block & right_sample_block_);
 
+    const TableJoin & getTableJoin() const override { return *table_join; }
+
     /// Add block of data from right hand of JOIN into current join object.
     /// If join-in-memory memory limit exceeded switches to join-on-disk and continue with it.
     /// @returns false, if join-on-disk disk limit exceeded
diff --git a/src/Interpreters/JoinedTables.cpp b/src/Interpreters/JoinedTables.cpp
index 17d7949e478..d947a3e2a48 100644
--- a/src/Interpreters/JoinedTables.cpp
+++ b/src/Interpreters/JoinedTables.cpp
@@ -1,25 +1,24 @@
 #include <Interpreters/JoinedTables.h>
-#include <Interpreters/TableJoin.h>
-#include <Interpreters/getTableExpressions.h>
-#include <Interpreters/InJoinSubqueriesPreprocessor.h>
+
 #include <Interpreters/IdentifierSemantic.h>
 #include <Interpreters/InDepthNodeVisitor.h>
-
-#include <Storages/IStorage.h>
-#include <Storages/ColumnsDescription.h>
-#include <Storages/StorageValues.h>
-#include <Storages/StorageJoin.h>
-#include <Storages/StorageDictionary.h>
-
+#include <Interpreters/InJoinSubqueriesPreprocessor.h>
+#include <Interpreters/TableJoin.h>
+#include <Interpreters/getTableExpressions.h>
 #include <Parsers/ASTFunction.h>
+#include <Parsers/ASTIdentifier.h>
+#include <Parsers/ASTQualifiedAsterisk.h>
 #include <Parsers/ASTSelectQuery.h>
 #include <Parsers/ASTSelectWithUnionQuery.h>
 #include <Parsers/ASTSubquery.h>
 #include <Parsers/ASTTablesInSelectQuery.h>
-#include <Parsers/ASTIdentifier.h>
-#include <Parsers/ASTQualifiedAsterisk.h>
 #include <Parsers/ParserTablesInSelectQuery.h>
 #include <Parsers/parseQuery.h>
+#include <Storages/ColumnsDescription.h>
+#include <Storages/IStorage.h>
+#include <Storages/StorageDictionary.h>
+#include <Storages/StorageJoin.h>
+#include <Storages/StorageValues.h>
 
 namespace DB
 {
@@ -129,7 +128,7 @@ using RenameQualifiedIdentifiersVisitor = InDepthNodeVisitor<RenameQualifiedIden
 
 }
 
-JoinedTables::JoinedTables(Context && context_, const ASTSelectQuery & select_query)
+JoinedTables::JoinedTables(ContextPtr context_, const ASTSelectQuery & select_query)
     : context(context_)
     , table_expressions(getTableExpressions(select_query))
     , left_table_expression(extractTableExpression(select_query, 0))
@@ -159,26 +158,26 @@ StoragePtr JoinedTables::getLeftTableStorage()
         return {};
 
     if (isLeftTableFunction())
-        return context.getQueryContext().executeTableFunction(left_table_expression);
+        return context->getQueryContext()->executeTableFunction(left_table_expression);
 
     StorageID table_id = StorageID::createEmpty();
     if (left_db_and_table)
     {
-        table_id = context.resolveStorageID(StorageID(left_db_and_table->database, left_db_and_table->table, left_db_and_table->uuid));
+        table_id = context->resolveStorageID(StorageID(left_db_and_table->database, left_db_and_table->table, left_db_and_table->uuid));
     }
     else /// If the table is not specified - use the table `system.one`.
     {
         table_id = StorageID("system", "one");
     }
 
-    if (auto view_source = context.getViewSource())
+    if (auto view_source = context->getViewSource())
     {
         const auto & storage_values = static_cast<const StorageValues &>(*view_source);
         auto tmp_table_id = storage_values.getStorageID();
         if (tmp_table_id.database_name == table_id.database_name && tmp_table_id.table_name == table_id.table_name)
         {
             /// Read from view source.
-            return context.getViewSource();
+            return context->getViewSource();
         }
     }
 
@@ -192,7 +191,7 @@ bool JoinedTables::resolveTables()
     if (tables_with_columns.size() != table_expressions.size())
         throw Exception("Unexpected tables count", ErrorCodes::LOGICAL_ERROR);
 
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = context->getSettingsRef();
     if (settings.joined_subquery_requires_alias && tables_with_columns.size() > 1)
     {
         for (size_t i = 0; i < tables_with_columns.size(); ++i)
@@ -234,7 +233,7 @@ void JoinedTables::rewriteDistributedInAndJoins(ASTPtr & query)
 
     String database;
     if (!renamed_tables.empty())
-        database = context.getCurrentDatabase();
+        database = context->getCurrentDatabase();
 
     for (auto & [subquery, ast_tables] : renamed_tables)
     {
@@ -254,8 +253,8 @@ std::shared_ptr<TableJoin> JoinedTables::makeTableJoin(const ASTSelectQuery & se
     if (tables_with_columns.size() < 2)
         return {};
 
-    auto settings = context.getSettingsRef();
-    auto table_join = std::make_shared<TableJoin>(settings, context.getTemporaryVolume());
+    auto settings = context->getSettingsRef();
+    auto table_join = std::make_shared<TableJoin>(settings, context->getTemporaryVolume());
 
     const ASTTablesInSelectQueryElement * ast_join = select_query.join();
     const auto & table_to_join = ast_join->table_expression->as<ASTTableExpression &>();
@@ -263,7 +262,7 @@ std::shared_ptr<TableJoin> JoinedTables::makeTableJoin(const ASTSelectQuery & se
     /// TODO This syntax does not support specifying a database name.
     if (table_to_join.database_and_table_name)
     {
-        auto joined_table_id = context.resolveStorageID(table_to_join.database_and_table_name);
+        auto joined_table_id = context->resolveStorageID(table_to_join.database_and_table_name);
         StoragePtr table = DatabaseCatalog::instance().tryGetTable(joined_table_id, context);
         if (table)
         {
diff --git a/src/Interpreters/JoinedTables.h b/src/Interpreters/JoinedTables.h
index 812808fed61..52eb71e419d 100644
--- a/src/Interpreters/JoinedTables.h
+++ b/src/Interpreters/JoinedTables.h
@@ -22,11 +22,11 @@ using StorageMetadataPtr = std::shared_ptr<const StorageInMemoryMetadata>;
 class JoinedTables
 {
 public:
-    JoinedTables(Context && context, const ASTSelectQuery & select_query);
+    JoinedTables(ContextPtr context, const ASTSelectQuery & select_query);
 
     void reset(const ASTSelectQuery & select_query)
     {
-        *this = JoinedTables(std::move(context), select_query);
+        *this = JoinedTables(Context::createCopy(context), select_query);
     }
 
     StoragePtr getLeftTableStorage();
@@ -48,7 +48,7 @@ public:
     std::unique_ptr<InterpreterSelectWithUnionQuery> makeLeftTableSubquery(const SelectQueryOptions & select_options);
 
 private:
-    Context context;
+    ContextPtr context;
     std::vector<const ASTTableExpression *> table_expressions;
     TablesWithColumns tables_with_columns;
 
diff --git a/src/Interpreters/MergeJoin.h b/src/Interpreters/MergeJoin.h
index d145a69ce9d..f286e74b385 100644
--- a/src/Interpreters/MergeJoin.h
+++ b/src/Interpreters/MergeJoin.h
@@ -23,6 +23,7 @@ class MergeJoin : public IJoin
 public:
     MergeJoin(std::shared_ptr<TableJoin> table_join_, const Block & right_sample_block);
 
+    const TableJoin & getTableJoin() const override { return *table_join; }
     bool addJoinedBlock(const Block & block, bool check_limits) override;
     void joinBlock(Block &, ExtraBlockPtr & not_processed) override;
     void joinTotals(Block &) const override;
diff --git a/src/Interpreters/MonotonicityCheckVisitor.h b/src/Interpreters/MonotonicityCheckVisitor.h
index 87571a44eb0..350318047c7 100644
--- a/src/Interpreters/MonotonicityCheckVisitor.h
+++ b/src/Interpreters/MonotonicityCheckVisitor.h
@@ -26,7 +26,7 @@ public:
     struct Data
     {
         const TablesWithColumns & tables;
-        const Context & context;
+        ContextPtr context;
         const std::unordered_set<String> & group_by_function_hashes;
         Monotonicity monotonicity{true, true, true};
         ASTIdentifier * identifier = nullptr;
diff --git a/src/Interpreters/MutationsInterpreter.cpp b/src/Interpreters/MutationsInterpreter.cpp
index 3573d48b837..f7872e0f742 100644
--- a/src/Interpreters/MutationsInterpreter.cpp
+++ b/src/Interpreters/MutationsInterpreter.cpp
@@ -50,7 +50,7 @@ class FirstNonDeterministicFunctionMatcher
 public:
     struct Data
     {
-        const Context & context;
+        ContextPtr context;
         std::optional<String> nondeterministic_function_name;
     };
 
@@ -80,7 +80,7 @@ public:
 
 using FirstNonDeterministicFunctionFinder = InDepthNodeVisitor<FirstNonDeterministicFunctionMatcher, true>;
 
-std::optional<String> findFirstNonDeterministicFunctionName(const MutationCommand & command, const Context & context)
+std::optional<String> findFirstNonDeterministicFunctionName(const MutationCommand & command, ContextPtr context)
 {
     FirstNonDeterministicFunctionMatcher::Data finder_data{context, std::nullopt};
 
@@ -113,7 +113,7 @@ std::optional<String> findFirstNonDeterministicFunctionName(const MutationComman
     return {};
 }
 
-ASTPtr prepareQueryAffectedAST(const std::vector<MutationCommand> & commands, const StoragePtr & storage, const Context & context)
+ASTPtr prepareQueryAffectedAST(const std::vector<MutationCommand> & commands, const StoragePtr & storage, ContextPtr context)
 {
     /// Execute `SELECT count() FROM storage WHERE predicate1 OR predicate2 OR ...` query.
     /// The result can differ from the number of affected rows (e.g. if there is an UPDATE command that
@@ -178,7 +178,7 @@ bool isStorageTouchedByMutations(
     const StoragePtr & storage,
     const StorageMetadataPtr & metadata_snapshot,
     const std::vector<MutationCommand> & commands,
-    Context context_copy)
+    ContextPtr context_copy)
 {
     if (commands.empty())
         return false;
@@ -206,8 +206,8 @@ bool isStorageTouchedByMutations(
     if (all_commands_can_be_skipped)
         return false;
 
-    context_copy.setSetting("max_streams_to_max_threads_ratio", 1);
-    context_copy.setSetting("max_threads", 1);
+    context_copy->setSetting("max_streams_to_max_threads_ratio", 1);
+    context_copy->setSetting("max_threads", 1);
 
     ASTPtr select_query = prepareQueryAffectedAST(commands, storage, context_copy);
 
@@ -232,7 +232,7 @@ bool isStorageTouchedByMutations(
 ASTPtr getPartitionAndPredicateExpressionForMutationCommand(
     const MutationCommand & command,
     const StoragePtr & storage,
-    const Context & context
+    ContextPtr context
 )
 {
     ASTPtr partition_predicate_as_ast_func;
@@ -266,7 +266,7 @@ MutationsInterpreter::MutationsInterpreter(
     StoragePtr storage_,
     const StorageMetadataPtr & metadata_snapshot_,
     MutationCommands commands_,
-    const Context & context_,
+    ContextPtr context_,
     bool can_execute_)
     : storage(std::move(storage_))
     , metadata_snapshot(metadata_snapshot_)
@@ -649,9 +649,9 @@ ASTPtr MutationsInterpreter::prepareInterpreterSelectQuery(std::vector<Stage> &
             all_asts->children.push_back(std::make_shared<ASTIdentifier>(column));
 
         auto syntax_result = TreeRewriter(context).analyze(all_asts, all_columns, storage, metadata_snapshot);
-        if (context.hasQueryContext())
+        if (context->hasQueryContext())
             for (const auto & it : syntax_result->getScalars())
-                context.getQueryContext().addScalar(it.first, it.second);
+                context->getQueryContext()->addScalar(it.first, it.second);
 
         stage.analyzer = std::make_unique<ExpressionAnalyzer>(all_asts, syntax_result, context);
 
@@ -756,7 +756,7 @@ QueryPipelinePtr MutationsInterpreter::addStreamsForLaterStages(const std::vecto
         SubqueriesForSets & subqueries_for_sets = stage.analyzer->getSubqueriesForSets();
         if (!subqueries_for_sets.empty())
         {
-            const Settings & settings = context.getSettingsRef();
+            const Settings & settings = context->getSettingsRef();
             SizeLimits network_transfer_limits(
                     settings.max_rows_to_transfer, settings.max_bytes_to_transfer, settings.transfer_overflow_mode);
             addCreatingSetsStep(plan, std::move(subqueries_for_sets), network_transfer_limits, context);
@@ -780,7 +780,7 @@ void MutationsInterpreter::validate()
     if (!select_interpreter)
         select_interpreter = std::make_unique<InterpreterSelectQuery>(mutation_ast, context, storage, metadata_snapshot, select_limits);
 
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
 
     /// For Replicated* storages mutations cannot employ non-deterministic functions
     /// because that produces inconsistencies between replicas
diff --git a/src/Interpreters/MutationsInterpreter.h b/src/Interpreters/MutationsInterpreter.h
index dcebba5743e..34a9b61771d 100644
--- a/src/Interpreters/MutationsInterpreter.h
+++ b/src/Interpreters/MutationsInterpreter.h
@@ -23,13 +23,13 @@ bool isStorageTouchedByMutations(
     const StoragePtr & storage,
     const StorageMetadataPtr & metadata_snapshot,
     const std::vector<MutationCommand> & commands,
-    Context context_copy
+    ContextPtr context_copy
 );
 
 ASTPtr getPartitionAndPredicateExpressionForMutationCommand(
     const MutationCommand & command,
     const StoragePtr & storage,
-    const Context & context
+    ContextPtr context
 );
 
 /// Create an input stream that will read data from storage and apply mutation commands (UPDATEs, DELETEs, MATERIALIZEs)
@@ -43,7 +43,7 @@ public:
         StoragePtr storage_,
         const StorageMetadataPtr & metadata_snapshot_,
         MutationCommands commands_,
-        const Context & context_,
+        ContextPtr context_,
         bool can_execute_);
 
     void validate();
@@ -74,7 +74,7 @@ private:
     StoragePtr storage;
     StorageMetadataPtr metadata_snapshot;
     MutationCommands commands;
-    Context context;
+    ContextPtr context;
     bool can_execute;
     SelectQueryOptions select_limits;
 
@@ -101,7 +101,7 @@ private:
 
     struct Stage
     {
-        Stage(const Context & context_) : expressions_chain(context_) {}
+        explicit Stage(ContextPtr context_) : expressions_chain(context_) {}
 
         ASTs filters;
         std::unordered_map<String, ASTPtr> column_to_updated;
diff --git a/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.cpp b/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.cpp
index dfc126a6c24..2420255c5c1 100644
--- a/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.cpp
+++ b/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.cpp
@@ -41,7 +41,7 @@ namespace MySQLInterpreter
 {
 
 static inline String resolveDatabase(
-    const String & database_in_query, const String & replica_mysql_database, const String & replica_clickhouse_database, const Context & context)
+    const String & database_in_query, const String & replica_mysql_database, const String & replica_clickhouse_database, ContextPtr context)
 {
     if (!database_in_query.empty())
     {
@@ -63,7 +63,7 @@ static inline String resolveDatabase(
     /// context.getCurrentDatabase() is always return `default database`
     /// When USE replica_mysql_database; CREATE TABLE table_name;
     /// context.getCurrentDatabase() is always return replica_clickhouse_database
-    const String & current_database = context.getCurrentDatabase();
+    const String & current_database = context->getCurrentDatabase();
     return current_database != replica_clickhouse_database ? "" : replica_clickhouse_database;
 }
 
@@ -117,7 +117,7 @@ static inline NamesAndTypesList getColumnsList(ASTExpressionList * columns_defin
     return columns_name_and_type;
 }
 
-static NamesAndTypesList getNames(const ASTFunction & expr, const Context & context, const NamesAndTypesList & columns)
+static NamesAndTypesList getNames(const ASTFunction & expr, ContextPtr context, const NamesAndTypesList & columns)
 {
     if (expr.arguments->children.empty())
         return NamesAndTypesList{};
@@ -158,7 +158,7 @@ static NamesAndTypesList modifyPrimaryKeysToNonNullable(const NamesAndTypesList
 }
 
 static inline std::tuple<NamesAndTypesList, NamesAndTypesList, NamesAndTypesList, NameSet> getKeys(
-    ASTExpressionList * columns_define, ASTExpressionList * indices_define, const Context & context, NamesAndTypesList & columns)
+    ASTExpressionList * columns_define, ASTExpressionList * indices_define, ContextPtr context, NamesAndTypesList & columns)
 {
     NameSet increment_columns;
     auto keys = makeASTFunction("tuple");
@@ -370,7 +370,7 @@ static ASTPtr getOrderByPolicy(
     return order_by_expression;
 }
 
-void InterpreterCreateImpl::validate(const InterpreterCreateImpl::TQuery & create_query, const Context &)
+void InterpreterCreateImpl::validate(const InterpreterCreateImpl::TQuery & create_query, ContextPtr)
 {
     /// This is dangerous, because the like table may not exists in ClickHouse
     if (create_query.like_table)
@@ -383,7 +383,7 @@ void InterpreterCreateImpl::validate(const InterpreterCreateImpl::TQuery & creat
 }
 
 ASTs InterpreterCreateImpl::getRewrittenQueries(
-    const TQuery & create_query, const Context & context, const String & mapped_to_database, const String & mysql_database)
+    const TQuery & create_query, ContextPtr context, const String & mapped_to_database, const String & mysql_database)
 {
     auto rewritten_query = std::make_shared<ASTCreateQuery>();
     if (resolveDatabase(create_query.database, mysql_database, mapped_to_database, context) != mapped_to_database)
@@ -453,12 +453,12 @@ ASTs InterpreterCreateImpl::getRewrittenQueries(
     return ASTs{rewritten_query};
 }
 
-void InterpreterDropImpl::validate(const InterpreterDropImpl::TQuery & /*query*/, const Context & /*context*/)
+void InterpreterDropImpl::validate(const InterpreterDropImpl::TQuery & /*query*/, ContextPtr /*context*/)
 {
 }
 
 ASTs InterpreterDropImpl::getRewrittenQueries(
-    const InterpreterDropImpl::TQuery & drop_query, const Context & context, const String & mapped_to_database, const String & mysql_database)
+    const InterpreterDropImpl::TQuery & drop_query, ContextPtr context, const String & mapped_to_database, const String & mysql_database)
 {
     const auto & database_name = resolveDatabase(drop_query.database, mysql_database, mapped_to_database, context);
 
@@ -471,14 +471,14 @@ ASTs InterpreterDropImpl::getRewrittenQueries(
     return ASTs{rewritten_query};
 }
 
-void InterpreterRenameImpl::validate(const InterpreterRenameImpl::TQuery & rename_query, const Context & /*context*/)
+void InterpreterRenameImpl::validate(const InterpreterRenameImpl::TQuery & rename_query, ContextPtr /*context*/)
 {
     if (rename_query.exchange)
         throw Exception("Cannot execute exchange for external ddl query.", ErrorCodes::NOT_IMPLEMENTED);
 }
 
 ASTs InterpreterRenameImpl::getRewrittenQueries(
-    const InterpreterRenameImpl::TQuery & rename_query, const Context & context, const String & mapped_to_database, const String & mysql_database)
+    const InterpreterRenameImpl::TQuery & rename_query, ContextPtr context, const String & mapped_to_database, const String & mysql_database)
 {
     ASTRenameQuery::Elements elements;
     for (const auto & rename_element : rename_query.elements)
@@ -507,12 +507,12 @@ ASTs InterpreterRenameImpl::getRewrittenQueries(
     return ASTs{rewritten_query};
 }
 
-void InterpreterAlterImpl::validate(const InterpreterAlterImpl::TQuery & /*query*/, const Context & /*context*/)
+void InterpreterAlterImpl::validate(const InterpreterAlterImpl::TQuery & /*query*/, ContextPtr /*context*/)
 {
 }
 
 ASTs InterpreterAlterImpl::getRewrittenQueries(
-    const InterpreterAlterImpl::TQuery & alter_query, const Context & context, const String & mapped_to_database, const String & mysql_database)
+    const InterpreterAlterImpl::TQuery & alter_query, ContextPtr context, const String & mapped_to_database, const String & mysql_database)
 {
     if (resolveDatabase(alter_query.database, mysql_database, mapped_to_database, context) != mapped_to_database)
         return {};
diff --git a/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.h b/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.h
index 497a661cc7f..3202612ac94 100644
--- a/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.h
+++ b/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.h
@@ -1,62 +1,66 @@
 #pragma once
 
-#include <Parsers/IAST_fwd.h>
-#include <Parsers/queryToString.h>
 #include <Interpreters/IInterpreter.h>
 #include <Interpreters/executeQuery.h>
 #include <Parsers/ASTDropQuery.h>
 #include <Parsers/ASTRenameQuery.h>
+#include <Parsers/IAST_fwd.h>
 #include <Parsers/MySQL/ASTAlterQuery.h>
 #include <Parsers/MySQL/ASTCreateQuery.h>
+#include <Parsers/queryToString.h>
 
 namespace DB
 {
 
 namespace MySQLInterpreter
 {
+    struct InterpreterDropImpl
+    {
+        using TQuery = ASTDropQuery;
 
-struct InterpreterDropImpl
-{
-    using TQuery = ASTDropQuery;
+        static void validate(const TQuery & query, ContextPtr context);
 
-    static void validate(const TQuery & query, const Context & context);
+        static ASTs getRewrittenQueries(
+            const TQuery & drop_query, ContextPtr context, const String & mapped_to_database, const String & mysql_database);
+    };
 
-    static ASTs getRewrittenQueries(const TQuery & drop_query, const Context & context, const String & mapped_to_database, const String & mysql_database);
-};
+    struct InterpreterAlterImpl
+    {
+        using TQuery = MySQLParser::ASTAlterQuery;
 
-struct InterpreterAlterImpl
-{
-    using TQuery = MySQLParser::ASTAlterQuery;
+        static void validate(const TQuery & query, ContextPtr context);
 
-    static void validate(const TQuery & query, const Context & context);
+        static ASTs getRewrittenQueries(
+            const TQuery & alter_query, ContextPtr context, const String & mapped_to_database, const String & mysql_database);
+    };
 
-    static ASTs getRewrittenQueries(const TQuery & alter_query, const Context & context, const String & mapped_to_database, const String & mysql_database);
-};
+    struct InterpreterRenameImpl
+    {
+        using TQuery = ASTRenameQuery;
 
-struct InterpreterRenameImpl
-{
-    using TQuery = ASTRenameQuery;
+        static void validate(const TQuery & query, ContextPtr context);
 
-    static void validate(const TQuery & query, const Context & context);
+        static ASTs getRewrittenQueries(
+            const TQuery & rename_query, ContextPtr context, const String & mapped_to_database, const String & mysql_database);
+    };
 
-    static ASTs getRewrittenQueries(const TQuery & rename_query, const Context & context, const String & mapped_to_database, const String & mysql_database);
-};
+    struct InterpreterCreateImpl
+    {
+        using TQuery = MySQLParser::ASTCreateQuery;
 
-struct InterpreterCreateImpl
-{
-    using TQuery = MySQLParser::ASTCreateQuery;
+        static void validate(const TQuery & query, ContextPtr context);
 
-    static void validate(const TQuery & query, const Context & context);
-
-    static ASTs getRewrittenQueries(const TQuery & create_query, const Context & context, const String & mapped_to_database, const String & mysql_database);
-};
+        static ASTs getRewrittenQueries(
+            const TQuery & create_query, ContextPtr context, const String & mapped_to_database, const String & mysql_database);
+    };
 
 template <typename InterpreterImpl>
-class InterpreterMySQLDDLQuery : public IInterpreter
+class InterpreterMySQLDDLQuery : public IInterpreter, WithContext
 {
 public:
-    InterpreterMySQLDDLQuery(const ASTPtr & query_ptr_, Context & context_, const String & mapped_to_database_, const String & mysql_database_)
-        : query_ptr(query_ptr_), context(context_), mapped_to_database(mapped_to_database_), mysql_database(mysql_database_)
+    InterpreterMySQLDDLQuery(
+        const ASTPtr & query_ptr_, ContextPtr context_, const String & mapped_to_database_, const String & mysql_database_)
+        : WithContext(context_), query_ptr(query_ptr_), mapped_to_database(mapped_to_database_), mysql_database(mysql_database_)
     {
     }
 
@@ -64,18 +68,17 @@ public:
     {
         const typename InterpreterImpl::TQuery & query = query_ptr->as<typename InterpreterImpl::TQuery &>();
 
-        InterpreterImpl::validate(query, context);
-        ASTs rewritten_queries = InterpreterImpl::getRewrittenQueries(query, context, mapped_to_database, mysql_database);
+        InterpreterImpl::validate(query, getContext());
+        ASTs rewritten_queries = InterpreterImpl::getRewrittenQueries(query, getContext(), mapped_to_database, mysql_database);
 
         for (const auto & rewritten_query : rewritten_queries)
-            executeQuery("/* Rewritten MySQL DDL Query */ " + queryToString(rewritten_query), context, true);
+            executeQuery("/* Rewritten MySQL DDL Query */ " + queryToString(rewritten_query), getContext(), true);
 
         return BlockIO{};
     }
 
 private:
     ASTPtr query_ptr;
-    Context & context;
     const String mapped_to_database;
     const String mysql_database;
 };
diff --git a/src/Interpreters/MySQL/tests/gtest_create_rewritten.cpp b/src/Interpreters/MySQL/tests/gtest_create_rewritten.cpp
index 5a82a570db0..77a14e780c5 100644
--- a/src/Interpreters/MySQL/tests/gtest_create_rewritten.cpp
+++ b/src/Interpreters/MySQL/tests/gtest_create_rewritten.cpp
@@ -18,7 +18,7 @@
 
 using namespace DB;
 
-static inline ASTPtr tryRewrittenCreateQuery(const String & query, const Context & context)
+static inline ASTPtr tryRewrittenCreateQuery(const String & query, ContextPtr context)
 {
     ParserExternalDDLQuery external_ddl_parser;
     ASTPtr ast = parseQuery(external_ddl_parser, "EXTERNAL DDL FROM MySQL(test_database, test_database) " + query, 0, 0);
diff --git a/src/Interpreters/OpenTelemetrySpanLog.cpp b/src/Interpreters/OpenTelemetrySpanLog.cpp
index f9ae6518af0..c72b0f3d326 100644
--- a/src/Interpreters/OpenTelemetrySpanLog.cpp
+++ b/src/Interpreters/OpenTelemetrySpanLog.cpp
@@ -116,7 +116,7 @@ OpenTelemetrySpanHolder::~OpenTelemetrySpanHolder()
             return;
         }
 
-        auto * context = thread_group->query_context;
+        auto context = thread_group->query_context.lock();
         if (!context)
         {
             // Both global and query contexts can be null when executing a
diff --git a/src/Interpreters/OptimizeShardingKeyRewriteInVisitor.cpp b/src/Interpreters/OptimizeShardingKeyRewriteInVisitor.cpp
new file mode 100644
index 00000000000..4d1c0526910
--- /dev/null
+++ b/src/Interpreters/OptimizeShardingKeyRewriteInVisitor.cpp
@@ -0,0 +1,110 @@
+#include <Interpreters/ExpressionActions.h>
+#include <Interpreters/convertFieldToType.h>
+#include <Parsers/ASTFunction.h>
+#include <Parsers/ASTLiteral.h>
+#include <Parsers/ASTIdentifier.h>
+#include <DataTypes/FieldToDataType.h>
+#include <Interpreters/OptimizeShardingKeyRewriteInVisitor.h>
+
+namespace
+{
+
+using namespace DB;
+
+Field executeFunctionOnField(
+    const Field & field, const std::string & name,
+    const ExpressionActionsPtr & expr,
+    const std::string & sharding_key_column_name)
+{
+    DataTypePtr type = applyVisitor(FieldToDataType{}, field);
+
+    ColumnWithTypeAndName column;
+    column.column = type->createColumnConst(1, field);
+    column.name = name;
+    column.type = type;
+
+    Block block{column};
+    size_t num_rows = 1;
+    expr->execute(block, num_rows);
+
+    ColumnWithTypeAndName & ret = block.getByName(sharding_key_column_name);
+    return (*ret.column)[0];
+}
+
+/// Return true if shard may contain such value (or it is unknown), otherwise false.
+bool shardContains(
+    const Field & sharding_column_value,
+    const std::string & sharding_column_name,
+    const ExpressionActionsPtr & expr,
+    const std::string & sharding_key_column_name,
+    const Cluster::ShardInfo & shard_info,
+    const Cluster::SlotToShard & slots)
+{
+    /// NULL is not allowed in sharding key,
+    /// so it should be safe to assume that shard cannot contain it.
+    if (sharding_column_value.isNull())
+        return false;
+
+    Field sharding_value = executeFunctionOnField(sharding_column_value, sharding_column_name, expr, sharding_key_column_name);
+    UInt64 value = sharding_value.get<UInt64>();
+    const auto shard_num = slots[value % slots.size()] + 1;
+    return shard_info.shard_num == shard_num;
+}
+
+}
+
+namespace DB
+{
+
+bool OptimizeShardingKeyRewriteInMatcher::needChildVisit(ASTPtr & /*node*/, const ASTPtr & /*child*/)
+{
+    return true;
+}
+
+void OptimizeShardingKeyRewriteInMatcher::visit(ASTPtr & node, Data & data)
+{
+    if (auto * function = node->as<ASTFunction>())
+        visit(*function, data);
+}
+
+void OptimizeShardingKeyRewriteInMatcher::visit(ASTFunction & function, Data & data)
+{
+    if (function.name != "in")
+        return;
+
+    auto * left = function.arguments->children.front().get();
+    auto * right = function.arguments->children.back().get();
+    auto * identifier = left->as<ASTIdentifier>();
+    if (!identifier)
+        return;
+
+    const auto & expr = data.sharding_key_expr;
+    const auto & sharding_key_column_name = data.sharding_key_column_name;
+
+    if (!expr->getRequiredColumnsWithTypes().contains(identifier->name()))
+        return;
+
+    /// NOTE: that we should not take care about empty tuple,
+    /// since after optimize_skip_unused_shards,
+    /// at least one element should match each shard.
+    if (auto * tuple_func = right->as<ASTFunction>(); tuple_func && tuple_func->name == "tuple")
+    {
+        auto * tuple_elements = tuple_func->children.front()->as<ASTExpressionList>();
+        std::erase_if(tuple_elements->children, [&](auto & child)
+        {
+            auto * literal = child->template as<ASTLiteral>();
+            return literal && !shardContains(literal->value, identifier->name(), expr, sharding_key_column_name, data.shard_info, data.slots);
+        });
+    }
+    else if (auto * tuple_literal = right->as<ASTLiteral>();
+        tuple_literal && tuple_literal->value.getType() == Field::Types::Tuple)
+    {
+        auto & tuple = tuple_literal->value.get<Tuple &>();
+        std::erase_if(tuple, [&](auto & child)
+        {
+            return !shardContains(child, identifier->name(), expr, sharding_key_column_name, data.shard_info, data.slots);
+        });
+    }
+}
+
+}
diff --git a/src/Interpreters/OptimizeShardingKeyRewriteInVisitor.h b/src/Interpreters/OptimizeShardingKeyRewriteInVisitor.h
new file mode 100644
index 00000000000..3087fb844ed
--- /dev/null
+++ b/src/Interpreters/OptimizeShardingKeyRewriteInVisitor.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <Interpreters/InDepthNodeVisitor.h>
+#include <Interpreters/Cluster.h>
+
+namespace DB
+{
+
+class ExpressionActions;
+using ExpressionActionsPtr = std::shared_ptr<ExpressionActions>;
+
+class ASTFunction;
+
+/// Rewrite `sharding_key IN (...)` for specific shard,
+/// so that it will contain only values that belong to this specific shard.
+///
+/// See also:
+/// - evaluateExpressionOverConstantCondition()
+/// - StorageDistributed::createSelector()
+/// - createBlockSelector()
+struct OptimizeShardingKeyRewriteInMatcher
+{
+    /// Cluster::SlotToShard
+    using SlotToShard = std::vector<UInt64>;
+
+    struct Data
+    {
+        const ExpressionActionsPtr & sharding_key_expr;
+        const std::string & sharding_key_column_name;
+        const Cluster::ShardInfo & shard_info;
+        const Cluster::SlotToShard & slots;
+    };
+
+    static bool needChildVisit(ASTPtr & /*node*/, const ASTPtr & /*child*/);
+    static void visit(ASTPtr & node, Data & data);
+    static void visit(ASTFunction & function, Data & data);
+};
+
+using OptimizeShardingKeyRewriteInVisitor = InDepthNodeVisitor<OptimizeShardingKeyRewriteInMatcher, true>;
+
+}
diff --git a/src/Interpreters/PartLog.cpp b/src/Interpreters/PartLog.cpp
index c180a4dd254..e4459399336 100644
--- a/src/Interpreters/PartLog.cpp
+++ b/src/Interpreters/PartLog.cpp
@@ -103,7 +103,7 @@ void PartLogElement::appendToBlock(MutableColumns & columns) const
 
 
 bool PartLog::addNewPart(
-    Context & current_context, const MutableDataPartPtr & part, UInt64 elapsed_ns, const ExecutionStatus & execution_status)
+    ContextPtr current_context, const MutableDataPartPtr & part, UInt64 elapsed_ns, const ExecutionStatus & execution_status)
 {
     return addNewParts(current_context, {part}, elapsed_ns, execution_status);
 }
@@ -120,7 +120,7 @@ inline UInt64 time_in_seconds(std::chrono::time_point<std::chrono::system_clock>
 }
 
 bool PartLog::addNewParts(
-    Context & current_context, const PartLog::MutableDataPartsVector & parts, UInt64 elapsed_ns, const ExecutionStatus & execution_status)
+    ContextPtr current_context, const PartLog::MutableDataPartsVector & parts, UInt64 elapsed_ns, const ExecutionStatus & execution_status)
 {
     if (parts.empty())
         return true;
@@ -130,7 +130,7 @@ bool PartLog::addNewParts(
     try
     {
         auto table_id = parts.front()->storage.getStorageID();
-        part_log = current_context.getPartLog(table_id.database_name); // assume parts belong to the same table
+        part_log = current_context->getPartLog(table_id.database_name); // assume parts belong to the same table
         if (!part_log)
             return false;
 
diff --git a/src/Interpreters/PartLog.h b/src/Interpreters/PartLog.h
index c946d6ce85f..edb6ab4a45f 100644
--- a/src/Interpreters/PartLog.h
+++ b/src/Interpreters/PartLog.h
@@ -69,9 +69,9 @@ class PartLog : public SystemLog<PartLogElement>
 
 public:
     /// Add a record about creation of new part.
-    static bool addNewPart(Context & context, const MutableDataPartPtr & part, UInt64 elapsed_ns,
+    static bool addNewPart(ContextPtr context, const MutableDataPartPtr & part, UInt64 elapsed_ns,
                            const ExecutionStatus & execution_status = {});
-    static bool addNewParts(Context & context, const MutableDataPartsVector & parts, UInt64 elapsed_ns,
+    static bool addNewParts(ContextPtr context, const MutableDataPartsVector & parts, UInt64 elapsed_ns,
                             const ExecutionStatus & execution_status = {});
 };
 
diff --git a/src/Interpreters/PredicateExpressionsOptimizer.cpp b/src/Interpreters/PredicateExpressionsOptimizer.cpp
index 476bdaaceea..f2e55441fb6 100644
--- a/src/Interpreters/PredicateExpressionsOptimizer.cpp
+++ b/src/Interpreters/PredicateExpressionsOptimizer.cpp
@@ -19,11 +19,11 @@ namespace ErrorCodes
 }
 
 PredicateExpressionsOptimizer::PredicateExpressionsOptimizer(
-    const Context & context_, const TablesWithColumns & tables_with_columns_, const Settings & settings)
-    : enable_optimize_predicate_expression(settings.enable_optimize_predicate_expression)
+    ContextPtr context_, const TablesWithColumns & tables_with_columns_, const Settings & settings)
+    : WithContext(context_)
+    , enable_optimize_predicate_expression(settings.enable_optimize_predicate_expression)
     , enable_optimize_predicate_expression_to_final_subquery(settings.enable_optimize_predicate_expression_to_final_subquery)
     , allow_push_predicate_when_subquery_contains_with(settings.allow_push_predicate_when_subquery_contains_with)
-    , context(context_)
     , tables_with_columns(tables_with_columns_)
 {
 }
@@ -87,7 +87,7 @@ std::vector<ASTs> PredicateExpressionsOptimizer::extractTablesPredicates(const A
 
     for (const auto & predicate_expression : splitConjunctionPredicate({where, prewhere}))
     {
-        ExpressionInfoVisitor::Data expression_info{.context = context, .tables = tables_with_columns};
+        ExpressionInfoVisitor::Data expression_info{WithContext{getContext()}, tables_with_columns};
         ExpressionInfoVisitor(expression_info).visit(predicate_expression);
 
         if (expression_info.is_stateful_function
@@ -162,7 +162,7 @@ bool PredicateExpressionsOptimizer::tryRewritePredicatesToTable(ASTPtr & table_e
     {
         auto optimize_final = enable_optimize_predicate_expression_to_final_subquery;
         auto optimize_with = allow_push_predicate_when_subquery_contains_with;
-        PredicateRewriteVisitor::Data data(context, table_predicates, table_columns, optimize_final, optimize_with);
+        PredicateRewriteVisitor::Data data(getContext(), table_predicates, table_columns, optimize_final, optimize_with);
 
         PredicateRewriteVisitor(data).visit(table_element);
         return data.is_rewrite;
@@ -187,7 +187,8 @@ bool PredicateExpressionsOptimizer::tryMovePredicatesFromHavingToWhere(ASTSelect
 
     for (const auto & moving_predicate: splitConjunctionPredicate({select_query.having()}))
     {
-        ExpressionInfoVisitor::Data expression_info{.context = context, .tables = {}};
+        TablesWithColumns tables;
+        ExpressionInfoVisitor::Data expression_info{WithContext{getContext()}, tables};
         ExpressionInfoVisitor(expression_info).visit(moving_predicate);
 
         /// TODO: If there is no group by, where, and prewhere expression, we can push down the stateful function
diff --git a/src/Interpreters/PredicateExpressionsOptimizer.h b/src/Interpreters/PredicateExpressionsOptimizer.h
index 223ac1e8998..a31b9907da6 100644
--- a/src/Interpreters/PredicateExpressionsOptimizer.h
+++ b/src/Interpreters/PredicateExpressionsOptimizer.h
@@ -1,12 +1,12 @@
 #pragma once
 
-#include <Parsers/ASTSelectQuery.h>
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/DatabaseAndTableWithAlias.h>
+#include <Parsers/ASTSelectQuery.h>
 
 namespace DB
 {
 
-class Context;
 struct Settings;
 
 /** Predicate optimization based on rewriting ast rules
@@ -15,10 +15,10 @@ struct Settings;
  *      - Move predicates from having to where
  *      - Push the predicate down from the current query to the having of the subquery
  */
-class PredicateExpressionsOptimizer
+class PredicateExpressionsOptimizer : WithContext
 {
 public:
-    PredicateExpressionsOptimizer(const Context & context_, const TablesWithColumns & tables_with_columns_, const Settings & settings_);
+    PredicateExpressionsOptimizer(ContextPtr context_, const TablesWithColumns & tables_with_columns_, const Settings & settings_);
 
     bool optimize(ASTSelectQuery & select_query);
 
@@ -26,7 +26,6 @@ private:
     const bool enable_optimize_predicate_expression;
     const bool enable_optimize_predicate_expression_to_final_subquery;
     const bool allow_push_predicate_when_subquery_contains_with;
-    const Context & context;
     const TablesWithColumns & tables_with_columns;
 
     std::vector<ASTs> extractTablesPredicates(const ASTPtr & where, const ASTPtr & prewhere);
diff --git a/src/Interpreters/PredicateRewriteVisitor.cpp b/src/Interpreters/PredicateRewriteVisitor.cpp
index 6f28b9050df..092d37d78dd 100644
--- a/src/Interpreters/PredicateRewriteVisitor.cpp
+++ b/src/Interpreters/PredicateRewriteVisitor.cpp
@@ -17,8 +17,16 @@ namespace DB
 {
 
 PredicateRewriteVisitorData::PredicateRewriteVisitorData(
-    const Context & context_, const ASTs & predicates_, const TableWithColumnNamesAndTypes & table_columns_, bool optimize_final_, bool optimize_with_)
-    : context(context_), predicates(predicates_), table_columns(table_columns_), optimize_final(optimize_final_), optimize_with(optimize_with_)
+    ContextPtr context_,
+    const ASTs & predicates_,
+    const TableWithColumnNamesAndTypes & table_columns_,
+    bool optimize_final_,
+    bool optimize_with_)
+    : WithContext(context_)
+    , predicates(predicates_)
+    , table_columns(table_columns_)
+    , optimize_final(optimize_final_)
+    , optimize_with(optimize_with_)
 {
 }
 
@@ -64,7 +72,7 @@ void PredicateRewriteVisitorData::visitOtherInternalSelect(ASTSelectQuery & sele
     }
 
     const Names & internal_columns = InterpreterSelectQuery(
-        temp_internal_select, context, SelectQueryOptions().analyze()).getSampleBlock().getNames();
+        temp_internal_select, getContext(), SelectQueryOptions().analyze()).getSampleBlock().getNames();
 
     if (rewriteSubquery(*temp_select_query, internal_columns))
     {
@@ -96,7 +104,7 @@ bool PredicateRewriteVisitorData::rewriteSubquery(ASTSelectQuery & subquery, con
         || (!optimize_with && subquery.with())
         || subquery.withFill()
         || subquery.limitBy() || subquery.limitLength()
-        || hasNonRewritableFunction(subquery.select(), context))
+        || hasNonRewritableFunction(subquery.select(), getContext()))
         return false;
 
     Names outer_columns = table_columns.columns.getNames();
diff --git a/src/Interpreters/PredicateRewriteVisitor.h b/src/Interpreters/PredicateRewriteVisitor.h
index 1132d93a5ec..fc076464925 100644
--- a/src/Interpreters/PredicateRewriteVisitor.h
+++ b/src/Interpreters/PredicateRewriteVisitor.h
@@ -1,15 +1,16 @@
 #pragma once
 
-#include <Parsers/IAST.h>
+#include <Interpreters/Context_fwd.h>
+#include <Interpreters/DatabaseAndTableWithAlias.h>
+#include <Interpreters/InDepthNodeVisitor.h>
 #include <Parsers/ASTSelectQuery.h>
 #include <Parsers/ASTSelectWithUnionQuery.h>
-#include <Interpreters/InDepthNodeVisitor.h>
-#include <Interpreters/DatabaseAndTableWithAlias.h>
+#include <Parsers/IAST.h>
 
 namespace DB
 {
 
-class PredicateRewriteVisitorData
+class PredicateRewriteVisitorData : WithContext
 {
 public:
     bool is_rewrite = false;
@@ -19,17 +20,17 @@ public:
 
     static bool needChild(const ASTPtr & node, const ASTPtr &)
     {
-        if (node && node->as<TypeToVisit>())
-            return false;
-
-        return true;
+        return !(node && node->as<TypeToVisit>());
     }
 
-    PredicateRewriteVisitorData(const Context & context_, const ASTs & predicates_,
-                                const TableWithColumnNamesAndTypes & table_columns_, bool optimize_final_, bool optimize_with_);
+    PredicateRewriteVisitorData(
+        ContextPtr context_,
+        const ASTs & predicates_,
+        const TableWithColumnNamesAndTypes & table_columns_,
+        bool optimize_final_,
+        bool optimize_with_);
 
 private:
-    const Context & context;
     const ASTs & predicates;
     const TableWithColumnNamesAndTypes & table_columns;
     bool optimize_final;
@@ -44,4 +45,5 @@ private:
 
 using PredicateRewriteMatcher = OneTypeMatcher<PredicateRewriteVisitorData, PredicateRewriteVisitorData::needChild>;
 using PredicateRewriteVisitor = InDepthNodeVisitor<PredicateRewriteMatcher, true>;
+
 }
diff --git a/src/Interpreters/ProcessList.cpp b/src/Interpreters/ProcessList.cpp
index 15bda5d213d..951ff6420c4 100644
--- a/src/Interpreters/ProcessList.cpp
+++ b/src/Interpreters/ProcessList.cpp
@@ -60,12 +60,12 @@ static bool isUnlimitedQuery(const IAST * ast)
 }
 
 
-ProcessList::EntryPtr ProcessList::insert(const String & query_, const IAST * ast, Context & query_context)
+ProcessList::EntryPtr ProcessList::insert(const String & query_, const IAST * ast, ContextPtr query_context)
 {
     EntryPtr res;
 
-    const ClientInfo & client_info = query_context.getClientInfo();
-    const Settings & settings = query_context.getSettingsRef();
+    const ClientInfo & client_info = query_context->getClientInfo();
+    const Settings & settings = query_context->getSettingsRef();
 
     if (client_info.current_query_id.empty())
         throw Exception("Query id cannot be empty", ErrorCodes::LOGICAL_ERROR);
@@ -174,12 +174,10 @@ ProcessList::EntryPtr ProcessList::insert(const String & query_, const IAST * as
         }
 
         auto process_it = processes.emplace(processes.end(),
-            query_, client_info, priorities.insert(settings.priority));
+            query_context, query_, client_info, priorities.insert(settings.priority));
 
         res = std::make_shared<Entry>(*this, process_it);
 
-        process_it->query_context = &query_context;
-
         ProcessListForUser & user_process_list = user_to_queries[client_info.current_user];
         user_process_list.queries.emplace(client_info.current_query_id, &res->get());
 
@@ -201,7 +199,7 @@ ProcessList::EntryPtr ProcessList::insert(const String & query_, const IAST * as
             /// Set query-level memory trackers
             thread_group->memory_tracker.setOrRaiseHardLimit(settings.max_memory_usage);
 
-            if (query_context.hasTraceCollector())
+            if (query_context->hasTraceCollector())
             {
                 /// Set up memory profiling
                 thread_group->memory_tracker.setOrRaiseProfilerLimit(settings.memory_profiler_step);
@@ -290,14 +288,12 @@ ProcessListEntry::~ProcessListEntry()
 
 
 QueryStatus::QueryStatus(
-    const String & query_,
-    const ClientInfo & client_info_,
-    QueryPriorities::Handle && priority_handle_)
-    :
-    query(query_),
-    client_info(client_info_),
-    priority_handle(std::move(priority_handle_)),
-    num_queries_increment{CurrentMetrics::Query}
+    ContextPtr context_, const String & query_, const ClientInfo & client_info_, QueryPriorities::Handle && priority_handle_)
+    : WithContext(context_)
+    , query(query_)
+    , client_info(client_info_)
+    , priority_handle(std::move(priority_handle_))
+    , num_queries_increment{CurrentMetrics::Query}
 {
 }
 
@@ -454,10 +450,10 @@ QueryStatusInfo QueryStatus::getInfo(bool get_thread_list, bool get_profile_even
             res.profile_counters = std::make_shared<ProfileEvents::Counters>(thread_group->performance_counters.getPartiallyAtomicSnapshot());
     }
 
-    if (get_settings && query_context)
+    if (get_settings && getContext())
     {
-        res.query_settings = std::make_shared<Settings>(query_context->getSettings());
-        res.current_database = query_context->getCurrentDatabase();
+        res.query_settings = std::make_shared<Settings>(getContext()->getSettings());
+        res.current_database = getContext()->getCurrentDatabase();
     }
 
     return res;
diff --git a/src/Interpreters/ProcessList.h b/src/Interpreters/ProcessList.h
index bc93ce7e191..3eeea9c8e5b 100644
--- a/src/Interpreters/ProcessList.h
+++ b/src/Interpreters/ProcessList.h
@@ -1,6 +1,5 @@
 #pragma once
 
-
 #include <Core/Defines.h>
 #include <DataStreams/BlockIO.h>
 #include <IO/Progress.h>
@@ -33,7 +32,6 @@ namespace CurrentMetrics
 namespace DB
 {
 
-class Context;
 struct Settings;
 class IAST;
 
@@ -72,7 +70,7 @@ struct QueryStatusInfo
 };
 
 /// Query and information about its execution.
-class QueryStatus
+class QueryStatus : public WithContext
 {
 protected:
     friend class ProcessList;
@@ -83,9 +81,6 @@ protected:
     String query;
     ClientInfo client_info;
 
-    /// Is set once when init
-    Context * query_context = nullptr;
-
     /// Info about all threads involved in query execution
     ThreadGroupStatusPtr thread_group;
 
@@ -128,6 +123,7 @@ protected:
 public:
 
     QueryStatus(
+        ContextPtr context_,
         const String & query_,
         const ClientInfo & client_info_,
         QueryPriorities::Handle && priority_handle_);
@@ -172,9 +168,6 @@ public:
 
     QueryStatusInfo getInfo(bool get_thread_list = false, bool get_profile_events = false, bool get_settings = false) const;
 
-    Context * tryGetQueryContext() { return query_context; }
-    const Context * tryGetQueryContext() const { return query_context; }
-
     /// Copies pointers to in/out streams
     void setQueryStreams(const BlockIO & io);
 
@@ -305,7 +298,7 @@ public:
       * If timeout is passed - throw an exception.
       * Don't count KILL QUERY queries.
       */
-    EntryPtr insert(const String & query_, const IAST * ast, Context & query_context);
+    EntryPtr insert(const String & query_, const IAST * ast, ContextPtr query_context);
 
     /// Number of currently executing queries.
     size_t size() const { return processes.size(); }
diff --git a/src/Interpreters/RedundantFunctionsInOrderByVisitor.h b/src/Interpreters/RedundantFunctionsInOrderByVisitor.h
index d737e877f01..f807849fb86 100644
--- a/src/Interpreters/RedundantFunctionsInOrderByVisitor.h
+++ b/src/Interpreters/RedundantFunctionsInOrderByVisitor.h
@@ -16,7 +16,7 @@ public:
     struct Data
     {
         std::unordered_set<String> & keys;
-        const Context & context;
+        ContextPtr context;
         bool redundant = true;
         bool done = false;
 
diff --git a/src/Interpreters/RemoveInjectiveFunctionsVisitor.cpp b/src/Interpreters/RemoveInjectiveFunctionsVisitor.cpp
index e0821b2985d..1dca2db859b 100644
--- a/src/Interpreters/RemoveInjectiveFunctionsVisitor.cpp
+++ b/src/Interpreters/RemoveInjectiveFunctionsVisitor.cpp
@@ -17,7 +17,7 @@ static bool isUniq(const ASTFunction & func)
 }
 
 /// Remove injective functions of one argument: replace with a child
-static bool removeInjectiveFunction(ASTPtr & ast, const Context & context, const FunctionFactory & function_factory)
+static bool removeInjectiveFunction(ASTPtr & ast, ContextPtr context, const FunctionFactory & function_factory)
 {
     const ASTFunction * func = ast->as<ASTFunction>();
     if (!func)
@@ -47,7 +47,7 @@ void RemoveInjectiveFunctionsMatcher::visit(ASTFunction & func, ASTPtr &, const
 
         for (auto & arg : func.arguments->children)
         {
-            while (removeInjectiveFunction(arg, data.context, function_factory))
+            while (removeInjectiveFunction(arg, data.getContext(), function_factory))
                 ;
         }
     }
diff --git a/src/Interpreters/RemoveInjectiveFunctionsVisitor.h b/src/Interpreters/RemoveInjectiveFunctionsVisitor.h
index 1adde0d35b0..a3bbd562407 100644
--- a/src/Interpreters/RemoveInjectiveFunctionsVisitor.h
+++ b/src/Interpreters/RemoveInjectiveFunctionsVisitor.h
@@ -1,7 +1,8 @@
 #pragma once
 
-#include <Parsers/IAST.h>
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/InDepthNodeVisitor.h>
+#include <Parsers/IAST.h>
 
 namespace DB
 {
@@ -12,9 +13,9 @@ class ASTFunction;
 class RemoveInjectiveFunctionsMatcher
 {
 public:
-    struct Data
+    struct Data : public WithContext
     {
-        const Context & context;
+        explicit Data(ContextPtr context_) : WithContext(context_) {}
     };
 
     static void visit(ASTPtr & ast, const Data & data);
diff --git a/src/Interpreters/SystemLog.cpp b/src/Interpreters/SystemLog.cpp
index 1667d845d77..31ceca8ec05 100644
--- a/src/Interpreters/SystemLog.cpp
+++ b/src/Interpreters/SystemLog.cpp
@@ -30,7 +30,7 @@ constexpr size_t DEFAULT_METRIC_LOG_COLLECT_INTERVAL_MILLISECONDS = 1000;
 /// Creates a system log with MergeTree engine using parameters from config
 template <typename TSystemLog>
 std::shared_ptr<TSystemLog> createSystemLog(
-    Context & context,
+    ContextPtr context,
     const String & default_database_name,
     const String & default_table_name,
     const Poco::Util::AbstractConfiguration & config,
@@ -88,7 +88,7 @@ std::shared_ptr<TSystemLog> createSystemLog(
 }
 
 
-SystemLogs::SystemLogs(Context & global_context, const Poco::Util::AbstractConfiguration & config)
+SystemLogs::SystemLogs(ContextPtr global_context, const Poco::Util::AbstractConfiguration & config)
 {
     query_log = createSystemLog<QueryLog>(global_context, "system", "query_log", config, "query_log");
     query_thread_log = createSystemLog<QueryThreadLog>(global_context, "system", "query_thread_log", config, "query_thread_log");
diff --git a/src/Interpreters/SystemLog.h b/src/Interpreters/SystemLog.h
index aa3dc113e44..2f7bdd4a22f 100644
--- a/src/Interpreters/SystemLog.h
+++ b/src/Interpreters/SystemLog.h
@@ -93,7 +93,7 @@ public:
 ///  because SystemLog destruction makes insert query while flushing data into underlying tables
 struct SystemLogs
 {
-    SystemLogs(Context & global_context, const Poco::Util::AbstractConfiguration & config);
+    SystemLogs(ContextPtr global_context, const Poco::Util::AbstractConfiguration & config);
     ~SystemLogs();
 
     void shutdown();
@@ -115,7 +115,7 @@ struct SystemLogs
 
 
 template <typename LogElement>
-class SystemLog : public ISystemLog, private boost::noncopyable
+class SystemLog : public ISystemLog, private boost::noncopyable, WithContext
 {
 public:
     using Self = SystemLog;
@@ -129,7 +129,7 @@ public:
       *   and new table get created - as if previous table was not exist.
       */
     SystemLog(
-        Context & context_,
+        ContextPtr context_,
         const String & database_name_,
         const String & table_name_,
         const String & storage_def_,
@@ -166,7 +166,6 @@ protected:
 
 private:
     /* Saving thread data */
-    Context & context;
     const StorageID table_id;
     const String storage_def;
     StoragePtr table;
@@ -184,12 +183,13 @@ private:
     // synchronous log flushing for SYSTEM FLUSH LOGS.
     uint64_t queue_front_index = 0;
     bool is_shutdown = false;
+    // A flag that says we must create the tables even if the queue is empty.
     bool is_force_prepare_tables = false;
     std::condition_variable flush_event;
     // Requested to flush logs up to this index, exclusive
-    uint64_t requested_flush_before = 0;
+    uint64_t requested_flush_up_to = 0;
     // Flushed log up to this index, exclusive
-    uint64_t flushed_before = 0;
+    uint64_t flushed_up_to = 0;
     // Logged overflow message at this queue front index
     uint64_t logged_queue_full_at_index = -1;
 
@@ -207,12 +207,13 @@ private:
 
 
 template <typename LogElement>
-SystemLog<LogElement>::SystemLog(Context & context_,
+SystemLog<LogElement>::SystemLog(
+    ContextPtr context_,
     const String & database_name_,
     const String & table_name_,
     const String & storage_def_,
     size_t flush_interval_milliseconds_)
-    : context(context_)
+    : WithContext(context_)
     , table_id(database_name_, table_name_)
     , storage_def(storage_def_)
     , flush_interval_milliseconds(flush_interval_milliseconds_)
@@ -267,8 +268,8 @@ void SystemLog<LogElement>::add(const LogElement & element)
             // It is enough to only wake the flushing thread once, after the message
             // count increases past half available size.
             const uint64_t queue_end = queue_front_index + queue.size();
-            if (requested_flush_before < queue_end)
-                requested_flush_before = queue_end;
+            if (requested_flush_up_to < queue_end)
+                requested_flush_up_to = queue_end;
 
             flush_event.notify_all();
         }
@@ -304,24 +305,36 @@ void SystemLog<LogElement>::add(const LogElement & element)
 template <typename LogElement>
 void SystemLog<LogElement>::flush(bool force)
 {
-    std::unique_lock lock(mutex);
+    uint64_t this_thread_requested_offset;
 
-    if (is_shutdown)
-        return;
-
-    const uint64_t queue_end = queue_front_index + queue.size();
-
-    is_force_prepare_tables = force;
-    if (requested_flush_before < queue_end || force)
     {
-        requested_flush_before = queue_end;
+        std::unique_lock lock(mutex);
+
+        if (is_shutdown)
+            return;
+
+        this_thread_requested_offset = queue_front_index + queue.size();
+
+        // Publish our flush request, taking care not to overwrite the requests
+        // made by other threads.
+        is_force_prepare_tables |= force;
+        requested_flush_up_to = std::max(requested_flush_up_to,
+            this_thread_requested_offset);
+
         flush_event.notify_all();
     }
 
-    // Use an arbitrary timeout to avoid endless waiting.
-    const int timeout_seconds = 60;
+    LOG_DEBUG(log, "Requested flush up to offset {}",
+        this_thread_requested_offset);
+
+    // Use an arbitrary timeout to avoid endless waiting. 60s proved to be
+    // too fast for our parallel functional tests, probably because they
+    // heavily load the disk.
+    const int timeout_seconds = 180;
+    std::unique_lock lock(mutex);
     bool result = flush_event.wait_for(lock, std::chrono::seconds(timeout_seconds),
-        [&] { return flushed_before >= queue_end && !is_force_prepare_tables; });
+        [&] { return flushed_up_to >= this_thread_requested_offset
+                && !is_force_prepare_tables; });
 
     if (!result)
     {
@@ -371,6 +384,8 @@ void SystemLog<LogElement>::savingThreadFunction()
             // The end index (exclusive, like std end()) of the messages we are
             // going to flush.
             uint64_t to_flush_end = 0;
+            // Should we prepare table even if there are no new messages.
+            bool should_prepare_tables_anyway = false;
 
             {
                 std::unique_lock lock(mutex);
@@ -378,7 +393,7 @@ void SystemLog<LogElement>::savingThreadFunction()
                     std::chrono::milliseconds(flush_interval_milliseconds),
                     [&] ()
                     {
-                        return requested_flush_before > flushed_before || is_shutdown || is_force_prepare_tables;
+                        return requested_flush_up_to > flushed_up_to || is_shutdown || is_force_prepare_tables;
                     }
                 );
 
@@ -389,18 +404,14 @@ void SystemLog<LogElement>::savingThreadFunction()
                 to_flush.resize(0);
                 queue.swap(to_flush);
 
+                should_prepare_tables_anyway = is_force_prepare_tables;
+
                 exit_this_thread = is_shutdown;
             }
 
             if (to_flush.empty())
             {
-                bool force;
-                {
-                    std::lock_guard lock(mutex);
-                    force = is_force_prepare_tables;
-                }
-
-                if (force)
+                if (should_prepare_tables_anyway)
                 {
                     prepareTable();
                     LOG_TRACE(log, "Table created (force)");
@@ -429,7 +440,8 @@ void SystemLog<LogElement>::flushImpl(const std::vector<LogElement> & to_flush,
 {
     try
     {
-        LOG_TRACE(log, "Flushing system log, {} entries to flush", to_flush.size());
+        LOG_TRACE(log, "Flushing system log, {} entries to flush up to offset {}",
+            to_flush.size(), to_flush_end);
 
         /// We check for existence of the table and create it as needed at every
         /// flush. This is done to allow user to drop the table at any moment
@@ -451,8 +463,8 @@ void SystemLog<LogElement>::flushImpl(const std::vector<LogElement> & to_flush,
         ASTPtr query_ptr(insert.release());
 
         // we need query context to do inserts to target table with MV containing subqueries or joins
-        Context insert_context(context);
-        insert_context.makeQueryContext();
+        auto insert_context = Context::createCopy(context);
+        insert_context->makeQueryContext();
 
         InterpreterInsertQuery interpreter(query_ptr, insert_context);
         BlockIO io = interpreter.execute();
@@ -468,12 +480,12 @@ void SystemLog<LogElement>::flushImpl(const std::vector<LogElement> & to_flush,
 
     {
         std::lock_guard lock(mutex);
-        flushed_before = to_flush_end;
+        flushed_up_to = to_flush_end;
         is_force_prepare_tables = false;
         flush_event.notify_all();
     }
 
-    LOG_TRACE(log, "Flushed system log");
+    LOG_TRACE(log, "Flushed system log up to offset {}", to_flush_end);
 }
 
 
@@ -482,7 +494,7 @@ void SystemLog<LogElement>::prepareTable()
 {
     String description = table_id.getNameForLogs();
 
-    table = DatabaseCatalog::instance().tryGetTable(table_id, context);
+    table = DatabaseCatalog::instance().tryGetTable(table_id, getContext());
 
     if (table)
     {
@@ -494,7 +506,8 @@ void SystemLog<LogElement>::prepareTable()
         {
             /// Rename the existing table.
             int suffix = 0;
-            while (DatabaseCatalog::instance().isTableExist({table_id.database_name, table_id.table_name + "_" + toString(suffix)}, context))
+            while (DatabaseCatalog::instance().isTableExist(
+                {table_id.database_name, table_id.table_name + "_" + toString(suffix)}, getContext()))
                 ++suffix;
 
             auto rename = std::make_shared<ASTRenameQuery>();
@@ -513,10 +526,14 @@ void SystemLog<LogElement>::prepareTable()
 
             rename->elements.emplace_back(elem);
 
-            LOG_DEBUG(log, "Existing table {} for system log has obsolete or different structure. Renaming it to {}", description, backQuoteIfNeed(to.table));
+            LOG_DEBUG(
+                log,
+                "Existing table {} for system log has obsolete or different structure. Renaming it to {}",
+                description,
+                backQuoteIfNeed(to.table));
 
-            Context query_context = context;
-            query_context.makeQueryContext();
+            auto query_context = Context::createCopy(context);
+            query_context->makeQueryContext();
             InterpreterRenameQuery(rename, query_context).execute();
 
             /// The required table will be created.
@@ -534,13 +551,14 @@ void SystemLog<LogElement>::prepareTable()
         auto create = getCreateTableQuery();
 
 
-        Context query_context = context;
-        query_context.makeQueryContext();
+        auto query_context = Context::createCopy(context);
+        query_context->makeQueryContext();
+
         InterpreterCreateQuery interpreter(create, query_context);
         interpreter.setInternal(true);
         interpreter.execute();
 
-        table = DatabaseCatalog::instance().getTable(table_id, context);
+        table = DatabaseCatalog::instance().getTable(table_id, getContext());
     }
 
     is_prepared = true;
diff --git a/src/Interpreters/TextLog.cpp b/src/Interpreters/TextLog.cpp
index 489bb302ad0..f5a0ce51d49 100644
--- a/src/Interpreters/TextLog.cpp
+++ b/src/Interpreters/TextLog.cpp
@@ -74,7 +74,7 @@ void TextLogElement::appendToBlock(MutableColumns & columns) const
     columns[i++]->insert(source_line);
 }
 
-TextLog::TextLog(Context & context_, const String & database_name_,
+TextLog::TextLog(ContextPtr context_, const String & database_name_,
         const String & table_name_, const String & storage_def_,
         size_t flush_interval_milliseconds_)
   : SystemLog<TextLogElement>(context_, database_name_, table_name_,
diff --git a/src/Interpreters/TextLog.h b/src/Interpreters/TextLog.h
index da678868be3..7ff55128a90 100644
--- a/src/Interpreters/TextLog.h
+++ b/src/Interpreters/TextLog.h
@@ -33,7 +33,7 @@ class TextLog : public SystemLog<TextLogElement>
 {
 public:
     TextLog(
-        Context & context_,
+        ContextPtr context_,
         const String & database_name_,
         const String & table_name_,
         const String & storage_def_,
diff --git a/src/Interpreters/ThreadStatusExt.cpp b/src/Interpreters/ThreadStatusExt.cpp
index 8a979721290..ec6bdb8d526 100644
--- a/src/Interpreters/ThreadStatusExt.cpp
+++ b/src/Interpreters/ThreadStatusExt.cpp
@@ -33,9 +33,11 @@ namespace ErrorCodes
 
 void ThreadStatus::applyQuerySettings()
 {
-    const Settings & settings = query_context->getSettingsRef();
+    auto query_context_ptr = query_context.lock();
+    assert(query_context_ptr);
+    const Settings & settings = query_context_ptr->getSettingsRef();
 
-    query_id = query_context->getCurrentQueryId();
+    query_id = query_context_ptr->getCurrentQueryId();
     initQueryProfiler();
 
     untracked_memory_limit = settings.max_untracked_memory;
@@ -58,26 +60,26 @@ void ThreadStatus::applyQuerySettings()
 }
 
 
-void ThreadStatus::attachQueryContext(Context & query_context_)
+void ThreadStatus::attachQueryContext(ContextPtr query_context_)
 {
-    query_context = &query_context_;
+    query_context = query_context_;
 
-    if (!global_context)
-        global_context = &query_context->getGlobalContext();
+    if (global_context.expired())
+        global_context = query_context_->getGlobalContext();
 
     if (thread_group)
     {
         std::lock_guard lock(thread_group->mutex);
 
         thread_group->query_context = query_context;
-        if (!thread_group->global_context)
+        if (thread_group->global_context.expired())
             thread_group->global_context = global_context;
     }
 
     // Generate new span for thread manually here, because we can't depend
     // on OpenTelemetrySpanHolder due to link order issues.
     // FIXME why and how is this different from setupState()?
-    thread_trace_context = query_context->query_trace_context;
+    thread_trace_context = query_context_->query_trace_context;
     if (thread_trace_context.trace_id)
     {
         thread_trace_context.span_id = thread_local_rng();
@@ -113,17 +115,17 @@ void ThreadStatus::setupState(const ThreadGroupStatusPtr & thread_group_)
         fatal_error_callback = thread_group->fatal_error_callback;
         query_context = thread_group->query_context;
 
-        if (!global_context)
+        if (global_context.expired())
             global_context = thread_group->global_context;
     }
 
-    if (query_context)
+    if (auto query_context_ptr = query_context.lock())
     {
         applyQuerySettings();
 
         // Generate new span for thread manually here, because we can't depend
         // on OpenTelemetrySpanHolder due to link order issues.
-        thread_trace_context = query_context->query_trace_context;
+        thread_trace_context = query_context_ptr->query_trace_context;
         if (thread_trace_context.trace_id)
         {
             thread_trace_context.span_id = thread_local_rng();
@@ -201,9 +203,9 @@ void ThreadStatus::initPerformanceCounters()
     // query_start_time_nanoseconds cannot be used here since RUsageCounters expect CLOCK_MONOTONIC
     *last_rusage = RUsageCounters::current();
 
-    if (query_context)
+    if (auto query_context_ptr = query_context.lock())
     {
-        const Settings & settings = query_context->getSettingsRef();
+        const Settings & settings = query_context_ptr->getSettingsRef();
         if (settings.metrics_perf_events_enabled)
         {
             try
@@ -246,8 +248,8 @@ void ThreadStatus::finalizePerformanceCounters()
     // 'select 1 settings metrics_perf_events_enabled = 1', I still get
     // query_context->getSettingsRef().metrics_perf_events_enabled == 0 *shrug*.
     bool close_perf_descriptors = true;
-    if (query_context)
-        close_perf_descriptors = !query_context->getSettingsRef().metrics_perf_events_enabled;
+    if (auto query_context_ptr = query_context.lock())
+        close_perf_descriptors = !query_context_ptr->getSettingsRef().metrics_perf_events_enabled;
 
     try
     {
@@ -262,17 +264,19 @@ void ThreadStatus::finalizePerformanceCounters()
 
     try
     {
-        if (global_context && query_context)
+        auto global_context_ptr = global_context.lock();
+        auto query_context_ptr = query_context.lock();
+        if (global_context_ptr && query_context_ptr)
         {
-            const auto & settings = query_context->getSettingsRef();
+            const auto & settings = query_context_ptr->getSettingsRef();
             if (settings.log_queries && settings.log_query_threads)
             {
                 const auto now = std::chrono::system_clock::now();
                 Int64 query_duration_ms = (time_in_microseconds(now) - query_start_time_microseconds) / 1000;
                 if (query_duration_ms >= settings.log_queries_min_query_duration_ms.totalMilliseconds())
                 {
-                    if (auto thread_log = global_context->getQueryThreadLog())
-                        logToQueryThreadLog(*thread_log, query_context->getCurrentDatabase(), now);
+                    if (auto thread_log = global_context_ptr->getQueryThreadLog())
+                        logToQueryThreadLog(*thread_log, query_context_ptr->getCurrentDatabase(), now);
                 }
             }
         }
@@ -286,10 +290,13 @@ void ThreadStatus::finalizePerformanceCounters()
 void ThreadStatus::initQueryProfiler()
 {
     /// query profilers are useless without trace collector
-    if (!global_context || !global_context->hasTraceCollector())
+    auto global_context_ptr = global_context.lock();
+    if (!global_context_ptr || !global_context_ptr->hasTraceCollector())
         return;
 
-    const auto & settings = query_context->getSettingsRef();
+    auto query_context_ptr = query_context.lock();
+    assert(query_context_ptr);
+    const auto & settings = query_context_ptr->getSettingsRef();
 
     try
     {
@@ -316,6 +323,8 @@ void ThreadStatus::finalizeQueryProfiler()
 
 void ThreadStatus::detachQuery(bool exit_if_already_detached, bool thread_exits)
 {
+    MemoryTracker::LockExceptionInThread lock;
+
     if (exit_if_already_detached && thread_state == ThreadState::DetachedFromQuery)
     {
         thread_state = thread_exits ? ThreadState::Died : ThreadState::DetachedFromQuery;
@@ -325,9 +334,10 @@ void ThreadStatus::detachQuery(bool exit_if_already_detached, bool thread_exits)
     assertState({ThreadState::AttachedToQuery}, __PRETTY_FUNCTION__);
 
     std::shared_ptr<OpenTelemetrySpanLog> opentelemetry_span_log;
-    if (thread_trace_context.trace_id && query_context)
+    auto query_context_ptr = query_context.lock();
+    if (thread_trace_context.trace_id && query_context_ptr)
     {
-        opentelemetry_span_log = query_context->getOpenTelemetrySpanLog();
+        opentelemetry_span_log = query_context_ptr->getOpenTelemetrySpanLog();
     }
 
     if (opentelemetry_span_log)
@@ -347,7 +357,8 @@ void ThreadStatus::detachQuery(bool exit_if_already_detached, bool thread_exits)
         // is going to fail, because we're going to reset it to zero later in
         // this function.
         span.span_id = thread_trace_context.span_id;
-        span.parent_span_id = query_context->query_trace_context.span_id;
+        assert(query_context_ptr);
+        span.parent_span_id = query_context_ptr->query_trace_context.span_id;
         span.operation_name = getThreadName();
         span.start_time_us = query_start_time_microseconds;
         span.finish_time_us =
@@ -370,7 +381,7 @@ void ThreadStatus::detachQuery(bool exit_if_already_detached, bool thread_exits)
     memory_tracker.setParent(thread_group->memory_tracker.getParent());
 
     query_id.clear();
-    query_context = nullptr;
+    query_context.reset();
     thread_trace_context.trace_id = 0;
     thread_trace_context.span_id = 0;
     thread_group.reset();
@@ -429,11 +440,12 @@ void ThreadStatus::logToQueryThreadLog(QueryThreadLog & thread_log, const String
         }
     }
 
-    if (query_context)
+    auto query_context_ptr = query_context.lock();
+    if (query_context_ptr)
     {
-        elem.client_info = query_context->getClientInfo();
+        elem.client_info = query_context_ptr->getClientInfo();
 
-        if (query_context->getSettingsRef().log_profile_events != 0)
+        if (query_context_ptr->getSettingsRef().log_profile_events != 0)
         {
             /// NOTE: Here we are in the same thread, so we can make memcpy()
             elem.profile_counters = std::make_shared<ProfileEvents::Counters>(performance_counters.getPartiallyAtomicSnapshot());
@@ -467,7 +479,7 @@ void CurrentThread::attachToIfDetached(const ThreadGroupStatusPtr & thread_group
     current_thread->deleter = CurrentThread::defaultThreadDeleter;
 }
 
-void CurrentThread::attachQueryContext(Context & query_context)
+void CurrentThread::attachQueryContext(ContextPtr query_context)
 {
     if (unlikely(!current_thread))
         return;
@@ -496,12 +508,12 @@ void CurrentThread::detachQueryIfNotDetached()
 }
 
 
-CurrentThread::QueryScope::QueryScope(Context & query_context)
+CurrentThread::QueryScope::QueryScope(ContextPtr query_context)
 {
     CurrentThread::initializeQuery();
     CurrentThread::attachQueryContext(query_context);
-    if (!query_context.hasQueryContext())
-        query_context.makeQueryContext();
+    if (!query_context->hasQueryContext())
+        query_context->makeQueryContext();
 }
 
 void CurrentThread::QueryScope::logPeakMemoryUsage()
diff --git a/src/Interpreters/TreeOptimizer.cpp b/src/Interpreters/TreeOptimizer.cpp
index 3f4c2e74e23..5b06c00435a 100644
--- a/src/Interpreters/TreeOptimizer.cpp
+++ b/src/Interpreters/TreeOptimizer.cpp
@@ -81,7 +81,7 @@ void appendUnusedGroupByColumn(ASTSelectQuery * select_query, const NameSet & so
 }
 
 /// Eliminates injective function calls and constant expressions from group by statement.
-void optimizeGroupBy(ASTSelectQuery * select_query, const NameSet & source_columns, const Context & context)
+void optimizeGroupBy(ASTSelectQuery * select_query, const NameSet & source_columns, ContextPtr context)
 {
     const FunctionFactory & function_factory = FunctionFactory::instance();
 
@@ -135,7 +135,7 @@ void optimizeGroupBy(ASTSelectQuery * select_query, const NameSet & source_colum
                 const auto & dict_name = dict_name_ast->value.safeGet<String>();
                 const auto & attr_name = attr_name_ast->value.safeGet<String>();
 
-                const auto & dict_ptr = context.getExternalDictionariesLoader().getDictionary(dict_name, context);
+                const auto & dict_ptr = context->getExternalDictionariesLoader().getDictionary(dict_name, context);
                 if (!dict_ptr->isInjective(attr_name))
                 {
                     ++i;
@@ -270,7 +270,7 @@ void optimizeDuplicatesInOrderBy(const ASTSelectQuery * select_query)
 }
 
 /// Optimize duplicate ORDER BY
-void optimizeDuplicateOrderBy(ASTPtr & query, const Context & context)
+void optimizeDuplicateOrderBy(ASTPtr & query, ContextPtr context)
 {
     DuplicateOrderByVisitor::Data order_by_data{context};
     DuplicateOrderByVisitor(order_by_data).visit(query);
@@ -396,7 +396,7 @@ void optimizeDuplicateDistinct(ASTSelectQuery & select)
 
 /// Replace monotonous functions in ORDER BY if they don't participate in GROUP BY expression,
 /// has a single argument and not an aggregate functions.
-void optimizeMonotonousFunctionsInOrderBy(ASTSelectQuery * select_query, const Context & context,
+void optimizeMonotonousFunctionsInOrderBy(ASTSelectQuery * select_query, ContextPtr context,
                                           const TablesWithColumns & tables_with_columns,
                                           const Names & sorting_key_columns)
 {
@@ -448,7 +448,7 @@ void optimizeMonotonousFunctionsInOrderBy(ASTSelectQuery * select_query, const C
 /// Optimize ORDER BY x, y, f(x), g(x, y), f(h(x)), t(f(x), g(x)) into ORDER BY x, y
 /// in case if f(), g(), h(), t() are deterministic (in scope of query).
 /// Don't optimize ORDER BY f(x), g(x), x even if f(x) is bijection for x or g(x).
-void optimizeRedundantFunctionsInOrderBy(const ASTSelectQuery * select_query, const Context & context)
+void optimizeRedundantFunctionsInOrderBy(const ASTSelectQuery * select_query, ContextPtr context)
 {
     const auto & order_by = select_query->orderBy();
     if (!order_by)
@@ -561,9 +561,9 @@ void optimizeCountConstantAndSumOne(ASTPtr & query)
 }
 
 
-void optimizeInjectiveFunctionsInsideUniq(ASTPtr & query, const Context & context)
+void optimizeInjectiveFunctionsInsideUniq(ASTPtr & query, ContextPtr context)
 {
-    RemoveInjectiveFunctionsVisitor::Data data = {context};
+    RemoveInjectiveFunctionsVisitor::Data data(context);
     RemoveInjectiveFunctionsVisitor(data).visit(query);
 }
 
@@ -592,10 +592,10 @@ void TreeOptimizer::optimizeIf(ASTPtr & query, Aliases & aliases, bool if_chain_
 
 void TreeOptimizer::apply(ASTPtr & query, Aliases & aliases, const NameSet & source_columns_set,
                           const std::vector<TableWithColumnNamesAndTypes> & tables_with_columns,
-                          const Context & context, const StorageMetadataPtr & metadata_snapshot,
+                          ContextPtr context, const StorageMetadataPtr & metadata_snapshot,
                           bool & rewrite_subqueries)
 {
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = context->getSettingsRef();
 
     auto * select_query = query->as<ASTSelectQuery>();
     if (!select_query)
diff --git a/src/Interpreters/TreeOptimizer.h b/src/Interpreters/TreeOptimizer.h
index a10dfc57451..b268b230f4e 100644
--- a/src/Interpreters/TreeOptimizer.h
+++ b/src/Interpreters/TreeOptimizer.h
@@ -1,13 +1,13 @@
 #pragma once
 
-#include <Parsers/IAST_fwd.h>
 #include <Interpreters/Aliases.h>
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/DatabaseAndTableWithAlias.h>
+#include <Parsers/IAST_fwd.h>
 
 namespace DB
 {
 
-class Context;
 struct StorageInMemoryMetadata;
 using StorageMetadataPtr = std::shared_ptr<const StorageInMemoryMetadata>;
 
@@ -16,10 +16,14 @@ using StorageMetadataPtr = std::shared_ptr<const StorageInMemoryMetadata>;
 class TreeOptimizer
 {
 public:
-    static void apply(ASTPtr & query, Aliases & aliases, const NameSet & source_columns_set,
-                      const std::vector<TableWithColumnNamesAndTypes> & tables_with_columns,
-                      const Context & context, const StorageMetadataPtr & metadata_snapshot,
-                      bool & rewrite_subqueries);
+    static void apply(
+        ASTPtr & query,
+        Aliases & aliases,
+        const NameSet & source_columns_set,
+        const std::vector<TableWithColumnNamesAndTypes> & tables_with_columns,
+        ContextPtr context,
+        const StorageMetadataPtr & metadata_snapshot,
+        bool & rewrite_subqueries);
 
     static void optimizeIf(ASTPtr & query, Aliases & aliases, bool if_chain_to_multiif);
 };
diff --git a/src/Interpreters/TreeRewriter.cpp b/src/Interpreters/TreeRewriter.cpp
index f88fd16045a..354f9d10099 100644
--- a/src/Interpreters/TreeRewriter.cpp
+++ b/src/Interpreters/TreeRewriter.cpp
@@ -293,13 +293,11 @@ void removeUnneededColumnsFromSelectClause(const ASTSelectQuery * select_query,
         else
         {
             ASTFunction * func = elem->as<ASTFunction>();
+
+            /// Never remove untuple. It's result column may be in required columns.
+            /// It is not easy to analyze untuple here, because types were not calculated yes.
             if (func && func->name == "untuple")
-                for (const auto & col : required_result_columns)
-                    if (col.rfind("_ut_", 0) == 0)
-                    {
-                        new_elements.push_back(elem);
-                        break;
-                    }
+                new_elements.push_back(elem);
         }
     }
 
@@ -307,10 +305,10 @@ void removeUnneededColumnsFromSelectClause(const ASTSelectQuery * select_query,
 }
 
 /// Replacing scalar subqueries with constant values.
-void executeScalarSubqueries(ASTPtr & query, const Context & context, size_t subquery_depth, Scalars & scalars, bool only_analyze)
+void executeScalarSubqueries(ASTPtr & query, ContextPtr context, size_t subquery_depth, Scalars & scalars, bool only_analyze)
 {
     LogAST log;
-    ExecuteScalarSubqueriesVisitor::Data visitor_data{context, subquery_depth, scalars, only_analyze};
+    ExecuteScalarSubqueriesVisitor::Data visitor_data{WithContext{context}, subquery_depth, scalars, only_analyze};
     ExecuteScalarSubqueriesVisitor(visitor_data, log.stream()).visit(query);
 }
 
@@ -408,7 +406,7 @@ void collectJoinedColumns(TableJoin & analyzed_join, const ASTSelectQuery & sele
                           const TablesWithColumns & tables, const Aliases & aliases, ASTPtr & new_where_conditions)
 {
     const ASTTablesInSelectQueryElement * node = select_query.join();
-    if (!node)
+    if (!node || tables.size() < 2)
         return;
 
     auto & table_join = node->table_join->as<ASTTableJoin &>();
@@ -789,7 +787,7 @@ TreeRewriterResultPtr TreeRewriter::analyzeSelect(
     size_t subquery_depth = select_options.subquery_depth;
     bool remove_duplicates = select_options.remove_duplicates;
 
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = getContext()->getSettingsRef();
 
     const NameSet & source_columns_set = result.source_columns_set;
 
@@ -832,9 +830,10 @@ TreeRewriterResultPtr TreeRewriter::analyzeSelect(
     removeUnneededColumnsFromSelectClause(select_query, required_result_columns, remove_duplicates);
 
     /// Executing scalar subqueries - replacing them with constant values.
-    executeScalarSubqueries(query, context, subquery_depth, result.scalars, select_options.only_analyze);
+    executeScalarSubqueries(query, getContext(), subquery_depth, result.scalars, select_options.only_analyze);
 
-    TreeOptimizer::apply(query, result.aliases, source_columns_set, tables_with_columns, context, result.metadata_snapshot, result.rewrite_subqueries);
+    TreeOptimizer::apply(
+        query, result.aliases, source_columns_set, tables_with_columns, getContext(), result.metadata_snapshot, result.rewrite_subqueries);
 
     /// array_join_alias_to_name, array_join_result_to_source.
     getArrayJoinedColumns(query, result, select_query, result.source_columns, source_columns_set);
@@ -850,7 +849,7 @@ TreeRewriterResultPtr TreeRewriter::analyzeSelect(
     /// rewrite filters for select query, must go after getArrayJoinedColumns
     if (settings.optimize_respect_aliases && result.metadata_snapshot)
     {
-        replaceAliasColumnsInQuery(query, result.metadata_snapshot->getColumns(), result.getArrayJoinSourceNameSet(), context);
+        replaceAliasColumnsInQuery(query, result.metadata_snapshot->getColumns(), result.getArrayJoinSourceNameSet(), getContext());
     }
 
     result.aggregates = getAggregates(query, *select_query);
@@ -877,14 +876,14 @@ TreeRewriterResultPtr TreeRewriter::analyze(
     if (query->as<ASTSelectQuery>())
         throw Exception("Not select analyze for select asts.", ErrorCodes::LOGICAL_ERROR);
 
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = getContext()->getSettingsRef();
 
     TreeRewriterResult result(source_columns, storage, metadata_snapshot, false);
 
     normalize(query, result.aliases, result.source_columns_set, settings);
 
     /// Executing scalar subqueries. Column defaults could be a scalar subquery.
-    executeScalarSubqueries(query, context, 0, result.scalars, false);
+    executeScalarSubqueries(query, getContext(), 0, result.scalars, false);
 
     TreeOptimizer::optimizeIf(query, result.aliases, settings.optimize_if_chain_to_multiif);
 
diff --git a/src/Interpreters/TreeRewriter.h b/src/Interpreters/TreeRewriter.h
index 4e3fe21bde9..26cfaad1fbb 100644
--- a/src/Interpreters/TreeRewriter.h
+++ b/src/Interpreters/TreeRewriter.h
@@ -3,8 +3,9 @@
 #include <Core/Block.h>
 #include <Core/NamesAndTypes.h>
 #include <Interpreters/Aliases.h>
-#include <Interpreters/SelectQueryOptions.h>
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/DatabaseAndTableWithAlias.h>
+#include <Interpreters/SelectQueryOptions.h>
 #include <Storages/IStorage_fwd.h>
 
 namespace DB
@@ -13,7 +14,6 @@ namespace DB
 class ASTFunction;
 struct ASTTablesInSelectQueryElement;
 class TableJoin;
-class Context;
 struct Settings;
 struct SelectQueryOptions;
 using Scalars = std::map<String, Block>;
@@ -92,12 +92,10 @@ using TreeRewriterResultPtr = std::shared_ptr<const TreeRewriterResult>;
 ///  * scalar subqueries are executed replaced with constants
 ///  * unneeded columns are removed from SELECT clause
 ///  * duplicated columns are removed from ORDER BY, LIMIT BY, USING(...).
-class TreeRewriter
+class TreeRewriter : WithContext
 {
 public:
-    TreeRewriter(const Context & context_)
-        : context(context_)
-    {}
+    explicit TreeRewriter(ContextPtr context_) : WithContext(context_) {}
 
     /// Analyze and rewrite not select query
     TreeRewriterResultPtr analyze(
@@ -117,8 +115,6 @@ public:
         std::shared_ptr<TableJoin> table_join = {}) const;
 
 private:
-    const Context & context;
-
     static void normalize(ASTPtr & query, Aliases & aliases, const NameSet & source_columns_set, const Settings & settings);
 };
 
diff --git a/src/Interpreters/WindowDescription.cpp b/src/Interpreters/WindowDescription.cpp
index a97ef41204a..05d75d4647e 100644
--- a/src/Interpreters/WindowDescription.cpp
+++ b/src/Interpreters/WindowDescription.cpp
@@ -86,6 +86,38 @@ void WindowFrame::toString(WriteBuffer & buf) const
 
 void WindowFrame::checkValid() const
 {
+    // Check the validity of offsets.
+    if (type == WindowFrame::FrameType::Rows
+        || type == WindowFrame::FrameType::Groups)
+    {
+        if (begin_type == BoundaryType::Offset
+            && !((begin_offset.getType() == Field::Types::UInt64
+                    || begin_offset.getType() == Field::Types::Int64)
+                && begin_offset.get<Int64>() >= 0
+                && begin_offset.get<Int64>() < INT_MAX))
+        {
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                "Frame start offset for '{}' frame must be a nonnegative 32-bit integer, '{}' of type '{}' given.",
+                toString(type),
+                applyVisitor(FieldVisitorToString(), begin_offset),
+                Field::Types::toString(begin_offset.getType()));
+        }
+
+        if (end_type == BoundaryType::Offset
+            && !((end_offset.getType() == Field::Types::UInt64
+                    || end_offset.getType() == Field::Types::Int64)
+                && end_offset.get<Int64>() >= 0
+                && end_offset.get<Int64>() < INT_MAX))
+        {
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                "Frame end offset for '{}' frame must be a nonnegative 32-bit integer, '{}' of type '{}' given.",
+                toString(type),
+                applyVisitor(FieldVisitorToString(), end_offset),
+                Field::Types::toString(end_offset.getType()));
+        }
+    }
+
+    // Check relative positioning of offsets.
     // UNBOUNDED PRECEDING end and UNBOUNDED FOLLOWING start should have been
     // forbidden at the parsing level.
     assert(!(begin_type == BoundaryType::Unbounded && !begin_preceding));
diff --git a/src/Interpreters/addMissingDefaults.cpp b/src/Interpreters/addMissingDefaults.cpp
index bb444103d8e..ef3e4e095bc 100644
--- a/src/Interpreters/addMissingDefaults.cpp
+++ b/src/Interpreters/addMissingDefaults.cpp
@@ -19,7 +19,7 @@ ActionsDAGPtr addMissingDefaults(
     const Block & header,
     const NamesAndTypesList & required_columns,
     const ColumnsDescription & columns,
-    const Context & context)
+    ContextPtr context)
 {
     auto actions = std::make_shared<ActionsDAG>(header.getColumnsWithTypeAndName());
     auto & index = actions->getIndex();
diff --git a/src/Interpreters/addMissingDefaults.h b/src/Interpreters/addMissingDefaults.h
index e746c7cc9e6..90376c41216 100644
--- a/src/Interpreters/addMissingDefaults.h
+++ b/src/Interpreters/addMissingDefaults.h
@@ -1,15 +1,16 @@
 #pragma once
 
-#include <unordered_map>
-#include <string>
+#include <Interpreters/Context_fwd.h>
+
 #include <memory>
+#include <string>
+#include <unordered_map>
 
 
 namespace DB
 {
 
 class Block;
-class Context;
 class NamesAndTypesList;
 class ColumnsDescription;
 
@@ -23,9 +24,5 @@ using ActionsDAGPtr = std::shared_ptr<ActionsDAG>;
   * All three types of columns are materialized (not constants).
   */
 ActionsDAGPtr addMissingDefaults(
-    const Block & header,
-    const NamesAndTypesList & required_columns,
-    const ColumnsDescription & columns,
-    const Context & context);
-
+    const Block & header, const NamesAndTypesList & required_columns, const ColumnsDescription & columns, ContextPtr context);
 }
diff --git a/src/Interpreters/addTypeConversionToAST.cpp b/src/Interpreters/addTypeConversionToAST.cpp
index 18591fd732c..73c95bd9a8c 100644
--- a/src/Interpreters/addTypeConversionToAST.cpp
+++ b/src/Interpreters/addTypeConversionToAST.cpp
@@ -32,7 +32,7 @@ ASTPtr addTypeConversionToAST(ASTPtr && ast, const String & type_name)
     return func;
 }
 
-ASTPtr addTypeConversionToAST(ASTPtr && ast, const String & type_name, const NamesAndTypesList & all_columns, const Context & context)
+ASTPtr addTypeConversionToAST(ASTPtr && ast, const String & type_name, const NamesAndTypesList & all_columns, ContextPtr context)
 {
     auto syntax_analyzer_result = TreeRewriter(context).analyze(ast, all_columns);
     const auto actions = ExpressionAnalyzer(ast, syntax_analyzer_result, context).getActions(true);
diff --git a/src/Interpreters/addTypeConversionToAST.h b/src/Interpreters/addTypeConversionToAST.h
index 16fa98f6e0c..eb391b2c749 100644
--- a/src/Interpreters/addTypeConversionToAST.h
+++ b/src/Interpreters/addTypeConversionToAST.h
@@ -1,17 +1,19 @@
 #pragma once
 
-#include <common/types.h>
+#include <Interpreters/Context_fwd.h>
 #include <Parsers/IAST_fwd.h>
+#include <common/types.h>
 
 
 namespace DB
 {
-class Context;
+
 class NamesAndTypesList;
+
 /// It will produce an expression with CAST to get an AST with the required type.
 ASTPtr addTypeConversionToAST(ASTPtr && ast, const String & type_name);
 
 // If same type, then ignore the wrapper of CAST function
-ASTPtr addTypeConversionToAST(ASTPtr && ast, const String & type_name, const NamesAndTypesList & all_columns, const Context & context);
+ASTPtr addTypeConversionToAST(ASTPtr && ast, const String & type_name, const NamesAndTypesList & all_columns, ContextPtr context);
 
 }
diff --git a/src/Interpreters/evaluateConstantExpression.cpp b/src/Interpreters/evaluateConstantExpression.cpp
index a3301bcf55b..89924025c08 100644
--- a/src/Interpreters/evaluateConstantExpression.cpp
+++ b/src/Interpreters/evaluateConstantExpression.cpp
@@ -30,14 +30,14 @@ namespace ErrorCodes
 }
 
 
-std::pair<Field, std::shared_ptr<const IDataType>> evaluateConstantExpression(const ASTPtr & node, const Context & context)
+std::pair<Field, std::shared_ptr<const IDataType>> evaluateConstantExpression(const ASTPtr & node, ContextPtr context)
 {
     NamesAndTypesList source_columns = {{ "_dummy", std::make_shared<DataTypeUInt8>() }};
     auto ast = node->clone();
-    ReplaceQueryParameterVisitor param_visitor(context.getQueryParameters());
+    ReplaceQueryParameterVisitor param_visitor(context->getQueryParameters());
     param_visitor.visit(ast);
 
-    if (context.getSettingsRef().normalize_function_names)
+    if (context->getSettingsRef().normalize_function_names)
         FunctionNameNormalizer().visit(ast.get());
 
     String name = ast->getColumnName();
@@ -66,7 +66,7 @@ std::pair<Field, std::shared_ptr<const IDataType>> evaluateConstantExpression(co
 }
 
 
-ASTPtr evaluateConstantExpressionAsLiteral(const ASTPtr & node, const Context & context)
+ASTPtr evaluateConstantExpressionAsLiteral(const ASTPtr & node, ContextPtr context)
 {
     /// If it's already a literal.
     if (node->as<ASTLiteral>())
@@ -74,7 +74,7 @@ ASTPtr evaluateConstantExpressionAsLiteral(const ASTPtr & node, const Context &
     return std::make_shared<ASTLiteral>(evaluateConstantExpression(node, context).first);
 }
 
-ASTPtr evaluateConstantExpressionOrIdentifierAsLiteral(const ASTPtr & node, const Context & context)
+ASTPtr evaluateConstantExpressionOrIdentifierAsLiteral(const ASTPtr & node, ContextPtr context)
 {
     if (const auto * id = node->as<ASTIdentifier>())
         return std::make_shared<ASTLiteral>(id->name());
@@ -82,18 +82,18 @@ ASTPtr evaluateConstantExpressionOrIdentifierAsLiteral(const ASTPtr & node, cons
     return evaluateConstantExpressionAsLiteral(node, context);
 }
 
-ASTPtr evaluateConstantExpressionForDatabaseName(const ASTPtr & node, const Context & context)
+ASTPtr evaluateConstantExpressionForDatabaseName(const ASTPtr & node, ContextPtr context)
 {
     ASTPtr res = evaluateConstantExpressionOrIdentifierAsLiteral(node, context);
     auto & literal = res->as<ASTLiteral &>();
     if (literal.value.safeGet<String>().empty())
     {
-        String current_database = context.getCurrentDatabase();
+        String current_database = context->getCurrentDatabase();
         if (current_database.empty())
         {
             /// Table was created on older version of ClickHouse and CREATE contains not folded expression.
             /// Current database is not set yet during server startup, so we cannot evaluate it correctly.
-            literal.value = context.getConfigRef().getString("default_database", "default");
+            literal.value = context->getConfigRef().getString("default_database", "default");
         }
         else
             literal.value = current_database;
diff --git a/src/Interpreters/evaluateConstantExpression.h b/src/Interpreters/evaluateConstantExpression.h
index c797b8461de..b95982f5b99 100644
--- a/src/Interpreters/evaluateConstantExpression.h
+++ b/src/Interpreters/evaluateConstantExpression.h
@@ -2,6 +2,7 @@
 
 #include <Core/Block.h>
 #include <Core/Field.h>
+#include <Interpreters/Context_fwd.h>
 #include <Parsers/IAST.h>
 #include <Parsers/IParser.h>
 
@@ -12,7 +13,6 @@
 namespace DB
 {
 
-class Context;
 class ExpressionActions;
 class IDataType;
 
@@ -23,25 +23,25 @@ using ExpressionActionsPtr = std::shared_ptr<ExpressionActions>;
   * Throws exception if it's not a constant expression.
   * Quite suboptimal.
   */
-std::pair<Field, std::shared_ptr<const IDataType>> evaluateConstantExpression(const ASTPtr & node, const Context & context);
+std::pair<Field, std::shared_ptr<const IDataType>> evaluateConstantExpression(const ASTPtr & node, ContextPtr context);
 
 
 /** Evaluate constant expression and returns ASTLiteral with its value.
   */
-ASTPtr evaluateConstantExpressionAsLiteral(const ASTPtr & node, const Context & context);
+ASTPtr evaluateConstantExpressionAsLiteral(const ASTPtr & node, ContextPtr context);
 
 
 /** Evaluate constant expression and returns ASTLiteral with its value.
   * Also, if AST is identifier, then return string literal with its name.
   * Useful in places where some name may be specified as identifier, or as result of a constant expression.
   */
-ASTPtr evaluateConstantExpressionOrIdentifierAsLiteral(const ASTPtr & node, const Context & context);
+ASTPtr evaluateConstantExpressionOrIdentifierAsLiteral(const ASTPtr & node, ContextPtr context);
 
 /** The same as evaluateConstantExpressionOrIdentifierAsLiteral(...),
  *  but if result is an empty string, replace it with current database name
  *  or default database name.
  */
-ASTPtr evaluateConstantExpressionForDatabaseName(const ASTPtr & node, const Context & context);
+ASTPtr evaluateConstantExpressionForDatabaseName(const ASTPtr & node, ContextPtr context);
 
 /** Try to fold condition to countable set of constant values.
   * @param node a condition that we try to fold.
diff --git a/src/Interpreters/executeDDLQueryOnCluster.cpp b/src/Interpreters/executeDDLQueryOnCluster.cpp
index d4e8d06e613..99ece6bb14c 100644
--- a/src/Interpreters/executeDDLQueryOnCluster.cpp
+++ b/src/Interpreters/executeDDLQueryOnCluster.cpp
@@ -48,17 +48,17 @@ bool isSupportedAlterType(int type)
 }
 
 
-BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, const Context & context)
+BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, ContextPtr context)
 {
     return executeDDLQueryOnCluster(query_ptr_, context, {});
 }
 
-BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr, const Context & context, const AccessRightsElements & query_requires_access)
+BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr, ContextPtr context, const AccessRightsElements & query_requires_access)
 {
     return executeDDLQueryOnCluster(query_ptr, context, AccessRightsElements{query_requires_access});
 }
 
-BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, const Context & context, AccessRightsElements && query_requires_access)
+BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, ContextPtr context, AccessRightsElements && query_requires_access)
 {
     /// Remove FORMAT <fmt> and INTO OUTFILE <file> if exists
     ASTPtr query_ptr = query_ptr_->clone();
@@ -71,7 +71,7 @@ BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, const Context & cont
         throw Exception("Distributed execution is not supported for such DDL queries", ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    if (!context.getSettingsRef().allow_distributed_ddl)
+    if (!context->getSettingsRef().allow_distributed_ddl)
         throw Exception("Distributed DDL queries are prohibited for the user", ErrorCodes::QUERY_IS_PROHIBITED);
 
     if (const auto * query_alter = query_ptr->as<ASTAlterQuery>())
@@ -83,9 +83,9 @@ BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, const Context & cont
         }
     }
 
-    query->cluster = context.getMacros()->expand(query->cluster);
-    ClusterPtr cluster = context.getCluster(query->cluster);
-    DDLWorker & ddl_worker = context.getDDLWorker();
+    query->cluster = context->getMacros()->expand(query->cluster);
+    ClusterPtr cluster = context->getCluster(query->cluster);
+    DDLWorker & ddl_worker = context->getDDLWorker();
 
     /// Enumerate hosts which will be used to send query.
     Cluster::AddressesWithFailover shards = cluster->getShardsAddresses();
@@ -109,7 +109,7 @@ BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, const Context & cont
            != query_requires_access.end());
 
     bool use_local_default_database = false;
-    const String & current_database = context.getCurrentDatabase();
+    const String & current_database = context->getCurrentDatabase();
 
     if (need_replace_current_database)
     {
@@ -157,7 +157,7 @@ BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, const Context & cont
     visitor.visitDDL(query_ptr);
 
     /// Check access rights, assume that all servers have the same users config
-    context.checkAccess(query_requires_access);
+    context->checkAccess(query_requires_access);
 
     DDLLogEntry entry;
     entry.hosts = std::move(hosts);
@@ -169,14 +169,14 @@ BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, const Context & cont
     return getDistributedDDLStatus(node_path, entry, context);
 }
 
-BlockIO getDistributedDDLStatus(const String & node_path, const DDLLogEntry & entry, const Context & context, const std::optional<Strings> & hosts_to_wait)
+BlockIO getDistributedDDLStatus(const String & node_path, const DDLLogEntry & entry, ContextPtr context, const std::optional<Strings> & hosts_to_wait)
 {
     BlockIO io;
-    if (context.getSettingsRef().distributed_ddl_task_timeout == 0)
+    if (context->getSettingsRef().distributed_ddl_task_timeout == 0)
         return io;
 
     auto stream = std::make_shared<DDLQueryStatusInputStream>(node_path, entry, context, hosts_to_wait);
-    if (context.getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::NONE)
+    if (context->getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::NONE)
     {
         /// Wait for query to finish, but ignore output
         NullBlockOutputStream output{Block{}};
@@ -189,18 +189,18 @@ BlockIO getDistributedDDLStatus(const String & node_path, const DDLLogEntry & en
     return io;
 }
 
-DDLQueryStatusInputStream::DDLQueryStatusInputStream(const String & zk_node_path, const DDLLogEntry & entry, const Context & context_,
+DDLQueryStatusInputStream::DDLQueryStatusInputStream(const String & zk_node_path, const DDLLogEntry & entry, ContextPtr context_,
                                                      const std::optional<Strings> & hosts_to_wait)
     : node_path(zk_node_path)
     , context(context_)
     , watch(CLOCK_MONOTONIC_COARSE)
     , log(&Poco::Logger::get("DDLQueryStatusInputStream"))
 {
-    if (context.getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::THROW ||
-        context.getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::NONE)
+    if (context->getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::THROW ||
+        context->getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::NONE)
         throw_on_timeout = true;
-    else if (context.getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::NULL_STATUS_ON_TIMEOUT ||
-             context.getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::NEVER_THROW)
+    else if (context->getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::NULL_STATUS_ON_TIMEOUT ||
+             context->getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::NEVER_THROW)
         throw_on_timeout = false;
     else
         throw Exception(ErrorCodes::LOGICAL_ERROR, "Unknown output mode");
@@ -235,7 +235,7 @@ DDLQueryStatusInputStream::DDLQueryStatusInputStream(const String & zk_node_path
 
     addTotalRowsApprox(waiting_hosts.size());
 
-    timeout_seconds = context.getSettingsRef().distributed_ddl_task_timeout;
+    timeout_seconds = context->getSettingsRef().distributed_ddl_task_timeout;
 }
 
 std::pair<String, UInt16> DDLQueryStatusInputStream::parseHostAndPort(const String & host_id) const
@@ -259,21 +259,21 @@ Block DDLQueryStatusInputStream::readImpl()
     assert(num_hosts_finished <= waiting_hosts.size());
     if (all_hosts_finished || timeout_exceeded)
     {
-        bool throw_if_error_on_host = context.getSettingsRef().distributed_ddl_output_mode != DistributedDDLOutputMode::NEVER_THROW;
+        bool throw_if_error_on_host = context->getSettingsRef().distributed_ddl_output_mode != DistributedDDLOutputMode::NEVER_THROW;
         if (first_exception && throw_if_error_on_host)
             throw Exception(*first_exception);
 
         return res;
     }
 
-    auto zookeeper = context.getZooKeeper();
+    auto zookeeper = context->getZooKeeper();
     size_t try_number = 0;
 
     while (res.rows() == 0)
     {
         if (isCancelled())
         {
-            bool throw_if_error_on_host = context.getSettingsRef().distributed_ddl_output_mode != DistributedDDLOutputMode::NEVER_THROW;
+            bool throw_if_error_on_host = context->getSettingsRef().distributed_ddl_output_mode != DistributedDDLOutputMode::NEVER_THROW;
             if (first_exception && throw_if_error_on_host)
                 throw Exception(*first_exception);
 
diff --git a/src/Interpreters/executeDDLQueryOnCluster.h b/src/Interpreters/executeDDLQueryOnCluster.h
index a33b89d0cb3..bbd39a6e8ec 100644
--- a/src/Interpreters/executeDDLQueryOnCluster.h
+++ b/src/Interpreters/executeDDLQueryOnCluster.h
@@ -1,5 +1,7 @@
 #pragma once
+
 #include <DataStreams/BlockIO.h>
+#include <Interpreters/Context_fwd.h>
 #include <Parsers/IAST_fwd.h>
 
 namespace zkutil
@@ -10,7 +12,6 @@ namespace zkutil
 namespace DB
 {
 
-class Context;
 class AccessRightsElements;
 struct DDLLogEntry;
 
@@ -20,16 +21,16 @@ bool isSupportedAlterType(int type);
 
 /// Pushes distributed DDL query to the queue.
 /// Returns DDLQueryStatusInputStream, which reads results of query execution on each host in the cluster.
-BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr, const Context & context);
-BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr, const Context & context, const AccessRightsElements & query_requires_access);
-BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr, const Context & context, AccessRightsElements && query_requires_access);
+BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr, ContextPtr context);
+BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr, ContextPtr context, const AccessRightsElements & query_requires_access);
+BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr, ContextPtr context, AccessRightsElements && query_requires_access);
 
-BlockIO getDistributedDDLStatus(const String & node_path, const DDLLogEntry & entry, const Context & context, const std::optional<Strings> & hosts_to_wait = {});
+BlockIO getDistributedDDLStatus(const String & node_path, const DDLLogEntry & entry, ContextPtr context, const std::optional<Strings> & hosts_to_wait = {});
 
 class DDLQueryStatusInputStream final : public IBlockInputStream
 {
 public:
-    DDLQueryStatusInputStream(const String & zk_node_path, const DDLLogEntry & entry, const Context & context_, const std::optional<Strings> & hosts_to_wait = {});
+    DDLQueryStatusInputStream(const String & zk_node_path, const DDLLogEntry & entry, ContextPtr context_, const std::optional<Strings> & hosts_to_wait = {});
 
     String getName() const override { return "DDLQueryStatusInputStream"; }
 
@@ -48,7 +49,7 @@ private:
     std::pair<String, UInt16> parseHostAndPort(const String & host_id) const;
 
     String node_path;
-    const Context & context;
+    ContextPtr context;
     Stopwatch watch;
     Poco::Logger * log;
 
diff --git a/src/Interpreters/executeQuery.cpp b/src/Interpreters/executeQuery.cpp
index a5c21405ff1..5df245f9f26 100644
--- a/src/Interpreters/executeQuery.cpp
+++ b/src/Interpreters/executeQuery.cpp
@@ -121,7 +121,7 @@ static String joinLines(const String & query)
 }
 
 
-static String prepareQueryForLogging(const String & query, Context & context)
+static String prepareQueryForLogging(const String & query, ContextPtr context)
 {
     String res = query;
 
@@ -136,14 +136,14 @@ static String prepareQueryForLogging(const String & query, Context & context)
         }
     }
 
-    res = res.substr(0, context.getSettingsRef().log_queries_cut_to_length);
+    res = res.substr(0, context->getSettingsRef().log_queries_cut_to_length);
 
     return res;
 }
 
 
 /// Log query into text log (not into system table).
-static void logQuery(const String & query, const Context & context, bool internal)
+static void logQuery(const String & query, ContextPtr context, bool internal)
 {
     if (internal)
     {
@@ -151,14 +151,14 @@ static void logQuery(const String & query, const Context & context, bool interna
     }
     else
     {
-        const auto & client_info = context.getClientInfo();
+        const auto & client_info = context->getClientInfo();
 
         const auto & current_query_id = client_info.current_query_id;
         const auto & initial_query_id = client_info.initial_query_id;
         const auto & current_user = client_info.current_user;
 
-        String comment = context.getSettingsRef().log_comment;
-        size_t max_query_size = context.getSettingsRef().max_query_size;
+        String comment = context->getSettingsRef().log_comment;
+        size_t max_query_size = context->getSettingsRef().max_query_size;
 
         if (comment.size() > max_query_size)
             comment.resize(max_query_size);
@@ -170,7 +170,7 @@ static void logQuery(const String & query, const Context & context, bool interna
             client_info.current_address.toString(),
             (current_user != "default" ? ", user: " + current_user : ""),
             (!initial_query_id.empty() && current_query_id != initial_query_id ? ", initial_query_id: " + initial_query_id : std::string()),
-            (context.getSettingsRef().use_antlr_parser ? "experimental" : "production"),
+            (context->getSettingsRef().use_antlr_parser ? "experimental" : "production"),
             comment,
             joinLines(query));
 
@@ -204,19 +204,30 @@ static void setExceptionStackTrace(QueryLogElement & elem)
 
 
 /// Log exception (with query info) into text log (not into system table).
-static void logException(Context & context, QueryLogElement & elem)
+static void logException(ContextPtr context, QueryLogElement & elem)
 {
     String comment;
     if (!elem.log_comment.empty())
         comment = fmt::format(" (comment: {})", elem.log_comment);
 
     if (elem.stack_trace.empty())
-        LOG_ERROR(&Poco::Logger::get("executeQuery"), "{} (from {}){} (in query: {})",
-            elem.exception, context.getClientInfo().current_address.toString(), comment, joinLines(elem.query));
+        LOG_ERROR(
+            &Poco::Logger::get("executeQuery"),
+            "{} (from {}){} (in query: {})",
+            elem.exception,
+            context->getClientInfo().current_address.toString(),
+            comment,
+            joinLines(elem.query));
     else
-        LOG_ERROR(&Poco::Logger::get("executeQuery"), "{} (from {}){} (in query: {})"
+        LOG_ERROR(
+            &Poco::Logger::get("executeQuery"),
+            "{} (from {}){} (in query: {})"
             ", Stack trace (when copying this message, always include the lines below):\n\n{}",
-            elem.exception, context.getClientInfo().current_address.toString(), comment, joinLines(elem.query), elem.stack_trace);
+            elem.exception,
+            context->getClientInfo().current_address.toString(),
+            comment,
+            joinLines(elem.query),
+            elem.stack_trace);
 }
 
 inline UInt64 time_in_microseconds(std::chrono::time_point<std::chrono::system_clock> timepoint)
@@ -230,13 +241,13 @@ inline UInt64 time_in_seconds(std::chrono::time_point<std::chrono::system_clock>
     return std::chrono::duration_cast<std::chrono::seconds>(timepoint.time_since_epoch()).count();
 }
 
-static void onExceptionBeforeStart(const String & query_for_logging, Context & context, UInt64 current_time_us, ASTPtr ast)
+static void onExceptionBeforeStart(const String & query_for_logging, ContextPtr context, UInt64 current_time_us, ASTPtr ast)
 {
     /// Exception before the query execution.
-    if (auto quota = context.getQuota())
+    if (auto quota = context->getQuota())
         quota->used(Quota::ERRORS, 1, /* check_exceeded = */ false);
 
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
 
     /// Log the start of query execution into the table if necessary.
     QueryLogElement elem;
@@ -251,7 +262,7 @@ static void onExceptionBeforeStart(const String & query_for_logging, Context & c
     elem.query_start_time = current_time_us / 1000000;
     elem.query_start_time_microseconds = current_time_us;
 
-    elem.current_database = context.getCurrentDatabase();
+    elem.current_database = context->getCurrentDatabase();
     elem.query = query_for_logging;
     elem.normalized_query_hash = normalizedQueryHash<false>(query_for_logging);
 
@@ -260,7 +271,7 @@ static void onExceptionBeforeStart(const String & query_for_logging, Context & c
     elem.exception_code = getCurrentExceptionCode();
     elem.exception = getCurrentExceptionMessage(false);
 
-    elem.client_info = context.getClientInfo();
+    elem.client_info = context->getClientInfo();
 
     elem.log_comment = settings.log_comment;
     if (elem.log_comment.size() > settings.max_query_size)
@@ -274,17 +285,17 @@ static void onExceptionBeforeStart(const String & query_for_logging, Context & c
     CurrentThread::finalizePerformanceCounters();
 
     if (settings.log_queries && elem.type >= settings.log_queries_min_type && !settings.log_queries_min_query_duration_ms.totalMilliseconds())
-        if (auto query_log = context.getQueryLog())
+        if (auto query_log = context->getQueryLog())
             query_log->add(elem);
 
-    if (auto opentelemetry_span_log = context.getOpenTelemetrySpanLog();
-        context.query_trace_context.trace_id
+    if (auto opentelemetry_span_log = context->getOpenTelemetrySpanLog();
+        context->query_trace_context.trace_id
             && opentelemetry_span_log)
     {
         OpenTelemetrySpanLogElement span;
-        span.trace_id = context.query_trace_context.trace_id;
-        span.span_id = context.query_trace_context.span_id;
-        span.parent_span_id = context.getClientInfo().client_trace_context.span_id;
+        span.trace_id = context->query_trace_context.trace_id;
+        span.span_id = context->query_trace_context.span_id;
+        span.parent_span_id = context->getClientInfo().client_trace_context.span_id;
         span.operation_name = "query";
         span.start_time_us = current_time_us;
         span.finish_time_us = current_time_us;
@@ -299,11 +310,11 @@ static void onExceptionBeforeStart(const String & query_for_logging, Context & c
         span.attribute_names.push_back("clickhouse.query_id");
         span.attribute_values.push_back(elem.client_info.current_query_id);
 
-        if (!context.query_trace_context.tracestate.empty())
+        if (!context->query_trace_context.tracestate.empty())
         {
             span.attribute_names.push_back("clickhouse.tracestate");
             span.attribute_values.push_back(
-                context.query_trace_context.tracestate);
+                context->query_trace_context.tracestate);
         }
 
         opentelemetry_span_log->add(span);
@@ -324,19 +335,19 @@ static void onExceptionBeforeStart(const String & query_for_logging, Context & c
     }
 }
 
-static void setQuerySpecificSettings(ASTPtr & ast, Context & context)
+static void setQuerySpecificSettings(ASTPtr & ast, ContextPtr context)
 {
     if (auto * ast_insert_into = dynamic_cast<ASTInsertQuery *>(ast.get()))
     {
         if (ast_insert_into->watch)
-            context.setSetting("output_format_enable_streaming", 1);
+            context->setSetting("output_format_enable_streaming", 1);
     }
 }
 
 static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
     const char * begin,
     const char * end,
-    Context & context,
+    ContextPtr context,
     bool internal,
     QueryProcessingStage::Enum stage,
     bool has_query_tail,
@@ -349,7 +360,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
     assert(internal || CurrentThread::get().getQueryContext()->getCurrentQueryId() == CurrentThread::getQueryId());
 #endif
 
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
 
     ASTPtr ast;
     const char * query_end;
@@ -365,7 +376,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
 #if !defined(ARCADIA_BUILD)
         if (settings.use_antlr_parser)
         {
-            ast = parseQuery(begin, end, max_query_size, settings.max_parser_depth, context.getCurrentDatabase());
+            ast = parseQuery(begin, end, max_query_size, settings.max_parser_depth, context->getCurrentDatabase());
         }
         else
         {
@@ -456,9 +467,9 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
     try
     {
         /// Replace ASTQueryParameter with ASTLiteral for prepared statements.
-        if (context.hasQueryParameters())
+        if (context->hasQueryParameters())
         {
-            ReplaceQueryParameterVisitor visitor(context.getQueryParameters());
+            ReplaceQueryParameterVisitor visitor(context->getQueryParameters());
             visitor.visit(ast);
             query = serializeAST(*ast);
         }
@@ -476,7 +487,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
         }
 
         /// Normalize SelectWithUnionQuery
-        NormalizeSelectWithUnionQueryVisitor::Data data{context.getSettingsRef().union_default_mode};
+        NormalizeSelectWithUnionQueryVisitor::Data data{context->getSettingsRef().union_default_mode};
         NormalizeSelectWithUnionQueryVisitor{data}.visit(ast);
 
         /// Check the limits.
@@ -487,12 +498,12 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
         if (!internal && !ast->as<ASTShowProcesslistQuery>())
         {
             /// processlist also has query masked now, to avoid secrets leaks though SHOW PROCESSLIST by other users.
-            process_list_entry = context.getProcessList().insert(query_for_logging, ast.get(), context);
-            context.setProcessListElement(&process_list_entry->get());
+            process_list_entry = context->getProcessList().insert(query_for_logging, ast.get(), context);
+            context->setProcessListElement(&process_list_entry->get());
         }
 
         /// Load external tables if they were provided
-        context.initializeExternalTablesIfSet();
+        context->initializeExternalTablesIfSet();
 
         auto * insert_query = ast->as<ASTInsertQuery>();
         if (insert_query && insert_query->select)
@@ -504,7 +515,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
                 insert_query->tryFindInputFunction(input_function);
                 if (input_function)
                 {
-                    StoragePtr storage = context.executeTableFunction(input_function);
+                    StoragePtr storage = context->executeTableFunction(input_function);
                     auto & input_storage = dynamic_cast<StorageInput &>(*storage);
                     auto input_metadata_snapshot = input_storage.getInMemoryMetadataPtr();
                     BlockInputStreamPtr input_stream = std::make_shared<InputStreamFromASTInsertQuery>(
@@ -515,14 +526,14 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
         }
         else
             /// reset Input callbacks if query is not INSERT SELECT
-            context.resetInputCallbacks();
+            context->resetInputCallbacks();
 
         auto interpreter = InterpreterFactory::get(ast, context, SelectQueryOptions(stage).setInternal(internal));
 
         std::shared_ptr<const EnabledQuota> quota;
         if (!interpreter->ignoreQuota())
         {
-            quota = context.getQuota();
+            quota = context->getQuota();
             if (quota)
             {
                 if (ast->as<ASTSelectQuery>() || ast->as<ASTSelectWithUnionQuery>())
@@ -558,7 +569,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
             /// Save insertion table (not table function). TODO: support remote() table function.
             auto table_id = insert_interpreter->getDatabaseTable();
             if (!table_id.empty())
-                context.setInsertionTable(std::move(table_id));
+                context->setInsertionTable(std::move(table_id));
         }
 
         if (process_list_entry)
@@ -578,8 +589,8 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
         {
             /// Limits on the result, the quota on the result, and also callback for progress.
             /// Limits apply only to the final result.
-            pipeline.setProgressCallback(context.getProgressCallback());
-            pipeline.setProcessListElement(context.getProcessListElement());
+            pipeline.setProgressCallback(context->getProgressCallback());
+            pipeline.setProcessListElement(context->getProcessListElement());
             if (stage == QueryProcessingStage::Complete && !pipeline.isCompleted())
             {
                 pipeline.resize(1);
@@ -597,8 +608,8 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
             /// Limits apply only to the final result.
             if (res.in)
             {
-                res.in->setProgressCallback(context.getProgressCallback());
-                res.in->setProcessListElement(context.getProcessListElement());
+                res.in->setProgressCallback(context->getProgressCallback());
+                res.in->setProcessListElement(context->getProcessListElement());
                 if (stage == QueryProcessingStage::Complete)
                 {
                     if (!interpreter->ignoreQuota())
@@ -612,7 +623,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
             {
                 if (auto * stream = dynamic_cast<CountingBlockOutputStream *>(res.out.get()))
                 {
-                    stream->setProcessListElement(context.getProcessListElement());
+                    stream->setProcessListElement(context->getProcessListElement());
                 }
             }
         }
@@ -628,11 +639,11 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
             elem.query_start_time = time_in_seconds(current_time);
             elem.query_start_time_microseconds = time_in_microseconds(current_time);
 
-            elem.current_database = context.getCurrentDatabase();
+            elem.current_database = context->getCurrentDatabase();
             elem.query = query_for_logging;
             elem.normalized_query_hash = normalizedQueryHash<false>(query_for_logging);
 
-            elem.client_info = context.getClientInfo();
+            elem.client_info = context->getClientInfo();
 
             bool log_queries = settings.log_queries && !internal;
 
@@ -641,7 +652,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
             {
                 if (use_processors)
                 {
-                    const auto & info = context.getQueryAccessInfo();
+                    const auto & info = context->getQueryAccessInfo();
                     elem.query_databases = info.databases;
                     elem.query_tables = info.tables;
                     elem.query_columns = info.columns;
@@ -650,7 +661,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
                 interpreter->extendQueryLogElem(elem, ast, context, query_database, query_table);
 
                 if (settings.log_query_settings)
-                    elem.query_settings = std::make_shared<Settings>(context.getSettingsRef());
+                    elem.query_settings = std::make_shared<Settings>(context->getSettingsRef());
 
                 elem.log_comment = settings.log_comment;
                 if (elem.log_comment.size() > settings.max_query_size)
@@ -658,7 +669,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
 
                 if (elem.type >= settings.log_queries_min_type && !settings.log_queries_min_query_duration_ms.totalMilliseconds())
                 {
-                    if (auto query_log = context.getQueryLog())
+                    if (auto query_log = context->getQueryLog())
                         query_log->add(elem);
                 }
             }
@@ -692,7 +703,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
             };
 
             /// Also make possible for caller to log successful query finish and exception during execution.
-            auto finish_callback = [elem, &context, ast,
+            auto finish_callback = [elem, context, ast,
                  log_queries,
                  log_queries_min_type = settings.log_queries_min_type,
                  log_queries_min_query_duration_ms = settings.log_queries_min_query_duration_ms.totalMilliseconds(),
@@ -700,7 +711,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
             ]
                 (IBlockInputStream * stream_in, IBlockOutputStream * stream_out, QueryPipeline * query_pipeline) mutable
             {
-                QueryStatus * process_list_elem = context.getProcessListElement();
+                QueryStatus * process_list_elem = context->getProcessListElement();
 
                 if (!process_list_elem)
                     return;
@@ -708,7 +719,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
                 /// Update performance counters before logging to query_log
                 CurrentThread::finalizePerformanceCounters();
 
-                QueryStatusInfo info = process_list_elem->getInfo(true, context.getSettingsRef().log_profile_events);
+                QueryStatusInfo info = process_list_elem->getInfo(true, context->getSettingsRef().log_profile_events);
 
                 double elapsed_seconds = info.elapsed_seconds;
 
@@ -721,7 +732,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
                 elem.event_time_microseconds = time_in_microseconds(finish_time);
                 status_info_to_query_log(elem, info, ast);
 
-                auto progress_callback = context.getProgressCallback();
+                auto progress_callback = context->getProgressCallback();
 
                 if (progress_callback)
                     progress_callback(Progress(WriteProgress(info.written_rows, info.written_bytes)));
@@ -763,7 +774,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
                 elem.thread_ids = std::move(info.thread_ids);
                 elem.profile_counters = std::move(info.profile_counters);
 
-                const auto & factories_info = context.getQueryFactoriesInfo();
+                const auto & factories_info = context->getQueryFactoriesInfo();
                 elem.used_aggregate_functions = factories_info.aggregate_functions;
                 elem.used_aggregate_function_combinators = factories_info.aggregate_function_combinators;
                 elem.used_database_engines = factories_info.database_engines;
@@ -776,18 +787,18 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
 
                 if (log_queries && elem.type >= log_queries_min_type && Int64(elem.query_duration_ms) >= log_queries_min_query_duration_ms)
                 {
-                    if (auto query_log = context.getQueryLog())
+                    if (auto query_log = context->getQueryLog())
                         query_log->add(elem);
                 }
 
-                if (auto opentelemetry_span_log = context.getOpenTelemetrySpanLog();
-                    context.query_trace_context.trace_id
+                if (auto opentelemetry_span_log = context->getOpenTelemetrySpanLog();
+                    context->query_trace_context.trace_id
                         && opentelemetry_span_log)
                 {
                     OpenTelemetrySpanLogElement span;
-                    span.trace_id = context.query_trace_context.trace_id;
-                    span.span_id = context.query_trace_context.span_id;
-                    span.parent_span_id = context.getClientInfo().client_trace_context.span_id;
+                    span.trace_id = context->query_trace_context.trace_id;
+                    span.span_id = context->query_trace_context.span_id;
+                    span.parent_span_id = context->getClientInfo().client_trace_context.span_id;
                     span.operation_name = "query";
                     span.start_time_us = elem.query_start_time_microseconds;
                     span.finish_time_us = time_in_microseconds(finish_time);
@@ -801,18 +812,18 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
 
                     span.attribute_names.push_back("clickhouse.query_id");
                     span.attribute_values.push_back(elem.client_info.current_query_id);
-                    if (!context.query_trace_context.tracestate.empty())
+                    if (!context->query_trace_context.tracestate.empty())
                     {
                         span.attribute_names.push_back("clickhouse.tracestate");
                         span.attribute_values.push_back(
-                            context.query_trace_context.tracestate);
+                            context->query_trace_context.tracestate);
                     }
 
                     opentelemetry_span_log->add(span);
                 }
             };
 
-            auto exception_callback = [elem, &context, ast,
+            auto exception_callback = [elem, context, ast,
                  log_queries,
                  log_queries_min_type = settings.log_queries_min_type,
                  log_queries_min_query_duration_ms = settings.log_queries_min_query_duration_ms.totalMilliseconds(),
@@ -833,8 +844,8 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
                 elem.exception_code = getCurrentExceptionCode();
                 elem.exception = getCurrentExceptionMessage(false);
 
-                QueryStatus * process_list_elem = context.getProcessListElement();
-                const Settings & current_settings = context.getSettingsRef();
+                QueryStatus * process_list_elem = context->getProcessListElement();
+                const Settings & current_settings = context->getSettingsRef();
 
                 /// Update performance counters before logging to query_log
                 CurrentThread::finalizePerformanceCounters();
@@ -852,7 +863,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
                 /// In case of exception we log internal queries also
                 if (log_queries && elem.type >= log_queries_min_type && Int64(elem.query_duration_ms) >= log_queries_min_query_duration_ms)
                 {
-                    if (auto query_log = context.getQueryLog())
+                    if (auto query_log = context->getQueryLog())
                         query_log->add(elem);
                 }
 
@@ -898,7 +909,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
 
 BlockIO executeQuery(
     const String & query,
-    Context & context,
+    ContextPtr context,
     bool internal,
     QueryProcessingStage::Enum stage,
     bool may_have_embedded_data)
@@ -912,7 +923,7 @@ BlockIO executeQuery(
     {
         String format_name = ast_query_with_output->format
                 ? getIdentifierName(ast_query_with_output->format)
-                : context.getDefaultFormat();
+                : context->getDefaultFormat();
 
         if (format_name == "Null")
             streams.null_format = true;
@@ -923,7 +934,7 @@ BlockIO executeQuery(
 
 BlockIO executeQuery(
     const String & query,
-    Context & context,
+    ContextPtr context,
     bool internal,
     QueryProcessingStage::Enum stage,
     bool may_have_embedded_data,
@@ -942,7 +953,7 @@ void executeQuery(
     ReadBuffer & istr,
     WriteBuffer & ostr,
     bool allow_into_outfile,
-    Context & context,
+    ContextPtr context,
     std::function<void(const String &, const String &, const String &, const String &)> set_result_details)
 {
     PODArray<char> parse_buf;
@@ -953,7 +964,7 @@ void executeQuery(
     if (!istr.hasPendingData())
         istr.next();
 
-    size_t max_query_size = context.getSettingsRef().max_query_size;
+    size_t max_query_size = context->getSettingsRef().max_query_size;
 
     bool may_have_tail;
     if (istr.buffer().end() - istr.position() > static_cast<ssize_t>(max_query_size))
@@ -1012,12 +1023,12 @@ void executeQuery(
 
             String format_name = ast_query_with_output && (ast_query_with_output->format != nullptr)
                 ? getIdentifierName(ast_query_with_output->format)
-                : context.getDefaultFormat();
+                : context->getDefaultFormat();
 
-            auto out = context.getOutputStreamParallelIfPossible(format_name, *out_buf, streams.in->getHeader());
+            auto out = context->getOutputStreamParallelIfPossible(format_name, *out_buf, streams.in->getHeader());
 
             /// Save previous progress callback if any. TODO Do it more conveniently.
-            auto previous_progress_callback = context.getProgressCallback();
+            auto previous_progress_callback = context->getProgressCallback();
 
             /// NOTE Progress callback takes shared ownership of 'out'.
             streams.in->setProgressCallback([out, previous_progress_callback] (const Progress & progress)
@@ -1028,7 +1039,8 @@ void executeQuery(
             });
 
             if (set_result_details)
-                set_result_details(context.getClientInfo().current_query_id, out->getContentType(), format_name, DateLUT::instance().getTimeZone());
+                set_result_details(
+                    context->getClientInfo().current_query_id, out->getContentType(), format_name, DateLUT::instance().getTimeZone());
 
             copyData(*streams.in, *out, [](){ return false; }, [&out](const Block &) { out->flush(); });
         }
@@ -1050,7 +1062,7 @@ void executeQuery(
 
             String format_name = ast_query_with_output && (ast_query_with_output->format != nullptr)
                                  ? getIdentifierName(ast_query_with_output->format)
-                                 : context.getDefaultFormat();
+                                 : context->getDefaultFormat();
 
             if (!pipeline.isCompleted())
             {
@@ -1059,11 +1071,11 @@ void executeQuery(
                     return std::make_shared<MaterializingTransform>(header);
                 });
 
-                auto out = context.getOutputFormatParallelIfPossible(format_name, *out_buf, pipeline.getHeader());
+                auto out = context->getOutputFormatParallelIfPossible(format_name, *out_buf, pipeline.getHeader());
                 out->setAutoFlush();
 
                 /// Save previous progress callback if any. TODO Do it more conveniently.
-                auto previous_progress_callback = context.getProgressCallback();
+                auto previous_progress_callback = context->getProgressCallback();
 
                 /// NOTE Progress callback takes shared ownership of 'out'.
                 pipeline.setProgressCallback([out, previous_progress_callback] (const Progress & progress)
@@ -1074,13 +1086,14 @@ void executeQuery(
                 });
 
                 if (set_result_details)
-                    set_result_details(context.getClientInfo().current_query_id, out->getContentType(), format_name, DateLUT::instance().getTimeZone());
+                    set_result_details(
+                        context->getClientInfo().current_query_id, out->getContentType(), format_name, DateLUT::instance().getTimeZone());
 
                 pipeline.setOutputFormat(std::move(out));
             }
             else
             {
-                pipeline.setProgressCallback(context.getProgressCallback());
+                pipeline.setProgressCallback(context->getProgressCallback());
             }
 
             {
diff --git a/src/Interpreters/executeQuery.h b/src/Interpreters/executeQuery.h
index 2850bb3baf4..bdb1f877ce3 100644
--- a/src/Interpreters/executeQuery.h
+++ b/src/Interpreters/executeQuery.h
@@ -2,7 +2,6 @@
 
 #include <Core/QueryProcessingStage.h>
 #include <DataStreams/BlockIO.h>
-
 #include <Processors/QueryPipeline.h>
 
 namespace DB
@@ -10,7 +9,6 @@ namespace DB
 
 class ReadBuffer;
 class WriteBuffer;
-class Context;
 
 
 /// Parse and execute a query.
@@ -18,7 +16,7 @@ void executeQuery(
     ReadBuffer & istr,                  /// Where to read query from (and data for INSERT, if present).
     WriteBuffer & ostr,                 /// Where to write query output to.
     bool allow_into_outfile,            /// If true and the query contains INTO OUTFILE section, redirect output to that file.
-    Context & context,                  /// DB, tables, data types, storage engines, functions, aggregate functions...
+    ContextPtr context,                 /// DB, tables, data types, storage engines, functions, aggregate functions...
     std::function<void(const String &, const String &, const String &, const String &)> set_result_details /// If a non-empty callback is passed, it will be called with the query id, the content-type, the format, and the timezone.
 );
 
@@ -39,7 +37,7 @@ void executeQuery(
 /// must be done separately.
 BlockIO executeQuery(
     const String & query,     /// Query text without INSERT data. The latter must be written to BlockIO::out.
-    Context & context,        /// DB, tables, data types, storage engines, functions, aggregate functions...
+    ContextPtr context,       /// DB, tables, data types, storage engines, functions, aggregate functions...
     bool internal = false,    /// If true, this query is caused by another query and thus needn't be registered in the ProcessList.
     QueryProcessingStage::Enum stage = QueryProcessingStage::Complete,    /// To which stage the query must be executed.
     bool may_have_embedded_data = false /// If insert query may have embedded data
@@ -48,7 +46,7 @@ BlockIO executeQuery(
 /// Old interface with allow_processors flag. For compatibility.
 BlockIO executeQuery(
     const String & query,
-    Context & context,
+    ContextPtr context,
     bool internal,
     QueryProcessingStage::Enum stage,
     bool may_have_embedded_data,
diff --git a/src/Interpreters/getHeaderForProcessingStage.cpp b/src/Interpreters/getHeaderForProcessingStage.cpp
index b56b90cdf3f..9c7c86a0b88 100644
--- a/src/Interpreters/getHeaderForProcessingStage.cpp
+++ b/src/Interpreters/getHeaderForProcessingStage.cpp
@@ -12,21 +12,27 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
-/// Rewrite original query removing joined tables from it
-bool removeJoin(ASTSelectQuery & select)
+bool hasJoin(const ASTSelectQuery & select)
 {
     const auto & tables = select.tables();
     if (!tables || tables->children.size() < 2)
         return false;
 
     const auto & joined_table = tables->children[1]->as<ASTTablesInSelectQueryElement &>();
-    if (!joined_table.table_join)
-        return false;
+    return joined_table.table_join != nullptr;
+}
 
-    /// The most simple temporary solution: leave only the first table in query.
-    /// TODO: we also need to remove joined columns and related functions (taking in account aliases if any).
-    tables->children.resize(1);
-    return true;
+/// Rewrite original query removing joined tables from it
+bool removeJoin(ASTSelectQuery & select)
+{
+    if (hasJoin(select))
+    {
+        /// The most simple temporary solution: leave only the first table in query.
+        /// TODO: we also need to remove joined columns and related functions (taking in account aliases if any).
+        select.tables()->children.resize(1);
+        return true;
+    }
+    return false;
 }
 
 Block getHeaderForProcessingStage(
@@ -34,7 +40,7 @@ Block getHeaderForProcessingStage(
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage)
 {
     switch (processed_stage)
diff --git a/src/Interpreters/getHeaderForProcessingStage.h b/src/Interpreters/getHeaderForProcessingStage.h
index ec238edf774..75a89bc5d39 100644
--- a/src/Interpreters/getHeaderForProcessingStage.h
+++ b/src/Interpreters/getHeaderForProcessingStage.h
@@ -1,7 +1,9 @@
 #pragma once
+
 #include <Core/Block.h>
 #include <Core/Names.h>
 #include <Core/QueryProcessingStage.h>
+#include <Interpreters/Context_fwd.h>
 
 
 namespace DB
@@ -11,9 +13,9 @@ class IStorage;
 struct StorageInMemoryMetadata;
 using StorageMetadataPtr = std::shared_ptr<const StorageInMemoryMetadata>;
 struct SelectQueryInfo;
-class Context;
 class ASTSelectQuery;
 
+bool hasJoin(const ASTSelectQuery & select);
 bool removeJoin(ASTSelectQuery & select);
 
 Block getHeaderForProcessingStage(
@@ -21,7 +23,7 @@ Block getHeaderForProcessingStage(
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage);
 
 }
diff --git a/src/Interpreters/getTableExpressions.cpp b/src/Interpreters/getTableExpressions.cpp
index a4e971c302c..22eb307071c 100644
--- a/src/Interpreters/getTableExpressions.cpp
+++ b/src/Interpreters/getTableExpressions.cpp
@@ -75,7 +75,7 @@ ASTPtr extractTableExpression(const ASTSelectQuery & select, size_t table_number
 
 static NamesAndTypesList getColumnsFromTableExpression(
     const ASTTableExpression & table_expression,
-    const Context & context,
+    ContextPtr context,
     NamesAndTypesList & materialized,
     NamesAndTypesList & aliases,
     NamesAndTypesList & virtuals)
@@ -89,7 +89,7 @@ static NamesAndTypesList getColumnsFromTableExpression(
     else if (table_expression.table_function)
     {
         const auto table_function = table_expression.table_function;
-        auto * query_context = const_cast<Context *>(&context.getQueryContext());
+        auto query_context = context->getQueryContext();
         const auto & function_storage = query_context->executeTableFunction(table_function);
         auto function_metadata_snapshot = function_storage->getInMemoryMetadataPtr();
         const auto & columns = function_metadata_snapshot->getColumns();
@@ -100,7 +100,7 @@ static NamesAndTypesList getColumnsFromTableExpression(
     }
     else if (table_expression.database_and_table_name)
     {
-        auto table_id = context.resolveStorageID(table_expression.database_and_table_name);
+        auto table_id = context->resolveStorageID(table_expression.database_and_table_name);
         const auto & table = DatabaseCatalog::instance().getTable(table_id, context);
         auto table_metadata_snapshot = table->getInMemoryMetadataPtr();
         const auto & columns = table_metadata_snapshot->getColumns();
@@ -113,7 +113,7 @@ static NamesAndTypesList getColumnsFromTableExpression(
     return names_and_type_list;
 }
 
-NamesAndTypesList getColumnsFromTableExpression(const ASTTableExpression & table_expression, const Context & context)
+NamesAndTypesList getColumnsFromTableExpression(const ASTTableExpression & table_expression, ContextPtr context)
 {
     NamesAndTypesList materialized;
     NamesAndTypesList aliases;
@@ -121,15 +121,15 @@ NamesAndTypesList getColumnsFromTableExpression(const ASTTableExpression & table
     return getColumnsFromTableExpression(table_expression, context, materialized, aliases, virtuals);
 }
 
-TablesWithColumns getDatabaseAndTablesWithColumns(const std::vector<const ASTTableExpression *> & table_expressions, const Context & context)
+TablesWithColumns getDatabaseAndTablesWithColumns(const std::vector<const ASTTableExpression *> & table_expressions, ContextPtr context)
 {
     TablesWithColumns tables_with_columns;
 
     if (!table_expressions.empty())
     {
-        String current_database = context.getCurrentDatabase();
-        bool include_alias_cols = context.getSettingsRef().asterisk_include_alias_columns;
-        bool include_materialized_cols = context.getSettingsRef().asterisk_include_materialized_columns;
+        String current_database = context->getCurrentDatabase();
+        bool include_alias_cols = context->getSettingsRef().asterisk_include_alias_columns;
+        bool include_materialized_cols = context->getSettingsRef().asterisk_include_materialized_columns;
 
         for (const ASTTableExpression * table_expression : table_expressions)
         {
diff --git a/src/Interpreters/getTableExpressions.h b/src/Interpreters/getTableExpressions.h
index 9254fb9d6a0..961176437b5 100644
--- a/src/Interpreters/getTableExpressions.h
+++ b/src/Interpreters/getTableExpressions.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Core/NamesAndTypes.h>
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/DatabaseAndTableWithAlias.h>
 
 namespace DB
@@ -8,7 +9,6 @@ namespace DB
 
 struct ASTTableExpression;
 class ASTSelectQuery;
-class Context;
 
 NameSet removeDuplicateColumns(NamesAndTypesList & columns);
 
@@ -16,7 +16,7 @@ std::vector<const ASTTableExpression *> getTableExpressions(const ASTSelectQuery
 const ASTTableExpression * getTableExpression(const ASTSelectQuery & select, size_t table_number);
 ASTPtr extractTableExpression(const ASTSelectQuery & select, size_t table_number);
 
-NamesAndTypesList getColumnsFromTableExpression(const ASTTableExpression & table_expression, const Context & context);
-TablesWithColumns getDatabaseAndTablesWithColumns(const std::vector<const ASTTableExpression *> & table_expressions, const Context & context);
+NamesAndTypesList getColumnsFromTableExpression(const ASTTableExpression & table_expression, ContextPtr context);
+TablesWithColumns getDatabaseAndTablesWithColumns(const std::vector<const ASTTableExpression *> & table_expressions, ContextPtr context);
 
 }
diff --git a/src/Interpreters/inplaceBlockConversions.cpp b/src/Interpreters/inplaceBlockConversions.cpp
index 47cd6cc20f6..ec625ff186e 100644
--- a/src/Interpreters/inplaceBlockConversions.cpp
+++ b/src/Interpreters/inplaceBlockConversions.cpp
@@ -92,7 +92,7 @@ ActionsDAGPtr createExpressions(
     ASTPtr expr_list,
     bool save_unneeded_columns,
     const NamesAndTypesList & required_columns,
-    const Context & context)
+    ContextPtr context)
 {
     if (!expr_list)
         return nullptr;
@@ -114,7 +114,7 @@ ActionsDAGPtr createExpressions(
 
 }
 
-void performRequiredConversions(Block & block, const NamesAndTypesList & required_columns, const Context & context)
+void performRequiredConversions(Block & block, const NamesAndTypesList & required_columns, ContextPtr context)
 {
     ASTPtr conversion_expr_list = convertRequiredExpressions(block, required_columns);
     if (conversion_expr_list->children.empty())
@@ -131,7 +131,7 @@ ActionsDAGPtr evaluateMissingDefaults(
     const Block & header,
     const NamesAndTypesList & required_columns,
     const ColumnsDescription & columns,
-    const Context & context, bool save_unneeded_columns)
+    ContextPtr context, bool save_unneeded_columns)
 {
     if (!columns.hasDefaults())
         return nullptr;
diff --git a/src/Interpreters/inplaceBlockConversions.h b/src/Interpreters/inplaceBlockConversions.h
index 63540e2994d..3d46523fafb 100644
--- a/src/Interpreters/inplaceBlockConversions.h
+++ b/src/Interpreters/inplaceBlockConversions.h
@@ -1,15 +1,16 @@
 #pragma once
 
-#include <unordered_map>
-#include <string>
+#include <Interpreters/Context_fwd.h>
+
 #include <memory>
+#include <string>
+#include <unordered_map>
 
 
 namespace DB
 {
 
 class Block;
-class Context;
 class NamesAndTypesList;
 class ColumnsDescription;
 
@@ -22,10 +23,9 @@ ActionsDAGPtr evaluateMissingDefaults(
     const Block & header,
     const NamesAndTypesList & required_columns,
     const ColumnsDescription & columns,
-    const Context & context, bool save_unneeded_columns = true);
+    ContextPtr context, bool save_unneeded_columns = true);
 
 /// Tries to convert columns in block to required_columns
-void performRequiredConversions(Block & block,
-    const NamesAndTypesList & required_columns,
-    const Context & context);
+void performRequiredConversions(Block & block, const NamesAndTypesList & required_columns, ContextPtr context);
+
 }
diff --git a/src/Interpreters/interpretSubquery.cpp b/src/Interpreters/interpretSubquery.cpp
index cf343a4fda2..2fb2f390b67 100644
--- a/src/Interpreters/interpretSubquery.cpp
+++ b/src/Interpreters/interpretSubquery.cpp
@@ -22,14 +22,14 @@ namespace ErrorCodes
 }
 
 std::shared_ptr<InterpreterSelectWithUnionQuery> interpretSubquery(
-    const ASTPtr & table_expression, const Context & context, size_t subquery_depth, const Names & required_source_columns)
+    const ASTPtr & table_expression, ContextPtr context, size_t subquery_depth, const Names & required_source_columns)
 {
     auto subquery_options = SelectQueryOptions(QueryProcessingStage::Complete, subquery_depth);
     return interpretSubquery(table_expression, context, required_source_columns, subquery_options);
 }
 
 std::shared_ptr<InterpreterSelectWithUnionQuery> interpretSubquery(
-    const ASTPtr & table_expression, const Context & context, const Names & required_source_columns, const SelectQueryOptions & options)
+    const ASTPtr & table_expression, ContextPtr context, const Names & required_source_columns, const SelectQueryOptions & options)
 {
     if (auto * expr = table_expression->as<ASTTableExpression>())
     {
@@ -59,13 +59,13 @@ std::shared_ptr<InterpreterSelectWithUnionQuery> interpretSubquery(
       *  max_rows_in_join, max_bytes_in_join, join_overflow_mode,
       *  which are checked separately (in the Set, Join objects).
       */
-    Context subquery_context = context;
-    Settings subquery_settings = context.getSettings();
+    auto subquery_context = Context::createCopy(context);
+    Settings subquery_settings = context->getSettings();
     subquery_settings.max_result_rows = 0;
     subquery_settings.max_result_bytes = 0;
     /// The calculation of `extremes` does not make sense and is not necessary (if you do it, then the `extremes` of the subquery can be taken instead of the whole query).
     subquery_settings.extremes = false;
-    subquery_context.setSettings(subquery_settings);
+    subquery_context->setSettings(subquery_settings);
 
     auto subquery_options = options.subquery();
 
@@ -88,14 +88,14 @@ std::shared_ptr<InterpreterSelectWithUnionQuery> interpretSubquery(
         /// get columns list for target table
         if (function)
         {
-            auto * query_context = const_cast<Context *>(&context.getQueryContext());
+            auto query_context = context->getQueryContext();
             const auto & storage = query_context->executeTableFunction(table_expression);
             columns = storage->getInMemoryMetadataPtr()->getColumns().getOrdinary();
             select_query->addTableFunction(*const_cast<ASTPtr *>(&table_expression)); // XXX: const_cast should be avoided!
         }
         else
         {
-            auto table_id = context.resolveStorageID(table_expression);
+            auto table_id = context->resolveStorageID(table_expression);
             const auto & storage = DatabaseCatalog::instance().getTable(table_id, context);
             columns = storage->getInMemoryMetadataPtr()->getColumns().getOrdinary();
             select_query->replaceDatabaseAndTable(table_id);
diff --git a/src/Interpreters/interpretSubquery.h b/src/Interpreters/interpretSubquery.h
index 2aee6ffd81a..3836d1f7664 100644
--- a/src/Interpreters/interpretSubquery.h
+++ b/src/Interpreters/interpretSubquery.h
@@ -6,12 +6,10 @@
 namespace DB
 {
 
-class Context;
+std::shared_ptr<InterpreterSelectWithUnionQuery> interpretSubquery(
+    const ASTPtr & table_expression, ContextPtr context, size_t subquery_depth, const Names & required_source_columns);
 
 std::shared_ptr<InterpreterSelectWithUnionQuery> interpretSubquery(
-    const ASTPtr & table_expression, const Context & context, size_t subquery_depth, const Names & required_source_columns);
-
-std::shared_ptr<InterpreterSelectWithUnionQuery> interpretSubquery(
-    const ASTPtr & table_expression, const Context & context, const Names & required_source_columns, const SelectQueryOptions & options);
+    const ASTPtr & table_expression, ContextPtr context, const Names & required_source_columns, const SelectQueryOptions & options);
 
 }
diff --git a/src/Interpreters/loadMetadata.cpp b/src/Interpreters/loadMetadata.cpp
index 71d3c7e6e5b..79076e57328 100644
--- a/src/Interpreters/loadMetadata.cpp
+++ b/src/Interpreters/loadMetadata.cpp
@@ -25,13 +25,14 @@ namespace DB
 
 static void executeCreateQuery(
     const String & query,
-    Context & context,
+    ContextPtr context,
     const String & database,
     const String & file_name,
     bool has_force_restore_data_flag)
 {
     ParserCreateQuery parser;
-    ASTPtr ast = parseQuery(parser, query.data(), query.data() + query.size(), "in file " + file_name, 0, context.getSettingsRef().max_parser_depth);
+    ASTPtr ast = parseQuery(
+        parser, query.data(), query.data() + query.size(), "in file " + file_name, 0, context->getSettingsRef().max_parser_depth);
 
     auto & ast_create_query = ast->as<ASTCreateQuery &>();
     ast_create_query.database = database;
@@ -45,7 +46,7 @@ static void executeCreateQuery(
 
 
 static void loadDatabase(
-    Context & context,
+    ContextPtr context,
     const String & database,
     const String & database_path,
     bool force_restore_data)
@@ -73,8 +74,7 @@ static void loadDatabase(
 
     try
     {
-        executeCreateQuery(database_attach_query, context, database,
-            database_metadata_file, force_restore_data);
+        executeCreateQuery(database_attach_query, context, database, database_metadata_file, force_restore_data);
     }
     catch (Exception & e)
     {
@@ -84,18 +84,18 @@ static void loadDatabase(
 }
 
 
-void loadMetadata(Context & context, const String & default_database_name)
+void loadMetadata(ContextPtr context, const String & default_database_name)
 {
     Poco::Logger * log = &Poco::Logger::get("loadMetadata");
 
-    String path = context.getPath() + "metadata";
+    String path = context->getPath() + "metadata";
 
     /** There may exist 'force_restore_data' file, that means,
       *  skip safety threshold on difference of data parts while initializing tables.
       * This file is deleted after successful loading of tables.
       * (flag is "one-shot")
       */
-    Poco::File force_restore_data_flag_file(context.getFlagsPath() + "force_restore_data");
+    Poco::File force_restore_data_flag_file(context->getFlagsPath() + "force_restore_data");
     bool has_force_restore_data_flag = force_restore_data_flag_file.exists();
 
     /// Loop over databases.
@@ -168,9 +168,9 @@ void loadMetadata(Context & context, const String & default_database_name)
 }
 
 
-void loadMetadataSystem(Context & context)
+void loadMetadataSystem(ContextPtr context)
 {
-    String path = context.getPath() + "metadata/" + DatabaseCatalog::SYSTEM_DATABASE;
+    String path = context->getPath() + "metadata/" + DatabaseCatalog::SYSTEM_DATABASE;
     String metadata_file = path + ".sql";
     if (Poco::File(path).exists() || Poco::File(metadata_file).exists())
     {
diff --git a/src/Interpreters/loadMetadata.h b/src/Interpreters/loadMetadata.h
index b23887d5282..047def84bba 100644
--- a/src/Interpreters/loadMetadata.h
+++ b/src/Interpreters/loadMetadata.h
@@ -1,16 +1,16 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
+
 
 namespace DB
 {
 
-class Context;
-
 /// Load tables from system database. Only real tables like query_log, part_log.
 /// You should first load system database, then attach system tables that you need into it, then load other databases.
-void loadMetadataSystem(Context & context);
+void loadMetadataSystem(ContextPtr context);
 
 /// Load tables from databases and add them to context. Database 'system' is ignored. Use separate function to load system tables.
-void loadMetadata(Context & context, const String & default_database_name = {});
+void loadMetadata(ContextPtr context, const String & default_database_name = {});
 
 }
diff --git a/src/Interpreters/replaceAliasColumnsInQuery.cpp b/src/Interpreters/replaceAliasColumnsInQuery.cpp
index 4daa787c397..4c8367b269a 100644
--- a/src/Interpreters/replaceAliasColumnsInQuery.cpp
+++ b/src/Interpreters/replaceAliasColumnsInQuery.cpp
@@ -6,7 +6,7 @@
 namespace DB
 {
 
-void replaceAliasColumnsInQuery(ASTPtr & ast, const ColumnsDescription & columns, const NameSet & forbidden_columns, const Context & context)
+void replaceAliasColumnsInQuery(ASTPtr & ast, const ColumnsDescription & columns, const NameSet & forbidden_columns, ContextPtr context)
 {
     ColumnAliasesVisitor::Data aliase_column_data(columns, forbidden_columns, context);
     ColumnAliasesVisitor aliase_column_visitor(aliase_column_data);
diff --git a/src/Interpreters/replaceAliasColumnsInQuery.h b/src/Interpreters/replaceAliasColumnsInQuery.h
index bf7143ba099..92d2686b45b 100644
--- a/src/Interpreters/replaceAliasColumnsInQuery.h
+++ b/src/Interpreters/replaceAliasColumnsInQuery.h
@@ -1,14 +1,15 @@
 #pragma once
 
-#include <common/types.h>
 #include <Core/Names.h>
+#include <Interpreters/Context_fwd.h>
 #include <Parsers/IAST_fwd.h>
+#include <common/types.h>
 
 namespace DB
 {
 
 class ColumnsDescription;
-class Context;
-void replaceAliasColumnsInQuery(ASTPtr & ast, const ColumnsDescription & columns, const NameSet & forbidden_columns, const Context & context);
+
+void replaceAliasColumnsInQuery(ASTPtr & ast, const ColumnsDescription & columns, const NameSet & forbidden_columns, ContextPtr context);
 
 }
diff --git a/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp b/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp
index 2b53277d02f..efe3882d086 100644
--- a/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp
+++ b/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp
@@ -1156,9 +1156,9 @@ static bool run()
 
 TestResult check(const TestEntry & entry)
 {
-    static DB::SharedContextHolder shared_context = DB::Context::createShared();
-    static DB::Context context = DB::Context::createGlobal(shared_context.get());
-    context.makeGlobalContext();
+    static auto shared_context = DB::Context::createShared();
+    static auto context = DB::Context::createGlobal(shared_context.get());
+    context->makeGlobalContext();
 
     try
     {
@@ -1170,8 +1170,8 @@ TestResult check(const TestEntry & entry)
         DB::DatabaseCatalog::instance().attachDatabase("test", database);
         database->attachTable("visits_all", storage_distributed_visits);
         database->attachTable("hits_all", storage_distributed_hits);
-        context.setCurrentDatabase("test");
-        context.setSetting("distributed_product_mode", entry.mode);
+        context->setCurrentDatabase("test");
+        context->setSetting("distributed_product_mode", entry.mode);
 
         /// Parse and process the incoming query.
         DB::ASTPtr ast_input;
diff --git a/src/Interpreters/ya.make b/src/Interpreters/ya.make
index 64f931a3eaf..90998077a5a 100644
--- a/src/Interpreters/ya.make
+++ b/src/Interpreters/ya.make
@@ -103,6 +103,7 @@ SRCS(
     InterpreterSystemQuery.cpp
     InterpreterUseQuery.cpp
     InterpreterWatchQuery.cpp
+    InterserverCredentials.cpp
     JoinSwitcher.cpp
     JoinToSubqueryTransformVisitor.cpp
     JoinedTables.cpp
@@ -117,6 +118,7 @@ SRCS(
     OpenTelemetrySpanLog.cpp
     OptimizeIfChains.cpp
     OptimizeIfWithConstantConditionVisitor.cpp
+    OptimizeShardingKeyRewriteInVisitor.cpp
     PartLog.cpp
     PredicateExpressionsOptimizer.cpp
     PredicateRewriteVisitor.cpp
diff --git a/src/Parsers/ASTFunction.cpp b/src/Parsers/ASTFunction.cpp
index 3cb2e8bfa37..18a47eb2126 100644
--- a/src/Parsers/ASTFunction.cpp
+++ b/src/Parsers/ASTFunction.cpp
@@ -15,8 +15,16 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int UNEXPECTED_EXPRESSION;
+}
+
 void ASTFunction::appendColumnNameImpl(WriteBuffer & ostr) const
 {
+    if (name == "view")
+        throw Exception("Table function view cannot be used as an expression", ErrorCodes::UNEXPECTED_EXPRESSION);
+
     writeString(name, ostr);
 
     if (parameters)
@@ -483,14 +491,14 @@ void ASTFunction::formatImplWithoutAlias(const FormatSettings & settings, Format
 
         if (!written && 0 == strcmp(name.c_str(), "map"))
         {
-            settings.ostr << (settings.hilite ? hilite_operator : "") << '{' << (settings.hilite ? hilite_none : "");
+            settings.ostr << (settings.hilite ? hilite_operator : "") << "map(" << (settings.hilite ? hilite_none : "");
             for (size_t i = 0; i < arguments->children.size(); ++i)
             {
                 if (i != 0)
                     settings.ostr << ", ";
                 arguments->children[i]->formatImpl(settings, state, nested_dont_need_parens);
             }
-            settings.ostr << (settings.hilite ? hilite_operator : "") << '}' << (settings.hilite ? hilite_none : "");
+            settings.ostr << (settings.hilite ? hilite_operator : "") << ')' << (settings.hilite ? hilite_none : "");
             written = true;
         }
     }
diff --git a/src/Parsers/ExpressionElementParsers.cpp b/src/Parsers/ExpressionElementParsers.cpp
index 84c178790b2..3e635b2accc 100644
--- a/src/Parsers/ExpressionElementParsers.cpp
+++ b/src/Parsers/ExpressionElementParsers.cpp
@@ -580,18 +580,6 @@ static bool tryParseFrameDefinition(ASTWindowDefinition * node, IParser::Pos & p
         else if (parser_literal.parse(pos, ast_literal, expected))
         {
             const Field & value = ast_literal->as<ASTLiteral &>().value;
-            if ((node->frame.type == WindowFrame::FrameType::Rows
-                    || node->frame.type == WindowFrame::FrameType::Groups)
-                && !(value.getType() == Field::Types::UInt64
-                     || (value.getType() == Field::Types::Int64
-                            && value.get<Int64>() >= 0)))
-            {
-                throw Exception(ErrorCodes::BAD_ARGUMENTS,
-                    "Frame offset for '{}' frame must be a nonnegative integer, '{}' of type '{}' given.",
-                    WindowFrame::toString(node->frame.type),
-                    applyVisitor(FieldVisitorToString(), value),
-                    Field::Types::toString(value.getType()));
-            }
             node->frame.begin_offset = value;
             node->frame.begin_type = WindowFrame::BoundaryType::Offset;
         }
@@ -641,18 +629,6 @@ static bool tryParseFrameDefinition(ASTWindowDefinition * node, IParser::Pos & p
             else if (parser_literal.parse(pos, ast_literal, expected))
             {
                 const Field & value = ast_literal->as<ASTLiteral &>().value;
-                if ((node->frame.type == WindowFrame::FrameType::Rows
-                        || node->frame.type == WindowFrame::FrameType::Groups)
-                    && !(value.getType() == Field::Types::UInt64
-                         || (value.getType() == Field::Types::Int64
-                                && value.get<Int64>() >= 0)))
-                {
-                    throw Exception(ErrorCodes::BAD_ARGUMENTS,
-                        "Frame offset for '{}' frame must be a nonnegative integer, '{}' of type '{}' given.",
-                        WindowFrame::toString(node->frame.type),
-                        applyVisitor(FieldVisitorToString(), value),
-                        Field::Types::toString(value.getType()));
-                }
                 node->frame.end_offset = value;
                 node->frame.end_type = WindowFrame::BoundaryType::Offset;
             }
diff --git a/src/Processors/DelayedPortsProcessor.cpp b/src/Processors/DelayedPortsProcessor.cpp
index ae4ba4659aa..8174619f8ce 100644
--- a/src/Processors/DelayedPortsProcessor.cpp
+++ b/src/Processors/DelayedPortsProcessor.cpp
@@ -8,9 +8,35 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
+InputPorts createInputPorts(
+    const Block & header,
+    size_t num_ports,
+    IProcessor::PortNumbers delayed_ports,
+    bool assert_main_ports_empty)
+{
+    if (!assert_main_ports_empty)
+        return InputPorts(num_ports, header);
+
+    InputPorts res;
+    std::sort(delayed_ports.begin(), delayed_ports.end());
+    size_t next_delayed_port = 0;
+    for (size_t i = 0; i < num_ports; ++i)
+    {
+        if (next_delayed_port < delayed_ports.size() && i == delayed_ports[next_delayed_port])
+        {
+            res.emplace_back(header);
+            ++next_delayed_port;
+        }
+        else
+            res.emplace_back(Block());
+    }
+
+    return res;
+}
+
 DelayedPortsProcessor::DelayedPortsProcessor(
     const Block & header, size_t num_ports, const PortNumbers & delayed_ports, bool assert_main_ports_empty)
-    : IProcessor(InputPorts(num_ports, header),
+    : IProcessor(createInputPorts(header, num_ports, delayed_ports, assert_main_ports_empty),
                  OutputPorts((assert_main_ports_empty ? delayed_ports.size() : num_ports), header))
     , num_delayed_ports(delayed_ports.size())
 {
diff --git a/src/Processors/Executors/PipelineExecutor.cpp b/src/Processors/Executors/PipelineExecutor.cpp
index a724f22ed31..b1751dfd030 100644
--- a/src/Processors/Executors/PipelineExecutor.cpp
+++ b/src/Processors/Executors/PipelineExecutor.cpp
@@ -1,14 +1,15 @@
-#include <Processors/Executors/PipelineExecutor.h>
 #include <queue>
 #include <IO/WriteBufferFromString.h>
-#include <Processors/printPipeline.h>
 #include <Common/EventCounter.h>
-#include <ext/scope_guard.h>
 #include <Common/CurrentThread.h>
-#include <Processors/ISource.h>
 #include <Common/setThreadName.h>
+#include <Common/MemoryTracker.h>
+#include <Processors/Executors/PipelineExecutor.h>
+#include <Processors/printPipeline.h>
+#include <Processors/ISource.h>
 #include <Interpreters/ProcessList.h>
 #include <Interpreters/OpenTelemetrySpanLog.h>
+#include <ext/scope_guard_safe.h>
 
 #ifndef NDEBUG
     #include <Common/Stopwatch.h>
@@ -740,7 +741,7 @@ void PipelineExecutor::executeImpl(size_t num_threads)
 
     bool finished_flag = false;
 
-    SCOPE_EXIT(
+    SCOPE_EXIT_SAFE(
         if (!finished_flag)
         {
             finish();
@@ -766,9 +767,9 @@ void PipelineExecutor::executeImpl(size_t num_threads)
                 if (thread_group)
                     CurrentThread::attachTo(thread_group);
 
-                SCOPE_EXIT(
-                        if (thread_group)
-                            CurrentThread::detachQueryIfNotDetached();
+                SCOPE_EXIT_SAFE(
+                    if (thread_group)
+                        CurrentThread::detachQueryIfNotDetached();
                 );
 
                 try
diff --git a/src/Processors/Executors/PullingAsyncPipelineExecutor.cpp b/src/Processors/Executors/PullingAsyncPipelineExecutor.cpp
index f1626414375..9f1999bc4a3 100644
--- a/src/Processors/Executors/PullingAsyncPipelineExecutor.cpp
+++ b/src/Processors/Executors/PullingAsyncPipelineExecutor.cpp
@@ -5,7 +5,7 @@
 #include <Processors/QueryPipeline.h>
 
 #include <Common/setThreadName.h>
-#include <ext/scope_guard.h>
+#include <ext/scope_guard_safe.h>
 
 namespace DB
 {
@@ -72,7 +72,7 @@ static void threadFunction(PullingAsyncPipelineExecutor::Data & data, ThreadGrou
         if (thread_group)
             CurrentThread::attachTo(thread_group);
 
-        SCOPE_EXIT(
+        SCOPE_EXIT_SAFE(
             if (thread_group)
                 CurrentThread::detachQueryIfNotDetached();
         );
diff --git a/src/Processors/Formats/IInputFormat.cpp b/src/Processors/Formats/IInputFormat.cpp
index 069d25564b1..5594e04dc74 100644
--- a/src/Processors/Formats/IInputFormat.cpp
+++ b/src/Processors/Formats/IInputFormat.cpp
@@ -5,11 +5,6 @@
 namespace DB
 {
 
-namespace ErrorCodes
-{
-    extern const int LOGICAL_ERROR;
-}
-
 IInputFormat::IInputFormat(Block header, ReadBuffer & in_)
     : ISource(std::move(header)), in(in_)
 {
@@ -18,9 +13,7 @@ IInputFormat::IInputFormat(Block header, ReadBuffer & in_)
 
 void IInputFormat::resetParser()
 {
-    if (in.hasPendingData())
-        throw Exception("Unread data in IInputFormat::resetParser. Most likely it's a bug.", ErrorCodes::LOGICAL_ERROR);
-
+    in.ignoreAll();
     // those are protected attributes from ISource (I didn't want to propagate resetParser up there)
     finished = false;
     got_exception = false;
diff --git a/src/Processors/Formats/Impl/ArrowBlockInputFormat.cpp b/src/Processors/Formats/Impl/ArrowBlockInputFormat.cpp
index 4edef1f1365..1e6ffa57e2d 100644
--- a/src/Processors/Formats/Impl/ArrowBlockInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ArrowBlockInputFormat.cpp
@@ -78,7 +78,7 @@ void ArrowBlockInputFormat::prepareReader()
 {
     if (stream)
     {
-        auto stream_reader_status = arrow::ipc::RecordBatchStreamReader::Open(asArrowFile(in));
+        auto stream_reader_status = arrow::ipc::RecordBatchStreamReader::Open(std::make_unique<ArrowInputStreamFromReadBuffer>(in));
         if (!stream_reader_status.ok())
             throw Exception(ErrorCodes::UNKNOWN_EXCEPTION,
                 "Error while opening a table: {}", stream_reader_status.status().ToString());
@@ -101,7 +101,7 @@ void ArrowBlockInputFormat::prepareReader()
     record_batch_current = 0;
 }
 
-void registerInputFormatProcessorArrow(FormatFactory &factory)
+void registerInputFormatProcessorArrow(FormatFactory & factory)
 {
     factory.registerInputFormatProcessor(
         "Arrow",
@@ -112,7 +112,7 @@ void registerInputFormatProcessorArrow(FormatFactory &factory)
         {
             return std::make_shared<ArrowBlockInputFormat>(buf, sample, false);
         });
-
+    factory.markFormatAsColumnOriented("Arrow");
     factory.registerInputFormatProcessor(
         "ArrowStream",
         [](ReadBuffer & buf,
diff --git a/src/Processors/Formats/Impl/ArrowBufferedStreams.cpp b/src/Processors/Formats/Impl/ArrowBufferedStreams.cpp
index c783e10debb..9582e0c3312 100644
--- a/src/Processors/Formats/Impl/ArrowBufferedStreams.cpp
+++ b/src/Processors/Formats/Impl/ArrowBufferedStreams.cpp
@@ -55,26 +55,23 @@ arrow::Status RandomAccessFileFromSeekableReadBuffer::Close()
 
 arrow::Result<int64_t> RandomAccessFileFromSeekableReadBuffer::Tell() const
 {
-    return arrow::Result<int64_t>(in.getPosition());
+    return in.getPosition();
 }
 
 arrow::Result<int64_t> RandomAccessFileFromSeekableReadBuffer::Read(int64_t nbytes, void * out)
 {
-    int64_t bytes_read = in.readBig(reinterpret_cast<char *>(out), nbytes);
-    return arrow::Result<int64_t>(bytes_read);
+    return in.readBig(reinterpret_cast<char *>(out), nbytes);
 }
 
 arrow::Result<std::shared_ptr<arrow::Buffer>> RandomAccessFileFromSeekableReadBuffer::Read(int64_t nbytes)
 {
-    auto buffer_status = arrow::AllocateBuffer(nbytes);
-    ARROW_RETURN_NOT_OK(buffer_status);
+    ARROW_ASSIGN_OR_RAISE(auto buffer, arrow::AllocateResizableBuffer(nbytes))
+    ARROW_ASSIGN_OR_RAISE(int64_t bytes_read, Read(nbytes, buffer->mutable_data()))
 
-    auto shared_buffer = std::shared_ptr<arrow::Buffer>(std::move(std::move(*buffer_status)));
+    if (bytes_read < nbytes)
+        RETURN_NOT_OK(buffer->Resize(bytes_read));
 
-    size_t n = in.readBig(reinterpret_cast<char *>(shared_buffer->mutable_data()), nbytes);
-
-    auto read_buffer = arrow::SliceBuffer(shared_buffer, 0, n);
-    return arrow::Result<std::shared_ptr<arrow::Buffer>>(shared_buffer);
+    return buffer;
 }
 
 arrow::Status RandomAccessFileFromSeekableReadBuffer::Seek(int64_t position)
@@ -83,6 +80,43 @@ arrow::Status RandomAccessFileFromSeekableReadBuffer::Seek(int64_t position)
     return arrow::Status::OK();
 }
 
+
+ArrowInputStreamFromReadBuffer::ArrowInputStreamFromReadBuffer(ReadBuffer & in_) : in(in_), is_open{true}
+{
+}
+
+arrow::Result<int64_t> ArrowInputStreamFromReadBuffer::Read(int64_t nbytes, void * out)
+{
+    return in.readBig(reinterpret_cast<char *>(out), nbytes);
+}
+
+arrow::Result<std::shared_ptr<arrow::Buffer>> ArrowInputStreamFromReadBuffer::Read(int64_t nbytes)
+{
+    ARROW_ASSIGN_OR_RAISE(auto buffer, arrow::AllocateResizableBuffer(nbytes))
+    ARROW_ASSIGN_OR_RAISE(int64_t bytes_read, Read(nbytes, buffer->mutable_data()))
+
+    if (bytes_read < nbytes)
+        RETURN_NOT_OK(buffer->Resize(bytes_read));
+
+    return buffer;
+}
+
+arrow::Status ArrowInputStreamFromReadBuffer::Abort()
+{
+    return arrow::Status();
+}
+
+arrow::Result<int64_t> ArrowInputStreamFromReadBuffer::Tell() const
+{
+    return in.count();
+}
+
+arrow::Status ArrowInputStreamFromReadBuffer::Close()
+{
+    is_open = false;
+    return arrow::Status();
+}
+
 std::shared_ptr<arrow::io::RandomAccessFile> asArrowFile(ReadBuffer & in)
 {
     if (auto * fd_in = dynamic_cast<ReadBufferFromFileDescriptor *>(&in))
diff --git a/src/Processors/Formats/Impl/ArrowBufferedStreams.h b/src/Processors/Formats/Impl/ArrowBufferedStreams.h
index bb94535549c..a10a5bcabdb 100644
--- a/src/Processors/Formats/Impl/ArrowBufferedStreams.h
+++ b/src/Processors/Formats/Impl/ArrowBufferedStreams.h
@@ -61,6 +61,24 @@ private:
     ARROW_DISALLOW_COPY_AND_ASSIGN(RandomAccessFileFromSeekableReadBuffer);
 };
 
+class ArrowInputStreamFromReadBuffer : public arrow::io::InputStream
+{
+public:
+    explicit ArrowInputStreamFromReadBuffer(ReadBuffer & in);
+    arrow::Result<int64_t> Read(int64_t nbytes, void* out) override;
+    arrow::Result<std::shared_ptr<arrow::Buffer>> Read(int64_t nbytes) override;
+    arrow::Status Abort() override;
+    arrow::Result<int64_t> Tell() const override;
+    arrow::Status Close() override;
+    bool closed() const override { return !is_open; }
+
+private:
+    ReadBuffer & in;
+    bool is_open = false;
+
+    ARROW_DISALLOW_COPY_AND_ASSIGN(ArrowInputStreamFromReadBuffer);
+};
+
 std::shared_ptr<arrow::io::RandomAccessFile> asArrowFile(ReadBuffer & in);
 
 }
diff --git a/src/Processors/Formats/Impl/ConstantExpressionTemplate.cpp b/src/Processors/Formats/Impl/ConstantExpressionTemplate.cpp
index caf57ded8b7..288c6ee09ef 100644
--- a/src/Processors/Formats/Impl/ConstantExpressionTemplate.cpp
+++ b/src/Processors/Formats/Impl/ConstantExpressionTemplate.cpp
@@ -144,9 +144,9 @@ class ReplaceLiteralsVisitor
 {
 public:
     LiteralsInfo replaced_literals;
-    const Context & context;
+    ContextPtr context;
 
-    explicit ReplaceLiteralsVisitor(const Context & context_) : context(context_) { }
+    explicit ReplaceLiteralsVisitor(ContextPtr context_) : context(context_) { }
 
     void visit(ASTPtr & ast, bool force_nullable)
     {
@@ -293,7 +293,7 @@ private:
 /// E.g. template of "position('some string', 'other string') != 0" is
 /// ["position", "(", DataTypeString, ",", DataTypeString, ")", "!=", DataTypeUInt64]
 ConstantExpressionTemplate::TemplateStructure::TemplateStructure(LiteralsInfo & replaced_literals, TokenIterator expression_begin, TokenIterator expression_end,
-                                                                 ASTPtr & expression, const IDataType & result_type, bool null_as_default_, const Context & context)
+                                                                 ASTPtr & expression, const IDataType & result_type, bool null_as_default_, ContextPtr context)
 {
     null_as_default = null_as_default_;
 
@@ -377,7 +377,7 @@ ConstantExpressionTemplate::Cache::getFromCacheOrConstruct(const DataTypePtr & r
                                                            TokenIterator expression_begin,
                                                            TokenIterator expression_end,
                                                            const ASTPtr & expression_,
-                                                           const Context & context,
+                                                           ContextPtr context,
                                                            bool * found_in_cache,
                                                            const String & salt)
 {
@@ -385,7 +385,7 @@ ConstantExpressionTemplate::Cache::getFromCacheOrConstruct(const DataTypePtr & r
     ASTPtr expression = expression_->clone();
     ReplaceLiteralsVisitor visitor(context);
     visitor.visit(expression, result_column_type->isNullable() || null_as_default);
-    ReplaceQueryParameterVisitor param_visitor(context.getQueryParameters());
+    ReplaceQueryParameterVisitor param_visitor(context->getQueryParameters());
     param_visitor.visit(expression);
 
     size_t template_hash = TemplateStructure::getTemplateHash(expression, visitor.replaced_literals, result_column_type, null_as_default, salt);
diff --git a/src/Processors/Formats/Impl/ConstantExpressionTemplate.h b/src/Processors/Formats/Impl/ConstantExpressionTemplate.h
index 4317cf4a3da..6659243df63 100644
--- a/src/Processors/Formats/Impl/ConstantExpressionTemplate.h
+++ b/src/Processors/Formats/Impl/ConstantExpressionTemplate.h
@@ -23,7 +23,7 @@ class ConstantExpressionTemplate : boost::noncopyable
     struct TemplateStructure : boost::noncopyable
     {
         TemplateStructure(LiteralsInfo & replaced_literals, TokenIterator expression_begin, TokenIterator expression_end,
-                          ASTPtr & expr, const IDataType & result_type, bool null_as_default_, const Context & context);
+                          ASTPtr & expr, const IDataType & result_type, bool null_as_default_, ContextPtr context);
 
         static void addNodesToCastResult(const IDataType & result_column_type, ASTPtr & expr, bool null_as_default);
         static size_t getTemplateHash(const ASTPtr & expression, const LiteralsInfo & replaced_literals,
@@ -59,7 +59,7 @@ public:
                                                      TokenIterator expression_begin,
                                                      TokenIterator expression_end,
                                                      const ASTPtr & expression_,
-                                                     const Context & context,
+                                                     ContextPtr context,
                                                      bool * found_in_cache = nullptr,
                                                      const String & salt = {});
     };
diff --git a/src/Processors/Formats/Impl/MySQLOutputFormat.cpp b/src/Processors/Formats/Impl/MySQLOutputFormat.cpp
index 9733d479a77..0f73349c271 100644
--- a/src/Processors/Formats/Impl/MySQLOutputFormat.cpp
+++ b/src/Processors/Formats/Impl/MySQLOutputFormat.cpp
@@ -40,7 +40,7 @@ void MySQLOutputFormat::initialize()
             packet_endpoint->sendPacket(getColumnDefinition(column_name, data_types[i]->getTypeId()));
         }
 
-        if (!(context->mysql.client_capabilities & Capability::CLIENT_DEPRECATE_EOF))
+        if (!(getContext()->mysql.client_capabilities & Capability::CLIENT_DEPRECATE_EOF))
         {
             packet_endpoint->sendPacket(EOFPacket(0, 0));
         }
@@ -64,7 +64,7 @@ void MySQLOutputFormat::finalize()
 {
     size_t affected_rows = 0;
     std::string human_readable_info;
-    if (QueryStatus * process_list_elem = context->getProcessListElement())
+    if (QueryStatus * process_list_elem = getContext()->getProcessListElement())
     {
         CurrentThread::finalizePerformanceCounters();
         QueryStatusInfo info = process_list_elem->getInfo();
@@ -78,10 +78,11 @@ void MySQLOutputFormat::finalize()
 
     const auto & header = getPort(PortKind::Main).getHeader();
     if (header.columns() == 0)
-        packet_endpoint->sendPacket(OKPacket(0x0, context->mysql.client_capabilities, affected_rows, 0, 0, "", human_readable_info), true);
-    else
-    if (context->mysql.client_capabilities & CLIENT_DEPRECATE_EOF)
-        packet_endpoint->sendPacket(OKPacket(0xfe, context->mysql.client_capabilities, affected_rows, 0, 0, "", human_readable_info), true);
+        packet_endpoint->sendPacket(
+            OKPacket(0x0, getContext()->mysql.client_capabilities, affected_rows, 0, 0, "", human_readable_info), true);
+    else if (getContext()->mysql.client_capabilities & CLIENT_DEPRECATE_EOF)
+        packet_endpoint->sendPacket(
+            OKPacket(0xfe, getContext()->mysql.client_capabilities, affected_rows, 0, 0, "", human_readable_info), true);
     else
         packet_endpoint->sendPacket(EOFPacket(0, 0), true);
 }
diff --git a/src/Processors/Formats/Impl/MySQLOutputFormat.h b/src/Processors/Formats/Impl/MySQLOutputFormat.h
index c47bbaadc33..01a892410df 100644
--- a/src/Processors/Formats/Impl/MySQLOutputFormat.h
+++ b/src/Processors/Formats/Impl/MySQLOutputFormat.h
@@ -15,21 +15,20 @@ namespace DB
 class IColumn;
 class IDataType;
 class WriteBuffer;
-class Context;
 
 /** A stream for outputting data in a binary line-by-line format.
   */
-class MySQLOutputFormat final : public IOutputFormat
+class MySQLOutputFormat final : public IOutputFormat, WithConstContext
 {
 public:
     MySQLOutputFormat(WriteBuffer & out_, const Block & header_, const FormatSettings & settings_);
 
     String getName() const override { return "MySQLOutputFormat"; }
 
-    void setContext(const Context & context_)
+    void setContext(ContextConstPtr context_)
     {
-        context = &context_;
-        packet_endpoint = std::make_unique<MySQLProtocol::PacketEndpoint>(out, const_cast<uint8_t &>(context_.mysql.sequence_id)); /// TODO: fix it
+        context = context_;
+        packet_endpoint = std::make_unique<MySQLProtocol::PacketEndpoint>(out, const_cast<uint8_t &>(getContext()->mysql.sequence_id)); /// TODO: fix it
     }
 
     void consume(Chunk) override;
@@ -40,10 +39,8 @@ public:
     void initialize();
 
 private:
-
     bool initialized = false;
 
-    const Context * context = nullptr;
     std::unique_ptr<MySQLProtocol::PacketEndpoint> packet_endpoint;
     FormatSettings format_settings;
     DataTypes data_types;
diff --git a/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp b/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp
index 7776a904f1c..9af03e93c32 100644
--- a/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ORCBlockInputFormat.cpp
@@ -64,6 +64,7 @@ void registerInputFormatProcessorORC(FormatFactory &factory)
             {
                 return std::make_shared<ORCBlockInputFormat>(buf, sample);
             });
+    factory.markFormatAsColumnOriented("ORC");
 }
 
 }
diff --git a/src/Processors/Formats/Impl/ParallelParsingInputFormat.cpp b/src/Processors/Formats/Impl/ParallelParsingInputFormat.cpp
index 1ad913a1a59..f295fe00299 100644
--- a/src/Processors/Formats/Impl/ParallelParsingInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ParallelParsingInputFormat.cpp
@@ -2,14 +2,14 @@
 #include <IO/ReadHelpers.h>
 #include <Common/CurrentThread.h>
 #include <Common/setThreadName.h>
-#include <ext/scope_guard.h>
+#include <ext/scope_guard_safe.h>
 
 namespace DB
 {
 
 void ParallelParsingInputFormat::segmentatorThreadFunction(ThreadGroupStatusPtr thread_group)
 {
-    SCOPE_EXIT(
+    SCOPE_EXIT_SAFE(
         if (thread_group)
             CurrentThread::detachQueryIfNotDetached();
     );
@@ -60,7 +60,7 @@ void ParallelParsingInputFormat::segmentatorThreadFunction(ThreadGroupStatusPtr
 
 void ParallelParsingInputFormat::parserThreadFunction(ThreadGroupStatusPtr thread_group, size_t current_ticket_number)
 {
-    SCOPE_EXIT(
+    SCOPE_EXIT_SAFE(
         if (thread_group)
             CurrentThread::detachQueryIfNotDetached();
     );
diff --git a/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp b/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp
index bb55c71b7ca..162185e75b8 100644
--- a/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp
@@ -94,6 +94,7 @@ void registerInputFormatProcessorParquet(FormatFactory &factory)
             {
                 return std::make_shared<ParquetBlockInputFormat>(buf, sample);
             });
+    factory.markFormatAsColumnOriented("Parquet");
 }
 
 }
diff --git a/src/Processors/Formats/Impl/TabSeparatedRowInputFormat.cpp b/src/Processors/Formats/Impl/TabSeparatedRowInputFormat.cpp
index 41adb6fc612..f89b76342a4 100644
--- a/src/Processors/Formats/Impl/TabSeparatedRowInputFormat.cpp
+++ b/src/Processors/Formats/Impl/TabSeparatedRowInputFormat.cpp
@@ -7,6 +7,7 @@
 #include <Formats/verbosePrintString.h>
 #include <Formats/FormatFactory.h>
 #include <DataTypes/DataTypeNothing.h>
+#include <DataTypes/DataTypeLowCardinality.h>
 #include <DataTypes/Serializations/SerializationNullable.h>
 
 namespace DB
@@ -338,8 +339,10 @@ void TabSeparatedRowInputFormat::tryDeserializeField(const DataTypePtr & type, I
     const auto & index = column_mapping->column_indexes_for_input_fields[file_column];
     if (index)
     {
+        bool can_be_parsed_as_null = removeLowCardinality(type)->isNullable();
+
         // check null value for type is not nullable. don't cross buffer bound for simplicity, so maybe missing some case
-        if (!type->isNullable() && !in.eof())
+        if (!can_be_parsed_as_null && !in.eof())
         {
             if (*in.position() == '\\' && in.available() >= 2)
             {
diff --git a/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp b/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp
index c054145016d..701385447b4 100644
--- a/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp
@@ -358,7 +358,7 @@ bool ValuesBlockInputFormat::parseExpression(IColumn & column, size_t column_idx
                 TokenIterator(tokens),
                 token_iterator,
                 ast,
-                *context,
+                context,
                 &found_in_cache,
                 delimiter);
             templates[column_idx].emplace(structure);
@@ -400,7 +400,7 @@ bool ValuesBlockInputFormat::parseExpression(IColumn & column, size_t column_idx
     /// Try to evaluate single expression if other parsers don't work
     buf.position() = const_cast<char *>(token_iterator->begin);
 
-    std::pair<Field, DataTypePtr> value_raw = evaluateConstantExpression(ast, *context);
+    std::pair<Field, DataTypePtr> value_raw = evaluateConstantExpression(ast, context);
 
     Field & expression_value = value_raw.first;
 
diff --git a/src/Processors/Formats/Impl/ValuesBlockInputFormat.h b/src/Processors/Formats/Impl/ValuesBlockInputFormat.h
index 8e7e15c572d..ea5ab9239e0 100644
--- a/src/Processors/Formats/Impl/ValuesBlockInputFormat.h
+++ b/src/Processors/Formats/Impl/ValuesBlockInputFormat.h
@@ -1,21 +1,19 @@
 #pragma once
 
 #include <Core/Block.h>
-#include <Processors/Formats/IInputFormat.h>
-#include <Processors/Formats/IRowInputFormat.h>
 #include <Formats/FormatSettings.h>
-#include <Processors/Formats/Impl/ConstantExpressionTemplate.h>
-
+#include <Interpreters/Context.h>
 #include <IO/PeekableReadBuffer.h>
 #include <Parsers/ExpressionListParsers.h>
+#include <Processors/Formats/IInputFormat.h>
+#include <Processors/Formats/IRowInputFormat.h>
+#include <Processors/Formats/Impl/ConstantExpressionTemplate.h>
 
 namespace DB
 {
 
-class Context;
 class ReadBuffer;
 
-
 /** Stream to read data in VALUES format (as in INSERT query).
   */
 class ValuesBlockInputFormat final : public IInputFormat
@@ -36,7 +34,7 @@ public:
     void resetParser() override;
 
     /// TODO: remove context somehow.
-    void setContext(const Context & context_) { context = std::make_unique<Context>(context_); }
+    void setContext(ContextConstPtr context_) { context = Context::createCopy(context_); }
 
     const BlockMissingValues & getMissingValues() const override { return block_missing_values; }
 
@@ -68,12 +66,11 @@ private:
 
     bool skipToNextRow(size_t min_chunk_bytes = 0, int balance = 0);
 
-private:
     PeekableReadBuffer buf;
 
     const RowInputFormatParams params;
 
-    std::unique_ptr<Context> context;   /// pimpl
+    ContextPtr context;   /// pimpl
     const FormatSettings format_settings;
 
     const size_t num_columns;
diff --git a/src/Processors/Pipe.cpp b/src/Processors/Pipe.cpp
index 129bebf452a..677956db299 100644
--- a/src/Processors/Pipe.cpp
+++ b/src/Processors/Pipe.cpp
@@ -252,10 +252,10 @@ static Pipes removeEmptyPipes(Pipes pipes)
 
 Pipe Pipe::unitePipes(Pipes pipes)
 {
-    return Pipe::unitePipes(std::move(pipes), nullptr);
+    return Pipe::unitePipes(std::move(pipes), nullptr, false);
 }
 
-Pipe Pipe::unitePipes(Pipes pipes, Processors * collected_processors)
+Pipe Pipe::unitePipes(Pipes pipes, Processors * collected_processors, bool allow_empty_header)
 {
     Pipe res;
 
@@ -275,12 +275,25 @@ Pipe Pipe::unitePipes(Pipes pipes, Processors * collected_processors)
 
     OutputPortRawPtrs totals;
     OutputPortRawPtrs extremes;
-    res.header = pipes.front().header;
     res.collected_processors = collected_processors;
+    res.header = pipes.front().header;
+    if (allow_empty_header && !res.header)
+    {
+        for (const auto & pipe : pipes)
+        {
+            if (const auto & header = pipe.getHeader())
+            {
+                res.header = header;
+                break;
+            }
+        }
+    }
 
     for (auto & pipe : pipes)
     {
-        assertBlocksHaveEqualStructure(res.header, pipe.header, "Pipe::unitePipes");
+        if (!allow_empty_header || pipe.header)
+            assertBlocksHaveEqualStructure(res.header, pipe.header, "Pipe::unitePipes");
+
         res.processors.insert(res.processors.end(), pipe.processors.begin(), pipe.processors.end());
         res.output_ports.insert(res.output_ports.end(), pipe.output_ports.begin(), pipe.output_ports.end());
 
diff --git a/src/Processors/Pipe.h b/src/Processors/Pipe.h
index f21f4761977..4ba08787579 100644
--- a/src/Processors/Pipe.h
+++ b/src/Processors/Pipe.h
@@ -1,8 +1,9 @@
 #pragma once
+
 #include <Processors/IProcessor.h>
-#include <Processors/Sources/SourceWithProgress.h>
 #include <Processors/QueryPlan/QueryIdHolder.h>
 #include <Processors/QueryPlan/QueryPlan.h>
+#include <Processors/Sources/SourceWithProgress.h>
 
 namespace DB
 {
@@ -155,7 +156,7 @@ private:
     /// This methods are for QueryPipeline. It is allowed to complete graph only there.
     /// So, we may be sure that Pipe always has output port if not empty.
     bool isCompleted() const { return !empty() && output_ports.empty(); }
-    static Pipe unitePipes(Pipes pipes, Processors * collected_processors);
+    static Pipe unitePipes(Pipes pipes, Processors * collected_processors, bool allow_empty_header);
     void setSinks(const Pipe::ProcessorGetterWithStreamKind & getter);
     void setOutputFormat(ProcessorPtr output);
 
diff --git a/src/Processors/QueryPipeline.cpp b/src/Processors/QueryPipeline.cpp
index 637a9480034..cabf5f19190 100644
--- a/src/Processors/QueryPipeline.cpp
+++ b/src/Processors/QueryPipeline.cpp
@@ -211,11 +211,14 @@ void QueryPipeline::setOutputFormat(ProcessorPtr output)
 
 QueryPipeline QueryPipeline::unitePipelines(
     std::vector<std::unique_ptr<QueryPipeline>> pipelines,
-    const Block & common_header,
-    const ExpressionActionsSettings & settings,
     size_t max_threads_limit,
     Processors * collected_processors)
 {
+    if (pipelines.empty())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot unite an empty set of pipelines");
+
+    Block common_header = pipelines.front()->getHeader();
+
     /// Should we limit the number of threads for united pipeline. True if all pipelines have max_threads != 0.
     /// If true, result max_threads will be sum(max_threads).
     /// Note: it may be > than settings.max_threads, so we should apply this limit again.
@@ -229,19 +232,7 @@ QueryPipeline QueryPipeline::unitePipelines(
         pipeline.checkInitialized();
         pipeline.pipe.collected_processors = collected_processors;
 
-        if (!pipeline.isCompleted())
-        {
-            auto actions_dag = ActionsDAG::makeConvertingActions(
-                    pipeline.getHeader().getColumnsWithTypeAndName(),
-                    common_header.getColumnsWithTypeAndName(),
-                    ActionsDAG::MatchColumnsMode::Position);
-            auto actions = std::make_shared<ExpressionActions>(actions_dag, settings);
-
-            pipeline.addSimpleTransform([&](const Block & header)
-            {
-               return std::make_shared<ExpressionTransform>(header, actions);
-            });
-        }
+        assertBlocksHaveEqualStructure(pipeline.getHeader(), common_header, "QueryPipeline::unitePipelines");
 
         pipes.emplace_back(std::move(pipeline.pipe));
 
@@ -255,7 +246,7 @@ QueryPipeline QueryPipeline::unitePipelines(
     }
 
     QueryPipeline pipeline;
-    pipeline.init(Pipe::unitePipes(std::move(pipes), collected_processors));
+    pipeline.init(Pipe::unitePipes(std::move(pipes), collected_processors, false));
 
     if (will_limit_max_threads)
     {
@@ -267,7 +258,7 @@ QueryPipeline QueryPipeline::unitePipelines(
 }
 
 
-void QueryPipeline::addCreatingSetsTransform(const Block & res_header, SubqueryForSet subquery_for_set, const SizeLimits & limits, const Context & context)
+void QueryPipeline::addCreatingSetsTransform(const Block & res_header, SubqueryForSet subquery_for_set, const SizeLimits & limits, ContextPtr context)
 {
     resize(1);
 
@@ -289,7 +280,9 @@ void QueryPipeline::addCreatingSetsTransform(const Block & res_header, SubqueryF
 void QueryPipeline::addPipelineBefore(QueryPipeline pipeline)
 {
     checkInitializedAndNotCompleted();
-    assertBlocksHaveEqualStructure(getHeader(), pipeline.getHeader(), "QueryPipeline");
+    if (pipeline.getHeader())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Pipeline for CreatingSets should have empty header. Got: {}",
+                        pipeline.getHeader().dumpStructure());
 
     IProcessor::PortNumbers delayed_streams(pipe.numOutputPorts());
     for (size_t i = 0; i < delayed_streams.size(); ++i)
@@ -300,7 +293,7 @@ void QueryPipeline::addPipelineBefore(QueryPipeline pipeline)
     Pipes pipes;
     pipes.emplace_back(std::move(pipe));
     pipes.emplace_back(QueryPipeline::getPipe(std::move(pipeline)));
-    pipe = Pipe::unitePipes(std::move(pipes), collected_processors);
+    pipe = Pipe::unitePipes(std::move(pipes), collected_processors, true);
 
     auto processor = std::make_shared<DelayedPortsProcessor>(getHeader(), pipe.numOutputPorts(), delayed_streams, true);
     addTransform(std::move(processor));
diff --git a/src/Processors/QueryPipeline.h b/src/Processors/QueryPipeline.h
index 8799237384e..ac0777d22c6 100644
--- a/src/Processors/QueryPipeline.h
+++ b/src/Processors/QueryPipeline.h
@@ -1,19 +1,16 @@
 #pragma once
-#include <Processors/IProcessor.h>
-#include <Processors/Executors/PipelineExecutor.h>
-#include <Processors/Pipe.h>
 
 #include <DataStreams/IBlockInputStream.h>
 #include <DataStreams/IBlockOutputStream.h>
-
+#include <Processors/Executors/PipelineExecutor.h>
+#include <Processors/IProcessor.h>
+#include <Processors/Pipe.h>
 #include <Storages/IStorage_fwd.h>
 #include <Storages/TableLockHolder.h>
 
 namespace DB
 {
 
-class Context;
-
 class IOutputFormat;
 
 class QueryPipelineProcessorsCollector;
@@ -90,16 +87,15 @@ public:
     /// If collector is used, it will collect only newly-added processors, but not processors from pipelines.
     static QueryPipeline unitePipelines(
             std::vector<std::unique_ptr<QueryPipeline>> pipelines,
-            const Block & common_header,
-            const ExpressionActionsSettings & settings,
             size_t max_threads_limit = 0,
             Processors * collected_processors = nullptr);
 
     /// Add other pipeline and execute it before current one.
-    /// Pipeline must have same header.
+    /// Pipeline must have empty header, it should not generate any chunk.
+    /// This is used for CreatingSets.
     void addPipelineBefore(QueryPipeline pipeline);
 
-    void addCreatingSetsTransform(const Block & res_header, SubqueryForSet subquery_for_set, const SizeLimits & limits, const Context & context);
+    void addCreatingSetsTransform(const Block & res_header, SubqueryForSet subquery_for_set, const SizeLimits & limits, ContextPtr context);
 
     PipelineExecutorPtr execute();
 
diff --git a/src/Processors/QueryPlan/AddingDelayedSourceStep.cpp b/src/Processors/QueryPlan/AddingDelayedSourceStep.cpp
deleted file mode 100644
index 1f02205dad8..00000000000
--- a/src/Processors/QueryPlan/AddingDelayedSourceStep.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <Processors/QueryPlan/AddingDelayedSourceStep.h>
-#include <Processors/QueryPipeline.h>
-
-namespace DB
-{
-
-static ITransformingStep::Traits getTraits()
-{
-    return ITransformingStep::Traits
-    {
-        {
-            .preserves_distinct_columns = false,
-            .returns_single_stream = false,
-            .preserves_number_of_streams = false,
-            .preserves_sorting = false,
-        },
-        {
-            .preserves_number_of_rows = false, /// New rows are added from delayed stream
-        }
-    };
-}
-
-AddingDelayedSourceStep::AddingDelayedSourceStep(
-    const DataStream & input_stream_,
-    ProcessorPtr source_)
-    : ITransformingStep(input_stream_, input_stream_.header, getTraits())
-    , source(std::move(source_))
-{
-}
-
-void AddingDelayedSourceStep::transformPipeline(QueryPipeline & pipeline, const BuildQueryPipelineSettings &)
-{
-    source->setQueryPlanStep(this);
-    pipeline.addDelayedStream(source);
-
-    /// Now, after adding delayed stream, it has implicit dependency on other port.
-    /// Here we add resize processor to remove this dependency.
-    /// Otherwise, if we add MergeSorting + MergingSorted transform to pipeline, we could get `Pipeline stuck`
-    pipeline.resize(pipeline.getNumStreams(), true);
-}
-
-}
diff --git a/src/Processors/QueryPlan/AddingDelayedSourceStep.h b/src/Processors/QueryPlan/AddingDelayedSourceStep.h
deleted file mode 100644
index 30565f2002a..00000000000
--- a/src/Processors/QueryPlan/AddingDelayedSourceStep.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-#include <Processors/QueryPlan/ITransformingStep.h>
-#include <DataStreams/SizeLimits.h>
-
-namespace DB
-{
-
-class IProcessor;
-using ProcessorPtr = std::shared_ptr<IProcessor>;
-
-/// Adds another source to pipeline. Data from this source will be read after data from all other sources.
-/// NOTE: tis step is needed because of non-joined data from JOIN. Remove this step after adding JoinStep.
-class AddingDelayedSourceStep : public ITransformingStep
-{
-public:
-    AddingDelayedSourceStep(
-            const DataStream & input_stream_,
-            ProcessorPtr source_);
-
-    String getName() const override { return "AddingDelayedSource"; }
-
-    void transformPipeline(QueryPipeline & pipeline, const BuildQueryPipelineSettings &) override;
-
-private:
-    ProcessorPtr source;
-};
-
-}
diff --git a/src/Processors/QueryPlan/BuildQueryPipelineSettings.cpp b/src/Processors/QueryPlan/BuildQueryPipelineSettings.cpp
index 0ff77770793..9691da4a362 100644
--- a/src/Processors/QueryPlan/BuildQueryPipelineSettings.cpp
+++ b/src/Processors/QueryPlan/BuildQueryPipelineSettings.cpp
@@ -13,9 +13,9 @@ BuildQueryPipelineSettings BuildQueryPipelineSettings::fromSettings(const Settin
     return settings;
 }
 
-BuildQueryPipelineSettings BuildQueryPipelineSettings::fromContext(const Context & from)
+BuildQueryPipelineSettings BuildQueryPipelineSettings::fromContext(ContextPtr from)
 {
-    return fromSettings(from.getSettingsRef());
+    return fromSettings(from->getSettingsRef());
 }
 
 }
diff --git a/src/Processors/QueryPlan/BuildQueryPipelineSettings.h b/src/Processors/QueryPlan/BuildQueryPipelineSettings.h
index 3fd37b6042e..c3282d43778 100644
--- a/src/Processors/QueryPlan/BuildQueryPipelineSettings.h
+++ b/src/Processors/QueryPlan/BuildQueryPipelineSettings.h
@@ -1,12 +1,13 @@
 #pragma once
-#include <cstddef>
+
 #include <Interpreters/ExpressionActionsSettings.h>
 
+#include <cstddef>
+
 namespace DB
 {
 
 struct Settings;
-class Context;
 
 struct BuildQueryPipelineSettings
 {
@@ -15,7 +16,7 @@ struct BuildQueryPipelineSettings
     const ExpressionActionsSettings & getActionsSettings() const { return actions_settings; }
 
     static BuildQueryPipelineSettings fromSettings(const Settings & from);
-    static BuildQueryPipelineSettings fromContext(const Context & from);
+    static BuildQueryPipelineSettings fromContext(ContextPtr from);
 };
 
 }
diff --git a/src/Processors/QueryPlan/CreatingSetsStep.cpp b/src/Processors/QueryPlan/CreatingSetsStep.cpp
index 73d5f479b98..9ea8e7b237b 100644
--- a/src/Processors/QueryPlan/CreatingSetsStep.cpp
+++ b/src/Processors/QueryPlan/CreatingSetsStep.cpp
@@ -30,22 +30,21 @@ static ITransformingStep::Traits getTraits()
 
 CreatingSetStep::CreatingSetStep(
     const DataStream & input_stream_,
-    Block header,
     String description_,
     SubqueryForSet subquery_for_set_,
     SizeLimits network_transfer_limits_,
-    const Context & context_)
-    : ITransformingStep(input_stream_, header, getTraits())
+    ContextPtr context_)
+    : ITransformingStep(input_stream_, Block{}, getTraits())
+    , WithContext(context_)
     , description(std::move(description_))
     , subquery_for_set(std::move(subquery_for_set_))
     , network_transfer_limits(std::move(network_transfer_limits_))
-    , context(context_)
 {
 }
 
 void CreatingSetStep::transformPipeline(QueryPipeline & pipeline, const BuildQueryPipelineSettings &)
 {
-    pipeline.addCreatingSetsTransform(getOutputStream().header, std::move(subquery_for_set), network_transfer_limits, context);
+    pipeline.addCreatingSetsTransform(getOutputStream().header, std::move(subquery_for_set), network_transfer_limits, getContext());
 }
 
 void CreatingSetStep::describeActions(FormatSettings & settings) const
@@ -70,10 +69,12 @@ CreatingSetsStep::CreatingSetsStep(DataStreams input_streams_)
     output_stream = input_streams.front();
 
     for (size_t i = 1; i < input_streams.size(); ++i)
-        assertBlocksHaveEqualStructure(output_stream->header, input_streams[i].header, "CreatingSets");
+        if (input_streams[i].header)
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Creating set input must have empty header. Got: {}",
+                            input_streams[i].header.dumpStructure());
 }
 
-QueryPipelinePtr CreatingSetsStep::updatePipeline(QueryPipelines pipelines, const BuildQueryPipelineSettings & settings)
+QueryPipelinePtr CreatingSetsStep::updatePipeline(QueryPipelines pipelines, const BuildQueryPipelineSettings &)
 {
     if (pipelines.empty())
         throw Exception("CreatingSetsStep cannot be created with no inputs", ErrorCodes::LOGICAL_ERROR);
@@ -82,14 +83,13 @@ QueryPipelinePtr CreatingSetsStep::updatePipeline(QueryPipelines pipelines, cons
     if (pipelines.size() == 1)
         return main_pipeline;
 
-    std::swap(pipelines.front(), pipelines.back());
-    pipelines.pop_back();
+    pipelines.erase(pipelines.begin());
 
     QueryPipeline delayed_pipeline;
     if (pipelines.size() > 1)
     {
         QueryPipelineProcessorsCollector collector(delayed_pipeline, this);
-        delayed_pipeline = QueryPipeline::unitePipelines(std::move(pipelines), output_stream->header, settings.getActionsSettings());
+        delayed_pipeline = QueryPipeline::unitePipelines(std::move(pipelines));
         processors = collector.detachProcessors();
     }
     else
@@ -109,7 +109,7 @@ void CreatingSetsStep::describePipeline(FormatSettings & settings) const
 }
 
 void addCreatingSetsStep(
-    QueryPlan & query_plan, SubqueriesForSets subqueries_for_sets, const SizeLimits & limits, const Context & context)
+    QueryPlan & query_plan, SubqueriesForSets subqueries_for_sets, const SizeLimits & limits, ContextPtr context)
 {
     DataStreams input_streams;
     input_streams.emplace_back(query_plan.getCurrentDataStream());
@@ -129,7 +129,6 @@ void addCreatingSetsStep(
 
         auto creating_set = std::make_unique<CreatingSetStep>(
                 plan->getCurrentDataStream(),
-                input_streams.front().header,
                 std::move(description),
                 std::move(set),
                 limits,
diff --git a/src/Processors/QueryPlan/CreatingSetsStep.h b/src/Processors/QueryPlan/CreatingSetsStep.h
index 79ae3ed65f0..c2b452ecdf5 100644
--- a/src/Processors/QueryPlan/CreatingSetsStep.h
+++ b/src/Processors/QueryPlan/CreatingSetsStep.h
@@ -1,22 +1,23 @@
 #pragma once
+
 #include <Processors/QueryPlan/ITransformingStep.h>
 #include <DataStreams/SizeLimits.h>
 #include <Interpreters/SubqueryForSet.h>
+#include <Interpreters/Context_fwd.h>
 
 namespace DB
 {
 
 /// Creates sets for subqueries and JOIN. See CreatingSetsTransform.
-class CreatingSetStep : public ITransformingStep
+class CreatingSetStep : public ITransformingStep, WithContext
 {
 public:
     CreatingSetStep(
             const DataStream & input_stream_,
-            Block header,
             String description_,
             SubqueryForSet subquery_for_set_,
             SizeLimits network_transfer_limits_,
-            const Context & context_);
+            ContextPtr context_);
 
     String getName() const override { return "CreatingSet"; }
 
@@ -28,7 +29,6 @@ private:
     String description;
     SubqueryForSet subquery_for_set;
     SizeLimits network_transfer_limits;
-    const Context & context;
 };
 
 class CreatingSetsStep : public IQueryPlanStep
@@ -38,7 +38,7 @@ public:
 
     String getName() const override { return "CreatingSets"; }
 
-    QueryPipelinePtr updatePipeline(QueryPipelines pipelines, const BuildQueryPipelineSettings & settings) override;
+    QueryPipelinePtr updatePipeline(QueryPipelines pipelines, const BuildQueryPipelineSettings &) override;
 
     void describePipeline(FormatSettings & settings) const override;
 
@@ -50,6 +50,6 @@ void addCreatingSetsStep(
     QueryPlan & query_plan,
     SubqueriesForSets subqueries_for_sets,
     const SizeLimits & limits,
-    const Context & context);
+    ContextPtr context);
 
 }
diff --git a/src/Processors/QueryPlan/ExpressionStep.cpp b/src/Processors/QueryPlan/ExpressionStep.cpp
index f7bb4a9e9c2..c85092edf05 100644
--- a/src/Processors/QueryPlan/ExpressionStep.cpp
+++ b/src/Processors/QueryPlan/ExpressionStep.cpp
@@ -4,6 +4,8 @@
 #include <Processors/Transforms/JoiningTransform.h>
 #include <Interpreters/ExpressionActions.h>
 #include <IO/Operators.h>
+#include <Processors/Sources/SourceFromInputStream.h>
+#include <Interpreters/JoinSwitcher.h>
 
 namespace DB
 {
@@ -108,12 +110,14 @@ void ExpressionStep::describeActions(FormatSettings & settings) const
     settings.out << '\n';
 }
 
-JoinStep::JoinStep(const DataStream & input_stream_, JoinPtr join_)
+JoinStep::JoinStep(const DataStream & input_stream_, JoinPtr join_, bool has_non_joined_rows_, size_t max_block_size_)
     : ITransformingStep(
         input_stream_,
         Transform::transformHeader(input_stream_.header, join_),
         getJoinTraits())
     , join(std::move(join_))
+    , has_non_joined_rows(has_non_joined_rows_)
+    , max_block_size(max_block_size_)
 {
 }
 
@@ -132,6 +136,21 @@ void JoinStep::transformPipeline(QueryPipeline & pipeline, const BuildQueryPipel
         bool on_totals = stream_type == QueryPipeline::StreamType::Totals;
         return std::make_shared<Transform>(header, join, on_totals, add_default_totals);
     });
+
+    if (has_non_joined_rows)
+    {
+        const Block & join_result_sample = pipeline.getHeader();
+        auto stream = std::make_shared<LazyNonJoinedBlockInputStream>(*join, join_result_sample, max_block_size);
+        auto source = std::make_shared<SourceFromInputStream>(std::move(stream));
+
+        source->setQueryPlanStep(this);
+        pipeline.addDelayedStream(source);
+
+        /// Now, after adding delayed stream, it has implicit dependency on other port.
+        /// Here we add resize processor to remove this dependency.
+        /// Otherwise, if we add MergeSorting + MergingSorted transform to pipeline, we could get `Pipeline stuck`
+        pipeline.resize(pipeline.getNumStreams(), true);
+    }
 }
 
 }
diff --git a/src/Processors/QueryPlan/ExpressionStep.h b/src/Processors/QueryPlan/ExpressionStep.h
index 71937b6f78f..bcc1b0ef7b6 100644
--- a/src/Processors/QueryPlan/ExpressionStep.h
+++ b/src/Processors/QueryPlan/ExpressionStep.h
@@ -40,13 +40,17 @@ class JoinStep : public ITransformingStep
 public:
     using Transform = JoiningTransform;
 
-    explicit JoinStep(const DataStream & input_stream_, JoinPtr join_);
+    explicit JoinStep(const DataStream & input_stream_, JoinPtr join_, bool has_non_joined_rows_, size_t max_block_size_);
     String getName() const override { return "Join"; }
 
     void transformPipeline(QueryPipeline & pipeline, const BuildQueryPipelineSettings &) override;
 
+    const JoinPtr & getJoin() const { return join; }
+
 private:
     JoinPtr join;
+    bool has_non_joined_rows;
+    size_t max_block_size;
 };
 
 }
diff --git a/src/Processors/QueryPlan/Optimizations/Optimizations.h b/src/Processors/QueryPlan/Optimizations/Optimizations.h
index f96237fc71a..7e946a71fad 100644
--- a/src/Processors/QueryPlan/Optimizations/Optimizations.h
+++ b/src/Processors/QueryPlan/Optimizations/Optimizations.h
@@ -1,5 +1,6 @@
 #pragma once
 #include <Processors/QueryPlan/QueryPlan.h>
+#include <Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.h>
 #include <array>
 
 namespace DB
@@ -23,6 +24,7 @@ struct Optimization
     using Function = size_t (*)(QueryPlan::Node *, QueryPlan::Nodes &);
     const Function apply = nullptr;
     const char * name;
+    const bool QueryPlanOptimizationSettings::* const is_enabled;
 };
 
 /// Move ARRAY JOIN up if possible.
@@ -46,11 +48,11 @@ inline const auto & getOptimizations()
 {
     static const std::array<Optimization, 5> optimizations =
     {{
-        {tryLiftUpArrayJoin, "liftUpArrayJoin"},
-        {tryPushDownLimit, "pushDownLimit"},
-        {trySplitFilter, "splitFilter"},
-        {tryMergeExpressions, "mergeExpressions"},
-        {tryPushDownFilter, "pushDownFilter"},
+        {tryLiftUpArrayJoin, "liftUpArrayJoin", &QueryPlanOptimizationSettings::optimize_plan},
+        {tryPushDownLimit, "pushDownLimit", &QueryPlanOptimizationSettings::optimize_plan},
+        {trySplitFilter, "splitFilter", &QueryPlanOptimizationSettings::optimize_plan},
+        {tryMergeExpressions, "mergeExpressions", &QueryPlanOptimizationSettings::optimize_plan},
+        {tryPushDownFilter, "pushDownFilter", &QueryPlanOptimizationSettings::filter_push_down},
      }};
 
     return optimizations;
diff --git a/src/Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.cpp b/src/Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.cpp
index a8791f757f4..1472fb87a89 100644
--- a/src/Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.cpp
+++ b/src/Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.cpp
@@ -8,13 +8,15 @@ namespace DB
 QueryPlanOptimizationSettings QueryPlanOptimizationSettings::fromSettings(const Settings & from)
 {
     QueryPlanOptimizationSettings settings;
+    settings.optimize_plan = from.query_plan_enable_optimizations;
     settings.max_optimizations_to_apply = from.query_plan_max_optimizations_to_apply;
+    settings.filter_push_down = from.query_plan_filter_push_down;
     return settings;
 }
 
-QueryPlanOptimizationSettings QueryPlanOptimizationSettings::fromContext(const Context & from)
+QueryPlanOptimizationSettings QueryPlanOptimizationSettings::fromContext(ContextPtr from)
 {
-    return fromSettings(from.getSettingsRef());
+    return fromSettings(from->getSettingsRef());
 }
 
 }
diff --git a/src/Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.h b/src/Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.h
index 64943ec40a8..b5a37bf69d6 100644
--- a/src/Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.h
+++ b/src/Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.h
@@ -1,12 +1,13 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
+
 #include <cstddef>
 
 namespace DB
 {
 
 struct Settings;
-class Context;
 
 struct QueryPlanOptimizationSettings
 {
@@ -14,8 +15,14 @@ struct QueryPlanOptimizationSettings
     /// It helps to avoid infinite optimization loop.
     size_t max_optimizations_to_apply = 0;
 
+    /// If disabled, no optimization applied.
+    bool optimize_plan = true;
+
+    /// If filter push down optimization is enabled.
+    bool filter_push_down = true;
+
     static QueryPlanOptimizationSettings fromSettings(const Settings & from);
-    static QueryPlanOptimizationSettings fromContext(const Context & from);
+    static QueryPlanOptimizationSettings fromContext(ContextPtr from);
 };
 
 }
diff --git a/src/Processors/QueryPlan/Optimizations/filterPushDown.cpp b/src/Processors/QueryPlan/Optimizations/filterPushDown.cpp
index 552720fa1a4..20813e9f548 100644
--- a/src/Processors/QueryPlan/Optimizations/filterPushDown.cpp
+++ b/src/Processors/QueryPlan/Optimizations/filterPushDown.cpp
@@ -4,6 +4,7 @@
 #include <Processors/QueryPlan/AggregatingStep.h>
 #include <Processors/QueryPlan/ExpressionStep.h>
 #include <Processors/QueryPlan/ArrayJoinStep.h>
+#include <Processors/QueryPlan/CreatingSetsStep.h>
 #include <Processors/QueryPlan/CubeStep.h>
 #include <Processors/QueryPlan/FinishSortingStep.h>
 #include <Processors/QueryPlan/MergeSortingStep.h>
@@ -11,8 +12,10 @@
 #include <Processors/QueryPlan/PartialSortingStep.h>
 #include <Processors/QueryPlan/TotalsHavingStep.h>
 #include <Processors/QueryPlan/DistinctStep.h>
+#include <Processors/QueryPlan/UnionStep.h>
 #include <Interpreters/ActionsDAG.h>
 #include <Interpreters/ArrayJoinAction.h>
+#include <Interpreters/TableJoin.h>
 #include <Common/typeid_cast.h>
 #include <DataTypes/DataTypeAggregateFunction.h>
 
@@ -73,8 +76,8 @@ static size_t tryAddNewFilterStep(
     child_node->children.emplace_back(&node);
     /// Expression/Filter -> Aggregating -> Filter -> Something
 
-    /// New filter column is added to the end.
-    auto split_filter_column_name = (*split_filter->getIndex().rbegin())->result_name;
+    /// New filter column is the first one.
+    auto split_filter_column_name = (*split_filter->getIndex().begin())->result_name;
     node.step = std::make_unique<FilterStep>(
             node.children.at(0)->step->getOutputStream(),
             std::move(split_filter), std::move(split_filter_column_name), true);
@@ -82,7 +85,7 @@ static size_t tryAddNewFilterStep(
     return 3;
 }
 
-static Names getAggregatinKeys(const Aggregator::Params & params)
+static Names getAggregatingKeys(const Aggregator::Params & params)
 {
     Names keys;
     keys.reserve(params.keys.size());
@@ -112,17 +115,36 @@ size_t tryPushDownFilter(QueryPlan::Node * parent_node, QueryPlan::Nodes & nodes
     if (auto * aggregating = typeid_cast<AggregatingStep *>(child.get()))
     {
         const auto & params = aggregating->getParams();
-        Names keys = getAggregatinKeys(params);
+        Names keys = getAggregatingKeys(params);
 
         if (auto updated_steps = tryAddNewFilterStep(parent_node, nodes, keys))
             return updated_steps;
     }
 
+    if (typeid_cast<CreatingSetsStep *>(child.get()))
+    {
+        /// CreatingSets does not change header.
+        /// We can push down filter and update header.
+        ///                       - Something
+        /// Filter - CreatingSets - CreatingSet
+        ///                       - CreatingSet
+        auto input_streams = child->getInputStreams();
+        input_streams.front() = filter->getOutputStream();
+        child = std::make_unique<CreatingSetsStep>(input_streams);
+        std::swap(parent, child);
+        std::swap(parent_node->children, child_node->children);
+        std::swap(parent_node->children.front(), child_node->children.front());
+        ///              - Filter - Something
+        /// CreatingSets - CreatingSet
+        ///              - CreatingSet
+        return 2;
+    }
+
     if (auto * totals_having = typeid_cast<TotalsHavingStep *>(child.get()))
     {
         /// If totals step has HAVING expression, skip it for now.
         /// TODO:
-        /// We can merge HAING expression with current filer.
+        /// We can merge HAVING expression with current filer.
         /// Also, we can push down part of HAVING which depend only on aggregation keys.
         if (totals_having->getActions())
             return 0;
@@ -168,6 +190,36 @@ size_t tryPushDownFilter(QueryPlan::Node * parent_node, QueryPlan::Nodes & nodes
             return updated_steps;
     }
 
+    if (auto * join = typeid_cast<JoinStep *>(child.get()))
+    {
+        const auto & table_join  = join->getJoin()->getTableJoin();
+        /// Push down is for left table only. We need to update JoinStep for push down into right.
+        /// Only inner and left join are supported. Other types may generate default values for left table keys.
+        /// So, if we push down a condition like `key != 0`, not all rows may be filtered.
+        if (table_join.kind() == ASTTableJoin::Kind::Inner || table_join.kind() == ASTTableJoin::Kind::Left)
+        {
+            const auto & left_header = join->getInputStreams().front().header;
+            const auto & res_header = join->getOutputStream().header;
+            Names allowed_keys;
+            for (const auto & name : table_join.keyNamesLeft())
+            {
+                /// Skip key if it is renamed.
+                /// I don't know if it is possible. Just in case.
+                if (!left_header.has(name) || !res_header.has(name))
+                    continue;
+
+                /// Skip if type is changed. Push down expression expect equal types.
+                if (!left_header.getByName(name).type->equals(*res_header.getByName(name).type))
+                    continue;
+
+                allowed_keys.push_back(name);
+            }
+
+            if (auto updated_steps = tryAddNewFilterStep(parent_node, nodes, allowed_keys))
+                return updated_steps;
+        }
+    }
+
     /// TODO.
     /// We can filter earlier if expression does not depend on WITH FILL columns.
     /// But we cannot just push down condition, because other column may be filled with defaults.
@@ -193,6 +245,48 @@ size_t tryPushDownFilter(QueryPlan::Node * parent_node, QueryPlan::Nodes & nodes
             return updated_steps;
     }
 
+    if (auto * union_step = typeid_cast<UnionStep *>(child.get()))
+    {
+        /// Union does not change header.
+        /// We can push down filter and update header.
+        auto union_input_streams = child->getInputStreams();
+        for (auto & input_stream : union_input_streams)
+            input_stream.header = filter->getOutputStream().header;
+
+        ///                - Something
+        /// Filter - Union - Something
+        ///                - Something
+
+        child = std::make_unique<UnionStep>(union_input_streams, union_step->getMaxThreads());
+
+        std::swap(parent, child);
+        std::swap(parent_node->children, child_node->children);
+        std::swap(parent_node->children.front(), child_node->children.front());
+
+        ///       - Filter - Something
+        /// Union - Something
+        ///       - Something
+
+        for (size_t i = 1; i < parent_node->children.size(); ++i)
+        {
+            auto & filter_node = nodes.emplace_back();
+            filter_node.children.push_back(parent_node->children[i]);
+            parent_node->children[i] = &filter_node;
+
+            filter_node.step = std::make_unique<FilterStep>(
+                filter_node.children.front()->step->getOutputStream(),
+                filter->getExpression()->clone(),
+                filter->getFilterColumnName(),
+                filter->removesFilterColumn());
+        }
+
+        ///       - Filter - Something
+        /// Union - Filter - Something
+        ///       - Filter - Something
+
+        return 3;
+    }
+
     return 0;
 }
 
diff --git a/src/Processors/QueryPlan/Optimizations/optimizeTree.cpp b/src/Processors/QueryPlan/Optimizations/optimizeTree.cpp
index 858bde9c660..da9b1e26f68 100644
--- a/src/Processors/QueryPlan/Optimizations/optimizeTree.cpp
+++ b/src/Processors/QueryPlan/Optimizations/optimizeTree.cpp
@@ -16,6 +16,9 @@ namespace QueryPlanOptimizations
 
 void optimizeTree(const QueryPlanOptimizationSettings & settings, QueryPlan::Node & root, QueryPlan::Nodes & nodes)
 {
+    if (!settings.optimize_plan)
+        return;
+
     const auto & optimizations = getOptimizations();
 
     struct Frame
@@ -63,6 +66,9 @@ void optimizeTree(const QueryPlanOptimizationSettings & settings, QueryPlan::Nod
         /// Apply all optimizations.
         for (const auto & optimization : optimizations)
         {
+            if (!(settings.*(optimization.is_enabled)))
+                continue;
+
             /// Just in case, skip optimization if it is not initialized.
             if (!optimization.apply)
                 continue;
diff --git a/src/Processors/QueryPlan/QueryPlan.h b/src/Processors/QueryPlan/QueryPlan.h
index d5cc2e8f4e8..bf7ed81fdc1 100644
--- a/src/Processors/QueryPlan/QueryPlan.h
+++ b/src/Processors/QueryPlan/QueryPlan.h
@@ -1,10 +1,12 @@
 #pragma once
-#include <memory>
-#include <list>
-#include <vector>
-#include <set>
 
 #include <Core/Names.h>
+#include <Interpreters/Context_fwd.h>
+
+#include <list>
+#include <memory>
+#include <set>
+#include <vector>
 
 namespace DB
 {
@@ -17,7 +19,6 @@ using QueryPlanStepPtr = std::unique_ptr<IQueryPlanStep>;
 class QueryPipeline;
 using QueryPipelinePtr = std::unique_ptr<QueryPipeline>;
 
-class Context;
 class WriteBuffer;
 
 class QueryPlan;
diff --git a/src/Processors/QueryPlan/SettingQuotaAndLimitsStep.cpp b/src/Processors/QueryPlan/SettingQuotaAndLimitsStep.cpp
index e1f72b2bb04..734e6db318d 100644
--- a/src/Processors/QueryPlan/SettingQuotaAndLimitsStep.cpp
+++ b/src/Processors/QueryPlan/SettingQuotaAndLimitsStep.cpp
@@ -28,7 +28,7 @@ SettingQuotaAndLimitsStep::SettingQuotaAndLimitsStep(
     StreamLocalLimits & limits_,
     SizeLimits & leaf_limits_,
     std::shared_ptr<const EnabledQuota> quota_,
-    std::shared_ptr<Context> context_)
+    ContextPtr context_)
     : ITransformingStep(input_stream_, input_stream_.header, getTraits())
     , context(std::move(context_))
     , storage(std::move(storage_))
diff --git a/src/Processors/QueryPlan/SettingQuotaAndLimitsStep.h b/src/Processors/QueryPlan/SettingQuotaAndLimitsStep.h
index 167e644e26d..3c73c208b70 100644
--- a/src/Processors/QueryPlan/SettingQuotaAndLimitsStep.h
+++ b/src/Processors/QueryPlan/SettingQuotaAndLimitsStep.h
@@ -1,4 +1,6 @@
 #pragma once
+
+#include <Interpreters/Context_fwd.h>
 #include <Processors/QueryPlan/ITransformingStep.h>
 #include <Storages/TableLockHolder.h>
 #include <DataStreams/StreamLocalLimits.h>
@@ -26,14 +28,14 @@ public:
         StreamLocalLimits & limits_,
         SizeLimits & leaf_limits_,
         std::shared_ptr<const EnabledQuota> quota_,
-        std::shared_ptr<Context> context_);
+        ContextPtr context_);
 
     String getName() const override { return "SettingQuotaAndLimits"; }
 
     void transformPipeline(QueryPipeline & pipeline, const BuildQueryPipelineSettings &) override;
 
 private:
-    std::shared_ptr<Context> context;
+    ContextPtr context;
     StoragePtr storage;
     TableLockHolder table_lock;
     StreamLocalLimits limits;
diff --git a/src/Processors/QueryPlan/UnionStep.cpp b/src/Processors/QueryPlan/UnionStep.cpp
index 66fb3ba8593..7403dd0a12a 100644
--- a/src/Processors/QueryPlan/UnionStep.cpp
+++ b/src/Processors/QueryPlan/UnionStep.cpp
@@ -6,8 +6,25 @@
 namespace DB
 {
 
-UnionStep::UnionStep(DataStreams input_streams_, Block result_header, size_t max_threads_)
-    : header(std::move(result_header))
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+static Block checkHeaders(const DataStreams & input_streams)
+{
+    if (input_streams.empty())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot unite an empty set of query plan steps");
+
+    Block res = input_streams.front().header;
+    for (const auto & stream : input_streams)
+        assertBlocksHaveEqualStructure(stream.header, res, "UnionStep");
+
+    return res;
+}
+
+UnionStep::UnionStep(DataStreams input_streams_, size_t max_threads_)
+    : header(checkHeaders(input_streams_))
     , max_threads(max_threads_)
 {
     input_streams = std::move(input_streams_);
@@ -18,7 +35,7 @@ UnionStep::UnionStep(DataStreams input_streams_, Block result_header, size_t max
         output_stream = DataStream{.header = header};
 }
 
-QueryPipelinePtr UnionStep::updatePipeline(QueryPipelines pipelines, const BuildQueryPipelineSettings & settings)
+QueryPipelinePtr UnionStep::updatePipeline(QueryPipelines pipelines, const BuildQueryPipelineSettings &)
 {
     auto pipeline = std::make_unique<QueryPipeline>();
     QueryPipelineProcessorsCollector collector(*pipeline, this);
@@ -30,7 +47,7 @@ QueryPipelinePtr UnionStep::updatePipeline(QueryPipelines pipelines, const Build
         return pipeline;
     }
 
-    *pipeline = QueryPipeline::unitePipelines(std::move(pipelines), output_stream->header, settings.getActionsSettings(), max_threads);
+    *pipeline = QueryPipeline::unitePipelines(std::move(pipelines), max_threads);
 
     processors = collector.detachProcessors();
     return pipeline;
diff --git a/src/Processors/QueryPlan/UnionStep.h b/src/Processors/QueryPlan/UnionStep.h
index 2d997e0a36d..81bd033d045 100644
--- a/src/Processors/QueryPlan/UnionStep.h
+++ b/src/Processors/QueryPlan/UnionStep.h
@@ -9,14 +9,16 @@ class UnionStep : public IQueryPlanStep
 {
 public:
     /// max_threads is used to limit the number of threads for result pipeline.
-    UnionStep(DataStreams input_streams_, Block result_header, size_t max_threads_ = 0);
+    explicit UnionStep(DataStreams input_streams_, size_t max_threads_ = 0);
 
     String getName() const override { return "Union"; }
 
-    QueryPipelinePtr updatePipeline(QueryPipelines pipelines, const BuildQueryPipelineSettings & settings) override;
+    QueryPipelinePtr updatePipeline(QueryPipelines pipelines, const BuildQueryPipelineSettings &) override;
 
     void describePipeline(FormatSettings & settings) const override;
 
+    size_t getMaxThreads() const { return max_threads; }
+
 private:
     Block header;
     size_t max_threads;
diff --git a/src/Processors/QueryPlan/WindowStep.cpp b/src/Processors/QueryPlan/WindowStep.cpp
index 76191eba51a..66c329acb4b 100644
--- a/src/Processors/QueryPlan/WindowStep.cpp
+++ b/src/Processors/QueryPlan/WindowStep.cpp
@@ -64,6 +64,11 @@ WindowStep::WindowStep(const DataStream & input_stream_,
 
 void WindowStep::transformPipeline(QueryPipeline & pipeline, const BuildQueryPipelineSettings &)
 {
+    // This resize is needed for cases such as `over ()` when we don't have a
+    // sort node, and the input might have multiple streams. The sort node would
+    // have resized it.
+    pipeline.resize(1);
+
     pipeline.addSimpleTransform([&](const Block & /*header*/)
     {
         return std::make_shared<WindowTransform>(input_header,
diff --git a/src/Processors/Transforms/CreatingSetsTransform.cpp b/src/Processors/Transforms/CreatingSetsTransform.cpp
index c5fb4f3a952..a5b5958eff1 100644
--- a/src/Processors/Transforms/CreatingSetsTransform.cpp
+++ b/src/Processors/Transforms/CreatingSetsTransform.cpp
@@ -25,11 +25,11 @@ CreatingSetsTransform::CreatingSetsTransform(
     Block out_header_,
     SubqueryForSet subquery_for_set_,
     SizeLimits network_transfer_limits_,
-    const Context & context_)
+    ContextPtr context_)
     : IAccumulatingTransform(std::move(in_header_), std::move(out_header_))
+    , WithContext(context_)
     , subquery(std::move(subquery_for_set_))
     , network_transfer_limits(std::move(network_transfer_limits_))
-    , context(context_)
 {
 }
 
@@ -51,7 +51,7 @@ void CreatingSetsTransform::startSubquery()
         LOG_TRACE(log, "Filling temporary table.");
 
     if (subquery.table)
-        table_out = subquery.table->write({}, subquery.table->getInMemoryMetadataPtr(), context);
+        table_out = subquery.table->write({}, subquery.table->getInMemoryMetadataPtr(), getContext());
 
     done_with_set = !subquery.set;
     done_with_join = !subquery.join;
diff --git a/src/Processors/Transforms/CreatingSetsTransform.h b/src/Processors/Transforms/CreatingSetsTransform.h
index 3452de63ea0..a5787b0a5f5 100644
--- a/src/Processors/Transforms/CreatingSetsTransform.h
+++ b/src/Processors/Transforms/CreatingSetsTransform.h
@@ -1,9 +1,12 @@
 #pragma once
-#include <Poco/Logger.h>
-#include <Processors/IAccumulatingTransform.h>
-#include <Interpreters/SubqueryForSet.h>
-#include <Common/Stopwatch.h>
+
 #include <DataStreams/SizeLimits.h>
+#include <Interpreters/Context_fwd.h>
+#include <Interpreters/SubqueryForSet.h>
+#include <Processors/IAccumulatingTransform.h>
+#include <Common/Stopwatch.h>
+
+#include <Poco/Logger.h>
 
 namespace DB
 {
@@ -16,7 +19,7 @@ using ProgressCallback = std::function<void(const Progress & progress)>;
 /// Don't return any data. Sets are created when Finish status is returned.
 /// In general, several work() methods need to be called to finish.
 /// Independent processors is created for each subquery.
-class CreatingSetsTransform : public IAccumulatingTransform
+class CreatingSetsTransform : public IAccumulatingTransform, WithContext
 {
 public:
     CreatingSetsTransform(
@@ -24,7 +27,7 @@ public:
         Block out_header_,
         SubqueryForSet subquery_for_set_,
         SizeLimits network_transfer_limits_,
-        const Context & context_);
+        ContextPtr context_);
 
     String getName() const override { return "CreatingSetsTransform"; }
 
@@ -44,7 +47,6 @@ private:
     bool done_with_table = true;
 
     SizeLimits network_transfer_limits;
-    const Context & context;
 
     size_t rows_to_transfer = 0;
     size_t bytes_to_transfer = 0;
diff --git a/src/Processors/Transforms/WindowTransform.cpp b/src/Processors/Transforms/WindowTransform.cpp
index 16d028f0fc1..0521912402c 100644
--- a/src/Processors/Transforms/WindowTransform.cpp
+++ b/src/Processors/Transforms/WindowTransform.cpp
@@ -257,10 +257,9 @@ WindowTransform::WindowTransform(const Block & input_header_,
         const IColumn * column = entry.column.get();
         APPLY_FOR_TYPES(compareValuesWithOffset)
 
-        // Check that the offset type matches the window type.
         // Convert the offsets to the ORDER BY column type. We can't just check
-        // that it matches, because e.g. the int literals are always (U)Int64,
-        // but the column might be Int8 and so on.
+        // that the type matches, because e.g. the int literals are always
+        // (U)Int64, but the column might be Int8 and so on.
         if (window_description.frame.begin_type
             == WindowFrame::BoundaryType::Offset)
         {
@@ -435,6 +434,9 @@ auto WindowTransform::moveRowNumberNoCheck(const RowNumber & _x, int offset) con
             assertValid(x);
             assert(offset <= 0);
 
+            // abs(offset) is less than INT_MAX, as checked in the parser, so
+            // this negation should always work.
+            assert(offset >= -INT_MAX);
             if (x.row >= static_cast<uint64_t>(-offset))
             {
                 x.row -= -offset;
@@ -1375,6 +1377,8 @@ struct WindowFunctionRank final : public WindowFunction
     DataTypePtr getReturnType() const override
     { return std::make_shared<DataTypeUInt64>(); }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void windowInsertResultInto(const WindowTransform * transform,
         size_t function_index) override
     {
@@ -1395,6 +1399,8 @@ struct WindowFunctionDenseRank final : public WindowFunction
     DataTypePtr getReturnType() const override
     { return std::make_shared<DataTypeUInt64>(); }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void windowInsertResultInto(const WindowTransform * transform,
         size_t function_index) override
     {
@@ -1415,6 +1421,8 @@ struct WindowFunctionRowNumber final : public WindowFunction
     DataTypePtr getReturnType() const override
     { return std::make_shared<DataTypeUInt64>(); }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void windowInsertResultInto(const WindowTransform * transform,
         size_t function_index) override
     {
@@ -1481,6 +1489,8 @@ struct WindowFunctionLagLeadInFrame final : public WindowFunction
     DataTypePtr getReturnType() const override
     { return argument_types[0]; }
 
+    bool allocatesMemoryInArena() const override { return false; }
+
     void windowInsertResultInto(const WindowTransform * transform,
         size_t function_index) override
     {
@@ -1500,6 +1510,12 @@ struct WindowFunctionLagLeadInFrame final : public WindowFunction
                     "The offset for function {} must be nonnegative, {} given",
                     getName(), offset);
             }
+            if (offset > INT_MAX)
+            {
+                throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                    "The offset for function {} must be less than {}, {} given",
+                    getName(), INT_MAX, offset);
+            }
         }
 
         const auto [target_row, offset_left] = transform->moveRowNumber(
diff --git a/src/Processors/ya.make b/src/Processors/ya.make
index 35abfbae756..ef1ff03568e 100644
--- a/src/Processors/ya.make
+++ b/src/Processors/ya.make
@@ -93,7 +93,6 @@ SRCS(
     Pipe.cpp
     Port.cpp
     QueryPipeline.cpp
-    QueryPlan/AddingDelayedSourceStep.cpp
     QueryPlan/AggregatingStep.cpp
     QueryPlan/ArrayJoinStep.cpp
     QueryPlan/BuildQueryPipelineSettings.cpp
diff --git a/src/Server/GRPCServer.cpp b/src/Server/GRPCServer.cpp
index 52a2c106488..6f0f2d30123 100644
--- a/src/Server/GRPCServer.cpp
+++ b/src/Server/GRPCServer.cpp
@@ -521,7 +521,7 @@ namespace
         Poco::Logger * log = nullptr;
 
         std::shared_ptr<NamedSession> session;
-        std::optional<Context> query_context;
+        ContextPtr query_context;
         std::optional<CurrentThread::QueryScope> query_scope;
         String query_text;
         ASTPtr ast;
@@ -651,7 +651,7 @@ namespace
         }
 
         /// Create context.
-        query_context.emplace(iserver.context());
+        query_context = Context::createCopy(iserver.context());
 
         /// Authentication.
         query_context->setUser(user, password, user_address);
@@ -665,11 +665,11 @@ namespace
         {
             session = query_context->acquireNamedSession(
                 query_info.session_id(), getSessionTimeout(query_info, iserver.config()), query_info.session_check());
-            query_context = session->context;
+            query_context = Context::createCopy(session->context);
             query_context->setSessionContext(session->context);
         }
 
-        query_scope.emplace(*query_context);
+        query_scope.emplace(query_context);
 
         /// Set client info.
         ClientInfo & client_info = query_context->getClientInfo();
@@ -741,26 +741,26 @@ namespace
             output_format = query_context->getDefaultFormat();
 
         /// Set callback to create and fill external tables
-        query_context->setExternalTablesInitializer([this] (Context & context)
+        query_context->setExternalTablesInitializer([this] (ContextPtr context)
         {
-            if (&context != &*query_context)
+            if (context != query_context)
                 throw Exception("Unexpected context in external tables initializer", ErrorCodes::LOGICAL_ERROR);
             createExternalTables();
         });
 
         /// Set callbacks to execute function input().
-        query_context->setInputInitializer([this] (Context & context, const StoragePtr & input_storage)
+        query_context->setInputInitializer([this] (ContextPtr context, const StoragePtr & input_storage)
         {
-            if (&context != &query_context.value())
+            if (context != query_context)
                 throw Exception("Unexpected context in Input initializer", ErrorCodes::LOGICAL_ERROR);
             input_function_is_used = true;
             initializeBlockInputStream(input_storage->getInMemoryMetadataPtr()->getSampleBlock());
             block_input_stream->readPrefix();
         });
 
-        query_context->setInputBlocksReaderCallback([this](Context & context) -> Block
+        query_context->setInputBlocksReaderCallback([this](ContextPtr context) -> Block
         {
-            if (&context != &query_context.value())
+            if (context != query_context)
                 throw Exception("Unexpected context in InputBlocksReader", ErrorCodes::LOGICAL_ERROR);
             auto block = block_input_stream->read();
             if (!block)
@@ -775,7 +775,7 @@ namespace
             query_end = insert_query->data;
         }
         String query(begin, query_end);
-        io = ::DB::executeQuery(query, *query_context, false, QueryProcessingStage::Complete, true, true);
+        io = ::DB::executeQuery(query, query_context, false, QueryProcessingStage::Complete, true, true);
     }
 
     void Call::processInput()
@@ -878,10 +878,10 @@ namespace
                 auto table_id = query_context->resolveStorageID(insert_query->table_id, Context::ResolveOrdinary);
                 if (query_context->getSettingsRef().input_format_defaults_for_omitted_fields && table_id)
                 {
-                    StoragePtr storage = DatabaseCatalog::instance().getTable(table_id, *query_context);
+                    StoragePtr storage = DatabaseCatalog::instance().getTable(table_id, query_context);
                     const auto & columns = storage->getInMemoryMetadataPtr()->getColumns();
                     if (!columns.empty())
-                        block_input_stream = std::make_shared<AddingDefaultsBlockInputStream>(block_input_stream, columns, *query_context);
+                        block_input_stream = std::make_shared<AddingDefaultsBlockInputStream>(block_input_stream, columns, query_context);
                 }
             }
         }
@@ -903,7 +903,7 @@ namespace
                 StoragePtr storage;
                 if (auto resolved = query_context->tryResolveStorageID(temporary_id, Context::ResolveExternal))
                 {
-                    storage = DatabaseCatalog::instance().getTable(resolved, *query_context);
+                    storage = DatabaseCatalog::instance().getTable(resolved, query_context);
                 }
                 else
                 {
@@ -918,7 +918,7 @@ namespace
                         column.type = DataTypeFactory::instance().get(name_and_type.type());
                         columns.emplace_back(std::move(column));
                     }
-                    auto temporary_table = TemporaryTableHolder(*query_context, ColumnsDescription{columns}, {});
+                    auto temporary_table = TemporaryTableHolder(query_context, ColumnsDescription{columns}, {});
                     storage = temporary_table.getTable();
                     query_context->addExternalTable(temporary_id.table_name, std::move(temporary_table));
                 }
@@ -927,17 +927,17 @@ namespace
                 {
                     /// The data will be written directly to the table.
                     auto metadata_snapshot = storage->getInMemoryMetadataPtr();
-                    auto out_stream = storage->write(ASTPtr(), metadata_snapshot, *query_context);
+                    auto out_stream = storage->write(ASTPtr(), metadata_snapshot, query_context);
                     ReadBufferFromMemory data(external_table.data().data(), external_table.data().size());
                     String format = external_table.format();
                     if (format.empty())
                         format = "TabSeparated";
-                    Context * external_table_context = &*query_context;
-                    std::optional<Context> temp_context;
+                    ContextPtr external_table_context = query_context;
+                    ContextPtr temp_context;
                     if (!external_table.settings().empty())
                     {
-                        temp_context = *query_context;
-                        external_table_context = &*temp_context;
+                        temp_context = Context::createCopy(query_context);
+                        external_table_context = temp_context;
                         SettingsChanges settings_changes;
                         for (const auto & [key, value] : external_table.settings())
                             settings_changes.push_back({key, value});
diff --git a/src/Server/HTTP/HTTPServer.cpp b/src/Server/HTTP/HTTPServer.cpp
index 5554a0ee31d..42e6467d0af 100644
--- a/src/Server/HTTP/HTTPServer.cpp
+++ b/src/Server/HTTP/HTTPServer.cpp
@@ -6,7 +6,7 @@
 namespace DB
 {
 HTTPServer::HTTPServer(
-    const Context & context,
+    ContextPtr context,
     HTTPRequestHandlerFactoryPtr factory_,
     UInt16 port_number,
     Poco::Net::HTTPServerParams::Ptr params)
@@ -15,7 +15,7 @@ HTTPServer::HTTPServer(
 }
 
 HTTPServer::HTTPServer(
-    const Context & context,
+    ContextPtr context,
     HTTPRequestHandlerFactoryPtr factory_,
     const Poco::Net::ServerSocket & socket,
     Poco::Net::HTTPServerParams::Ptr params)
@@ -24,7 +24,7 @@ HTTPServer::HTTPServer(
 }
 
 HTTPServer::HTTPServer(
-    const Context & context,
+    ContextPtr context,
     HTTPRequestHandlerFactoryPtr factory_,
     Poco::ThreadPool & thread_pool,
     const Poco::Net::ServerSocket & socket,
diff --git a/src/Server/HTTP/HTTPServer.h b/src/Server/HTTP/HTTPServer.h
index 3d2a2ac9cf4..d95bdff0baa 100644
--- a/src/Server/HTTP/HTTPServer.h
+++ b/src/Server/HTTP/HTTPServer.h
@@ -17,19 +17,19 @@ class HTTPServer : public Poco::Net::TCPServer
 {
 public:
     explicit HTTPServer(
-        const Context & context,
+        ContextPtr context,
         HTTPRequestHandlerFactoryPtr factory,
         UInt16 port_number = 80,
         Poco::Net::HTTPServerParams::Ptr params = new Poco::Net::HTTPServerParams);
 
     HTTPServer(
-        const Context & context,
+        ContextPtr context,
         HTTPRequestHandlerFactoryPtr factory,
         const Poco::Net::ServerSocket & socket,
         Poco::Net::HTTPServerParams::Ptr params);
 
     HTTPServer(
-        const Context & context,
+        ContextPtr context,
         HTTPRequestHandlerFactoryPtr factory,
         Poco::ThreadPool & thread_pool,
         const Poco::Net::ServerSocket & socket,
diff --git a/src/Server/HTTP/HTTPServerConnection.cpp b/src/Server/HTTP/HTTPServerConnection.cpp
index 7a6cd4cab54..19985949005 100644
--- a/src/Server/HTTP/HTTPServerConnection.cpp
+++ b/src/Server/HTTP/HTTPServerConnection.cpp
@@ -6,11 +6,11 @@ namespace DB
 {
 
 HTTPServerConnection::HTTPServerConnection(
-    const Context & context_,
+    ContextPtr context_,
     const Poco::Net::StreamSocket & socket,
     Poco::Net::HTTPServerParams::Ptr params_,
     HTTPRequestHandlerFactoryPtr factory_)
-    : TCPServerConnection(socket), context(context_), params(params_), factory(factory_), stopped(false)
+    : TCPServerConnection(socket), context(Context::createCopy(context_)), params(params_), factory(factory_), stopped(false)
 {
     poco_check_ptr(factory);
 }
diff --git a/src/Server/HTTP/HTTPServerConnection.h b/src/Server/HTTP/HTTPServerConnection.h
index 55b6e921d9f..1c7ae6cd2b7 100644
--- a/src/Server/HTTP/HTTPServerConnection.h
+++ b/src/Server/HTTP/HTTPServerConnection.h
@@ -14,7 +14,7 @@ class HTTPServerConnection : public Poco::Net::TCPServerConnection
 {
 public:
     HTTPServerConnection(
-        const Context & context,
+        ContextPtr context,
         const Poco::Net::StreamSocket & socket,
         Poco::Net::HTTPServerParams::Ptr params,
         HTTPRequestHandlerFactoryPtr factory);
@@ -25,7 +25,7 @@ protected:
     static void sendErrorResponse(Poco::Net::HTTPServerSession & session, Poco::Net::HTTPResponse::HTTPStatus status);
 
 private:
-    Context context;
+    ContextPtr context;
     Poco::Net::HTTPServerParams::Ptr params;
     HTTPRequestHandlerFactoryPtr factory;
     bool stopped;
diff --git a/src/Server/HTTP/HTTPServerConnectionFactory.cpp b/src/Server/HTTP/HTTPServerConnectionFactory.cpp
index 876ccb9096b..0e4fb6cfcec 100644
--- a/src/Server/HTTP/HTTPServerConnectionFactory.cpp
+++ b/src/Server/HTTP/HTTPServerConnectionFactory.cpp
@@ -5,8 +5,8 @@
 namespace DB
 {
 HTTPServerConnectionFactory::HTTPServerConnectionFactory(
-    const Context & context_, Poco::Net::HTTPServerParams::Ptr params_, HTTPRequestHandlerFactoryPtr factory_)
-    : context(context_), params(params_), factory(factory_)
+    ContextPtr context_, Poco::Net::HTTPServerParams::Ptr params_, HTTPRequestHandlerFactoryPtr factory_)
+    : context(Context::createCopy(context_)), params(params_), factory(factory_)
 {
     poco_check_ptr(factory);
 }
diff --git a/src/Server/HTTP/HTTPServerConnectionFactory.h b/src/Server/HTTP/HTTPServerConnectionFactory.h
index 4f8ca43cbfb..3f11eca0f69 100644
--- a/src/Server/HTTP/HTTPServerConnectionFactory.h
+++ b/src/Server/HTTP/HTTPServerConnectionFactory.h
@@ -12,12 +12,12 @@ namespace DB
 class HTTPServerConnectionFactory : public Poco::Net::TCPServerConnectionFactory
 {
 public:
-    HTTPServerConnectionFactory(const Context & context, Poco::Net::HTTPServerParams::Ptr params, HTTPRequestHandlerFactoryPtr factory);
+    HTTPServerConnectionFactory(ContextPtr context, Poco::Net::HTTPServerParams::Ptr params, HTTPRequestHandlerFactoryPtr factory);
 
     Poco::Net::TCPServerConnection * createConnection(const Poco::Net::StreamSocket & socket) override;
 
 private:
-    Context context;
+    ContextPtr context;
     Poco::Net::HTTPServerParams::Ptr params;
     HTTPRequestHandlerFactoryPtr factory;
 };
diff --git a/src/Server/HTTP/HTTPServerRequest.cpp b/src/Server/HTTP/HTTPServerRequest.cpp
index ab8b803c29d..69dc8d4dbda 100644
--- a/src/Server/HTTP/HTTPServerRequest.cpp
+++ b/src/Server/HTTP/HTTPServerRequest.cpp
@@ -15,8 +15,8 @@
 
 namespace DB
 {
-HTTPServerRequest::HTTPServerRequest(const Context & context, HTTPServerResponse & response, Poco::Net::HTTPServerSession & session)
-    : max_uri_size(context.getSettingsRef().http_max_uri_size)
+HTTPServerRequest::HTTPServerRequest(ContextPtr context, HTTPServerResponse & response, Poco::Net::HTTPServerSession & session)
+    : max_uri_size(context->getSettingsRef().http_max_uri_size)
 {
     response.attachRequest(this);
 
@@ -24,8 +24,8 @@ HTTPServerRequest::HTTPServerRequest(const Context & context, HTTPServerResponse
     client_address = session.clientAddress();
     server_address = session.serverAddress();
 
-    auto receive_timeout = context.getSettingsRef().http_receive_timeout;
-    auto send_timeout = context.getSettingsRef().http_send_timeout;
+    auto receive_timeout = context->getSettingsRef().http_receive_timeout;
+    auto send_timeout = context->getSettingsRef().http_send_timeout;
 
     session.socket().setReceiveTimeout(receive_timeout);
     session.socket().setSendTimeout(send_timeout);
diff --git a/src/Server/HTTP/HTTPServerRequest.h b/src/Server/HTTP/HTTPServerRequest.h
index a0f022f32ec..a560f907cf0 100644
--- a/src/Server/HTTP/HTTPServerRequest.h
+++ b/src/Server/HTTP/HTTPServerRequest.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
 #include <IO/ReadBuffer.h>
 #include <Server/HTTP/HTTPRequest.h>
 
@@ -8,14 +9,13 @@
 namespace DB
 {
 
-class Context;
 class HTTPServerResponse;
 class ReadBufferFromPocoSocket;
 
 class HTTPServerRequest : public HTTPRequest
 {
 public:
-    HTTPServerRequest(const Context & context, HTTPServerResponse & response, Poco::Net::HTTPServerSession & session);
+    HTTPServerRequest(ContextPtr context, HTTPServerResponse & response, Poco::Net::HTTPServerSession & session);
 
     /// FIXME: it's a little bit inconvenient interface. The rationale is that all other ReadBuffer's wrap each other
     ///        via unique_ptr - but we can't inherit HTTPServerRequest from ReadBuffer and pass it around,
diff --git a/src/Server/HTTP/ReadHeaders.cpp b/src/Server/HTTP/ReadHeaders.cpp
index 77ec48c11b1..2fc2de8321a 100644
--- a/src/Server/HTTP/ReadHeaders.cpp
+++ b/src/Server/HTTP/ReadHeaders.cpp
@@ -51,7 +51,7 @@ void readHeaders(
             if (name.size() > max_name_length)
                 throw Poco::Net::MessageException("Field name is too long");
             if (ch != ':')
-                throw Poco::Net::MessageException("Field name is invalid or no colon found");
+                throw Poco::Net::MessageException(fmt::format("Field name is invalid or no colon found: \"{}\"", name));
         }
 
         in.ignore();
diff --git a/src/Server/HTTPHandler.cpp b/src/Server/HTTPHandler.cpp
index 6b4981beae0..8aed5d20f74 100644
--- a/src/Server/HTTPHandler.cpp
+++ b/src/Server/HTTPHandler.cpp
@@ -277,7 +277,7 @@ HTTPHandler::~HTTPHandler()
 
 
 bool HTTPHandler::authenticateUser(
-    Context & context,
+    ContextPtr context,
     HTTPServerRequest & request,
     HTMLForm & params,
     HTTPServerResponse & response)
@@ -381,7 +381,7 @@ bool HTTPHandler::authenticateUser(
 
     /// Set client info. It will be used for quota accounting parameters in 'setUser' method.
 
-    ClientInfo & client_info = context.getClientInfo();
+    ClientInfo & client_info = context->getClientInfo();
     client_info.query_kind = ClientInfo::QueryKind::INITIAL_QUERY;
     client_info.interface = ClientInfo::Interface::HTTP;
 
@@ -398,7 +398,7 @@ bool HTTPHandler::authenticateUser(
 
     try
     {
-        context.setUser(*request_credentials, request.clientAddress());
+        context->setUser(*request_credentials, request.clientAddress());
     }
     catch (const Authentication::Require<BasicCredentials> & required_credentials)
     {
@@ -430,7 +430,7 @@ bool HTTPHandler::authenticateUser(
     request_credentials.reset();
 
     if (!quota_key.empty())
-        context.setQuotaKey(quota_key);
+        context->setQuotaKey(quota_key);
 
     /// Query sent through HTTP interface is initial.
     client_info.initial_user = client_info.current_user;
@@ -441,7 +441,7 @@ bool HTTPHandler::authenticateUser(
 
 
 void HTTPHandler::processQuery(
-    Context & context,
+    ContextPtr context,
     HTTPServerRequest & request,
     HTMLForm & params,
     HTTPServerResponse & response,
@@ -470,10 +470,10 @@ void HTTPHandler::processQuery(
         session_timeout = parseSessionTimeout(config, params);
         std::string session_check = params.get("session_check", "");
 
-        session = context.acquireNamedSession(session_id, session_timeout, session_check == "1");
+        session = context->acquireNamedSession(session_id, session_timeout, session_check == "1");
 
-        context = session->context;
-        context.setSessionContext(session->context);
+        context->copyFrom(session->context);  /// FIXME: maybe move this part to HandleRequest(), copyFrom() is used only here.
+        context->setSessionContext(session->context);
     }
 
     SCOPE_EXIT({
@@ -489,7 +489,7 @@ void HTTPHandler::processQuery(
     {
         std::string opentelemetry_traceparent = request.get("traceparent");
         std::string error;
-        if (!context.getClientInfo().client_trace_context.parseTraceparentHeader(
+        if (!context->getClientInfo().client_trace_context.parseTraceparentHeader(
             opentelemetry_traceparent, error))
         {
             throw Exception(ErrorCodes::BAD_REQUEST_PARAMETER,
@@ -497,14 +497,14 @@ void HTTPHandler::processQuery(
                 opentelemetry_traceparent, error);
         }
 
-        context.getClientInfo().client_trace_context.tracestate = request.get("tracestate", "");
+        context->getClientInfo().client_trace_context.tracestate = request.get("tracestate", "");
     }
 #endif
 
     // Set the query id supplied by the user, if any, and also update the OpenTelemetry fields.
-    context.setCurrentQueryId(params.get("query_id", request.get("X-ClickHouse-Query-Id", "")));
+    context->setCurrentQueryId(params.get("query_id", request.get("X-ClickHouse-Query-Id", "")));
 
-    ClientInfo & client_info = context.getClientInfo();
+    ClientInfo & client_info = context->getClientInfo();
     client_info.initial_query_id = client_info.current_query_id;
 
     /// The client can pass a HTTP header indicating supported compression method (gzip or deflate).
@@ -570,7 +570,7 @@ void HTTPHandler::processQuery(
 
         if (buffer_until_eof)
         {
-            const std::string tmp_path(context.getTemporaryVolume()->getDisk()->getPath());
+            const std::string tmp_path(context->getTemporaryVolume()->getDisk()->getPath());
             const std::string tmp_path_template(tmp_path + "http_buffers/");
 
             auto create_tmp_disk_buffer = [tmp_path_template] (const WriteBufferPtr &)
@@ -658,13 +658,13 @@ void HTTPHandler::processQuery(
 
     /// In theory if initially readonly = 0, the client can change any setting and then set readonly
     /// to some other value.
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = context->getSettingsRef();
 
     /// Only readonly queries are allowed for HTTP GET requests.
     if (request.getMethod() == HTTPServerRequest::HTTP_GET)
     {
         if (settings.readonly == 0)
-            context.setSetting("readonly", 2);
+            context->setSetting("readonly", 2);
     }
 
     bool has_external_data = startsWith(request.getContentType(), "multipart/form-data");
@@ -707,14 +707,14 @@ void HTTPHandler::processQuery(
     }
 
     if (!database.empty())
-        context.setCurrentDatabase(database);
+        context->setCurrentDatabase(database);
 
     if (!default_format.empty())
-        context.setDefaultFormat(default_format);
+        context->setDefaultFormat(default_format);
 
     /// For external data we also want settings
-    context.checkSettingsConstraints(settings_changes);
-    context.applySettingsChanges(settings_changes);
+    context->checkSettingsConstraints(settings_changes);
+    context->applySettingsChanges(settings_changes);
 
     const auto & query = getQuery(request, params, context);
     std::unique_ptr<ReadBuffer> in_param = std::make_unique<ReadBufferFromString>(query);
@@ -737,11 +737,11 @@ void HTTPHandler::processQuery(
     /// Origin header.
     used_output.out->addHeaderCORS(settings.add_http_cors_header && !request.get("Origin", "").empty());
 
-    auto append_callback = [&context] (ProgressCallback callback)
+    auto append_callback = [context] (ProgressCallback callback)
     {
-        auto prev = context.getProgressCallback();
+        auto prev = context->getProgressCallback();
 
-        context.setProgressCallback([prev, callback] (const Progress & progress)
+        context->setProgressCallback([prev, callback] (const Progress & progress)
         {
             if (prev)
                 prev(progress);
@@ -756,12 +756,12 @@ void HTTPHandler::processQuery(
 
     if (settings.readonly > 0 && settings.cancel_http_readonly_queries_on_client_close)
     {
-        append_callback([&context, &request](const Progress &)
+        append_callback([context, &request](const Progress &)
         {
             /// Assume that at the point this method is called no one is reading data from the socket any more:
             /// should be true for read-only queries.
             if (!request.checkPeerConnected())
-                context.killCurrentQuery();
+                context->killCurrentQuery();
         });
     }
 
@@ -877,7 +877,7 @@ void HTTPHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse
     if (!request_context)
     {
         // Context should be initialized before anything, for correct memory accounting.
-        request_context = std::make_unique<Context>(server.context());
+        request_context = Context::createCopy(server.context());
         request_credentials.reset();
     }
 
@@ -899,6 +899,7 @@ void HTTPHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse
         HTMLForm params(request);
         with_stacktrace = params.getParsed<bool>("stacktrace", false);
 
+        /// FIXME: maybe this check is already unnecessary.
         /// Workaround. Poco does not detect 411 Length Required case.
         if (request.getMethod() == HTTPRequest::HTTP_POST && !request.getChunkedTransferEncoding() && !request.hasContentLength())
         {
@@ -907,7 +908,7 @@ void HTTPHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse
                 ErrorCodes::HTTP_LENGTH_REQUIRED);
         }
 
-        processQuery(*request_context, request, params, response, used_output, query_scope);
+        processQuery(request_context, request, params, response, used_output, query_scope);
         LOG_DEBUG(log, (request_credentials ? "Authentication in progress..." : "Done processing query"));
     }
     catch (...)
@@ -936,7 +937,7 @@ DynamicQueryHandler::DynamicQueryHandler(IServer & server_, const std::string &
 {
 }
 
-bool DynamicQueryHandler::customizeQueryParam(Context & context, const std::string & key, const std::string & value)
+bool DynamicQueryHandler::customizeQueryParam(ContextPtr context, const std::string & key, const std::string & value)
 {
     if (key == param_name)
         return true;    /// do nothing
@@ -945,14 +946,14 @@ bool DynamicQueryHandler::customizeQueryParam(Context & context, const std::stri
     {
         /// Save name and values of substitution in dictionary.
         const String parameter_name = key.substr(strlen("param_"));
-        context.setQueryParameter(parameter_name, value);
+        context->setQueryParameter(parameter_name, value);
         return true;
     }
 
     return false;
 }
 
-std::string DynamicQueryHandler::getQuery(HTTPServerRequest & request, HTMLForm & params, Context & context)
+std::string DynamicQueryHandler::getQuery(HTTPServerRequest & request, HTMLForm & params, ContextPtr context)
 {
     if (likely(!startsWith(request.getContentType(), "multipart/form-data")))
     {
@@ -978,25 +979,31 @@ std::string DynamicQueryHandler::getQuery(HTTPServerRequest & request, HTMLForm
 }
 
 PredefinedQueryHandler::PredefinedQueryHandler(
-    IServer & server_, const NameSet & receive_params_, const std::string & predefined_query_
-    , const CompiledRegexPtr & url_regex_, const std::unordered_map<String, CompiledRegexPtr> & header_name_with_regex_)
-    : HTTPHandler(server_, "PredefinedQueryHandler"), receive_params(receive_params_), predefined_query(predefined_query_)
-    , url_regex(url_regex_), header_name_with_capture_regex(header_name_with_regex_)
+    IServer & server_,
+    const NameSet & receive_params_,
+    const std::string & predefined_query_,
+    const CompiledRegexPtr & url_regex_,
+    const std::unordered_map<String, CompiledRegexPtr> & header_name_with_regex_)
+    : HTTPHandler(server_, "PredefinedQueryHandler")
+    , receive_params(receive_params_)
+    , predefined_query(predefined_query_)
+    , url_regex(url_regex_)
+    , header_name_with_capture_regex(header_name_with_regex_)
 {
 }
 
-bool PredefinedQueryHandler::customizeQueryParam(Context & context, const std::string & key, const std::string & value)
+bool PredefinedQueryHandler::customizeQueryParam(ContextPtr context, const std::string & key, const std::string & value)
 {
     if (receive_params.count(key))
     {
-        context.setQueryParameter(key, value);
+        context->setQueryParameter(key, value);
         return true;
     }
 
     return false;
 }
 
-void PredefinedQueryHandler::customizeContext(HTTPServerRequest & request, DB::Context & context)
+void PredefinedQueryHandler::customizeContext(HTTPServerRequest & request, ContextPtr context)
 {
     /// If in the configuration file, the handler's header is regex and contains named capture group
     /// We will extract regex named capture groups as query parameters
@@ -1014,7 +1021,7 @@ void PredefinedQueryHandler::customizeContext(HTTPServerRequest & request, DB::C
                 const auto & capturing_value = matches[capturing_index];
 
                 if (capturing_value.data())
-                    context.setQueryParameter(capturing_name, String(capturing_value.data(), capturing_value.size()));
+                    context->setQueryParameter(capturing_name, String(capturing_value.data(), capturing_value.size()));
             }
         }
     };
@@ -1032,7 +1039,7 @@ void PredefinedQueryHandler::customizeContext(HTTPServerRequest & request, DB::C
     }
 }
 
-std::string PredefinedQueryHandler::getQuery(HTTPServerRequest & request, HTMLForm & params, Context & context)
+std::string PredefinedQueryHandler::getQuery(HTTPServerRequest & request, HTMLForm & params, ContextPtr context)
 {
     if (unlikely(startsWith(request.getContentType(), "multipart/form-data")))
     {
diff --git a/src/Server/HTTPHandler.h b/src/Server/HTTPHandler.h
index 0f1d75664bd..4715949cb87 100644
--- a/src/Server/HTTPHandler.h
+++ b/src/Server/HTTPHandler.h
@@ -18,7 +18,6 @@ namespace Poco { class Logger; }
 namespace DB
 {
 
-class Context;
 class Credentials;
 class IServer;
 class WriteBufferFromHTTPServerResponse;
@@ -34,11 +33,11 @@ public:
     void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response) override;
 
     /// This method is called right before the query execution.
-    virtual void customizeContext(HTTPServerRequest & /* request */, Context & /* context */) {}
+    virtual void customizeContext(HTTPServerRequest & /* request */, ContextPtr /* context */) {}
 
-    virtual bool customizeQueryParam(Context & context, const std::string & key, const std::string & value) = 0;
+    virtual bool customizeQueryParam(ContextPtr context, const std::string & key, const std::string & value) = 0;
 
-    virtual std::string getQuery(HTTPServerRequest & request, HTMLForm & params, Context & context) = 0;
+    virtual std::string getQuery(HTTPServerRequest & request, HTMLForm & params, ContextPtr context) = 0;
 
 private:
     struct Output
@@ -74,7 +73,7 @@ private:
 
     // The request_context and the request_credentials instances may outlive a single request/response loop.
     // This happens only when the authentication mechanism requires more than a single request/response exchange (e.g., SPNEGO).
-    std::unique_ptr<Context> request_context;
+    ContextPtr request_context;
     std::unique_ptr<Credentials> request_credentials;
 
     // Returns true when the user successfully authenticated,
@@ -83,14 +82,14 @@ private:
     //  the request_context and request_credentials instances are preserved.
     // Throws an exception if authentication failed.
     bool authenticateUser(
-        Context & context,
+        ContextPtr context,
         HTTPServerRequest & request,
         HTMLForm & params,
         HTTPServerResponse & response);
 
     /// Also initializes 'used_output'.
     void processQuery(
-        Context & context,
+        ContextPtr context,
         HTTPServerRequest & request,
         HTMLForm & params,
         HTTPServerResponse & response,
@@ -114,9 +113,9 @@ private:
 public:
     explicit DynamicQueryHandler(IServer & server_, const std::string & param_name_ = "query");
 
-    std::string getQuery(HTTPServerRequest & request, HTMLForm & params, Context & context) override;
+    std::string getQuery(HTTPServerRequest & request, HTMLForm & params, ContextPtr context) override;
 
-    bool customizeQueryParam(Context &context, const std::string &key, const std::string &value) override;
+    bool customizeQueryParam(ContextPtr context, const std::string &key, const std::string &value) override;
 };
 
 class PredefinedQueryHandler : public HTTPHandler
@@ -131,11 +130,11 @@ public:
         IServer & server_, const NameSet & receive_params_, const std::string & predefined_query_
         , const CompiledRegexPtr & url_regex_, const std::unordered_map<String, CompiledRegexPtr> & header_name_with_regex_);
 
-    virtual void customizeContext(HTTPServerRequest & request, Context & context) override;
+    virtual void customizeContext(HTTPServerRequest & request, ContextPtr context) override;
 
-    std::string getQuery(HTTPServerRequest & request, HTMLForm & params, Context & context) override;
+    std::string getQuery(HTTPServerRequest & request, HTMLForm & params, ContextPtr context) override;
 
-    bool customizeQueryParam(Context & context, const std::string & key, const std::string & value) override;
+    bool customizeQueryParam(ContextPtr context, const std::string & key, const std::string & value) override;
 };
 
 }
diff --git a/src/Server/IServer.h b/src/Server/IServer.h
index 131e7443646..80736fda3ea 100644
--- a/src/Server/IServer.h
+++ b/src/Server/IServer.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
+
 namespace Poco
 {
 
@@ -7,6 +9,7 @@ namespace Util
 {
 class LayeredConfiguration;
 }
+
 class Logger;
 
 }
@@ -15,8 +18,6 @@ class Logger;
 namespace DB
 {
 
-class Context;
-
 class IServer
 {
 public:
@@ -27,12 +28,12 @@ public:
     virtual Poco::Logger & logger() const = 0;
 
     /// Returns global application's context.
-    virtual Context & context() const = 0;
+    virtual ContextPtr context() const = 0;
 
     /// Returns true if shutdown signaled.
     virtual bool isCancelled() const = 0;
 
-    virtual ~IServer() {}
+    virtual ~IServer() = default;
 };
 
 }
diff --git a/src/Server/InterserverIOHTTPHandler.cpp b/src/Server/InterserverIOHTTPHandler.cpp
index 426e4ca2138..64af8860b23 100644
--- a/src/Server/InterserverIOHTTPHandler.cpp
+++ b/src/Server/InterserverIOHTTPHandler.cpp
@@ -25,29 +25,26 @@ namespace ErrorCodes
 
 std::pair<String, bool> InterserverIOHTTPHandler::checkAuthentication(HTTPServerRequest & request) const
 {
-    const auto & config = server.config();
-
-    if (config.has("interserver_http_credentials.user"))
+    auto server_credentials = server.context()->getInterserverCredentials();
+    if (server_credentials)
     {
         if (!request.hasCredentials())
-            return {"Server requires HTTP Basic authentication, but client doesn't provide it", false};
+            return server_credentials->isValidUser("", "");
+
         String scheme, info;
         request.getCredentials(scheme, info);
 
         if (scheme != "Basic")
             return {"Server requires HTTP Basic authentication but client provides another method", false};
 
-        String user = config.getString("interserver_http_credentials.user");
-        String password = config.getString("interserver_http_credentials.password", "");
-
         Poco::Net::HTTPBasicCredentials credentials(info);
-        if (std::make_pair(user, password) != std::make_pair(credentials.getUsername(), credentials.getPassword()))
-            return {"Incorrect user or password in HTTP Basic authentication", false};
+        return server_credentials->isValidUser(credentials.getUsername(), credentials.getPassword());
     }
     else if (request.hasCredentials())
     {
         return {"Client requires HTTP Basic authentication, but server doesn't provide it", false};
     }
+
     return {"", true};
 }
 
@@ -62,7 +59,7 @@ void InterserverIOHTTPHandler::processQuery(HTTPServerRequest & request, HTTPSer
 
     auto & body = request.getStream();
 
-    auto endpoint = server.context().getInterserverIOHandler().getEndpoint(endpoint_name);
+    auto endpoint = server.context()->getInterserverIOHandler().getEndpoint(endpoint_name);
     /// Locked for read while query processing
     std::shared_lock lock(endpoint->rwlock);
     if (endpoint->blocker.isCancelled())
diff --git a/src/Server/InterserverIOHTTPHandler.h b/src/Server/InterserverIOHTTPHandler.h
index 47892aa678f..c0d776115e1 100644
--- a/src/Server/InterserverIOHTTPHandler.h
+++ b/src/Server/InterserverIOHTTPHandler.h
@@ -2,10 +2,12 @@
 
 #include <Server/HTTP/HTTPRequestHandler.h>
 #include <Common/CurrentMetrics.h>
+#include <Interpreters/InterserverCredentials.h>
 
 #include <Poco/Logger.h>
 
 #include <memory>
+#include <string>
 
 
 namespace CurrentMetrics
diff --git a/src/Server/KeeperTCPHandler.cpp b/src/Server/KeeperTCPHandler.cpp
index bf725581a29..1dadd3437f7 100644
--- a/src/Server/KeeperTCPHandler.cpp
+++ b/src/Server/KeeperTCPHandler.cpp
@@ -192,11 +192,11 @@ struct SocketInterruptablePollWrapper
 KeeperTCPHandler::KeeperTCPHandler(IServer & server_, const Poco::Net::StreamSocket & socket_)
     : Poco::Net::TCPServerConnection(socket_)
     , server(server_)
-    , log(&Poco::Logger::get("KeeperTCPHandler"))
-    , global_context(server.context())
-    , nu_keeper_storage_dispatcher(global_context.getKeeperStorageDispatcher())
-    , operation_timeout(0, global_context.getConfigRef().getUInt("keeper_server.operation_timeout_ms", Coordination::DEFAULT_OPERATION_TIMEOUT_MS) * 1000)
-    , session_timeout(0, global_context.getConfigRef().getUInt("keeper_server.session_timeout_ms", Coordination::DEFAULT_SESSION_TIMEOUT_MS) * 1000)
+    , log(&Poco::Logger::get("NuKeeperTCPHandler"))
+    , global_context(Context::createCopy(server.context()))
+    , nu_keeper_storage_dispatcher(global_context->getKeeperStorageDispatcher())
+    , operation_timeout(0, global_context->getConfigRef().getUInt("test_keeper_server.operation_timeout_ms", Coordination::DEFAULT_OPERATION_TIMEOUT_MS) * 1000)
+    , session_timeout(0, global_context->getConfigRef().getUInt("test_keeper_server.session_timeout_ms", Coordination::DEFAULT_SESSION_TIMEOUT_MS) * 1000)
     , poll_wrapper(std::make_unique<SocketInterruptablePollWrapper>(socket_))
     , responses(std::make_unique<ThreadSafeResponseQueue>())
 {
@@ -258,8 +258,8 @@ void KeeperTCPHandler::runImpl()
 {
     setThreadName("TstKprHandler");
     ThreadStatus thread_status;
-    auto global_receive_timeout = global_context.getSettingsRef().receive_timeout;
-    auto global_send_timeout = global_context.getSettingsRef().send_timeout;
+    auto global_receive_timeout = global_context->getSettingsRef().receive_timeout;
+    auto global_send_timeout = global_context->getSettingsRef().send_timeout;
 
     socket().setReceiveTimeout(global_receive_timeout);
     socket().setSendTimeout(global_send_timeout);
diff --git a/src/Server/KeeperTCPHandler.h b/src/Server/KeeperTCPHandler.h
index fecaf1cc38f..6c3929198c0 100644
--- a/src/Server/KeeperTCPHandler.h
+++ b/src/Server/KeeperTCPHandler.h
@@ -37,7 +37,7 @@ public:
 private:
     IServer & server;
     Poco::Logger * log;
-    Context global_context;
+    ContextPtr global_context;
     std::shared_ptr<KeeperStorageDispatcher> nu_keeper_storage_dispatcher;
     Poco::Timespan operation_timeout;
     Poco::Timespan session_timeout;
diff --git a/src/Server/KeeperTCPHandlerFactory.h b/src/Server/KeeperTCPHandlerFactory.h
index adeb829b4c3..132a8b96c23 100644
--- a/src/Server/KeeperTCPHandlerFactory.h
+++ b/src/Server/KeeperTCPHandlerFactory.h
@@ -5,6 +5,7 @@
 #include <Poco/Net/NetException.h>
 #include <common/logger_useful.h>
 #include <Server/IServer.h>
+#include <string>
 
 namespace DB
 {
@@ -21,9 +22,9 @@ private:
         void run() override {}
     };
 public:
-    KeeperTCPHandlerFactory(IServer & server_)
+    KeeperTCPHandlerFactory(IServer & server_, bool secure)
         : server(server_)
-        , log(&Poco::Logger::get("KeeperTCPHandlerFactory"))
+        , log(&Poco::Logger::get(std::string{"KeeperTCP"} + (secure ? "S" : "") + "HandlerFactory"))
     {
     }
 
diff --git a/src/Server/MySQLHandler.cpp b/src/Server/MySQLHandler.cpp
index 75c88a6ff93..7b1df092aa1 100644
--- a/src/Server/MySQLHandler.cpp
+++ b/src/Server/MySQLHandler.cpp
@@ -72,7 +72,7 @@ MySQLHandler::MySQLHandler(IServer & server_, const Poco::Net::StreamSocket & so
     : Poco::Net::TCPServerConnection(socket_)
     , server(server_)
     , log(&Poco::Logger::get("MySQLHandler"))
-    , connection_context(server.context())
+    , connection_context(Context::createCopy(server.context()))
     , connection_id(connection_id_)
     , auth_plugin(new MySQLProtocol::Authentication::Native41())
 {
@@ -89,14 +89,14 @@ void MySQLHandler::run()
 {
     setThreadName("MySQLHandler");
     ThreadStatus thread_status;
-    connection_context.makeSessionContext();
-    connection_context.getClientInfo().interface = ClientInfo::Interface::MYSQL;
-    connection_context.setDefaultFormat("MySQLWire");
-    connection_context.getClientInfo().connection_id = connection_id;
+    connection_context->makeSessionContext();
+    connection_context->getClientInfo().interface = ClientInfo::Interface::MYSQL;
+    connection_context->setDefaultFormat("MySQLWire");
+    connection_context->getClientInfo().connection_id = connection_id;
 
     in = std::make_shared<ReadBufferFromPocoSocket>(socket());
     out = std::make_shared<WriteBufferFromPocoSocket>(socket());
-    packet_endpoint = std::make_shared<PacketEndpoint>(*in, *out, connection_context.mysql.sequence_id);
+    packet_endpoint = std::make_shared<PacketEndpoint>(*in, *out, connection_context->mysql.sequence_id);
 
     try
     {
@@ -108,11 +108,11 @@ void MySQLHandler::run()
 
         HandshakeResponse handshake_response;
         finishHandshake(handshake_response);
-        connection_context.mysql.client_capabilities = handshake_response.capability_flags;
+        connection_context->mysql.client_capabilities = handshake_response.capability_flags;
         if (handshake_response.max_packet_size)
-            connection_context.mysql.max_packet_size = handshake_response.max_packet_size;
-        if (!connection_context.mysql.max_packet_size)
-            connection_context.mysql.max_packet_size = MAX_PACKET_LENGTH;
+            connection_context->mysql.max_packet_size = handshake_response.max_packet_size;
+        if (!connection_context->mysql.max_packet_size)
+            connection_context->mysql.max_packet_size = MAX_PACKET_LENGTH;
 
         LOG_TRACE(log,
             "Capabilities: {}, max_packet_size: {}, character_set: {}, user: {}, auth_response length: {}, database: {}, auth_plugin_name: {}",
@@ -133,8 +133,8 @@ void MySQLHandler::run()
         try
         {
             if (!handshake_response.database.empty())
-                connection_context.setCurrentDatabase(handshake_response.database);
-            connection_context.setCurrentQueryId(Poco::format("mysql:%lu", connection_id));
+                connection_context->setCurrentDatabase(handshake_response.database);
+            connection_context->setCurrentQueryId(Poco::format("mysql:%lu", connection_id));
 
         }
         catch (const Exception & exc)
@@ -252,7 +252,7 @@ void MySQLHandler::authenticate(const String & user_name, const String & auth_pl
     try
     {
         // For compatibility with JavaScript MySQL client, Native41 authentication plugin is used when possible (if password is specified using double SHA1). Otherwise SHA256 plugin is used.
-        auto user = connection_context.getAccessControlManager().read<User>(user_name);
+        auto user = connection_context->getAccessControlManager().read<User>(user_name);
         const DB::Authentication::Type user_auth_type = user->authentication.getType();
         if (user_auth_type == DB::Authentication::SHA256_PASSWORD)
         {
@@ -276,7 +276,7 @@ void MySQLHandler::comInitDB(ReadBuffer & payload)
     String database;
     readStringUntilEOF(database, payload);
     LOG_DEBUG(log, "Setting current database to {}", database);
-    connection_context.setCurrentDatabase(database);
+    connection_context->setCurrentDatabase(database);
     packet_endpoint->sendPacket(OKPacket(0, client_capability_flags, 0, 0, 1), true);
 }
 
@@ -284,7 +284,7 @@ void MySQLHandler::comFieldList(ReadBuffer & payload)
 {
     ComFieldList packet;
     packet.readPayloadWithUnpacked(payload);
-    String database = connection_context.getCurrentDatabase();
+    String database = connection_context->getCurrentDatabase();
     StoragePtr table_ptr = DatabaseCatalog::instance().getTable({database, packet.table}, connection_context);
     auto metadata_snapshot = table_ptr->getInMemoryMetadataPtr();
     for (const NameAndTypePair & column : metadata_snapshot->getColumns().getAll())
@@ -332,11 +332,11 @@ void MySQLHandler::comQuery(ReadBuffer & payload)
 
         ReadBufferFromString replacement(replacement_query);
 
-        Context query_context = connection_context;
+        auto query_context = Context::createCopy(connection_context);
 
         std::atomic<size_t> affected_rows {0};
-        auto prev = query_context.getProgressCallback();
-        query_context.setProgressCallback([&, prev = prev](const Progress & progress)
+        auto prev = query_context->getProgressCallback();
+        query_context->setProgressCallback([&, prev = prev](const Progress & progress)
         {
             if (prev)
                 prev(progress);
@@ -391,14 +391,14 @@ void MySQLHandlerSSL::finishHandshakeSSL(
     ReadBufferFromMemory payload(buf, pos);
     payload.ignore(PACKET_HEADER_SIZE);
     ssl_request.readPayloadWithUnpacked(payload);
-    connection_context.mysql.client_capabilities = ssl_request.capability_flags;
-    connection_context.mysql.max_packet_size = ssl_request.max_packet_size ? ssl_request.max_packet_size : MAX_PACKET_LENGTH;
+    connection_context->mysql.client_capabilities = ssl_request.capability_flags;
+    connection_context->mysql.max_packet_size = ssl_request.max_packet_size ? ssl_request.max_packet_size : MAX_PACKET_LENGTH;
     secure_connection = true;
     ss = std::make_shared<SecureStreamSocket>(SecureStreamSocket::attach(socket(), SSLManager::instance().defaultServerContext()));
     in = std::make_shared<ReadBufferFromPocoSocket>(*ss);
     out = std::make_shared<WriteBufferFromPocoSocket>(*ss);
-    connection_context.mysql.sequence_id = 2;
-    packet_endpoint = std::make_shared<PacketEndpoint>(*in, *out, connection_context.mysql.sequence_id);
+    connection_context->mysql.sequence_id = 2;
+    packet_endpoint = std::make_shared<PacketEndpoint>(*in, *out, connection_context->mysql.sequence_id);
     packet_endpoint->receivePacket(packet); /// Reading HandshakeResponse from secure socket.
 }
 
diff --git a/src/Server/MySQLHandler.h b/src/Server/MySQLHandler.h
index 1418d068ffd..f5fb82b5bef 100644
--- a/src/Server/MySQLHandler.h
+++ b/src/Server/MySQLHandler.h
@@ -56,7 +56,7 @@ private:
 protected:
     Poco::Logger * log;
 
-    Context connection_context;
+    ContextPtr connection_context;
 
     std::shared_ptr<MySQLProtocol::PacketEndpoint> packet_endpoint;
 
diff --git a/src/Server/PostgreSQLHandler.cpp b/src/Server/PostgreSQLHandler.cpp
index b3a3bbf2aaa..01887444c65 100644
--- a/src/Server/PostgreSQLHandler.cpp
+++ b/src/Server/PostgreSQLHandler.cpp
@@ -33,7 +33,7 @@ PostgreSQLHandler::PostgreSQLHandler(
     std::vector<std::shared_ptr<PostgreSQLProtocol::PGAuthentication::AuthenticationMethod>> & auth_methods_)
     : Poco::Net::TCPServerConnection(socket_)
     , server(server_)
-    , connection_context(server.context())
+    , connection_context(Context::createCopy(server.context()))
     , ssl_enabled(ssl_enabled_)
     , connection_id(connection_id_)
     , authentication_manager(auth_methods_)
@@ -52,9 +52,9 @@ void PostgreSQLHandler::run()
 {
     setThreadName("PostgresHandler");
     ThreadStatus thread_status;
-    connection_context.makeSessionContext();
-    connection_context.getClientInfo().interface = ClientInfo::Interface::POSTGRESQL;
-    connection_context.setDefaultFormat("PostgreSQLWire");
+    connection_context->makeSessionContext();
+    connection_context->getClientInfo().interface = ClientInfo::Interface::POSTGRESQL;
+    connection_context->setDefaultFormat("PostgreSQLWire");
 
     try
     {
@@ -132,8 +132,8 @@ bool PostgreSQLHandler::startup()
     try
     {
         if (!start_up_msg->database.empty())
-            connection_context.setCurrentDatabase(start_up_msg->database);
-        connection_context.setCurrentQueryId(Poco::format("postgres:%d:%d", connection_id, secret_key));
+            connection_context->setCurrentDatabase(start_up_msg->database);
+        connection_context->setCurrentQueryId(Poco::format("postgres:%d:%d", connection_id, secret_key));
     }
     catch (const Exception & exc)
     {
@@ -213,8 +213,8 @@ void PostgreSQLHandler::sendParameterStatusData(PostgreSQLProtocol::Messaging::S
 
 void PostgreSQLHandler::cancelRequest()
 {
-    connection_context.setCurrentQueryId("");
-    connection_context.setDefaultFormat("Null");
+    connection_context->setCurrentQueryId("");
+    connection_context->setDefaultFormat("Null");
 
     std::unique_ptr<PostgreSQLProtocol::Messaging::CancelRequest> msg =
         message_transport->receiveWithPayloadSize<PostgreSQLProtocol::Messaging::CancelRequest>(8);
@@ -268,7 +268,7 @@ void PostgreSQLHandler::processQuery()
             return;
         }
 
-        const auto & settings = connection_context.getSettingsRef();
+        const auto & settings = connection_context->getSettingsRef();
         std::vector<String> queries;
         auto parse_res = splitMultipartQuery(query->query, queries, settings.max_query_size, settings.max_parser_depth);
         if (!parse_res.second)
diff --git a/src/Server/PostgreSQLHandler.h b/src/Server/PostgreSQLHandler.h
index 697aa9b6744..cc30c85d8bb 100644
--- a/src/Server/PostgreSQLHandler.h
+++ b/src/Server/PostgreSQLHandler.h
@@ -37,7 +37,7 @@ private:
     Poco::Logger * log = &Poco::Logger::get("PostgreSQLHandler");
 
     IServer & server;
-    Context connection_context;
+    ContextPtr connection_context;
     bool ssl_enabled;
     Int32 connection_id;
     Int32 secret_key;
diff --git a/src/Server/ReplicasStatusHandler.cpp b/src/Server/ReplicasStatusHandler.cpp
index 778f9827131..86295cc5170 100644
--- a/src/Server/ReplicasStatusHandler.cpp
+++ b/src/Server/ReplicasStatusHandler.cpp
@@ -34,7 +34,7 @@ void ReplicasStatusHandler::handleRequest(HTTPServerRequest & request, HTTPServe
         /// Even if lag is small, output detailed information about the lag.
         bool verbose = params.get("verbose", "") == "1";
 
-        const MergeTreeSettings & settings = context.getReplicatedMergeTreeSettings();
+        const MergeTreeSettings & settings = context->getReplicatedMergeTreeSettings();
 
         bool ok = true;
         WriteBufferFromOwnString message;
@@ -73,7 +73,7 @@ void ReplicasStatusHandler::handleRequest(HTTPServerRequest & request, HTTPServe
             }
         }
 
-        const auto & config = context.getConfigRef();
+        const auto & config = context->getConfigRef();
         setResponseDefaultHeaders(response, config.getUInt("keep_alive_timeout", 10));
 
         if (!ok)
diff --git a/src/Server/ReplicasStatusHandler.h b/src/Server/ReplicasStatusHandler.h
index 8a790b13ad6..eda0b15ed6f 100644
--- a/src/Server/ReplicasStatusHandler.h
+++ b/src/Server/ReplicasStatusHandler.h
@@ -12,7 +12,7 @@ class IServer;
 class ReplicasStatusHandler : public HTTPRequestHandler
 {
 private:
-    Context & context;
+    ContextPtr context;
 
 public:
     explicit ReplicasStatusHandler(IServer & server_);
diff --git a/src/Server/StaticRequestHandler.cpp b/src/Server/StaticRequestHandler.cpp
index 9f959239be9..169d6859b43 100644
--- a/src/Server/StaticRequestHandler.cpp
+++ b/src/Server/StaticRequestHandler.cpp
@@ -137,7 +137,7 @@ void StaticRequestHandler::writeResponse(WriteBuffer & out)
 
     if (startsWith(response_expression, file_prefix))
     {
-        const auto & user_files_absolute_path = Poco::Path(server.context().getUserFilesPath()).makeAbsolute().makeDirectory().toString();
+        const auto & user_files_absolute_path = Poco::Path(server.context()->getUserFilesPath()).makeAbsolute().makeDirectory().toString();
         const auto & file_name = response_expression.substr(file_prefix.size(), response_expression.size() - file_prefix.size());
 
         const auto & file_path = Poco::Path(user_files_absolute_path, file_name).makeAbsolute().toString();
diff --git a/src/Server/TCPHandler.cpp b/src/Server/TCPHandler.cpp
index 7ff18b3c0f5..d1a0ea61066 100644
--- a/src/Server/TCPHandler.cpp
+++ b/src/Server/TCPHandler.cpp
@@ -62,8 +62,8 @@ TCPHandler::TCPHandler(IServer & server_, const Poco::Net::StreamSocket & socket
     , server(server_)
     , parse_proxy_protocol(parse_proxy_protocol_)
     , log(&Poco::Logger::get("TCPHandler"))
-    , connection_context(server.context())
-    , query_context(server.context())
+    , connection_context(Context::createCopy(server.context()))
+    , query_context(Context::createCopy(server.context()))
     , server_display_name(std::move(server_display_name_))
 {
 }
@@ -86,13 +86,13 @@ void TCPHandler::runImpl()
     setThreadName("TCPHandler");
     ThreadStatus thread_status;
 
-    connection_context = server.context();
-    connection_context.makeSessionContext();
+    connection_context = Context::createCopy(server.context());
+    connection_context->makeSessionContext();
 
     /// These timeouts can be changed after receiving query.
 
-    auto global_receive_timeout = connection_context.getSettingsRef().receive_timeout;
-    auto global_send_timeout = connection_context.getSettingsRef().send_timeout;
+    auto global_receive_timeout = connection_context->getSettingsRef().receive_timeout;
+    auto global_send_timeout = connection_context->getSettingsRef().send_timeout;
 
     socket().setReceiveTimeout(global_receive_timeout);
     socket().setSendTimeout(global_send_timeout);
@@ -133,7 +133,7 @@ void TCPHandler::runImpl()
         try
         {
             /// We try to send error information to the client.
-            sendException(e, connection_context.getSettingsRef().calculate_text_stack_trace);
+            sendException(e, connection_context->getSettingsRef().calculate_text_stack_trace);
         }
         catch (...) {}
 
@@ -147,18 +147,18 @@ void TCPHandler::runImpl()
         {
             Exception e("Database " + backQuote(default_database) + " doesn't exist", ErrorCodes::UNKNOWN_DATABASE);
             LOG_ERROR(log, "Code: {}, e.displayText() = {}, Stack trace:\n\n{}", e.code(), e.displayText(), e.getStackTraceString());
-            sendException(e, connection_context.getSettingsRef().calculate_text_stack_trace);
+            sendException(e, connection_context->getSettingsRef().calculate_text_stack_trace);
             return;
         }
 
-        connection_context.setCurrentDatabase(default_database);
+        connection_context->setCurrentDatabase(default_database);
     }
 
-    Settings connection_settings = connection_context.getSettings();
+    Settings connection_settings = connection_context->getSettings();
 
     sendHello();
 
-    connection_context.setProgressCallback([this] (const Progress & value) { return this->updateProgress(value); });
+    connection_context->setProgressCallback([this] (const Progress & value) { return this->updateProgress(value); });
 
     while (true)
     {
@@ -181,7 +181,7 @@ void TCPHandler::runImpl()
             break;
 
         /// Set context of request.
-        query_context = connection_context;
+        query_context = Context::createCopy(connection_context);
 
         Stopwatch watch;
         state.reset();
@@ -214,7 +214,7 @@ void TCPHandler::runImpl()
             if (state.empty() && state.part_uuids && !receivePacket())
                 continue;
 
-            query_scope.emplace(*query_context);
+            query_scope.emplace(query_context);
 
             send_exception_with_stack_trace = query_context->getSettingsRef().calculate_text_stack_trace;
 
@@ -229,9 +229,9 @@ void TCPHandler::runImpl()
                 CurrentThread::setFatalErrorCallback([this]{ sendLogs(); });
             }
 
-            query_context->setExternalTablesInitializer([&connection_settings, this] (Context & context)
+            query_context->setExternalTablesInitializer([&connection_settings, this] (ContextPtr context)
             {
-                if (&context != &*query_context)
+                if (context != query_context)
                     throw Exception("Unexpected context in external tables initializer", ErrorCodes::LOGICAL_ERROR);
 
                 /// Get blocks of temporary tables
@@ -246,9 +246,9 @@ void TCPHandler::runImpl()
             });
 
             /// Send structure of columns to client for function input()
-            query_context->setInputInitializer([this] (Context & context, const StoragePtr & input_storage)
+            query_context->setInputInitializer([this] (ContextPtr context, const StoragePtr & input_storage)
             {
-                if (&context != &query_context.value())
+                if (context != query_context)
                     throw Exception("Unexpected context in Input initializer", ErrorCodes::LOGICAL_ERROR);
 
                 auto metadata_snapshot = input_storage->getInMemoryMetadataPtr();
@@ -266,9 +266,9 @@ void TCPHandler::runImpl()
                 sendData(state.input_header);
             });
 
-            query_context->setInputBlocksReaderCallback([&connection_settings, this] (Context & context) -> Block
+            query_context->setInputBlocksReaderCallback([&connection_settings, this] (ContextPtr context) -> Block
             {
-                if (&context != &query_context.value())
+                if (context != query_context)
                     throw Exception("Unexpected context in InputBlocksReader", ErrorCodes::LOGICAL_ERROR);
 
                 size_t poll_interval;
@@ -283,11 +283,11 @@ void TCPHandler::runImpl()
                 return state.block_for_input;
             });
 
-            customizeContext(*query_context);
+            customizeContext(query_context);
 
             bool may_have_embedded_data = client_tcp_protocol_version >= DBMS_MIN_REVISION_WITH_CLIENT_SUPPORT_EMBEDDED_DATA;
             /// Processing Query
-            state.io = executeQuery(state.query, *query_context, false, state.stage, may_have_embedded_data);
+            state.io = executeQuery(state.query, query_context, false, state.stage, may_have_embedded_data);
 
             after_check_cancelled.restart();
             after_send_progress.restart();
@@ -537,7 +537,7 @@ void TCPHandler::processInsertQuery(const Settings & connection_settings)
         {
             if (!table_id.empty())
             {
-                auto storage_ptr = DatabaseCatalog::instance().getTable(table_id, *query_context);
+                auto storage_ptr = DatabaseCatalog::instance().getTable(table_id, query_context);
                 sendTableColumns(storage_ptr->getInMemoryMetadataPtr()->getColumns());
             }
         }
@@ -701,7 +701,7 @@ void TCPHandler::processTablesStatusRequest()
     TablesStatusResponse response;
     for (const QualifiedTableName & table_name: request.tables)
     {
-        auto resolved_id = connection_context.tryResolveStorageID({table_name.database, table_name.table});
+        auto resolved_id = connection_context->tryResolveStorageID({table_name.database, table_name.table});
         StoragePtr table = DatabaseCatalog::instance().tryGetTable(resolved_id, connection_context);
         if (!table)
             continue;
@@ -862,7 +862,7 @@ bool TCPHandler::receiveProxyHeader()
     }
 
     LOG_TRACE(log, "Forwarded client address from PROXY header: {}", forwarded_address);
-    connection_context.getClientInfo().forwarded_for = forwarded_address;
+    connection_context->getClientInfo().forwarded_for = forwarded_address;
     return true;
 }
 
@@ -915,7 +915,7 @@ void TCPHandler::receiveHello()
 
     if (user != USER_INTERSERVER_MARKER)
     {
-        connection_context.setUser(user, password, socket().peerAddress());
+        connection_context->setUser(user, password, socket().peerAddress());
     }
     else
     {
@@ -1033,7 +1033,7 @@ void TCPHandler::receiveClusterNameAndSalt()
         try
         {
             /// We try to send error information to the client.
-            sendException(e, connection_context.getSettingsRef().calculate_text_stack_trace);
+            sendException(e, connection_context->getSettingsRef().calculate_text_stack_trace);
         }
         catch (...) {}
 
@@ -1236,18 +1236,18 @@ bool TCPHandler::receiveData(bool scalar)
             /// If such a table does not exist, create it.
             if (resolved)
             {
-                storage = DatabaseCatalog::instance().getTable(resolved, *query_context);
+                storage = DatabaseCatalog::instance().getTable(resolved, query_context);
             }
             else
             {
                 NamesAndTypesList columns = block.getNamesAndTypesList();
-                auto temporary_table = TemporaryTableHolder(*query_context, ColumnsDescription{columns}, {});
+                auto temporary_table = TemporaryTableHolder(query_context, ColumnsDescription{columns}, {});
                 storage = temporary_table.getTable();
                 query_context->addExternalTable(temporary_id.table_name, std::move(temporary_table));
             }
             auto metadata_snapshot = storage->getInMemoryMetadataPtr();
             /// The data will be written directly to the table.
-            auto temporary_table_out = storage->write(ASTPtr(), metadata_snapshot, *query_context);
+            auto temporary_table_out = storage->write(ASTPtr(), metadata_snapshot, query_context);
             temporary_table_out->write(block);
             temporary_table_out->writeSuffix();
 
@@ -1346,7 +1346,7 @@ void TCPHandler::initBlockOutput(const Block & block)
             *state.maybe_compressed_out,
             client_tcp_protocol_version,
             block.cloneEmpty(),
-            !connection_context.getSettingsRef().low_cardinality_allow_in_native_format);
+            !connection_context->getSettingsRef().low_cardinality_allow_in_native_format);
     }
 }
 
@@ -1359,7 +1359,7 @@ void TCPHandler::initLogsBlockOutput(const Block & block)
             *out,
             client_tcp_protocol_version,
             block.cloneEmpty(),
-            !connection_context.getSettingsRef().low_cardinality_allow_in_native_format);
+            !connection_context->getSettingsRef().low_cardinality_allow_in_native_format);
     }
 }
 
diff --git a/src/Server/TCPHandler.h b/src/Server/TCPHandler.h
index c3dd8346c8e..e0160b82962 100644
--- a/src/Server/TCPHandler.h
+++ b/src/Server/TCPHandler.h
@@ -113,14 +113,13 @@ public:
       *  because it allows to check the IP ranges of the trusted proxy.
       * Proxy-forwarded (original client) IP address is used for quota accounting if quota is keyed by forwarded IP.
       */
-    TCPHandler(IServer & server_, const Poco::Net::StreamSocket & socket_, bool parse_proxy_protocol_,
-        std::string server_display_name_);
+    TCPHandler(IServer & server_, const Poco::Net::StreamSocket & socket_, bool parse_proxy_protocol_, std::string server_display_name_);
     ~TCPHandler() override;
 
     void run() override;
 
     /// This method is called right before the query execution.
-    virtual void customizeContext(DB::Context & /*context*/) {}
+    virtual void customizeContext(ContextPtr /*context*/) {}
 
 private:
     IServer & server;
@@ -133,8 +132,8 @@ private:
     UInt64 client_version_patch = 0;
     UInt64 client_tcp_protocol_version = 0;
 
-    Context connection_context;
-    std::optional<Context> query_context;
+    ContextPtr connection_context;
+    ContextPtr query_context;
 
     /// Streams for reading/writing from/to client connection socket.
     std::shared_ptr<ReadBuffer> in;
diff --git a/src/Storages/AlterCommands.cpp b/src/Storages/AlterCommands.cpp
index 7043a32760b..e3177c167c5 100644
--- a/src/Storages/AlterCommands.cpp
+++ b/src/Storages/AlterCommands.cpp
@@ -299,7 +299,7 @@ std::optional<AlterCommand> AlterCommand::parse(const ASTAlterCommand * command_
 }
 
 
-void AlterCommand::apply(StorageInMemoryMetadata & metadata, const Context & context) const
+void AlterCommand::apply(StorageInMemoryMetadata & metadata, ContextPtr context) const
 {
     if (type == ADD_COLUMN)
     {
@@ -320,7 +320,7 @@ void AlterCommand::apply(StorageInMemoryMetadata & metadata, const Context & con
         metadata.columns.add(column, after_column, first);
 
         /// Slow, because each time a list is copied
-        if (context.getSettingsRef().flatten_nested)
+        if (context->getSettingsRef().flatten_nested)
             metadata.columns.flattenNested();
     }
     else if (type == DROP_COLUMN)
@@ -702,7 +702,7 @@ bool AlterCommand::isRemovingProperty() const
     return to_remove != RemoveProperty::NO_PROPERTY;
 }
 
-std::optional<MutationCommand> AlterCommand::tryConvertToMutationCommand(StorageInMemoryMetadata & metadata, const Context & context) const
+std::optional<MutationCommand> AlterCommand::tryConvertToMutationCommand(StorageInMemoryMetadata & metadata, ContextPtr context) const
 {
     if (!isRequireMutationStage(metadata))
         return {};
@@ -788,7 +788,7 @@ String alterTypeToString(const AlterCommand::Type type)
     __builtin_unreachable();
 }
 
-void AlterCommands::apply(StorageInMemoryMetadata & metadata, const Context & context) const
+void AlterCommands::apply(StorageInMemoryMetadata & metadata, ContextPtr context) const
 {
     if (!prepared)
         throw DB::Exception("Alter commands is not prepared. Cannot apply. It's a bug", ErrorCodes::LOGICAL_ERROR);
@@ -880,7 +880,7 @@ void AlterCommands::prepare(const StorageInMemoryMetadata & metadata)
     prepared = true;
 }
 
-void AlterCommands::validate(const StorageInMemoryMetadata & metadata, const Context & context) const
+void AlterCommands::validate(const StorageInMemoryMetadata & metadata, ContextPtr context) const
 {
     auto all_columns = metadata.columns;
     /// Default expression for all added/modified columns
@@ -907,7 +907,7 @@ void AlterCommands::validate(const StorageInMemoryMetadata & metadata, const Con
                                 ErrorCodes::BAD_ARGUMENTS};
 
             if (command.codec)
-                CompressionCodecFactory::instance().validateCodecAndGetPreprocessedAST(command.codec, command.data_type, !context.getSettingsRef().allow_suspicious_codecs);
+                CompressionCodecFactory::instance().validateCodecAndGetPreprocessedAST(command.codec, command.data_type, !context->getSettingsRef().allow_suspicious_codecs);
 
             all_columns.add(ColumnDescription(column_name, command.data_type));
         }
@@ -927,7 +927,7 @@ void AlterCommands::validate(const StorageInMemoryMetadata & metadata, const Con
                                 ErrorCodes::NOT_IMPLEMENTED};
 
             if (command.codec)
-                CompressionCodecFactory::instance().validateCodecAndGetPreprocessedAST(command.codec, command.data_type, !context.getSettingsRef().allow_suspicious_codecs);
+                CompressionCodecFactory::instance().validateCodecAndGetPreprocessedAST(command.codec, command.data_type, !context->getSettingsRef().allow_suspicious_codecs);
             auto column_default = all_columns.getDefault(column_name);
             if (column_default)
             {
@@ -1172,7 +1172,7 @@ static MutationCommand createMaterializeTTLCommand()
     return command;
 }
 
-MutationCommands AlterCommands::getMutationCommands(StorageInMemoryMetadata metadata, bool materialize_ttl, const Context & context) const
+MutationCommands AlterCommands::getMutationCommands(StorageInMemoryMetadata metadata, bool materialize_ttl, ContextPtr context) const
 {
     MutationCommands result;
     for (const auto & alter_cmd : *this)
diff --git a/src/Storages/AlterCommands.h b/src/Storages/AlterCommands.h
index c973b0b6a6f..d6c80bc5ed4 100644
--- a/src/Storages/AlterCommands.h
+++ b/src/Storages/AlterCommands.h
@@ -128,7 +128,7 @@ struct AlterCommand
 
     static std::optional<AlterCommand> parse(const ASTAlterCommand * command);
 
-    void apply(StorageInMemoryMetadata & metadata, const Context & context) const;
+    void apply(StorageInMemoryMetadata & metadata, ContextPtr context) const;
 
     /// Check that alter command require data modification (mutation) to be
     /// executed. For example, cast from Date to UInt16 type can be executed
@@ -151,7 +151,7 @@ struct AlterCommand
     /// If possible, convert alter command to mutation command. In other case
     /// return empty optional. Some storages may execute mutations after
     /// metadata changes.
-    std::optional<MutationCommand> tryConvertToMutationCommand(StorageInMemoryMetadata & metadata, const Context & context) const;
+    std::optional<MutationCommand> tryConvertToMutationCommand(StorageInMemoryMetadata & metadata, ContextPtr context) const;
 };
 
 /// Return string representation of AlterCommand::Type
@@ -170,7 +170,7 @@ public:
     /// Checks that all columns exist and dependencies between them.
     /// This check is lightweight and base only on metadata.
     /// More accurate check have to be performed with storage->checkAlterIsPossible.
-    void validate(const StorageInMemoryMetadata & metadata, const Context & context) const;
+    void validate(const StorageInMemoryMetadata & metadata, ContextPtr context) const;
 
     /// Prepare alter commands. Set ignore flag to some of them and set some
     /// parts to commands from storage's metadata (for example, absent default)
@@ -178,7 +178,7 @@ public:
 
     /// Apply all alter command in sequential order to storage metadata.
     /// Commands have to be prepared before apply.
-    void apply(StorageInMemoryMetadata & metadata, const Context & context) const;
+    void apply(StorageInMemoryMetadata & metadata, ContextPtr context) const;
 
     /// At least one command modify settings.
     bool isSettingsAlter() const;
@@ -190,7 +190,7 @@ public:
     /// alter. If alter can be performed as pure metadata update, than result is
     /// empty. If some TTL changes happened than, depending on materialize_ttl
     /// additional mutation command (MATERIALIZE_TTL) will be returned.
-    MutationCommands getMutationCommands(StorageInMemoryMetadata metadata, bool materialize_ttl, const Context & context) const;
+    MutationCommands getMutationCommands(StorageInMemoryMetadata metadata, bool materialize_ttl, ContextPtr context) const;
 };
 
 }
diff --git a/src/Storages/ColumnDefault.h b/src/Storages/ColumnDefault.h
index 1035bfcc834..38b61415a9a 100644
--- a/src/Storages/ColumnDefault.h
+++ b/src/Storages/ColumnDefault.h
@@ -1,10 +1,10 @@
 #pragma once
 
+#include <Parsers/IAST.h>
+
 #include <string>
 #include <unordered_map>
 
-#include <Parsers/IAST.h>
-
 
 namespace DB
 {
@@ -18,7 +18,7 @@ enum class ColumnDefaultKind
 
 
 ColumnDefaultKind columnDefaultKindFromString(const std::string & str);
-std::string toString(const ColumnDefaultKind kind);
+std::string toString(ColumnDefaultKind kind);
 
 
 struct ColumnDefault
diff --git a/src/Storages/ColumnsDescription.cpp b/src/Storages/ColumnsDescription.cpp
index fc6bb661986..545911f1465 100644
--- a/src/Storages/ColumnsDescription.cpp
+++ b/src/Storages/ColumnsDescription.cpp
@@ -582,7 +582,7 @@ void ColumnsDescription::removeSubcolumns(const String & name_in_storage, const
         subcolumns.erase(name_in_storage + "." + subcolumn_name);
 }
 
-Block validateColumnsDefaultsAndGetSampleBlock(ASTPtr default_expr_list, const NamesAndTypesList & all_columns, const Context & context)
+Block validateColumnsDefaultsAndGetSampleBlock(ASTPtr default_expr_list, const NamesAndTypesList & all_columns, ContextPtr context)
 {
     for (const auto & child : default_expr_list->children)
         if (child->as<ASTSelectQuery>() || child->as<ASTSelectWithUnionQuery>() || child->as<ASTSubquery>())
diff --git a/src/Storages/ColumnsDescription.h b/src/Storages/ColumnsDescription.h
index 26e30004544..7fff22abf71 100644
--- a/src/Storages/ColumnsDescription.h
+++ b/src/Storages/ColumnsDescription.h
@@ -1,18 +1,20 @@
 #pragma once
 
-#include <Core/NamesAndTypes.h>
-#include <Core/Names.h>
-#include <Core/Block.h>
-#include <Common/Exception.h>
-#include <Storages/ColumnDefault.h>
-#include <Storages/ColumnCodec.h>
-#include <optional>
 #include <Compression/CompressionFactory.h>
+#include <Core/Block.h>
+#include <Core/Names.h>
+#include <Core/NamesAndTypes.h>
+#include <Interpreters/Context_fwd.h>
+#include <Storages/ColumnCodec.h>
+#include <Storages/ColumnDefault.h>
+#include <Common/Exception.h>
 
-#include <boost/multi_index_container.hpp>
-#include <boost/multi_index/sequenced_index.hpp>
-#include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/multi_index_container.hpp>
+
+#include <optional>
 
 
 namespace DB
@@ -159,5 +161,5 @@ private:
 /// default expression result can be casted to column_type. Also checks, that we
 /// don't have strange constructions in default expression like SELECT query or
 /// arrayJoin function.
-Block validateColumnsDefaultsAndGetSampleBlock(ASTPtr default_expr_list, const NamesAndTypesList & all_columns, const Context & context);
+Block validateColumnsDefaultsAndGetSampleBlock(ASTPtr default_expr_list, const NamesAndTypesList & all_columns, ContextPtr context);
 }
diff --git a/src/Storages/ConstraintsDescription.cpp b/src/Storages/ConstraintsDescription.cpp
index e6315872a66..1e86a17523b 100644
--- a/src/Storages/ConstraintsDescription.cpp
+++ b/src/Storages/ConstraintsDescription.cpp
@@ -41,7 +41,7 @@ ConstraintsDescription ConstraintsDescription::parse(const String & str)
     return res;
 }
 
-ConstraintsExpressions ConstraintsDescription::getExpressions(const DB::Context & context,
+ConstraintsExpressions ConstraintsDescription::getExpressions(const DB::ContextPtr context,
                                                               const DB::NamesAndTypesList & source_columns_) const
 {
     ConstraintsExpressions res;
diff --git a/src/Storages/ConstraintsDescription.h b/src/Storages/ConstraintsDescription.h
index d6d2baefbd2..5e6416822bb 100644
--- a/src/Storages/ConstraintsDescription.h
+++ b/src/Storages/ConstraintsDescription.h
@@ -19,7 +19,7 @@ struct ConstraintsDescription
 
     static ConstraintsDescription parse(const String & str);
 
-    ConstraintsExpressions getExpressions(const Context & context, const NamesAndTypesList & source_columns_) const;
+    ConstraintsExpressions getExpressions(ContextPtr context, const NamesAndTypesList & source_columns_) const;
 
     ConstraintsDescription(const ConstraintsDescription & other);
     ConstraintsDescription & operator=(const ConstraintsDescription & other);
diff --git a/src/Storages/Distributed/DirectoryMonitor.cpp b/src/Storages/Distributed/DirectoryMonitor.cpp
index fb5e5080314..2afa9747c60 100644
--- a/src/Storages/Distributed/DirectoryMonitor.cpp
+++ b/src/Storages/Distributed/DirectoryMonitor.cpp
@@ -9,6 +9,8 @@
 #include <Common/quoteString.h>
 #include <Common/hex.h>
 #include <Common/ActionBlocker.h>
+#include <Common/formatReadable.h>
+#include <Common/Stopwatch.h>
 #include <common/StringRef.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/Cluster.h>
@@ -104,12 +106,14 @@ namespace
         size_t rows = 0;
         size_t bytes = 0;
 
-        std::string header;
+        /// dumpStructure() of the header -- obsolete
+        std::string block_header_string;
+        Block block_header;
     };
 
-    DistributedHeader readDistributedHeader(ReadBuffer & in, Poco::Logger * log)
+    DistributedHeader readDistributedHeader(ReadBufferFromFile & in, Poco::Logger * log)
     {
-        DistributedHeader header;
+        DistributedHeader distributed_header;
 
         UInt64 query_size;
         readVarUInt(query_size, in);
@@ -135,17 +139,25 @@ namespace
                 LOG_WARNING(log, "ClickHouse shard version is older than ClickHouse initiator version. It may lack support for new features.");
             }
 
-            readStringBinary(header.insert_query, header_buf);
-            header.insert_settings.read(header_buf);
+            readStringBinary(distributed_header.insert_query, header_buf);
+            distributed_header.insert_settings.read(header_buf);
 
             if (header_buf.hasPendingData())
-                header.client_info.read(header_buf, initiator_revision);
+                distributed_header.client_info.read(header_buf, initiator_revision);
 
             if (header_buf.hasPendingData())
             {
-                readVarUInt(header.rows, header_buf);
-                readVarUInt(header.bytes, header_buf);
-                readStringBinary(header.header, header_buf);
+                readVarUInt(distributed_header.rows, header_buf);
+                readVarUInt(distributed_header.bytes, header_buf);
+                readStringBinary(distributed_header.block_header_string, header_buf);
+            }
+
+            if (header_buf.hasPendingData())
+            {
+                NativeBlockInputStream header_block_in(header_buf, DBMS_TCP_PROTOCOL_VERSION);
+                distributed_header.block_header = header_block_in.read();
+                if (!distributed_header.block_header)
+                    throw Exception(ErrorCodes::CANNOT_READ_ALL_DATA, "Cannot read header from the {} batch", in.getFileName());
             }
 
             /// Add handling new data here, for example:
@@ -155,20 +167,20 @@ namespace
             ///
             /// And note that it is safe, because we have checksum and size for header.
 
-            return header;
+            return distributed_header;
         }
 
         if (query_size == DBMS_DISTRIBUTED_SIGNATURE_HEADER_OLD_FORMAT)
         {
-            header.insert_settings.read(in, SettingsWriteFormat::BINARY);
-            readStringBinary(header.insert_query, in);
-            return header;
+            distributed_header.insert_settings.read(in, SettingsWriteFormat::BINARY);
+            readStringBinary(distributed_header.insert_query, in);
+            return distributed_header;
         }
 
-        header.insert_query.resize(query_size);
-        in.readStrict(header.insert_query.data(), query_size);
+        distributed_header.insert_query.resize(query_size);
+        in.readStrict(distributed_header.insert_query.data(), query_size);
 
-        return header;
+        return distributed_header;
     }
 
     /// remote_error argument is used to decide whether some errors should be
@@ -200,35 +212,58 @@ namespace
         return nullptr;
     }
 
-    void writeRemoteConvert(const DistributedHeader & header, RemoteBlockOutputStream & remote, ReadBufferFromFile & in, Poco::Logger * log)
+    void writeAndConvert(RemoteBlockOutputStream & remote, ReadBufferFromFile & in)
     {
-        if (remote.getHeader() && header.header != remote.getHeader().dumpStructure())
+        CompressedReadBuffer decompressing_in(in);
+        NativeBlockInputStream block_in(decompressing_in, DBMS_TCP_PROTOCOL_VERSION);
+        block_in.readPrefix();
+
+        while (Block block = block_in.read())
         {
-            LOG_WARNING(log,
-                "Structure does not match (remote: {}, local: {}), implicit conversion will be done",
-                remote.getHeader().dumpStructure(), header.header);
-
-            CompressedReadBuffer decompressing_in(in);
-            /// Lack of header, requires to read blocks
-            NativeBlockInputStream block_in(decompressing_in, DBMS_TCP_PROTOCOL_VERSION);
-
-            block_in.readPrefix();
-            while (Block block = block_in.read())
-            {
-                ConvertingBlockInputStream convert(
-                    std::make_shared<OneBlockInputStream>(block),
-                    remote.getHeader(),
-                    ConvertingBlockInputStream::MatchColumnsMode::Name);
-                auto adopted_block = convert.read();
-                remote.write(adopted_block);
-            }
-            block_in.readSuffix();
+            ConvertingBlockInputStream convert(
+                std::make_shared<OneBlockInputStream>(block),
+                remote.getHeader(),
+                ConvertingBlockInputStream::MatchColumnsMode::Name);
+            auto adopted_block = convert.read();
+            remote.write(adopted_block);
         }
-        else
+
+        block_in.readSuffix();
+    }
+
+    void writeRemoteConvert(const DistributedHeader & distributed_header, RemoteBlockOutputStream & remote, ReadBufferFromFile & in, Poco::Logger * log)
+    {
+        if (!remote.getHeader())
         {
             CheckingCompressedReadBuffer checking_in(in);
             remote.writePrepared(checking_in);
+            return;
         }
+
+        /// This is old format, that does not have header for the block in the file header,
+        /// applying ConvertingBlockInputStream in this case is not a big overhead.
+        ///
+        /// Anyway we can get header only from the first block, which contain all rows anyway.
+        if (!distributed_header.block_header)
+        {
+            LOG_TRACE(log, "Processing batch {} with old format (no header)", in.getFileName());
+
+            writeAndConvert(remote, in);
+            return;
+        }
+
+        if (!blocksHaveEqualStructure(distributed_header.block_header, remote.getHeader()))
+        {
+            LOG_WARNING(log,
+                "Structure does not match (remote: {}, local: {}), implicit conversion will be done",
+                remote.getHeader().dumpStructure(), distributed_header.block_header.dumpStructure());
+
+            writeAndConvert(remote, in);
+            return;
+        }
+
+        CheckingCompressedReadBuffer checking_in(in);
+        remote.writePrepared(checking_in);
     }
 }
 
@@ -245,14 +280,14 @@ StorageDistributedDirectoryMonitor::StorageDistributedDirectoryMonitor(
     , disk(disk_)
     , relative_path(relative_path_)
     , path(disk->getPath() + relative_path + '/')
-    , should_batch_inserts(storage.global_context.getSettingsRef().distributed_directory_monitor_batch_inserts)
+    , should_batch_inserts(storage.getContext()->getSettingsRef().distributed_directory_monitor_batch_inserts)
     , dir_fsync(storage.getDistributedSettingsRef().fsync_directories)
-    , min_batched_block_size_rows(storage.global_context.getSettingsRef().min_insert_block_size_rows)
-    , min_batched_block_size_bytes(storage.global_context.getSettingsRef().min_insert_block_size_bytes)
+    , min_batched_block_size_rows(storage.getContext()->getSettingsRef().min_insert_block_size_rows)
+    , min_batched_block_size_bytes(storage.getContext()->getSettingsRef().min_insert_block_size_bytes)
     , current_batch_file_path(path + "current_batch.txt")
-    , default_sleep_time(storage.global_context.getSettingsRef().distributed_directory_monitor_sleep_time_ms.totalMilliseconds())
+    , default_sleep_time(storage.getContext()->getSettingsRef().distributed_directory_monitor_sleep_time_ms.totalMilliseconds())
     , sleep_time(default_sleep_time)
-    , max_sleep_time(storage.global_context.getSettingsRef().distributed_directory_monitor_max_sleep_time_ms.totalMilliseconds())
+    , max_sleep_time(storage.getContext()->getSettingsRef().distributed_directory_monitor_max_sleep_time_ms.totalMilliseconds())
     , log(&Poco::Logger::get(getLoggerName()))
     , monitor_blocker(monitor_blocker_)
     , metric_pending_files(CurrentMetrics::DistributedFilesToInsert, 0)
@@ -427,7 +462,7 @@ ConnectionPoolPtr StorageDistributedDirectoryMonitor::createPool(const std::stri
 
     auto pools = createPoolsForAddresses(name, pool_factory, storage.log);
 
-    const auto settings = storage.global_context.getSettings();
+    const auto settings = storage.getContext()->getSettings();
     return pools.size() == 1 ? pools.front() : std::make_shared<ConnectionPoolWithFailover>(pools,
         settings.load_balancing,
         settings.distributed_replica_error_half_life.totalSeconds(),
@@ -490,21 +525,27 @@ bool StorageDistributedDirectoryMonitor::processFiles(const std::map<UInt64, std
 
 void StorageDistributedDirectoryMonitor::processFile(const std::string & file_path)
 {
-    LOG_TRACE(log, "Started processing `{}`", file_path);
-    auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(storage.global_context.getSettingsRef());
+    Stopwatch watch;
+    auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(storage.getContext()->getSettingsRef());
 
     try
     {
         CurrentMetrics::Increment metric_increment{CurrentMetrics::DistributedSend};
 
         ReadBufferFromFile in(file_path);
-        const auto & header = readDistributedHeader(in, log);
+        const auto & distributed_header = readDistributedHeader(in, log);
 
-        auto connection = pool->get(timeouts, &header.insert_settings);
+        LOG_TRACE(log, "Started processing `{}` ({} rows, {} bytes)", file_path,
+            formatReadableQuantity(distributed_header.rows),
+            formatReadableSizeWithBinarySuffix(distributed_header.bytes));
+
+        auto connection = pool->get(timeouts, &distributed_header.insert_settings);
         RemoteBlockOutputStream remote{*connection, timeouts,
-            header.insert_query, header.insert_settings, header.client_info};
+            distributed_header.insert_query,
+            distributed_header.insert_settings,
+            distributed_header.client_info};
         remote.writePrefix();
-        writeRemoteConvert(header, remote, in, log);
+        writeRemoteConvert(distributed_header, remote, in, log);
         remote.writeSuffix();
     }
     catch (const Exception & e)
@@ -515,7 +556,7 @@ void StorageDistributedDirectoryMonitor::processFile(const std::string & file_pa
 
     auto dir_sync_guard = getDirectorySyncGuard(dir_fsync, disk, relative_path);
     markAsSend(file_path);
-    LOG_TRACE(log, "Finished processing `{}`", file_path);
+    LOG_TRACE(log, "Finished processing `{}` (took {} ms)", file_path, watch.elapsedMilliseconds());
 }
 
 struct StorageDistributedDirectoryMonitor::BatchHeader
@@ -523,20 +564,21 @@ struct StorageDistributedDirectoryMonitor::BatchHeader
     Settings settings;
     String query;
     ClientInfo client_info;
-    String sample_block_structure;
+    Block header;
 
-    BatchHeader(Settings settings_, String query_, ClientInfo client_info_, String sample_block_structure_)
+    BatchHeader(Settings settings_, String query_, ClientInfo client_info_, Block header_)
         : settings(std::move(settings_))
         , query(std::move(query_))
         , client_info(std::move(client_info_))
-        , sample_block_structure(std::move(sample_block_structure_))
+        , header(std::move(header_))
     {
     }
 
     bool operator==(const BatchHeader & other) const
     {
-        return std::tie(settings, query, client_info.query_kind, sample_block_structure) ==
-               std::tie(other.settings, other.query, other.client_info.query_kind, other.sample_block_structure);
+        return std::tie(settings, query, client_info.query_kind) ==
+               std::tie(other.settings, other.query, other.client_info.query_kind) &&
+               blocksHaveEqualStructure(header, other.header);
     }
 
     struct Hash
@@ -545,7 +587,7 @@ struct StorageDistributedDirectoryMonitor::BatchHeader
         {
             SipHash hash_state;
             hash_state.update(batch_header.query.data(), batch_header.query.size());
-            hash_state.update(batch_header.sample_block_structure.data(), batch_header.sample_block_structure.size());
+            batch_header.header.updateHash(hash_state);
             return hash_state.get64();
         }
     };
@@ -587,6 +629,12 @@ struct StorageDistributedDirectoryMonitor::Batch
 
         CurrentMetrics::Increment metric_increment{CurrentMetrics::DistributedSend};
 
+        Stopwatch watch;
+
+        LOG_TRACE(parent.log, "Sending a batch of {} files ({} rows, {} bytes).", file_indices.size(),
+            formatReadableQuantity(total_rows),
+            formatReadableSizeWithBinarySuffix(total_bytes));
+
         if (!recovered)
         {
             /// For deduplication in Replicated tables to work, in case of error
@@ -613,7 +661,7 @@ struct StorageDistributedDirectoryMonitor::Batch
 
             Poco::File{tmp_file}.renameTo(parent.current_batch_file_path);
         }
-        auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(parent.storage.global_context.getSettingsRef());
+        auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(parent.storage.getContext()->getSettingsRef());
         auto connection = parent.pool->get(timeouts);
 
         bool batch_broken = false;
@@ -632,16 +680,17 @@ struct StorageDistributedDirectoryMonitor::Batch
                 }
 
                 ReadBufferFromFile in(file_path->second);
-                const auto & header = readDistributedHeader(in, parent.log);
+                const auto & distributed_header = readDistributedHeader(in, parent.log);
 
                 if (!remote)
                 {
                     remote = std::make_unique<RemoteBlockOutputStream>(*connection, timeouts,
-                        header.insert_query, header.insert_settings, header.client_info);
+                        distributed_header.insert_query,
+                        distributed_header.insert_settings,
+                        distributed_header.client_info);
                     remote->writePrefix();
                 }
-
-                writeRemoteConvert(header, *remote, in, parent.log);
+                writeRemoteConvert(distributed_header, *remote, in, parent.log);
             }
 
             if (remote)
@@ -660,7 +709,7 @@ struct StorageDistributedDirectoryMonitor::Batch
 
         if (!batch_broken)
         {
-            LOG_TRACE(parent.log, "Sent a batch of {} files.", file_indices.size());
+            LOG_TRACE(parent.log, "Sent a batch of {} files (took {} ms).", file_indices.size(), watch.elapsedMilliseconds());
 
             auto dir_sync_guard = getDirectorySyncGuard(dir_fsync, parent.disk, parent.relative_path);
             for (UInt64 file_index : file_indices)
@@ -808,22 +857,27 @@ void StorageDistributedDirectoryMonitor::processFilesWithBatching(const std::map
 
         size_t total_rows = 0;
         size_t total_bytes = 0;
-        std::string sample_block_structure;
-        DistributedHeader header;
+        Block header;
+        DistributedHeader distributed_header;
         try
         {
             /// Determine metadata of the current file and check if it is not broken.
             ReadBufferFromFile in{file_path};
-            header = readDistributedHeader(in, log);
+            distributed_header = readDistributedHeader(in, log);
 
-            if (header.rows)
+            if (distributed_header.rows)
             {
-                total_rows += header.rows;
-                total_bytes += header.bytes;
-                sample_block_structure = header.header;
+                total_rows += distributed_header.rows;
+                total_bytes += distributed_header.bytes;
             }
-            else
+
+            if (distributed_header.block_header)
+                header = distributed_header.block_header;
+
+            if (!total_rows || !header)
             {
+                LOG_TRACE(log, "Processing batch {} with old format (no header/rows)", in.getFileName());
+
                 CompressedReadBuffer decompressing_in(in);
                 NativeBlockInputStream block_in(decompressing_in, DBMS_TCP_PROTOCOL_VERSION);
                 block_in.readPrefix();
@@ -833,8 +887,8 @@ void StorageDistributedDirectoryMonitor::processFilesWithBatching(const std::map
                     total_rows += block.rows();
                     total_bytes += block.bytes();
 
-                    if (sample_block_structure.empty())
-                        sample_block_structure = block.cloneEmpty().dumpStructure();
+                    if (!header)
+                        header = block.cloneEmpty();
                 }
                 block_in.readSuffix();
             }
@@ -850,7 +904,12 @@ void StorageDistributedDirectoryMonitor::processFilesWithBatching(const std::map
                 throw;
         }
 
-        BatchHeader batch_header(std::move(header.insert_settings), std::move(header.insert_query), std::move(header.client_info), std::move(sample_block_structure));
+        BatchHeader batch_header(
+            std::move(distributed_header.insert_settings),
+            std::move(distributed_header.insert_query),
+            std::move(distributed_header.client_info),
+            std::move(header)
+        );
         Batch & batch = header_to_batch.try_emplace(batch_header, *this, files).first->second;
 
         batch.file_indices.push_back(file_idx);
diff --git a/src/Storages/Distributed/DistributedBlockOutputStream.cpp b/src/Storages/Distributed/DistributedBlockOutputStream.cpp
index f8ba4221842..d05fbae60d9 100644
--- a/src/Storages/Distributed/DistributedBlockOutputStream.cpp
+++ b/src/Storages/Distributed/DistributedBlockOutputStream.cpp
@@ -58,6 +58,7 @@ namespace ErrorCodes
 {
     extern const int LOGICAL_ERROR;
     extern const int TIMEOUT_EXCEEDED;
+    extern const int TOO_LARGE_DISTRIBUTED_DEPTH;
 }
 
 static Block adoptBlock(const Block & header, const Block & block, Poco::Logger * log)
@@ -86,14 +87,14 @@ static void writeBlockConvert(const BlockOutputStreamPtr & out, const Block & bl
 
 
 DistributedBlockOutputStream::DistributedBlockOutputStream(
-    const Context & context_,
+    ContextPtr context_,
     StorageDistributed & storage_,
     const StorageMetadataPtr & metadata_snapshot_,
     const ASTPtr & query_ast_,
     const ClusterPtr & cluster_,
     bool insert_sync_,
     UInt64 insert_timeout_)
-    : context(context_)
+    : context(Context::createCopy(context_))
     , storage(storage_)
     , metadata_snapshot(metadata_snapshot_)
     , query_ast(query_ast_)
@@ -103,6 +104,10 @@ DistributedBlockOutputStream::DistributedBlockOutputStream(
     , insert_timeout(insert_timeout_)
     , log(&Poco::Logger::get("DistributedBlockOutputStream"))
 {
+    const auto & settings = context->getSettingsRef();
+    if (settings.max_distributed_depth && context->getClientInfo().distributed_depth > settings.max_distributed_depth)
+        throw Exception("Maximum distributed depth exceeded", ErrorCodes::TOO_LARGE_DISTRIBUTED_DEPTH);
+    context->getClientInfo().distributed_depth += 1;
 }
 
 
@@ -143,7 +148,7 @@ void DistributedBlockOutputStream::write(const Block & block)
 
 void DistributedBlockOutputStream::writeAsync(const Block & block)
 {
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
     bool random_shard_insert = settings.insert_distributed_one_random_shard && !storage.has_sharding_key;
 
     if (random_shard_insert)
@@ -194,7 +199,7 @@ std::string DistributedBlockOutputStream::getCurrentStateDescription()
 
 void DistributedBlockOutputStream::initWritingJobs(const Block & first_block, size_t start, size_t end)
 {
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
     const auto & addresses_with_failovers = cluster->getShardsAddresses();
     const auto & shards_info = cluster->getShardsInfo();
     size_t num_shards = end - start;
@@ -303,7 +308,7 @@ DistributedBlockOutputStream::runWritingJob(DistributedBlockOutputStream::JobRep
         }
 
         const Block & shard_block = (num_shards > 1) ? job.current_shard_block : current_block;
-        const Settings & settings = context.getSettingsRef();
+        const Settings & settings = context->getSettingsRef();
 
         /// Do not initiate INSERT for empty block.
         if (shard_block.rows() == 0)
@@ -343,7 +348,8 @@ DistributedBlockOutputStream::runWritingJob(DistributedBlockOutputStream::JobRep
                 if (throttler)
                     job.connection_entry->setThrottler(throttler);
 
-                job.stream = std::make_shared<RemoteBlockOutputStream>(*job.connection_entry, timeouts, query_string, settings, context.getClientInfo());
+                job.stream = std::make_shared<RemoteBlockOutputStream>(
+                    *job.connection_entry, timeouts, query_string, settings, context->getClientInfo());
                 job.stream->writePrefix();
             }
 
@@ -357,7 +363,7 @@ DistributedBlockOutputStream::runWritingJob(DistributedBlockOutputStream::JobRep
             if (!job.stream)
             {
                 /// Forward user settings
-                job.local_context = std::make_unique<Context>(context);
+                job.local_context = Context::createCopy(context);
 
                 /// Copying of the query AST is required to avoid race,
                 /// in case of INSERT into multiple local shards.
@@ -367,7 +373,7 @@ DistributedBlockOutputStream::runWritingJob(DistributedBlockOutputStream::JobRep
                 /// to resolve tables (in InterpreterInsertQuery::getTable())
                 auto copy_query_ast = query_ast->clone();
 
-                InterpreterInsertQuery interp(copy_query_ast, *job.local_context);
+                InterpreterInsertQuery interp(copy_query_ast, job.local_context);
                 auto block_io = interp.execute();
 
                 job.stream = block_io.out;
@@ -385,7 +391,7 @@ DistributedBlockOutputStream::runWritingJob(DistributedBlockOutputStream::JobRep
 
 void DistributedBlockOutputStream::writeSync(const Block & block)
 {
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
     const auto & shards_info = cluster->getShardsInfo();
     bool random_shard_insert = settings.insert_distributed_one_random_shard && !storage.has_sharding_key;
     size_t start = 0;
@@ -562,7 +568,7 @@ void DistributedBlockOutputStream::writeSplitAsync(const Block & block)
 void DistributedBlockOutputStream::writeAsyncImpl(const Block & block, size_t shard_id)
 {
     const auto & shard_info = cluster->getShardsInfo()[shard_id];
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = context->getSettingsRef();
 
     if (shard_info.hasInternalReplication())
     {
@@ -610,7 +616,7 @@ void DistributedBlockOutputStream::writeToLocal(const Block & block, size_t repe
 
 void DistributedBlockOutputStream::writeToShard(const Block & block, const std::vector<std::string> & dir_names)
 {
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = context->getSettingsRef();
     const auto & distributed_settings = storage.getDistributedSettingsRef();
 
     bool fsync = distributed_settings.fsync_after_insert;
@@ -675,11 +681,17 @@ void DistributedBlockOutputStream::writeToShard(const Block & block, const std::
             WriteBufferFromOwnString header_buf;
             writeVarUInt(DBMS_TCP_PROTOCOL_VERSION, header_buf);
             writeStringBinary(query_string, header_buf);
-            context.getSettingsRef().write(header_buf);
-            context.getClientInfo().write(header_buf, DBMS_TCP_PROTOCOL_VERSION);
+            context->getSettingsRef().write(header_buf);
+            context->getClientInfo().write(header_buf, DBMS_TCP_PROTOCOL_VERSION);
             writeVarUInt(block.rows(), header_buf);
             writeVarUInt(block.bytes(), header_buf);
-            writeStringBinary(block.cloneEmpty().dumpStructure(), header_buf);
+            writeStringBinary(block.cloneEmpty().dumpStructure(), header_buf); /// obsolete
+            /// Write block header separately in the batch header.
+            /// It is required for checking does conversion is required or not.
+            {
+                NativeBlockOutputStream header_stream{header_buf, DBMS_TCP_PROTOCOL_VERSION, block.cloneEmpty()};
+                header_stream.write(block.cloneEmpty());
+            }
 
             /// Add new fields here, for example:
             /// writeVarUInt(my_new_data, header_buf);
@@ -724,7 +736,7 @@ void DistributedBlockOutputStream::writeToShard(const Block & block, const std::
     Poco::File(first_file_tmp_path).remove();
 
     /// Notify
-    auto sleep_ms = context.getSettingsRef().distributed_directory_monitor_sleep_time_ms;
+    auto sleep_ms = context->getSettingsRef().distributed_directory_monitor_sleep_time_ms;
     for (const auto & dir_name : dir_names)
     {
         auto & directory_monitor = storage.requireDirectoryMonitor(disk, dir_name);
@@ -732,5 +744,4 @@ void DistributedBlockOutputStream::writeToShard(const Block & block, const std::
     }
 }
 
-
 }
diff --git a/src/Storages/Distributed/DistributedBlockOutputStream.h b/src/Storages/Distributed/DistributedBlockOutputStream.h
index ca57ad46fbb..a9425a98ebf 100644
--- a/src/Storages/Distributed/DistributedBlockOutputStream.h
+++ b/src/Storages/Distributed/DistributedBlockOutputStream.h
@@ -38,7 +38,7 @@ class DistributedBlockOutputStream : public IBlockOutputStream
 {
 public:
     DistributedBlockOutputStream(
-        const Context & context_,
+        ContextPtr context_,
         StorageDistributed & storage_,
         const StorageMetadataPtr & metadata_snapshot_,
         const ASTPtr & query_ast_,
@@ -83,8 +83,7 @@ private:
     /// Returns the number of blocks was written for each cluster node. Uses during exception handling.
     std::string getCurrentStateDescription();
 
-private:
-    const Context & context;
+    ContextPtr context;
     StorageDistributed & storage;
     StorageMetadataPtr metadata_snapshot;
     ASTPtr query_ast;
@@ -115,7 +114,7 @@ private:
         Block current_shard_block;
 
         ConnectionPool::Entry connection_entry;
-        std::unique_ptr<Context> local_context;
+        ContextPtr local_context;
         BlockOutputStreamPtr stream;
 
         UInt64 blocks_written = 0;
diff --git a/src/Storages/HDFS/StorageHDFS.cpp b/src/Storages/HDFS/StorageHDFS.cpp
index e26d3375c33..392495ff77f 100644
--- a/src/Storages/HDFS/StorageHDFS.cpp
+++ b/src/Storages/HDFS/StorageHDFS.cpp
@@ -40,15 +40,15 @@ StorageHDFS::StorageHDFS(const String & uri_,
     const String & format_name_,
     const ColumnsDescription & columns_,
     const ConstraintsDescription & constraints_,
-    Context & context_,
+    ContextPtr context_,
     const String & compression_method_ = "")
     : IStorage(table_id_)
+    , WithContext(context_)
     , uri(uri_)
     , format_name(format_name_)
-    , context(context_)
     , compression_method(compression_method_)
 {
-    context.getRemoteHostFilter().checkURL(Poco::URI(uri));
+    context_->getRemoteHostFilter().checkURL(Poco::URI(uri));
 
     StorageInMemoryMetadata storage_metadata;
     storage_metadata.setColumns(columns_);
@@ -59,7 +59,7 @@ StorageHDFS::StorageHDFS(const String & uri_,
 namespace
 {
 
-class HDFSSource : public SourceWithProgress
+class HDFSSource : public SourceWithProgress, WithContext
 {
 public:
     struct SourcesInfo
@@ -90,16 +90,16 @@ public:
         String format_,
         String compression_method_,
         Block sample_block_,
-        const Context & context_,
+        ContextPtr context_,
         UInt64 max_block_size_)
         : SourceWithProgress(getHeader(sample_block_, source_info_->need_path_column, source_info_->need_file_column))
+        , WithContext(context_)
         , source_info(std::move(source_info_))
         , uri(std::move(uri_))
         , format(std::move(format_))
         , compression_method(compression_method_)
         , max_block_size(max_block_size_)
         , sample_block(std::move(sample_block_))
-        , context(context_)
     {
     }
 
@@ -122,8 +122,8 @@ public:
                 current_path = uri + path;
 
                 auto compression = chooseCompressionMethod(path, compression_method);
-                auto read_buf = wrapReadBufferWithCompressionMethod(std::make_unique<ReadBufferFromHDFS>(current_path, context.getGlobalContext().getConfigRef()), compression);
-                auto input_format = FormatFactory::instance().getInput(format, *read_buf, sample_block, context, max_block_size);
+                auto read_buf = wrapReadBufferWithCompressionMethod(std::make_unique<ReadBufferFromHDFS>(current_path, getContext()->getGlobalContext()->getConfigRef()), compression);
+                auto input_format = FormatFactory::instance().getInput(format, *read_buf, sample_block, getContext(), max_block_size);
                 auto input_stream = std::make_shared<InputStreamFromInputFormat>(input_format);
 
                 reader = std::make_shared<OwningBlockInputStream<ReadBuffer>>(input_stream, std::move(read_buf));
@@ -169,7 +169,6 @@ private:
 
     UInt64 max_block_size;
     Block sample_block;
-    const Context & context;
 };
 
 class HDFSBlockOutputStream : public IBlockOutputStream
@@ -178,11 +177,11 @@ public:
     HDFSBlockOutputStream(const String & uri,
         const String & format,
         const Block & sample_block_,
-        const Context & context,
+        ContextPtr context,
         const CompressionMethod compression_method)
         : sample_block(sample_block_)
     {
-        write_buf = wrapWriteBufferWithCompressionMethod(std::make_unique<WriteBufferFromHDFS>(uri, context.getGlobalContext().getConfigRef()), compression_method, 3);
+        write_buf = wrapWriteBufferWithCompressionMethod(std::make_unique<WriteBufferFromHDFS>(uri, context->getGlobalContext()->getConfigRef()), compression_method, 3);
         writer = FormatFactory::instance().getOutputStreamParallelIfPossible(format, *write_buf, sample_block, context);
     }
 
@@ -267,7 +266,7 @@ Pipe StorageHDFS::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & context_,
+    ContextPtr context_,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size,
     unsigned num_streams)
@@ -276,7 +275,7 @@ Pipe StorageHDFS::read(
     const String path_from_uri = uri.substr(begin_of_path);
     const String uri_without_path = uri.substr(0, begin_of_path);
 
-    HDFSBuilderWrapper builder = createHDFSBuilder(uri_without_path + "/", context_.getGlobalContext().getConfigRef());
+    HDFSBuilderWrapper builder = createHDFSBuilder(uri_without_path + "/", context_->getGlobalContext()->getConfigRef());
     HDFSFSPtr fs = createHDFSFS(builder.get());
 
     auto sources_info = std::make_shared<HDFSSource::SourcesInfo>();
@@ -302,12 +301,12 @@ Pipe StorageHDFS::read(
     return Pipe::unitePipes(std::move(pipes));
 }
 
-BlockOutputStreamPtr StorageHDFS::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & /*context*/)
+BlockOutputStreamPtr StorageHDFS::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr /*context*/)
 {
     return std::make_shared<HDFSBlockOutputStream>(uri,
         format_name,
         metadata_snapshot->getSampleBlock(),
-        context,
+        getContext(),
         chooseCompressionMethod(uri, compression_method));
 }
 
@@ -321,22 +320,22 @@ void registerStorageHDFS(StorageFactory & factory)
             throw Exception(
                 "Storage HDFS requires 2 or 3 arguments: url, name of used format and optional compression method.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        engine_args[0] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[0], args.local_context);
+        engine_args[0] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[0], args.getLocalContext());
 
         String url = engine_args[0]->as<ASTLiteral &>().value.safeGet<String>();
 
-        engine_args[1] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[1], args.local_context);
+        engine_args[1] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[1], args.getLocalContext());
 
         String format_name = engine_args[1]->as<ASTLiteral &>().value.safeGet<String>();
 
         String compression_method;
         if (engine_args.size() == 3)
         {
-            engine_args[2] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[2], args.local_context);
+            engine_args[2] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[2], args.getLocalContext());
             compression_method = engine_args[2]->as<ASTLiteral &>().value.safeGet<String>();
         } else compression_method = "auto";
 
-        return StorageHDFS::create(url, args.table_id, format_name, args.columns, args.constraints, args.context, compression_method);
+        return StorageHDFS::create(url, args.table_id, format_name, args.columns, args.constraints, args.getContext(), compression_method);
     },
     {
         .source_access_type = AccessType::HDFS,
diff --git a/src/Storages/HDFS/StorageHDFS.h b/src/Storages/HDFS/StorageHDFS.h
index 4172bce1cd1..0dd57685354 100644
--- a/src/Storages/HDFS/StorageHDFS.h
+++ b/src/Storages/HDFS/StorageHDFS.h
@@ -13,7 +13,7 @@ namespace DB
  * This class represents table engine for external hdfs files.
  * Read method is supported for now.
  */
-class StorageHDFS final : public ext::shared_ptr_helper<StorageHDFS>, public IStorage
+class StorageHDFS final : public ext::shared_ptr_helper<StorageHDFS>, public IStorage, WithContext
 {
     friend struct ext::shared_ptr_helper<StorageHDFS>;
 public:
@@ -23,12 +23,12 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     NamesAndTypesList getVirtuals() const override;
 
@@ -38,13 +38,12 @@ protected:
         const String & format_name_,
         const ColumnsDescription & columns_,
         const ConstraintsDescription & constraints_,
-        Context & context_,
+        ContextPtr context_,
         const String & compression_method_);
 
 private:
     String uri;
     String format_name;
-    Context & context;
     String compression_method;
 
     Poco::Logger * log = &Poco::Logger::get("StorageHDFS");
diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp
index 39f6d1f632e..f7fb359432e 100644
--- a/src/Storages/IStorage.cpp
+++ b/src/Storages/IStorage.cpp
@@ -84,7 +84,7 @@ Pipe IStorage::read(
     const Names & /*column_names*/,
     const StorageMetadataPtr & /*metadata_snapshot*/,
     SelectQueryInfo & /*query_info*/,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t /*max_block_size*/,
     unsigned /*num_streams*/)
@@ -97,7 +97,7 @@ void IStorage::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum processed_stage,
     size_t max_block_size,
     unsigned num_streams)
@@ -116,12 +116,12 @@ void IStorage::read(
 }
 
 Pipe IStorage::alterPartition(
-    const StorageMetadataPtr & /* metadata_snapshot */, const PartitionCommands & /* commands */, const Context & /* context */)
+    const StorageMetadataPtr & /* metadata_snapshot */, const PartitionCommands & /* commands */, ContextPtr /* context */)
 {
     throw Exception("Partition operations are not supported by storage " + getName(), ErrorCodes::NOT_IMPLEMENTED);
 }
 
-void IStorage::alter(const AlterCommands & params, const Context & context, TableLockHolder &)
+void IStorage::alter(const AlterCommands & params, ContextPtr context, TableLockHolder &)
 {
     auto table_id = getStorageID();
     StorageInMemoryMetadata new_metadata = getInMemoryMetadata();
@@ -131,7 +131,7 @@ void IStorage::alter(const AlterCommands & params, const Context & context, Tabl
 }
 
 
-void IStorage::checkAlterIsPossible(const AlterCommands & commands, const Context & /* context */) const
+void IStorage::checkAlterIsPossible(const AlterCommands & commands, ContextPtr /* context */) const
 {
     for (const auto & command : commands)
     {
@@ -179,7 +179,7 @@ Names IStorage::getAllRegisteredNames() const
     return result;
 }
 
-NameDependencies IStorage::getDependentViewsByColumn(const Context & context) const
+NameDependencies IStorage::getDependentViewsByColumn(ContextPtr context) const
 {
     NameDependencies name_deps;
     auto dependencies = DatabaseCatalog::instance().getDependencies(storage_id);
diff --git a/src/Storages/IStorage.h b/src/Storages/IStorage.h
index 4dfd2ca50f3..e48e9e49919 100644
--- a/src/Storages/IStorage.h
+++ b/src/Storages/IStorage.h
@@ -5,13 +5,15 @@
 #include <DataStreams/IBlockStream_fwd.h>
 #include <Databases/IDatabase.h>
 #include <Interpreters/CancellationCode.h>
-#include <Storages/IStorage_fwd.h>
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/StorageID.h>
-#include <Storages/TableLockHolder.h>
+#include <Processors/QueryPipeline.h>
 #include <Storages/CheckResults.h>
-#include <Storages/StorageInMemoryMetadata.h>
 #include <Storages/ColumnDependency.h>
+#include <Storages/IStorage_fwd.h>
 #include <Storages/SelectQueryDescription.h>
+#include <Storages/StorageInMemoryMetadata.h>
+#include <Storages/TableLockHolder.h>
 #include <Common/ActionLock.h>
 #include <Common/Exception.h>
 #include <Common/RWLock.h>
@@ -29,11 +31,10 @@ namespace ErrorCodes
     extern const int NOT_IMPLEMENTED;
 }
 
-class Context;
-
 using StorageActionBlockType = size_t;
 
 class ASTCreateQuery;
+class ASTInsertQuery;
 
 struct Settings;
 
@@ -50,6 +51,9 @@ class Pipe;
 class QueryPlan;
 using QueryPlanPtr = std::unique_ptr<QueryPlan>;
 
+class QueryPipeline;
+using QueryPipelinePtr = std::unique_ptr<QueryPipeline>;
+
 class IStoragePolicy;
 using StoragePolicyPtr = std::shared_ptr<const IStoragePolicy>;
 
@@ -176,7 +180,7 @@ public:
 
     Names getAllRegisteredNames() const override;
 
-    NameDependencies getDependentViewsByColumn(const Context & context) const;
+    NameDependencies getDependentViewsByColumn(ContextPtr context) const;
 
 protected:
     /// Returns whether the column is virtual - by default all columns are real.
@@ -226,7 +230,7 @@ public:
       * QueryProcessingStage::Enum required for Distributed over Distributed,
       * since it cannot return Complete for intermediate queries never.
       */
-    virtual QueryProcessingStage::Enum getQueryProcessingStage(const Context &, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const
+    virtual QueryProcessingStage::Enum getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const
     {
         return QueryProcessingStage::FetchColumns;
     }
@@ -253,7 +257,7 @@ public:
     virtual BlockInputStreams watch(
         const Names & /*column_names*/,
         const SelectQueryInfo & /*query_info*/,
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         QueryProcessingStage::Enum & /*processed_stage*/,
         size_t /*max_block_size*/,
         unsigned /*num_streams*/)
@@ -285,7 +289,7 @@ public:
         const Names & /*column_names*/,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & /*query_info*/,
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         QueryProcessingStage::Enum /*processed_stage*/,
         size_t /*max_block_size*/,
         unsigned /*num_streams*/);
@@ -297,7 +301,7 @@ public:
         const Names & /*column_names*/,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & /*query_info*/,
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         QueryProcessingStage::Enum /*processed_stage*/,
         size_t /*max_block_size*/,
         unsigned /*num_streams*/);
@@ -314,11 +318,24 @@ public:
     virtual BlockOutputStreamPtr write(
         const ASTPtr & /*query*/,
         const StorageMetadataPtr & /*metadata_snapshot*/,
-        const Context & /*context*/)
+        ContextPtr /*context*/)
     {
         throw Exception("Method write is not supported by storage " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
+    /** Writes the data to a table in distributed manner.
+      * It is supposed that implementation looks into SELECT part of the query and executes distributed
+      * INSERT SELECT if it is possible with current storage as a receiver and query SELECT part as a producer.
+      *
+      * Returns query pipeline if distributed writing is possible, and nullptr otherwise.
+      */
+    virtual QueryPipelinePtr distributedWrite(
+        const ASTInsertQuery & /*query*/,
+        ContextPtr /*context*/)
+    {
+        return nullptr;
+    }
+
     /** Delete the table data. Called before deleting the directory with the data.
       * The method can be called only after detaching table from Context (when no queries are performed with table).
       * The table is not usable during and after call to this method.
@@ -333,7 +350,7 @@ public:
     virtual void truncate(
         const ASTPtr & /*query*/,
         const StorageMetadataPtr & /* metadata_snapshot */,
-        const Context & /* context */,
+        ContextPtr /* context */,
         TableExclusiveLockHolder &)
     {
         throw Exception("Truncate is not supported by storage " + getName(), ErrorCodes::NOT_IMPLEMENTED);
@@ -361,12 +378,12 @@ public:
     /** ALTER tables in the form of column changes that do not affect the change
       * to Storage or its parameters. Executes under alter lock (lockForAlter).
       */
-    virtual void alter(const AlterCommands & params, const Context & context, TableLockHolder & alter_lock_holder);
+    virtual void alter(const AlterCommands & params, ContextPtr context, TableLockHolder & alter_lock_holder);
 
     /** Checks that alter commands can be applied to storage. For example, columns can be modified,
       * or primary key can be changes, etc.
       */
-    virtual void checkAlterIsPossible(const AlterCommands & commands, const Context & context) const;
+    virtual void checkAlterIsPossible(const AlterCommands & commands, ContextPtr context) const;
 
     /**
       * Checks that mutation commands can be applied to storage.
@@ -379,7 +396,7 @@ public:
     virtual Pipe alterPartition(
         const StorageMetadataPtr & /* metadata_snapshot */,
         const PartitionCommands & /* commands */,
-        const Context & /* context */);
+        ContextPtr /* context */);
 
     /// Checks that partition commands can be applied to storage.
     virtual void checkAlterPartitionIsPossible(const PartitionCommands & commands, const StorageMetadataPtr & metadata_snapshot, const Settings & settings) const;
@@ -394,13 +411,13 @@ public:
         bool /*final*/,
         bool /*deduplicate*/,
         const Names & /* deduplicate_by_columns */,
-        const Context & /*context*/)
+        ContextPtr /*context*/)
     {
         throw Exception("Method optimize is not supported by storage " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
     /// Mutate the table contents
-    virtual void mutate(const MutationCommands &, const Context &)
+    virtual void mutate(const MutationCommands &, ContextPtr)
     {
         throw Exception("Mutations are not supported by storage " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
@@ -444,10 +461,10 @@ public:
     virtual bool supportsIndexForIn() const { return false; }
 
     /// Provides a hint that the storage engine may evaluate the IN-condition by using an index.
-    virtual bool mayBenefitFromIndexForIn(const ASTPtr & /* left_in_operand */, const Context & /* query_context */, const StorageMetadataPtr & /* metadata_snapshot */) const { return false; }
+    virtual bool mayBenefitFromIndexForIn(const ASTPtr & /* left_in_operand */, ContextPtr /* query_context */, const StorageMetadataPtr & /* metadata_snapshot */) const { return false; }
 
     /// Checks validity of the data
-    virtual CheckResults checkData(const ASTPtr & /* query */, const Context & /* context */) { throw Exception("Check query is not supported for " + getName() + " storage", ErrorCodes::NOT_IMPLEMENTED); }
+    virtual CheckResults checkData(const ASTPtr & /* query */, ContextPtr /* context */) { throw Exception("Check query is not supported for " + getName() + " storage", ErrorCodes::NOT_IMPLEMENTED); }
 
     /// Checks that table could be dropped right now
     /// Otherwise - throws an exception with detailed information.
@@ -480,7 +497,7 @@ public:
     virtual std::optional<UInt64> totalRows(const Settings &) const { return {}; }
 
     /// Same as above but also take partition predicate into account.
-    virtual std::optional<UInt64> totalRowsByPartitionPredicate(const SelectQueryInfo &, const Context &) const { return {}; }
+    virtual std::optional<UInt64> totalRowsByPartitionPredicate(const SelectQueryInfo &, ContextPtr) const { return {}; }
 
     /// If it is possible to quickly determine exact number of bytes for the table on storage:
     /// - memory (approximated, resident)
diff --git a/src/Storages/IndicesDescription.cpp b/src/Storages/IndicesDescription.cpp
index dbc95615383..3147ad70696 100644
--- a/src/Storages/IndicesDescription.cpp
+++ b/src/Storages/IndicesDescription.cpp
@@ -67,7 +67,7 @@ IndexDescription & IndexDescription::operator=(const IndexDescription & other)
     return *this;
 }
 
-IndexDescription IndexDescription::getIndexFromAST(const ASTPtr & definition_ast, const ColumnsDescription & columns, const Context & context)
+IndexDescription IndexDescription::getIndexFromAST(const ASTPtr & definition_ast, const ColumnsDescription & columns, ContextPtr context)
 {
     const auto * index_definition = definition_ast->as<ASTIndexDeclaration>();
     if (!index_definition)
@@ -118,7 +118,7 @@ IndexDescription IndexDescription::getIndexFromAST(const ASTPtr & definition_ast
     return result;
 }
 
-void IndexDescription::recalculateWithNewColumns(const ColumnsDescription & new_columns, const Context & context)
+void IndexDescription::recalculateWithNewColumns(const ColumnsDescription & new_columns, ContextPtr context)
 {
     *this = getIndexFromAST(definition_ast, new_columns, context);
 }
@@ -144,7 +144,7 @@ String IndicesDescription::toString() const
 }
 
 
-IndicesDescription IndicesDescription::parse(const String & str, const ColumnsDescription & columns, const Context & context)
+IndicesDescription IndicesDescription::parse(const String & str, const ColumnsDescription & columns, ContextPtr context)
 {
     IndicesDescription result;
     if (str.empty())
@@ -160,7 +160,7 @@ IndicesDescription IndicesDescription::parse(const String & str, const ColumnsDe
 }
 
 
-ExpressionActionsPtr IndicesDescription::getSingleExpressionForIndices(const ColumnsDescription & columns, const Context & context) const
+ExpressionActionsPtr IndicesDescription::getSingleExpressionForIndices(const ColumnsDescription & columns, ContextPtr context) const
 {
     ASTPtr combined_expr_list = std::make_shared<ASTExpressionList>();
     for (const auto & index : *this)
diff --git a/src/Storages/IndicesDescription.h b/src/Storages/IndicesDescription.h
index f383029837e..d9c7efdb75c 100644
--- a/src/Storages/IndicesDescription.h
+++ b/src/Storages/IndicesDescription.h
@@ -46,7 +46,7 @@ struct IndexDescription
     size_t granularity;
 
     /// Parse index from definition AST
-    static IndexDescription getIndexFromAST(const ASTPtr & definition_ast, const ColumnsDescription & columns, const Context & context);
+    static IndexDescription getIndexFromAST(const ASTPtr & definition_ast, const ColumnsDescription & columns, ContextPtr context);
 
     IndexDescription() = default;
 
@@ -57,7 +57,7 @@ struct IndexDescription
 
     /// Recalculate index with new columns because index expression may change
     /// if something change in columns.
-    void recalculateWithNewColumns(const ColumnsDescription & new_columns, const Context & context);
+    void recalculateWithNewColumns(const ColumnsDescription & new_columns, ContextPtr context);
 };
 
 /// All secondary indices in storage
@@ -68,10 +68,10 @@ struct IndicesDescription : public std::vector<IndexDescription>
     /// Convert description to string
     String toString() const;
     /// Parse description from string
-    static IndicesDescription parse(const String & str, const ColumnsDescription & columns, const Context & context);
+    static IndicesDescription parse(const String & str, const ColumnsDescription & columns, ContextPtr context);
 
     /// Return common expression for all stored indices
-    ExpressionActionsPtr getSingleExpressionForIndices(const ColumnsDescription & columns, const Context & context) const;
+    ExpressionActionsPtr getSingleExpressionForIndices(const ColumnsDescription & columns, ContextPtr context) const;
 };
 
 }
diff --git a/src/Storages/Kafka/KafkaBlockInputStream.cpp b/src/Storages/Kafka/KafkaBlockInputStream.cpp
index bf985902b4d..5d9b19b1972 100644
--- a/src/Storages/Kafka/KafkaBlockInputStream.cpp
+++ b/src/Storages/Kafka/KafkaBlockInputStream.cpp
@@ -35,8 +35,8 @@ KafkaBlockInputStream::KafkaBlockInputStream(
     , max_block_size(max_block_size_)
     , commit_in_suffix(commit_in_suffix_)
     , non_virtual_header(metadata_snapshot->getSampleBlockNonMaterialized())
-    , virtual_header(metadata_snapshot->getSampleBlockForColumns(
-            {"_topic", "_key", "_offset", "_partition", "_timestamp", "_timestamp_ms", "_headers.name", "_headers.value"}, storage.getVirtuals(), storage.getStorageID()))
+    , virtual_header(metadata_snapshot->getSampleBlockForColumns(storage.getVirtualColumnNames(), storage.getVirtuals(), storage.getStorageID()))
+    , handle_error_mode(storage.getHandleKafkaErrorMode())
 {
 }
 
@@ -78,21 +78,22 @@ Block KafkaBlockInputStream::readImpl()
     // now it's one-time usage InputStream
     // one block of the needed size (or with desired flush timeout) is formed in one internal iteration
     // otherwise external iteration will reuse that and logic will became even more fuzzy
-
     MutableColumns result_columns  = non_virtual_header.cloneEmptyColumns();
     MutableColumns virtual_columns = virtual_header.cloneEmptyColumns();
 
+    auto put_error_to_stream = handle_error_mode == HandleKafkaErrorMode::STREAM;
+
     auto input_format = FormatFactory::instance().getInputFormat(
-        storage.getFormatName(), *buffer, non_virtual_header, *context, max_block_size);
+        storage.getFormatName(), *buffer, non_virtual_header, context, max_block_size);
 
     InputPort port(input_format->getPort().getHeader(), input_format.get());
     connect(input_format->getPort(), port);
     port.setNeeded();
 
+    std::optional<std::string> exception_message;
     auto read_kafka_message = [&]
     {
         size_t new_rows = 0;
-
         while (true)
         {
             auto status = input_format->prepare();
@@ -136,7 +137,41 @@ Block KafkaBlockInputStream::readImpl()
 
     while (true)
     {
-        auto new_rows = buffer->poll() ? read_kafka_message() : 0;
+        size_t new_rows = 0;
+        exception_message.reset();
+        if (buffer->poll())
+        {
+            try
+            {
+                new_rows = read_kafka_message();
+            }
+            catch (Exception & e)
+            {
+                if (put_error_to_stream)
+                {
+                    input_format->resetParser();
+                    exception_message = e.message();
+                    for (auto & column : result_columns)
+                    {
+                        // read_kafka_message could already push some rows to result_columns
+                        // before exception, we need to fix it.
+                        auto cur_rows = column->size();
+                        if (cur_rows > total_rows)
+                        {
+                            column->popBack(cur_rows - total_rows);
+                        }
+                        // all data columns will get default value in case of error
+                        column->insertDefault();
+                    }
+                    new_rows = 1;
+                }
+                else
+                {
+                    e.addMessage("while parsing Kafka message (topic: {}, partition: {}, offset: {})'", buffer->currentTopic(), buffer->currentPartition(), buffer->currentOffset());
+                    throw;
+                }
+            }
+        }
 
         if (new_rows)
         {
@@ -189,6 +224,20 @@ Block KafkaBlockInputStream::readImpl()
                 }
                 virtual_columns[6]->insert(headers_names);
                 virtual_columns[7]->insert(headers_values);
+                if (put_error_to_stream)
+                {
+                    if (exception_message)
+                    {
+                        auto payload = buffer->currentPayload();
+                        virtual_columns[8]->insert(payload);
+                        virtual_columns[9]->insert(*exception_message);
+                    }
+                    else
+                    {
+                        virtual_columns[8]->insertDefault();
+                        virtual_columns[9]->insertDefault();
+                    }
+                }
             }
 
             total_rows = total_rows + new_rows;
diff --git a/src/Storages/Kafka/KafkaBlockInputStream.h b/src/Storages/Kafka/KafkaBlockInputStream.h
index 517df6ecaf7..98e4b8982e0 100644
--- a/src/Storages/Kafka/KafkaBlockInputStream.h
+++ b/src/Storages/Kafka/KafkaBlockInputStream.h
@@ -39,7 +39,7 @@ public:
 private:
     StorageKafka & storage;
     StorageMetadataPtr metadata_snapshot;
-    const std::shared_ptr<Context> context;
+    ContextPtr context;
     Names column_names;
     Poco::Logger * log;
     UInt64 max_block_size;
@@ -51,6 +51,7 @@ private:
 
     const Block non_virtual_header;
     const Block virtual_header;
+    const HandleKafkaErrorMode handle_error_mode;
 };
 
 }
diff --git a/src/Storages/Kafka/KafkaBlockOutputStream.cpp b/src/Storages/Kafka/KafkaBlockOutputStream.cpp
index 2cb0fd98c71..21de27708b4 100644
--- a/src/Storages/Kafka/KafkaBlockOutputStream.cpp
+++ b/src/Storages/Kafka/KafkaBlockOutputStream.cpp
@@ -9,7 +9,7 @@ namespace DB
 KafkaBlockOutputStream::KafkaBlockOutputStream(
     StorageKafka & storage_,
     const StorageMetadataPtr & metadata_snapshot_,
-    const std::shared_ptr<Context> & context_)
+    const ContextPtr & context_)
     : storage(storage_)
     , metadata_snapshot(metadata_snapshot_)
     , context(context_)
@@ -25,11 +25,11 @@ void KafkaBlockOutputStream::writePrefix()
 {
     buffer = storage.createWriteBuffer(getHeader());
 
-    auto format_settings = getFormatSettings(*context);
+    auto format_settings = getFormatSettings(context);
     format_settings.protobuf.allow_multiple_rows_without_delimiter = true;
 
     child = FormatFactory::instance().getOutputStream(storage.getFormatName(), *buffer,
-        getHeader(), *context,
+        getHeader(), context,
         [this](const Columns & columns, size_t row)
         {
             buffer->countRow(columns, row);
diff --git a/src/Storages/Kafka/KafkaSettings.h b/src/Storages/Kafka/KafkaSettings.h
index 1df10d16339..1010c486abb 100644
--- a/src/Storages/Kafka/KafkaSettings.h
+++ b/src/Storages/Kafka/KafkaSettings.h
@@ -29,7 +29,8 @@ class ASTStorage;
     M(Char, kafka_row_delimiter, '\0', "The character to be considered as a delimiter in Kafka message.", 0) \
     M(String, kafka_schema, "", "Schema identifier (used by schema-based formats) for Kafka engine", 0) \
     M(UInt64, kafka_skip_broken_messages, 0, "Skip at least this number of broken messages from Kafka topic per block", 0) \
-    M(Bool, kafka_thread_per_consumer, false, "Provide independent thread for each consumer", 0)
+    M(Bool, kafka_thread_per_consumer, false, "Provide independent thread for each consumer", 0) \
+    M(HandleKafkaErrorMode, kafka_handle_error_mode, HandleKafkaErrorMode::DEFAULT, "How to handle errors for Kafka engine. Passible values: default, stream.", 0) \
 
     /** TODO: */
     /* https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md */
diff --git a/src/Storages/Kafka/ReadBufferFromKafkaConsumer.h b/src/Storages/Kafka/ReadBufferFromKafkaConsumer.h
index 1d889655941..49d3df0e180 100644
--- a/src/Storages/Kafka/ReadBufferFromKafkaConsumer.h
+++ b/src/Storages/Kafka/ReadBufferFromKafkaConsumer.h
@@ -63,6 +63,7 @@ public:
     auto currentPartition() const { return current[-1].get_partition(); }
     auto currentTimestamp() const { return current[-1].get_timestamp(); }
     const auto & currentHeaderList() const { return current[-1].get_header_list(); }
+    String currentPayload() const { return current[-1].get_payload(); }
 
 private:
     using Messages = std::vector<cppkafka::Message>;
diff --git a/src/Storages/Kafka/StorageKafka.cpp b/src/Storages/Kafka/StorageKafka.cpp
index 45e4ec538a1..e2b5ce7c325 100644
--- a/src/Storages/Kafka/StorageKafka.cpp
+++ b/src/Storages/Kafka/StorageKafka.cpp
@@ -169,20 +169,19 @@ namespace
 }
 
 StorageKafka::StorageKafka(
-    const StorageID & table_id_,
-    const Context & context_,
-    const ColumnsDescription & columns_,
-    std::unique_ptr<KafkaSettings> kafka_settings_)
+    const StorageID & table_id_, ContextPtr context_, const ColumnsDescription & columns_, std::unique_ptr<KafkaSettings> kafka_settings_)
     : IStorage(table_id_)
-    , global_context(context_.getGlobalContext())
+    , WithContext(context_->getGlobalContext())
     , kafka_settings(std::move(kafka_settings_))
-    , topics(parseTopics(global_context.getMacros()->expand(kafka_settings->kafka_topic_list.value)))
-    , brokers(global_context.getMacros()->expand(kafka_settings->kafka_broker_list.value))
-    , group(global_context.getMacros()->expand(kafka_settings->kafka_group_name.value))
-    , client_id(kafka_settings->kafka_client_id.value.empty() ? getDefaultClientId(table_id_) : global_context.getMacros()->expand(kafka_settings->kafka_client_id.value))
-    , format_name(global_context.getMacros()->expand(kafka_settings->kafka_format.value))
+    , topics(parseTopics(getContext()->getMacros()->expand(kafka_settings->kafka_topic_list.value)))
+    , brokers(getContext()->getMacros()->expand(kafka_settings->kafka_broker_list.value))
+    , group(getContext()->getMacros()->expand(kafka_settings->kafka_group_name.value))
+    , client_id(
+          kafka_settings->kafka_client_id.value.empty() ? getDefaultClientId(table_id_)
+                                                        : getContext()->getMacros()->expand(kafka_settings->kafka_client_id.value))
+    , format_name(getContext()->getMacros()->expand(kafka_settings->kafka_format.value))
     , row_delimiter(kafka_settings->kafka_row_delimiter.value)
-    , schema_name(global_context.getMacros()->expand(kafka_settings->kafka_schema.value))
+    , schema_name(getContext()->getMacros()->expand(kafka_settings->kafka_schema.value))
     , num_consumers(kafka_settings->kafka_num_consumers.value)
     , log(&Poco::Logger::get("StorageKafka (" + table_id_.table_name + ")"))
     , semaphore(0, num_consumers)
@@ -190,13 +189,18 @@ StorageKafka::StorageKafka(
     , settings_adjustments(createSettingsAdjustments())
     , thread_per_consumer(kafka_settings->kafka_thread_per_consumer.value)
 {
+    if (kafka_settings->kafka_handle_error_mode == HandleKafkaErrorMode::STREAM)
+    {
+        kafka_settings->input_format_allow_errors_num = 0;
+        kafka_settings->input_format_allow_errors_ratio = 0;
+    }
     StorageInMemoryMetadata storage_metadata;
     storage_metadata.setColumns(columns_);
     setInMemoryMetadata(storage_metadata);
     auto task_count = thread_per_consumer ? num_consumers : 1;
     for (size_t i = 0; i < task_count; ++i)
     {
-        auto task = global_context.getMessageBrokerSchedulePool().createTask(log->name(), [this, i]{ threadFunc(i); });
+        auto task = getContext()->getMessageBrokerSchedulePool().createTask(log->name(), [this, i]{ threadFunc(i); });
         task->deactivate();
         tasks.emplace_back(std::make_shared<TaskContext>(std::move(task)));
     }
@@ -255,7 +259,7 @@ Pipe StorageKafka::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /* query_info */,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum /* processed_stage */,
     size_t /* max_block_size */,
     unsigned /* num_streams */)
@@ -266,7 +270,7 @@ Pipe StorageKafka::read(
     /// Always use all consumers at once, otherwise SELECT may not read messages from all partitions.
     Pipes pipes;
     pipes.reserve(num_created_consumers);
-    auto modified_context = std::make_shared<Context>(context);
+    auto modified_context = Context::createCopy(local_context);
     modified_context->applySettingsChanges(settings_adjustments);
 
     // Claim as many consumers as requested, but don't block
@@ -284,9 +288,9 @@ Pipe StorageKafka::read(
 }
 
 
-BlockOutputStreamPtr StorageKafka::write(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr StorageKafka::write(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr local_context)
 {
-    auto modified_context = std::make_shared<Context>(context);
+    auto modified_context = Context::createCopy(local_context);
     modified_context->applySettingsChanges(settings_adjustments);
 
     if (topics.size() > 1)
@@ -382,7 +386,7 @@ ProducerBufferPtr StorageKafka::createWriteBuffer(const Block & header)
     updateConfiguration(conf);
 
     auto producer = std::make_shared<cppkafka::Producer>(conf);
-    const Settings & settings = global_context.getSettingsRef();
+    const Settings & settings = getContext()->getSettingsRef();
     size_t poll_timeout = settings.stream_poll_timeout_ms.totalMilliseconds();
 
     return std::make_shared<WriteBufferToKafkaProducer>(
@@ -438,14 +442,14 @@ size_t StorageKafka::getMaxBlockSize() const
 {
     return kafka_settings->kafka_max_block_size.changed
         ? kafka_settings->kafka_max_block_size.value
-        : (global_context.getSettingsRef().max_insert_block_size.value / num_consumers);
+        : (getContext()->getSettingsRef().max_insert_block_size.value / num_consumers);
 }
 
 size_t StorageKafka::getPollMaxBatchSize() const
 {
     size_t batch_size = kafka_settings->kafka_poll_max_batch_size.changed
                         ? kafka_settings->kafka_poll_max_batch_size.value
-                        : global_context.getSettingsRef().max_block_size.value;
+                        : getContext()->getSettingsRef().max_block_size.value;
 
     return std::min(batch_size,getMaxBlockSize());
 }
@@ -454,13 +458,13 @@ size_t StorageKafka::getPollTimeoutMillisecond() const
 {
     return kafka_settings->kafka_poll_timeout_ms.changed
         ? kafka_settings->kafka_poll_timeout_ms.totalMilliseconds()
-        : global_context.getSettingsRef().stream_poll_timeout_ms.totalMilliseconds();
+        : getContext()->getSettingsRef().stream_poll_timeout_ms.totalMilliseconds();
 }
 
 void StorageKafka::updateConfiguration(cppkafka::Configuration & conf)
 {
     // Update consumer configuration from the configuration
-    const auto & config = global_context.getConfigRef();
+    const auto & config = getContext()->getConfigRef();
     if (config.has(CONFIG_PREFIX))
         loadFromConfig(conf, config, CONFIG_PREFIX);
 
@@ -512,7 +516,7 @@ bool StorageKafka::checkDependencies(const StorageID & table_id)
     // Check the dependencies are ready?
     for (const auto & db_tab : dependencies)
     {
-        auto table = DatabaseCatalog::instance().tryGetTable(db_tab, global_context);
+        auto table = DatabaseCatalog::instance().tryGetTable(db_tab, getContext());
         if (!table)
             return false;
 
@@ -582,7 +586,7 @@ void StorageKafka::threadFunc(size_t idx)
 bool StorageKafka::streamToViews()
 {
     auto table_id = getStorageID();
-    auto table = DatabaseCatalog::instance().getTable(table_id, global_context);
+    auto table = DatabaseCatalog::instance().getTable(table_id, getContext());
     if (!table)
         throw Exception("Engine table " + table_id.getNameForLogs() + " doesn't exist.", ErrorCodes::LOGICAL_ERROR);
     auto metadata_snapshot = getInMemoryMetadataPtr();
@@ -593,13 +597,13 @@ bool StorageKafka::streamToViews()
 
     size_t block_size = getMaxBlockSize();
 
-    auto kafka_context = std::make_shared<Context>(global_context);
+    auto kafka_context = Context::createCopy(getContext());
     kafka_context->makeQueryContext();
     kafka_context->applySettingsChanges(settings_adjustments);
 
     // Create a stream for each consumer and join them in a union stream
     // Only insert into dependent views and expect that input blocks contain virtual columns
-    InterpreterInsertQuery interpreter(insert, *kafka_context, false, true, true);
+    InterpreterInsertQuery interpreter(insert, kafka_context, false, true, true);
     auto block_io = interpreter.execute();
 
     // Create a stream for each consumer and join them in a union stream
@@ -617,7 +621,7 @@ bool StorageKafka::streamToViews()
 
         limits.speed_limits.max_execution_time = kafka_settings->kafka_flush_interval_ms.changed
                                                  ? kafka_settings->kafka_flush_interval_ms
-                                                 : global_context.getSettingsRef().stream_flush_interval_ms;
+                                                 : getContext()->getSettingsRef().stream_flush_interval_ms;
 
         limits.timeout_overflow_mode = OverflowMode::BREAK;
         stream->setLimits(limits);
@@ -690,14 +694,14 @@ void registerStorageKafka(StorageFactory & factory)
                         engine_args[(ARG_NUM)-1] =                          \
                             evaluateConstantExpressionAsLiteral(            \
                                 engine_args[(ARG_NUM)-1],                   \
-                                args.local_context);                        \
+                                args.getLocalContext());                    \
                     }                                                       \
                     if ((EVAL) == 2)                                        \
                     {                                                       \
                         engine_args[(ARG_NUM)-1] =                          \
                            evaluateConstantExpressionOrIdentifierAsLiteral( \
                                 engine_args[(ARG_NUM)-1],                   \
-                                args.local_context);                        \
+                                args.getLocalContext());                    \
                     }                                                       \
                     kafka_settings->PAR_NAME =                              \
                         engine_args[(ARG_NUM)-1]->as<ASTLiteral &>().value; \
@@ -752,7 +756,7 @@ void registerStorageKafka(StorageFactory & factory)
             throw Exception("kafka_poll_max_batch_size can not be lower than 1", ErrorCodes::BAD_ARGUMENTS);
         }
 
-        return StorageKafka::create(args.table_id, args.context, args.columns, std::move(kafka_settings));
+        return StorageKafka::create(args.table_id, args.getContext(), args.columns, std::move(kafka_settings));
     };
 
     factory.registerStorage("Kafka", creator_fn, StorageFactory::StorageFeatures{ .supports_settings = true, });
@@ -760,7 +764,7 @@ void registerStorageKafka(StorageFactory & factory)
 
 NamesAndTypesList StorageKafka::getVirtuals() const
 {
-    return NamesAndTypesList{
+    auto result = NamesAndTypesList{
         {"_topic", std::make_shared<DataTypeString>()},
         {"_key", std::make_shared<DataTypeString>()},
         {"_offset", std::make_shared<DataTypeUInt64>()},
@@ -770,6 +774,32 @@ NamesAndTypesList StorageKafka::getVirtuals() const
         {"_headers.name", std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>())},
         {"_headers.value", std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>())}
     };
+    if (kafka_settings->kafka_handle_error_mode == HandleKafkaErrorMode::STREAM)
+    {
+        result.push_back({"_raw_message", std::make_shared<DataTypeString>()});
+        result.push_back({"_error", std::make_shared<DataTypeString>()});
+    }
+    return result;
+}
+
+Names StorageKafka::getVirtualColumnNames() const
+{
+    auto result = Names {
+        "_topic",
+        "_key",
+        "_offset",
+        "_partition",
+        "_timestamp",
+        "_timestamp_ms",
+        "_headers.name",
+        "_headers.value",
+    };
+    if (kafka_settings->kafka_handle_error_mode == HandleKafkaErrorMode::STREAM)
+    {
+        result.push_back({"_raw_message"});
+        result.push_back({"_error"});
+    }
+    return result;
 }
 
 }
diff --git a/src/Storages/Kafka/StorageKafka.h b/src/Storages/Kafka/StorageKafka.h
index 53871990810..b09b2ecd39e 100644
--- a/src/Storages/Kafka/StorageKafka.h
+++ b/src/Storages/Kafka/StorageKafka.h
@@ -28,7 +28,7 @@ struct StorageKafkaInterceptors;
 /** Implements a Kafka queue table engine that can be used as a persistent queue / buffer,
   * or as a basic building block for creating pipelines with a continuous insertion / ETL.
   */
-class StorageKafka final : public ext::shared_ptr_helper<StorageKafka>, public IStorage
+class StorageKafka final : public ext::shared_ptr_helper<StorageKafka>, public IStorage, WithContext
 {
     friend struct ext::shared_ptr_helper<StorageKafka>;
     friend struct StorageKafkaInterceptors;
@@ -45,7 +45,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -53,7 +53,7 @@ public:
     BlockOutputStreamPtr write(
         const ASTPtr & query,
         const StorageMetadataPtr & /*metadata_snapshot*/,
-        const Context & context) override;
+        ContextPtr context) override;
 
     void pushReadBuffer(ConsumerBufferPtr buf);
     ConsumerBufferPtr popReadBuffer();
@@ -64,16 +64,17 @@ public:
     const auto & getFormatName() const { return format_name; }
 
     NamesAndTypesList getVirtuals() const override;
+    Names getVirtualColumnNames() const;
+    HandleKafkaErrorMode getHandleKafkaErrorMode() const { return kafka_settings->kafka_handle_error_mode; }
 protected:
     StorageKafka(
         const StorageID & table_id_,
-        const Context & context_,
+        ContextPtr context_,
         const ColumnsDescription & columns_,
         std::unique_ptr<KafkaSettings> kafka_settings_);
 
 private:
     // Configuration and state
-    const Context & global_context;
     std::unique_ptr<KafkaSettings> kafka_settings;
     const Names topics;
     const String brokers;
@@ -112,6 +113,9 @@ private:
     std::mutex thread_statuses_mutex;
     std::list<std::shared_ptr<ThreadStatus>> thread_statuses;
 
+    /// Handle error mode
+    HandleKafkaErrorMode handle_error_mode;
+
     SettingsChanges createSettingsAdjustments();
     ConsumerBufferPtr createReadBuffer(const size_t consumer_number);
 
diff --git a/src/Storages/KeyDescription.cpp b/src/Storages/KeyDescription.cpp
index ee4a20bfc4f..be327313b4d 100644
--- a/src/Storages/KeyDescription.cpp
+++ b/src/Storages/KeyDescription.cpp
@@ -66,14 +66,14 @@ KeyDescription & KeyDescription::operator=(const KeyDescription & other)
 void KeyDescription::recalculateWithNewAST(
     const ASTPtr & new_ast,
     const ColumnsDescription & columns,
-    const Context & context)
+    ContextPtr context)
 {
     *this = getSortingKeyFromAST(new_ast, columns, context, additional_column);
 }
 
 void KeyDescription::recalculateWithNewColumns(
     const ColumnsDescription & new_columns,
-    const Context & context)
+    ContextPtr context)
 {
     *this = getSortingKeyFromAST(definition_ast, new_columns, context, additional_column);
 }
@@ -81,7 +81,7 @@ void KeyDescription::recalculateWithNewColumns(
 KeyDescription KeyDescription::getKeyFromAST(
     const ASTPtr & definition_ast,
     const ColumnsDescription & columns,
-    const Context & context)
+    ContextPtr context)
 {
     return getSortingKeyFromAST(definition_ast, columns, context, {});
 }
@@ -89,7 +89,7 @@ KeyDescription KeyDescription::getKeyFromAST(
 KeyDescription KeyDescription::getSortingKeyFromAST(
     const ASTPtr & definition_ast,
     const ColumnsDescription & columns,
-    const Context & context,
+    ContextPtr context,
     const std::optional<String> & additional_column)
 {
     KeyDescription result;
diff --git a/src/Storages/KeyDescription.h b/src/Storages/KeyDescription.h
index 7d1e7efb55f..194aad4d5b2 100644
--- a/src/Storages/KeyDescription.h
+++ b/src/Storages/KeyDescription.h
@@ -40,28 +40,28 @@ struct KeyDescription
     static KeyDescription getKeyFromAST(
         const ASTPtr & definition_ast,
         const ColumnsDescription & columns,
-        const Context & context);
+        ContextPtr context);
 
     /// Sorting key can contain additional column defined by storage type (like
     /// Version column in VersionedCollapsingMergeTree).
     static KeyDescription getSortingKeyFromAST(
         const ASTPtr & definition_ast,
         const ColumnsDescription & columns,
-        const Context & context,
+        ContextPtr context,
         const std::optional<String> & additional_column);
 
     /// Recalculate all expressions and fields for key with new columns without
     /// changes in constant fields. Just wrapper for static methods.
     void recalculateWithNewColumns(
         const ColumnsDescription & new_columns,
-        const Context & context);
+        ContextPtr context);
 
     /// Recalculate all expressions and fields for key with new ast without
     /// changes in constant fields. Just wrapper for static methods.
     void recalculateWithNewAST(
         const ASTPtr & new_ast,
         const ColumnsDescription & columns,
-        const Context & context);
+        ContextPtr context);
 
     KeyDescription() = default;
 
diff --git a/src/Storages/LiveView/StorageBlocks.h b/src/Storages/LiveView/StorageBlocks.h
index 4ad0ffb93ca..f4ba8d7b09c 100644
--- a/src/Storages/LiveView/StorageBlocks.h
+++ b/src/Storages/LiveView/StorageBlocks.h
@@ -33,13 +33,13 @@ public:
     bool supportsSampling() const override { return true; }
     bool supportsFinal() const override { return true; }
 
-    QueryProcessingStage::Enum getQueryProcessingStage(const Context &, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const override { return to_stage; }
+    QueryProcessingStage::Enum getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const override { return to_stage; }
 
     Pipe read(
         const Names & /*column_names*/,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & /*query_info*/,
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         QueryProcessingStage::Enum /*processed_stage*/,
         size_t /*max_block_size*/,
         unsigned /*num_streams*/) override
diff --git a/src/Storages/LiveView/StorageLiveView.cpp b/src/Storages/LiveView/StorageLiveView.cpp
index bfec7bffc8c..1d81405ec26 100644
--- a/src/Storages/LiveView/StorageLiveView.cpp
+++ b/src/Storages/LiveView/StorageLiveView.cpp
@@ -56,13 +56,13 @@ namespace ErrorCodes
 }
 
 
-static StorageID extractDependentTable(ASTPtr & query, Context & context, const String & table_name, ASTPtr & inner_subquery)
+static StorageID extractDependentTable(ASTPtr & query, ContextPtr context, const String & table_name, ASTPtr & inner_subquery)
 {
     ASTSelectQuery & select_query = typeid_cast<ASTSelectQuery &>(*query);
 
     if (auto db_and_table = getDatabaseAndTable(select_query, 0))
     {
-        String select_database_name = context.getCurrentDatabase();
+        String select_database_name = context->getCurrentDatabase();
         String select_table_name = db_and_table->table;
 
         if (db_and_table->database.empty())
@@ -98,7 +98,7 @@ static StorageID extractDependentTable(ASTPtr & query, Context & context, const
     }
 }
 
-MergeableBlocksPtr StorageLiveView::collectMergeableBlocks(const Context & context)
+MergeableBlocksPtr StorageLiveView::collectMergeableBlocks(ContextPtr local_context)
 {
     ASTPtr mergeable_query = inner_query;
 
@@ -109,7 +109,7 @@ MergeableBlocksPtr StorageLiveView::collectMergeableBlocks(const Context & conte
     BlocksPtrs new_blocks = std::make_shared<std::vector<BlocksPtr>>();
     BlocksPtr base_blocks = std::make_shared<Blocks>();
 
-    InterpreterSelectQuery interpreter(mergeable_query->clone(), context, SelectQueryOptions(QueryProcessingStage::WithMergeableState), Names());
+    InterpreterSelectQuery interpreter(mergeable_query->clone(), local_context, SelectQueryOptions(QueryProcessingStage::WithMergeableState), Names());
 
     auto view_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(interpreter.execute().getInputStream());
 
@@ -137,7 +137,7 @@ Pipes StorageLiveView::blocksToPipes(BlocksPtrs blocks, Block & sample_block)
 BlockInputStreamPtr StorageLiveView::completeQuery(Pipes pipes)
 {
     //FIXME it's dangerous to create Context on stack
-    auto block_context = std::make_unique<Context>(global_context);
+    auto block_context = Context::createCopy(getContext());
     block_context->makeQueryContext();
 
     auto creator = [&](const StorageID & blocks_id_global)
@@ -147,17 +147,17 @@ BlockInputStreamPtr StorageLiveView::completeQuery(Pipes pipes)
             blocks_id_global, parent_table_metadata->getColumns(),
             std::move(pipes), QueryProcessingStage::WithMergeableState);
     };
-    block_context->addExternalTable(getBlocksTableName(), TemporaryTableHolder(global_context, creator));
+    block_context->addExternalTable(getBlocksTableName(), TemporaryTableHolder(getContext(), creator));
 
-    InterpreterSelectQuery select(getInnerBlocksQuery(), *block_context, StoragePtr(), nullptr, SelectQueryOptions(QueryProcessingStage::Complete));
+    InterpreterSelectQuery select(getInnerBlocksQuery(), block_context, StoragePtr(), nullptr, SelectQueryOptions(QueryProcessingStage::Complete));
     BlockInputStreamPtr data = std::make_shared<MaterializingBlockInputStream>(select.execute().getInputStream());
 
     /// Squashing is needed here because the view query can generate a lot of blocks
     /// even when only one block is inserted into the parent table (e.g. if the query is a GROUP BY
     /// and two-level aggregation is triggered).
     data = std::make_shared<SquashingBlockInputStream>(
-        data, global_context.getSettingsRef().min_insert_block_size_rows,
-        global_context.getSettingsRef().min_insert_block_size_bytes);
+        data, getContext()->getSettingsRef().min_insert_block_size_rows,
+        getContext()->getSettingsRef().min_insert_block_size_bytes);
 
     return data;
 }
@@ -165,7 +165,7 @@ BlockInputStreamPtr StorageLiveView::completeQuery(Pipes pipes)
 void StorageLiveView::writeIntoLiveView(
     StorageLiveView & live_view,
     const Block & block,
-    const Context & context)
+    ContextPtr local_context)
 {
     BlockOutputStreamPtr output = std::make_shared<LiveViewBlockOutputStream>(live_view);
 
@@ -190,9 +190,9 @@ void StorageLiveView::writeIntoLiveView(
         std::lock_guard lock(live_view.mutex);
 
         mergeable_blocks = live_view.getMergeableBlocks();
-        if (!mergeable_blocks || mergeable_blocks->blocks->size() >= context.getGlobalContext().getSettingsRef().max_live_view_insert_blocks_before_refresh)
+        if (!mergeable_blocks || mergeable_blocks->blocks->size() >= local_context->getGlobalContext()->getSettingsRef().max_live_view_insert_blocks_before_refresh)
         {
-            mergeable_blocks = live_view.collectMergeableBlocks(context);
+            mergeable_blocks = live_view.collectMergeableBlocks(local_context);
             live_view.setMergeableBlocks(mergeable_blocks);
             from = live_view.blocksToPipes(mergeable_blocks->blocks, mergeable_blocks->sample_block);
             is_block_processed = true;
@@ -216,9 +216,9 @@ void StorageLiveView::writeIntoLiveView(
                 blocks_id_global, parent_metadata->getColumns(),
                 std::move(pipes), QueryProcessingStage::FetchColumns);
         };
-        TemporaryTableHolder blocks_storage(context, creator);
+        TemporaryTableHolder blocks_storage(local_context, creator);
 
-        InterpreterSelectQuery select_block(mergeable_query, context, blocks_storage.getTable(), blocks_storage.getTable()->getInMemoryMetadataPtr(),
+        InterpreterSelectQuery select_block(mergeable_query, local_context, blocks_storage.getTable(), blocks_storage.getTable()->getInMemoryMetadataPtr(),
             QueryProcessingStage::WithMergeableState);
 
         auto data_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(
@@ -246,13 +246,13 @@ void StorageLiveView::writeIntoLiveView(
 
 StorageLiveView::StorageLiveView(
     const StorageID & table_id_,
-    Context & local_context,
+    ContextPtr context_,
     const ASTCreateQuery & query,
     const ColumnsDescription & columns_)
     : IStorage(table_id_)
-    , global_context(local_context.getGlobalContext())
+    , WithContext(context_->getGlobalContext())
 {
-    live_view_context = std::make_unique<Context>(global_context);
+    live_view_context = Context::createCopy(getContext());
     live_view_context->makeQueryContext();
 
     log = &Poco::Logger::get("StorageLiveView (" + table_id_.database_name + "." + table_id_.table_name + ")");
@@ -271,7 +271,7 @@ StorageLiveView::StorageLiveView(
     inner_query = query.select->list_of_selects->children.at(0);
 
     auto inner_query_tmp = inner_query->clone();
-    select_table_id = extractDependentTable(inner_query_tmp, global_context, table_id_.table_name, inner_subquery);
+    select_table_id = extractDependentTable(inner_query_tmp, getContext(), table_id_.table_name, inner_subquery);
 
     DatabaseCatalog::instance().addDependency(select_table_id, table_id_);
 
@@ -291,7 +291,7 @@ StorageLiveView::StorageLiveView(
     blocks_metadata_ptr = std::make_shared<BlocksMetadataPtr>();
     active_ptr = std::make_shared<bool>(true);
 
-    periodic_refresh_task = global_context.getSchedulePool().createTask("LieViewPeriodicRefreshTask", [this]{ periodicRefreshTaskFunc(); });
+    periodic_refresh_task = getContext()->getSchedulePool().createTask("LieViewPeriodicRefreshTask", [this]{ periodicRefreshTaskFunc(); });
     periodic_refresh_task->deactivate();
 }
 
@@ -301,7 +301,7 @@ Block StorageLiveView::getHeader() const
 
     if (!sample_block)
     {
-        sample_block = InterpreterSelectQuery(inner_query->clone(), *live_view_context, SelectQueryOptions(QueryProcessingStage::Complete)).getSampleBlock();
+        sample_block = InterpreterSelectQuery(inner_query->clone(), live_view_context, SelectQueryOptions(QueryProcessingStage::Complete)).getSampleBlock();
         sample_block.insert({DataTypeUInt64().createColumnConst(
             sample_block.rows(), 0)->convertToFullColumnIfConst(),
             std::make_shared<DataTypeUInt64>(),
@@ -318,7 +318,7 @@ Block StorageLiveView::getHeader() const
 
 StoragePtr StorageLiveView::getParentStorage() const
 {
-    return DatabaseCatalog::instance().getTable(select_table_id, global_context);
+    return DatabaseCatalog::instance().getTable(select_table_id, getContext());
 }
 
 ASTPtr StorageLiveView::getInnerBlocksQuery()
@@ -330,9 +330,9 @@ ASTPtr StorageLiveView::getInnerBlocksQuery()
         /// Rewrite inner query with right aliases for JOIN.
         /// It cannot be done in constructor or startup() because InterpreterSelectQuery may access table,
         /// which is not loaded yet during server startup, so we do it lazily
-        InterpreterSelectQuery(inner_blocks_query, *live_view_context, SelectQueryOptions().modify().analyze()); // NOLINT
+        InterpreterSelectQuery(inner_blocks_query, live_view_context, SelectQueryOptions().modify().analyze()); // NOLINT
         auto table_id = getStorageID();
-        extractDependentTable(inner_blocks_query, global_context, table_id.table_name, inner_subquery);
+        extractDependentTable(inner_blocks_query, getContext(), table_id.table_name, inner_subquery);
     }
     return inner_blocks_query->clone();
 }
@@ -350,7 +350,7 @@ bool StorageLiveView::getNewBlocks()
     /// called before writeIntoLiveView function is called which can lead to
     /// the same block added twice to the mergeable_blocks leading to
     /// inserted data to be duplicated
-    auto new_mergeable_blocks = collectMergeableBlocks(*live_view_context);
+    auto new_mergeable_blocks = collectMergeableBlocks(live_view_context);
     Pipes from = blocksToPipes(new_mergeable_blocks->blocks, new_mergeable_blocks->sample_block);
     BlockInputStreamPtr data = completeQuery(std::move(from));
 
@@ -500,7 +500,7 @@ Pipe StorageLiveView::read(
     const Names & /*column_names*/,
     const StorageMetadataPtr & /*metadata_snapshot*/,
     SelectQueryInfo & /*query_info*/,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t /*max_block_size*/,
     const unsigned /*num_streams*/)
@@ -525,7 +525,7 @@ Pipe StorageLiveView::read(
 BlockInputStreams StorageLiveView::watch(
     const Names & /*column_names*/,
     const SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum & processed_stage,
     size_t /*max_block_size*/,
     const unsigned /*num_streams*/)
@@ -546,12 +546,12 @@ BlockInputStreams StorageLiveView::watch(
         reader = std::make_shared<LiveViewEventsBlockInputStream>(
             std::static_pointer_cast<StorageLiveView>(shared_from_this()),
             blocks_ptr, blocks_metadata_ptr, active_ptr, has_limit, limit,
-            context.getSettingsRef().live_view_heartbeat_interval.totalSeconds());
+            local_context->getSettingsRef().live_view_heartbeat_interval.totalSeconds());
     else
         reader = std::make_shared<LiveViewBlockInputStream>(
             std::static_pointer_cast<StorageLiveView>(shared_from_this()),
             blocks_ptr, blocks_metadata_ptr, active_ptr, has_limit, limit,
-            context.getSettingsRef().live_view_heartbeat_interval.totalSeconds());
+            local_context->getSettingsRef().live_view_heartbeat_interval.totalSeconds());
 
     {
         std::lock_guard lock(mutex);
@@ -578,10 +578,12 @@ void registerStorageLiveView(StorageFactory & factory)
 {
     factory.registerStorage("LiveView", [](const StorageFactory::Arguments & args)
     {
-        if (!args.attach && !args.local_context.getSettingsRef().allow_experimental_live_view)
-            throw Exception("Experimental LIVE VIEW feature is not enabled (the setting 'allow_experimental_live_view')", ErrorCodes::SUPPORT_IS_DISABLED);
+        if (!args.attach && !args.getLocalContext()->getSettingsRef().allow_experimental_live_view)
+            throw Exception(
+                "Experimental LIVE VIEW feature is not enabled (the setting 'allow_experimental_live_view')",
+                ErrorCodes::SUPPORT_IS_DISABLED);
 
-        return StorageLiveView::create(args.table_id, args.local_context, args.query, args.columns);
+        return StorageLiveView::create(args.table_id, args.getLocalContext(), args.query, args.columns);
     });
 }
 
diff --git a/src/Storages/LiveView/StorageLiveView.h b/src/Storages/LiveView/StorageLiveView.h
index e30a8f51705..df09316f333 100644
--- a/src/Storages/LiveView/StorageLiveView.h
+++ b/src/Storages/LiveView/StorageLiveView.h
@@ -49,7 +49,7 @@ class Pipe;
 using Pipes = std::vector<Pipe>;
 
 
-class StorageLiveView final : public ext::shared_ptr_helper<StorageLiveView>, public IStorage
+class StorageLiveView final : public ext::shared_ptr_helper<StorageLiveView>, public IStorage, WithContext
 {
 friend struct ext::shared_ptr_helper<StorageLiveView>;
 friend class LiveViewBlockInputStream;
@@ -142,13 +142,13 @@ public:
     void startup() override;
     void shutdown() override;
 
-    void refresh(const bool grab_lock = true);
+    void refresh(bool grab_lock = true);
 
     Pipe read(
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -156,7 +156,7 @@ public:
     BlockInputStreams watch(
         const Names & column_names,
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum & processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -165,7 +165,7 @@ public:
     MergeableBlocksPtr getMergeableBlocks() { return mergeable_blocks; }
 
     /// Collect mergeable blocks and their sample. Must be called holding mutex
-    MergeableBlocksPtr collectMergeableBlocks(const Context & context);
+    MergeableBlocksPtr collectMergeableBlocks(ContextPtr context);
     /// Complete query using input streams from mergeable blocks
     BlockInputStreamPtr completeQuery(Pipes pipes);
 
@@ -183,7 +183,7 @@ public:
     static void writeIntoLiveView(
         StorageLiveView & live_view,
         const Block & block,
-        const Context & context);
+        ContextPtr context);
 
 private:
     /// TODO move to common struct SelectQueryDescription
@@ -191,8 +191,7 @@ private:
     ASTPtr inner_query; /// stored query : SELECT * FROM ( SELECT a FROM A)
     ASTPtr inner_subquery; /// stored query's innermost subquery if any
     ASTPtr inner_blocks_query; /// query over the mergeable blocks to produce final result
-    Context & global_context;
-    std::unique_ptr<Context> live_view_context;
+    ContextPtr live_view_context;
 
     Poco::Logger * log;
 
@@ -231,7 +230,7 @@ private:
 
     StorageLiveView(
         const StorageID & table_id_,
-        Context & local_context,
+        ContextPtr context_,
         const ASTCreateQuery & query,
         const ColumnsDescription & columns
     );
diff --git a/src/Storages/LiveView/TemporaryLiveViewCleaner.cpp b/src/Storages/LiveView/TemporaryLiveViewCleaner.cpp
index 143e7460cc3..7294b82f10d 100644
--- a/src/Storages/LiveView/TemporaryLiveViewCleaner.cpp
+++ b/src/Storages/LiveView/TemporaryLiveViewCleaner.cpp
@@ -1,8 +1,9 @@
 #include <Storages/LiveView/TemporaryLiveViewCleaner.h>
-#include <Storages/LiveView/StorageLiveView.h>
+
 #include <Interpreters/DatabaseCatalog.h>
 #include <Interpreters/InterpreterDropQuery.h>
 #include <Parsers/ASTDropQuery.h>
+#include <Storages/LiveView/StorageLiveView.h>
 
 
 namespace DB
@@ -15,7 +16,7 @@ namespace ErrorCodes
 
 namespace
 {
-    void executeDropQuery(const StorageID & storage_id, Context & context)
+    void executeDropQuery(const StorageID & storage_id, ContextPtr context)
     {
         if (!DatabaseCatalog::instance().isTableExist(storage_id, context))
             return;
@@ -41,45 +42,20 @@ namespace
 std::unique_ptr<TemporaryLiveViewCleaner> TemporaryLiveViewCleaner::the_instance;
 
 
-void TemporaryLiveViewCleaner::init(Context & global_context_)
+void TemporaryLiveViewCleaner::init(ContextPtr global_context_)
 {
     if (the_instance)
         throw Exception("TemporaryLiveViewCleaner already initialized", ErrorCodes::LOGICAL_ERROR);
     the_instance.reset(new TemporaryLiveViewCleaner(global_context_));
 }
 
-void TemporaryLiveViewCleaner::startupIfNecessary()
+void TemporaryLiveViewCleaner::startup()
 {
+    background_thread_can_start = true;
+
     std::lock_guard lock{mutex};
-    if (background_thread_should_exit)
-        return;
     if (!views.empty())
-        startupIfNecessaryImpl(lock);
-    else
-        can_start_background_thread = true;
-}
-
-void TemporaryLiveViewCleaner::startupIfNecessaryImpl(const std::lock_guard<std::mutex> &)
-{
-    /// If views.empty() the background thread isn't running or it's going to stop right now.
-    /// If can_start_background_thread is false, then the thread has not been started previously.
-    bool background_thread_is_running;
-    if (can_start_background_thread)
-    {
-        background_thread_is_running = !views.empty();
-    }
-    else
-    {
-        can_start_background_thread = true;
-        background_thread_is_running = false;
-    }
-
-    if (!background_thread_is_running)
-    {
-        if (background_thread.joinable())
-            background_thread.join();
-        background_thread = ThreadFromGlobalPool{&TemporaryLiveViewCleaner::backgroundThreadFunc, this};
-    }
+        startBackgroundThread();
 }
 
 void TemporaryLiveViewCleaner::shutdown()
@@ -87,13 +63,10 @@ void TemporaryLiveViewCleaner::shutdown()
     the_instance.reset();
 }
 
-
-TemporaryLiveViewCleaner::TemporaryLiveViewCleaner(Context & global_context_)
-    : global_context(global_context_)
+TemporaryLiveViewCleaner::TemporaryLiveViewCleaner(ContextPtr global_context_) : WithContext(global_context_)
 {
 }
 
-
 TemporaryLiveViewCleaner::~TemporaryLiveViewCleaner()
 {
     stopBackgroundThread();
@@ -108,27 +81,29 @@ void TemporaryLiveViewCleaner::addView(const std::shared_ptr<StorageLiveView> &
     auto current_time = std::chrono::system_clock::now();
     auto time_of_next_check = current_time + view->getTimeout();
 
-    std::lock_guard lock{mutex};
-    if (background_thread_should_exit)
-        return;
-
-    if (can_start_background_thread)
-        startupIfNecessaryImpl(lock);
-
     /// Keep the vector `views` sorted by time of next check.
     StorageAndTimeOfCheck storage_and_time_of_check{view, time_of_next_check};
+    std::lock_guard lock{mutex};
     views.insert(std::upper_bound(views.begin(), views.end(), storage_and_time_of_check), storage_and_time_of_check);
 
-    background_thread_wake_up.notify_one();
+    if (background_thread_can_start)
+    {
+        startBackgroundThread();
+        background_thread_wake_up.notify_one();
+    }
 }
 
 
 void TemporaryLiveViewCleaner::backgroundThreadFunc()
 {
     std::unique_lock lock{mutex};
-    while (!background_thread_should_exit && !views.empty())
+    while (!background_thread_should_exit)
     {
-        background_thread_wake_up.wait_until(lock, views.front().time_of_check);
+        if (views.empty())
+            background_thread_wake_up.wait(lock);
+        else
+            background_thread_wake_up.wait_until(lock, views.front().time_of_check);
+
         if (background_thread_should_exit)
             break;
 
@@ -167,20 +142,24 @@ void TemporaryLiveViewCleaner::backgroundThreadFunc()
 
         lock.unlock();
         for (const auto & storage_id : storages_to_drop)
-            executeDropQuery(storage_id, global_context);
+            executeDropQuery(storage_id, getContext());
         lock.lock();
     }
 }
 
 
+void TemporaryLiveViewCleaner::startBackgroundThread()
+{
+    if (!background_thread.joinable() && background_thread_can_start && !background_thread_should_exit)
+        background_thread = ThreadFromGlobalPool{&TemporaryLiveViewCleaner::backgroundThreadFunc, this};
+}
+
 void TemporaryLiveViewCleaner::stopBackgroundThread()
 {
+    background_thread_should_exit = true;
+    background_thread_wake_up.notify_one();
     if (background_thread.joinable())
-    {
-        background_thread_should_exit = true;
-        background_thread_wake_up.notify_one();
         background_thread.join();
-    }
 }
 
 }
diff --git a/src/Storages/LiveView/TemporaryLiveViewCleaner.h b/src/Storages/LiveView/TemporaryLiveViewCleaner.h
index 8d57aa9fbfa..9b31bf9c999 100644
--- a/src/Storages/LiveView/TemporaryLiveViewCleaner.h
+++ b/src/Storages/LiveView/TemporaryLiveViewCleaner.h
@@ -1,17 +1,20 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
 #include <Common/ThreadPool.h>
+
 #include <chrono>
 
 
 namespace DB
 {
+
 class StorageLiveView;
 struct StorageID;
 
 /// This class removes temporary live views in the background thread when it's possible.
 /// There should only a single instance of this class.
-class TemporaryLiveViewCleaner
+class TemporaryLiveViewCleaner : WithContext
 {
 public:
     static TemporaryLiveViewCleaner & instance() { return *the_instance; }
@@ -20,19 +23,19 @@ public:
     void addView(const std::shared_ptr<StorageLiveView> & view);
 
     /// Should be called once.
-    static void init(Context & global_context_);
+    static void init(ContextPtr global_context_);
     static void shutdown();
 
-    void startupIfNecessary();
-    void startupIfNecessaryImpl(const std::lock_guard<std::mutex> &);
+    void startup();
 
 private:
     friend std::unique_ptr<TemporaryLiveViewCleaner>::deleter_type;
 
-    TemporaryLiveViewCleaner(Context & global_context_);
+    TemporaryLiveViewCleaner(ContextPtr global_context_);
     ~TemporaryLiveViewCleaner();
 
     void backgroundThreadFunc();
+    void startBackgroundThread();
     void stopBackgroundThread();
 
     struct StorageAndTimeOfCheck
@@ -43,11 +46,10 @@ private:
     };
 
     static std::unique_ptr<TemporaryLiveViewCleaner> the_instance;
-    Context & global_context;
     std::mutex mutex;
     std::vector<StorageAndTimeOfCheck> views;
     ThreadFromGlobalPool background_thread;
-    bool can_start_background_thread = false;
+    std::atomic<bool> background_thread_can_start = false;
     std::atomic<bool> background_thread_should_exit = false;
     std::condition_variable background_thread_wake_up;
 };
diff --git a/src/Storages/MergeTree/BackgroundJobsExecutor.cpp b/src/Storages/MergeTree/BackgroundJobsExecutor.cpp
index 8e5a0e8a3b8..ae06721b43d 100644
--- a/src/Storages/MergeTree/BackgroundJobsExecutor.cpp
+++ b/src/Storages/MergeTree/BackgroundJobsExecutor.cpp
@@ -16,10 +16,10 @@ namespace DB
 {
 
 IBackgroundJobExecutor::IBackgroundJobExecutor(
-        Context & global_context_,
+        ContextPtr global_context_,
         const BackgroundTaskSchedulingSettings & sleep_settings_,
         const std::vector<PoolConfig> & pools_configs_)
-    : global_context(global_context_)
+    : WithContext(global_context_)
     , sleep_settings(sleep_settings_)
     , rng(randomSeed())
 {
@@ -155,7 +155,7 @@ void IBackgroundJobExecutor::start()
     std::lock_guard lock(scheduling_task_mutex);
     if (!scheduling_task)
     {
-        scheduling_task = global_context.getSchedulePool().createTask(
+        scheduling_task = getContext()->getSchedulePool().createTask(
             getBackgroundTaskName(), [this]{ jobExecutingTask(); });
     }
 
@@ -187,12 +187,12 @@ IBackgroundJobExecutor::~IBackgroundJobExecutor()
 
 BackgroundJobsExecutor::BackgroundJobsExecutor(
        MergeTreeData & data_,
-       Context & global_context_)
+       ContextPtr global_context_)
     : IBackgroundJobExecutor(
         global_context_,
-        global_context_.getBackgroundProcessingTaskSchedulingSettings(),
-        {PoolConfig{PoolType::MERGE_MUTATE, global_context_.getSettingsRef().background_pool_size, CurrentMetrics::BackgroundPoolTask},
-         PoolConfig{PoolType::FETCH, global_context_.getSettingsRef().background_fetches_pool_size, CurrentMetrics::BackgroundFetchesPoolTask}})
+        global_context_->getBackgroundProcessingTaskSchedulingSettings(),
+        {PoolConfig{PoolType::MERGE_MUTATE, global_context_->getSettingsRef().background_pool_size, CurrentMetrics::BackgroundPoolTask},
+         PoolConfig{PoolType::FETCH, global_context_->getSettingsRef().background_fetches_pool_size, CurrentMetrics::BackgroundFetchesPoolTask}})
     , data(data_)
 {
 }
@@ -209,11 +209,11 @@ std::optional<JobAndPool> BackgroundJobsExecutor::getBackgroundJob()
 
 BackgroundMovesExecutor::BackgroundMovesExecutor(
        MergeTreeData & data_,
-       Context & global_context_)
+       ContextPtr global_context_)
     : IBackgroundJobExecutor(
         global_context_,
-        global_context_.getBackgroundMoveTaskSchedulingSettings(),
-      {PoolConfig{PoolType::MOVE, global_context_.getSettingsRef().background_move_pool_size, CurrentMetrics::BackgroundMovePoolTask}})
+        global_context_->getBackgroundMoveTaskSchedulingSettings(),
+      {PoolConfig{PoolType::MOVE, global_context_->getSettingsRef().background_move_pool_size, CurrentMetrics::BackgroundMovePoolTask}})
     , data(data_)
 {
 }
diff --git a/src/Storages/MergeTree/BackgroundJobsExecutor.h b/src/Storages/MergeTree/BackgroundJobsExecutor.h
index da22c752e1b..e9cefc7a6b0 100644
--- a/src/Storages/MergeTree/BackgroundJobsExecutor.h
+++ b/src/Storages/MergeTree/BackgroundJobsExecutor.h
@@ -50,11 +50,9 @@ struct JobAndPool
 /// Consists of two important parts:
 /// 1) Task in background scheduling pool which receives new jobs from storages and put them into required pool.
 /// 2) One or more ThreadPool objects, which execute background jobs.
-class IBackgroundJobExecutor
+class IBackgroundJobExecutor : protected WithContext
 {
 protected:
-    Context & global_context;
-
     /// Configuration for single background ThreadPool
     struct PoolConfig
     {
@@ -106,7 +104,7 @@ public:
 
 protected:
     IBackgroundJobExecutor(
-        Context & global_context_,
+        ContextPtr global_context_,
         const BackgroundTaskSchedulingSettings & sleep_settings_,
         const std::vector<PoolConfig> & pools_configs_);
 
@@ -134,7 +132,7 @@ private:
 public:
     BackgroundJobsExecutor(
         MergeTreeData & data_,
-        Context & global_context_);
+        ContextPtr global_context_);
 
 protected:
     String getBackgroundTaskName() const override;
@@ -150,7 +148,7 @@ private:
 public:
     BackgroundMovesExecutor(
         MergeTreeData & data_,
-        Context & global_context_);
+        ContextPtr global_context_);
 
 protected:
     String getBackgroundTaskName() const override;
diff --git a/src/Storages/MergeTree/DataPartsExchange.cpp b/src/Storages/MergeTree/DataPartsExchange.cpp
index 862a3088f89..205d57f533e 100644
--- a/src/Storages/MergeTree/DataPartsExchange.cpp
+++ b/src/Storages/MergeTree/DataPartsExchange.cpp
@@ -481,7 +481,7 @@ MergeTreeData::MutableDataPartPtr Fetcher::fetchPart(
 
     auto storage_id = data.getStorageID();
     String new_part_path = part_type == "InMemory" ? "memory" : data.getFullPathOnDisk(reservation->getDisk()) + part_name + "/";
-    auto entry = data.global_context.getReplicatedFetchList().insert(
+    auto entry = data.getContext()->getReplicatedFetchList().insert(
         storage_id.getDatabaseName(), storage_id.getTableName(),
         part_info.partition_id, part_name, new_part_path,
         replica_path, uri, to_detached, sum_files_size);
diff --git a/src/Storages/MergeTree/IMergeTreeDataPart.cpp b/src/Storages/MergeTree/IMergeTreeDataPart.cpp
index 72ce05e7aab..71a99aa2a87 100644
--- a/src/Storages/MergeTree/IMergeTreeDataPart.cpp
+++ b/src/Storages/MergeTree/IMergeTreeDataPart.cpp
@@ -1356,6 +1356,24 @@ String IMergeTreeDataPart::getUniqueId() const
     return id;
 }
 
+
+String IMergeTreeDataPart::getZeroLevelPartBlockID() const
+{
+    if (info.level != 0)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Trying to get block id for non zero level part {}", name);
+
+    SipHash hash;
+    checksums.computeTotalChecksumDataOnly(hash);
+    union
+    {
+        char bytes[16];
+        UInt64 words[2];
+    } hash_value;
+    hash.get128(hash_value.bytes);
+
+    return info.partition_id + "_" + toString(hash_value.words[0]) + "_" + toString(hash_value.words[1]);
+}
+
 bool isCompactPart(const MergeTreeDataPartPtr & data_part)
 {
     return (data_part && data_part->getType() == MergeTreeDataPartType::COMPACT);
@@ -1372,4 +1390,3 @@ bool isInMemoryPart(const MergeTreeDataPartPtr & data_part)
 }
 
 }
-
diff --git a/src/Storages/MergeTree/IMergeTreeDataPart.h b/src/Storages/MergeTree/IMergeTreeDataPart.h
index 03f6564788a..4e531826c98 100644
--- a/src/Storages/MergeTree/IMergeTreeDataPart.h
+++ b/src/Storages/MergeTree/IMergeTreeDataPart.h
@@ -164,6 +164,9 @@ public:
 
     bool isEmpty() const { return rows_count == 0; }
 
+    /// Compute part block id for zero level part. Otherwise throws an exception.
+    String getZeroLevelPartBlockID() const;
+
     const MergeTreeData & storage;
 
     String name;
diff --git a/src/Storages/MergeTree/IMergeTreeReader.cpp b/src/Storages/MergeTree/IMergeTreeReader.cpp
index 53ab4713267..52d3e7ca9ab 100644
--- a/src/Storages/MergeTree/IMergeTreeReader.cpp
+++ b/src/Storages/MergeTree/IMergeTreeReader.cpp
@@ -187,12 +187,12 @@ void IMergeTreeReader::evaluateMissingDefaults(Block additional_columns, Columns
         }
 
         auto dag = DB::evaluateMissingDefaults(
-                additional_columns, columns, metadata_snapshot->getColumns(), storage.global_context);
+                additional_columns, columns, metadata_snapshot->getColumns(), storage.getContext());
         if (dag)
         {
             auto actions = std::make_shared<
                 ExpressionActions>(std::move(dag),
-                ExpressionActionsSettings::fromSettings(storage.global_context.getSettingsRef()));
+                ExpressionActionsSettings::fromSettings(storage.getContext()->getSettingsRef()));
             actions->execute(additional_columns);
         }
 
@@ -270,7 +270,7 @@ void IMergeTreeReader::performRequiredConversions(Columns & res_columns)
             copy_block.insert({res_columns[pos], getColumnFromPart(*name_and_type).type, name_and_type->name});
         }
 
-        DB::performRequiredConversions(copy_block, columns, storage.global_context);
+        DB::performRequiredConversions(copy_block, columns, storage.getContext());
 
         /// Move columns from block.
         name_and_type = columns.begin();
diff --git a/src/Storages/MergeTree/KeyCondition.cpp b/src/Storages/MergeTree/KeyCondition.cpp
index 6833d2e2fd4..41bcb93b2c8 100644
--- a/src/Storages/MergeTree/KeyCondition.cpp
+++ b/src/Storages/MergeTree/KeyCondition.cpp
@@ -370,7 +370,7 @@ inline bool Range::less(const Field & lhs, const Field & rhs) { return applyVisi
   * For index to work when something like "WHERE Date = toDate(now())" is written.
   */
 Block KeyCondition::getBlockWithConstants(
-    const ASTPtr & query, const TreeRewriterResultPtr & syntax_analyzer_result, const Context & context)
+    const ASTPtr & query, const TreeRewriterResultPtr & syntax_analyzer_result, ContextPtr context)
 {
     Block result
     {
@@ -387,7 +387,7 @@ Block KeyCondition::getBlockWithConstants(
 
 KeyCondition::KeyCondition(
     const SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     const Names & key_column_names,
     const ExpressionActionsPtr & key_expr_,
     bool single_point_,
@@ -556,7 +556,7 @@ static FieldRef applyFunction(const FunctionBasePtr & func, const DataTypePtr &
     return {field.columns, field.row_idx, result_idx};
 }
 
-void KeyCondition::traverseAST(const ASTPtr & node, const Context & context, Block & block_with_constants)
+void KeyCondition::traverseAST(const ASTPtr & node, ContextPtr context, Block & block_with_constants)
 {
     RPNElement element;
 
@@ -786,7 +786,7 @@ bool KeyCondition::canConstantBeWrappedByFunctions(
 
 bool KeyCondition::tryPrepareSetIndex(
     const ASTs & args,
-    const Context & context,
+    ContextPtr context,
     RPNElement & out,
     size_t & out_key_column_num)
 {
@@ -947,7 +947,7 @@ private:
 
 bool KeyCondition::isKeyPossiblyWrappedByMonotonicFunctions(
     const ASTPtr & node,
-    const Context & context,
+    ContextPtr context,
     size_t & out_key_column_num,
     DataTypePtr & out_key_res_column_type,
     MonotonicFunctionsChain & out_functions_chain)
@@ -1075,7 +1075,7 @@ static void castValueToType(const DataTypePtr & desired_type, Field & src_value,
 }
 
 
-bool KeyCondition::tryParseAtomFromAST(const ASTPtr & node, const Context & context, Block & block_with_constants, RPNElement & out)
+bool KeyCondition::tryParseAtomFromAST(const ASTPtr & node, ContextPtr context, Block & block_with_constants, RPNElement & out)
 {
     /** Functions < > = != <= >= in `notIn`, where one argument is a constant, and the other is one of columns of key,
       *  or itself, wrapped in a chain of possibly-monotonic functions,
@@ -1326,11 +1326,12 @@ String KeyCondition::toString() const
   * The set of all possible tuples can be considered as an n-dimensional space, where n is the size of the tuple.
   * A range of tuples specifies some subset of this space.
   *
-  * Hyperrectangles (you can also find the term "rail")
-  *  will be the subrange of an n-dimensional space that is a direct product of one-dimensional ranges.
-  * In this case, the one-dimensional range can be: a period, a segment, an interval, a half-interval, unlimited on the left, unlimited on the right ...
+  * Hyperrectangles will be the subrange of an n-dimensional space that is a direct product of one-dimensional ranges.
+  * In this case, the one-dimensional range can be: 
+  * a point, a segment, an open interval, a half-open interval;
+  * unlimited on the left, unlimited on the right ...
   *
-  * The range of tuples can always be represented as a combination of hyperrectangles.
+  * The range of tuples can always be represented as a combination (union) of hyperrectangles.
   * For example, the range [ x1 y1 .. x2 y2 ] given x1 != x2 is equal to the union of the following three hyperrectangles:
   * [x1]       x [y1 .. +inf)
   * (x1 .. x2) x (-inf .. +inf)
diff --git a/src/Storages/MergeTree/KeyCondition.h b/src/Storages/MergeTree/KeyCondition.h
index b8167f406bd..631fb0b7cc4 100644
--- a/src/Storages/MergeTree/KeyCondition.h
+++ b/src/Storages/MergeTree/KeyCondition.h
@@ -229,7 +229,7 @@ public:
     /// Does not take into account the SAMPLE section. all_columns - the set of all columns of the table.
     KeyCondition(
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         const Names & key_column_names,
         const ExpressionActionsPtr & key_expr,
         bool single_point_ = false,
@@ -307,7 +307,7 @@ public:
             const ASTPtr & expr, Block & block_with_constants, Field & out_value, DataTypePtr & out_type);
 
     static Block getBlockWithConstants(
-        const ASTPtr & query, const TreeRewriterResultPtr & syntax_analyzer_result, const Context & context);
+        const ASTPtr & query, const TreeRewriterResultPtr & syntax_analyzer_result, ContextPtr context);
 
     static std::optional<Range> applyMonotonicFunctionsChainToRange(
         Range key_range,
@@ -375,8 +375,8 @@ private:
         bool right_bounded,
         BoolMask initial_mask) const;
 
-    void traverseAST(const ASTPtr & node, const Context & context, Block & block_with_constants);
-    bool tryParseAtomFromAST(const ASTPtr & node, const Context & context, Block & block_with_constants, RPNElement & out);
+    void traverseAST(const ASTPtr & node, ContextPtr context, Block & block_with_constants);
+    bool tryParseAtomFromAST(const ASTPtr & node, ContextPtr context, Block & block_with_constants, RPNElement & out);
     static bool tryParseLogicalOperatorFromAST(const ASTFunction * func, RPNElement & out);
 
     /** Is node the key column
@@ -387,7 +387,7 @@ private:
       */
     bool isKeyPossiblyWrappedByMonotonicFunctions(
         const ASTPtr & node,
-        const Context & context,
+        ContextPtr context,
         size_t & out_key_column_num,
         DataTypePtr & out_key_res_column_type,
         MonotonicFunctionsChain & out_functions_chain);
@@ -413,7 +413,7 @@ private:
     /// do it and return true.
     bool tryPrepareSetIndex(
         const ASTs & args,
-        const Context & context,
+        ContextPtr context,
         RPNElement & out,
         size_t & out_key_column_num);
 
diff --git a/src/Storages/MergeTree/MergeTreeBlockOutputStream.cpp b/src/Storages/MergeTree/MergeTreeBlockOutputStream.cpp
index bb5644567ae..bc91e29d900 100644
--- a/src/Storages/MergeTree/MergeTreeBlockOutputStream.cpp
+++ b/src/Storages/MergeTree/MergeTreeBlockOutputStream.cpp
@@ -35,12 +35,14 @@ void MergeTreeBlockOutputStream::write(const Block & block)
         if (!part)
             continue;
 
-        storage.renameTempPartAndAdd(part, &storage.increment);
+        /// Part can be deduplicated, so increment counters and add to part log only if it's really added
+        if (storage.renameTempPartAndAdd(part, &storage.increment, nullptr, storage.getDeduplicationLog()))
+        {
+            PartLog::addNewPart(storage.getContext(), part, watch.elapsed());
 
-        PartLog::addNewPart(storage.global_context, part, watch.elapsed());
-
-        /// Initiate async merge - it will be done if it's good time for merge and if there are space in 'background_pool'.
-        storage.background_executor.triggerTask();
+            /// Initiate async merge - it will be done if it's good time for merge and if there are space in 'background_pool'.
+            storage.background_executor.triggerTask();
+        }
     }
 }
 
diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp
index d61de13b604..ee8e15008cb 100644
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@@ -56,6 +56,8 @@
 #include <boost/range/adaptor/filtered.hpp>
 #include <boost/algorithm/string/join.hpp>
 
+#include <ext/scope_guard_safe.h>
+
 #include <algorithm>
 #include <iomanip>
 #include <optional>
@@ -71,6 +73,7 @@ namespace ProfileEvents
     extern const Event RejectedInserts;
     extern const Event DelayedInserts;
     extern const Event DelayedInsertsMilliseconds;
+    extern const Event DuplicatedInsertedBlocks;
 }
 
 namespace CurrentMetrics
@@ -132,7 +135,7 @@ MergeTreeData::MergeTreeData(
     const StorageID & table_id_,
     const String & relative_data_path_,
     const StorageInMemoryMetadata & metadata_,
-    Context & context_,
+    ContextPtr context_,
     const String & date_column_name,
     const MergingParams & merging_params_,
     std::unique_ptr<MergeTreeSettings> storage_settings_,
@@ -140,7 +143,7 @@ MergeTreeData::MergeTreeData(
     bool attach,
     BrokenPartCallback broken_part_callback_)
     : IStorage(table_id_)
-    , global_context(context_.getGlobalContext())
+    , WithContext(context_->getGlobalContext())
     , merging_params(merging_params_)
     , require_part_metadata(require_part_metadata_)
     , relative_data_path(relative_data_path_)
@@ -160,7 +163,7 @@ MergeTreeData::MergeTreeData(
 
     /// Check sanity of MergeTreeSettings. Only when table is created.
     if (!attach)
-        settings->sanityCheck(global_context.getSettingsRef());
+        settings->sanityCheck(getContext()->getSettingsRef());
 
     MergeTreeDataFormatVersion min_format_version(0);
     if (!date_column_name.empty())
@@ -230,7 +233,7 @@ MergeTreeData::MergeTreeData(
         format_version = min_format_version;
         auto buf = version_file.second->writeFile(version_file.first);
         writeIntText(format_version.toUnderType(), *buf);
-        if (global_context.getSettingsRef().fsync_metadata)
+        if (getContext()->getSettingsRef().fsync_metadata)
             buf->sync();
     }
     else
@@ -259,7 +262,7 @@ MergeTreeData::MergeTreeData(
 
 StoragePolicyPtr MergeTreeData::getStoragePolicy() const
 {
-    return global_context.getStoragePolicy(getSettings()->storage_policy);
+    return getContext()->getStoragePolicy(getSettings()->storage_policy);
 }
 
 static void checkKeyExpression(const ExpressionActions & expr, const Block & sample_block, const String & key_name, bool allow_nullable_key)
@@ -316,8 +319,8 @@ void MergeTreeData::checkProperties(
         {
             const String & pk_column = new_primary_key.column_names[i];
             if (pk_column != sorting_key_column)
-                throw Exception("Primary key must be a prefix of the sorting key, but in position "
-                    + toString(i) + " its column is " + pk_column + ", not " + sorting_key_column,
+                throw Exception("Primary key must be a prefix of the sorting key, but the column in the position "
+                    + toString(i) + " is " + sorting_key_column +", not " + pk_column,
                     ErrorCodes::BAD_ARGUMENTS);
 
             if (!primary_key_columns_set.emplace(pk_column).second)
@@ -354,7 +357,7 @@ void MergeTreeData::checkProperties(
 
         if (!added_key_column_expr_list->children.empty())
         {
-            auto syntax = TreeRewriter(global_context).analyze(added_key_column_expr_list, all_columns);
+            auto syntax = TreeRewriter(getContext()).analyze(added_key_column_expr_list, all_columns);
             Names used_columns = syntax->requiredSourceColumns();
 
             NamesAndTypesList deleted_columns;
@@ -411,7 +414,7 @@ ExpressionActionsPtr getCombinedIndicesExpression(
     const KeyDescription & key,
     const IndicesDescription & indices,
     const ColumnsDescription & columns,
-    const Context & context)
+    ContextPtr context)
 {
     ASTPtr combined_expr_list = key.expression_list_ast->clone();
 
@@ -450,12 +453,12 @@ DataTypes MergeTreeData::getMinMaxColumnsTypes(const KeyDescription & partition_
 
 ExpressionActionsPtr MergeTreeData::getPrimaryKeyAndSkipIndicesExpression(const StorageMetadataPtr & metadata_snapshot) const
 {
-    return getCombinedIndicesExpression(metadata_snapshot->getPrimaryKey(), metadata_snapshot->getSecondaryIndices(), metadata_snapshot->getColumns(), global_context);
+    return getCombinedIndicesExpression(metadata_snapshot->getPrimaryKey(), metadata_snapshot->getSecondaryIndices(), metadata_snapshot->getColumns(), getContext());
 }
 
 ExpressionActionsPtr MergeTreeData::getSortingKeyAndSkipIndicesExpression(const StorageMetadataPtr & metadata_snapshot) const
 {
-    return getCombinedIndicesExpression(metadata_snapshot->getSortingKey(), metadata_snapshot->getSecondaryIndices(), metadata_snapshot->getColumns(), global_context);
+    return getCombinedIndicesExpression(metadata_snapshot->getSortingKey(), metadata_snapshot->getSecondaryIndices(), metadata_snapshot->getColumns(), getContext());
 }
 
 
@@ -683,16 +686,16 @@ void MergeTreeData::MergingParams::check(const StorageInMemoryMetadata & metadat
 
 
 std::optional<UInt64> MergeTreeData::totalRowsByPartitionPredicateImpl(
-    const SelectQueryInfo & query_info, const Context & context, const DataPartsVector & parts) const
+    const SelectQueryInfo & query_info, ContextPtr local_context, const DataPartsVector & parts) const
 {
     auto metadata_snapshot = getInMemoryMetadataPtr();
     ASTPtr expression_ast;
     Block virtual_columns_block = MergeTreeDataSelectExecutor::getSampleBlockWithVirtualPartColumns();
 
     // Generate valid expressions for filtering
-    bool valid = VirtualColumnUtils::prepareFilterBlockWithQuery(query_info.query, context, virtual_columns_block, expression_ast);
+    bool valid = VirtualColumnUtils::prepareFilterBlockWithQuery(query_info.query, local_context, virtual_columns_block, expression_ast);
 
-    PartitionPruner partition_pruner(metadata_snapshot->getPartitionKey(), query_info, context, true /* strict */);
+    PartitionPruner partition_pruner(metadata_snapshot->getPartitionKey(), query_info, local_context, true /* strict */);
     if (partition_pruner.isUseless() && !valid)
         return {};
 
@@ -700,7 +703,7 @@ std::optional<UInt64> MergeTreeData::totalRowsByPartitionPredicateImpl(
     if (valid && expression_ast)
     {
         MergeTreeDataSelectExecutor::fillBlockWithVirtualPartColumns(parts, virtual_columns_block);
-        VirtualColumnUtils::filterBlockWithQuery(query_info.query, virtual_columns_block, context, expression_ast);
+        VirtualColumnUtils::filterBlockWithQuery(query_info.query, virtual_columns_block, local_context, expression_ast);
         part_values = VirtualColumnUtils::extractSingleValueFromBlock<String>(virtual_columns_block, "_part");
         if (part_values.empty())
             return 0;
@@ -765,7 +768,7 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks)
         for (const auto & disk_ptr : disks)
             defined_disk_names.insert(disk_ptr->getName());
 
-        for (const auto & [disk_name, disk] : global_context.getDisksMap())
+        for (const auto & [disk_name, disk] : getContext()->getDisksMap())
         {
             if (defined_disk_names.count(disk_name) == 0 && disk->exists(relative_data_path))
             {
@@ -1168,7 +1171,7 @@ void MergeTreeData::removePartsFinally(const MergeTreeData::DataPartsVector & pa
     /// NOTE: There is no need to log parts deletion somewhere else, all deleting parts pass through this function and pass away
 
     auto table_id = getStorageID();
-    if (auto part_log = global_context.getPartLog(table_id.database_name))
+    if (auto part_log = getContext()->getPartLog(table_id.database_name))
     {
         PartLogElement part_log_elem;
 
@@ -1200,7 +1203,7 @@ void MergeTreeData::clearOldPartsFromFilesystem(bool force)
     /// This is needed to close files to avoid they reside on disk after being deleted.
     /// NOTE: we can drop files from cache more selectively but this is good enough.
     if (!parts_to_remove.empty())
-        global_context.dropMMappedFileCache();
+        getContext()->dropMMappedFileCache();
 }
 
 void MergeTreeData::clearPartsFromFilesystem(const DataPartsVector & parts_to_remove)
@@ -1210,14 +1213,21 @@ void MergeTreeData::clearPartsFromFilesystem(const DataPartsVector & parts_to_re
     {
         /// Parallel parts removal.
 
-        size_t num_threads = std::min(size_t(settings->max_part_removal_threads), parts_to_remove.size());
+        size_t num_threads = std::min<size_t>(settings->max_part_removal_threads, parts_to_remove.size());
         ThreadPool pool(num_threads);
 
         /// NOTE: Under heavy system load you may get "Cannot schedule a task" from ThreadPool.
         for (const DataPartPtr & part : parts_to_remove)
         {
-            pool.scheduleOrThrowOnError([&]
+            pool.scheduleOrThrowOnError([&, thread_group = CurrentThread::getGroup()]
             {
+                SCOPE_EXIT_SAFE(
+                    if (thread_group)
+                        CurrentThread::detachQueryIfNotDetached();
+                );
+                if (thread_group)
+                    CurrentThread::attachTo(thread_group);
+
                 LOG_DEBUG(log, "Removing part from filesystem {}", part->name);
                 part->remove();
             });
@@ -1302,7 +1312,7 @@ void MergeTreeData::clearEmptyParts()
         {
             ASTPtr literal = std::make_shared<ASTLiteral>(part->name);
             /// If another replica has already started drop, it's ok, no need to throw.
-            dropPartition(literal, /* detach = */ false, /*drop_part = */ true, global_context, /* throw_if_noop = */ false);
+            dropPartition(literal, /* detach = */ false, /*drop_part = */ true, getContext(), /* throw_if_noop = */ false);
         }
     }
 }
@@ -1325,7 +1335,7 @@ void MergeTreeData::rename(const String & new_table_path, const StorageID & new_
     }
 
     if (!getStorageID().hasUUID())
-        global_context.dropCaches();
+        getContext()->dropCaches();
 
     relative_data_path = new_table_path;
     renameInMemory(new_table_id);
@@ -1347,7 +1357,7 @@ void MergeTreeData::dropAllData()
     /// Tables in atomic databases have UUID and stored in persistent locations.
     /// No need to drop caches (that are keyed by filesystem path) because collision is not possible.
     if (!getStorageID().hasUUID())
-        global_context.dropCaches();
+        getContext()->dropCaches();
 
     LOG_TRACE(log, "dropAllData: removing data from filesystem.");
 
@@ -1472,23 +1482,23 @@ void checkVersionColumnTypesConversion(const IDataType * old_type, const IDataTy
 
 }
 
-void MergeTreeData::checkAlterIsPossible(const AlterCommands & commands, const Context & context) const
+void MergeTreeData::checkAlterIsPossible(const AlterCommands & commands, ContextPtr local_context) const
 {
     /// Check that needed transformations can be applied to the list of columns without considering type conversions.
     StorageInMemoryMetadata new_metadata = getInMemoryMetadata();
     StorageInMemoryMetadata old_metadata = getInMemoryMetadata();
 
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = local_context->getSettingsRef();
 
     if (!settings.allow_non_metadata_alters)
     {
 
-        auto mutation_commands = commands.getMutationCommands(new_metadata, settings.materialize_ttl_after_modify, global_context);
+        auto mutation_commands = commands.getMutationCommands(new_metadata, settings.materialize_ttl_after_modify, getContext());
 
         if (!mutation_commands.empty())
             throw Exception(ErrorCodes::ALTER_OF_COLUMN_IS_FORBIDDEN, "The following alter commands: '{}' will modify data on disk, but setting `allow_non_metadata_alters` is disabled", queryToString(mutation_commands.ast()));
     }
-    commands.apply(new_metadata, global_context);
+    commands.apply(new_metadata, getContext());
 
     /// Set of columns that shouldn't be altered.
     NameSet columns_alter_type_forbidden;
@@ -1551,13 +1561,13 @@ void MergeTreeData::checkAlterIsPossible(const AlterCommands & commands, const C
         old_types.emplace(column.name, column.type.get());
 
     NamesAndTypesList columns_to_check_conversion;
-    auto name_deps = getDependentViewsByColumn(context);
+    auto name_deps = getDependentViewsByColumn(local_context);
     for (const AlterCommand & command : commands)
     {
         /// Just validate partition expression
         if (command.partition)
         {
-            getPartitionIDFromQuery(command.partition, global_context);
+            getPartitionIDFromQuery(command.partition, getContext());
         }
 
         if (command.column_name == merging_params.version_column)
@@ -1691,7 +1701,7 @@ void MergeTreeData::checkAlterIsPossible(const AlterCommands & commands, const C
     if (!columns_to_check_conversion.empty())
     {
         auto old_header = old_metadata.getSampleBlock();
-        performRequiredConversions(old_header, columns_to_check_conversion, global_context);
+        performRequiredConversions(old_header, columns_to_check_conversion, getContext());
     }
 
     if (old_metadata.hasSettingsChanges())
@@ -1722,7 +1732,7 @@ void MergeTreeData::checkAlterIsPossible(const AlterCommands & commands, const C
             }
 
             if (setting_name == "storage_policy")
-                checkStoragePolicy(global_context.getStoragePolicy(new_value.safeGet<String>()));
+                checkStoragePolicy(getContext()->getStoragePolicy(new_value.safeGet<String>()));
         }
     }
 
@@ -1847,7 +1857,7 @@ void MergeTreeData::changeSettings(
         {
             if (change.name == "storage_policy")
             {
-                StoragePolicyPtr new_storage_policy = global_context.getStoragePolicy(change.value.safeGet<String>());
+                StoragePolicyPtr new_storage_policy = getContext()->getStoragePolicy(change.value.safeGet<String>());
                 StoragePolicyPtr old_storage_policy = getStoragePolicy();
 
                 /// StoragePolicy of different version or name is guaranteed to have different pointer
@@ -1884,7 +1894,7 @@ void MergeTreeData::changeSettings(
         MergeTreeSettings copy = *getSettings();
         copy.applyChanges(new_changes);
 
-        copy.sanityCheck(global_context.getSettingsRef());
+        copy.sanityCheck(getContext()->getSettingsRef());
 
         storage_settings.set(std::make_unique<const MergeTreeSettings>(copy));
         StorageInMemoryMetadata new_metadata = getInMemoryMetadata();
@@ -2022,7 +2032,7 @@ MergeTreeData::DataPartsVector MergeTreeData::getActivePartsToReplace(
 }
 
 
-bool MergeTreeData::renameTempPartAndAdd(MutableDataPartPtr & part, SimpleIncrement * increment, Transaction * out_transaction)
+bool MergeTreeData::renameTempPartAndAdd(MutableDataPartPtr & part, SimpleIncrement * increment, Transaction * out_transaction, MergeTreeDeduplicationLog * deduplication_log)
 {
     if (out_transaction && &out_transaction->data != this)
         throw Exception("MergeTreeData::Transaction for one table cannot be used with another. It is a bug.",
@@ -2031,7 +2041,7 @@ bool MergeTreeData::renameTempPartAndAdd(MutableDataPartPtr & part, SimpleIncrem
     DataPartsVector covered_parts;
     {
         auto lock = lockParts();
-        if (!renameTempPartAndReplace(part, increment, out_transaction, lock, &covered_parts))
+        if (!renameTempPartAndReplace(part, increment, out_transaction, lock, &covered_parts, deduplication_log))
             return false;
     }
     if (!covered_parts.empty())
@@ -2044,7 +2054,7 @@ bool MergeTreeData::renameTempPartAndAdd(MutableDataPartPtr & part, SimpleIncrem
 
 bool MergeTreeData::renameTempPartAndReplace(
     MutableDataPartPtr & part, SimpleIncrement * increment, Transaction * out_transaction,
-    std::unique_lock<std::mutex> & lock, DataPartsVector * out_covered_parts)
+    std::unique_lock<std::mutex> & lock, DataPartsVector * out_covered_parts, MergeTreeDeduplicationLog * deduplication_log)
 {
     if (out_transaction && &out_transaction->data != this)
         throw Exception("MergeTreeData::Transaction for one table cannot be used with another. It is a bug.",
@@ -2099,6 +2109,22 @@ bool MergeTreeData::renameTempPartAndReplace(
         return false;
     }
 
+    /// Deduplication log used only from non-replicated MergeTree. Replicated
+    /// tables have their own mechanism. We try to deduplicate at such deep
+    /// level, because only here we know real part name which is required for
+    /// deduplication.
+    if (deduplication_log)
+    {
+        String block_id = part->getZeroLevelPartBlockID();
+        auto res = deduplication_log->addPart(block_id, part_info);
+        if (!res.second)
+        {
+            ProfileEvents::increment(ProfileEvents::DuplicatedInsertedBlocks);
+            LOG_INFO(log, "Block with ID {} already exists as part {}; ignoring it", block_id, res.first.getPartName());
+            return false;
+        }
+    }
+
     /// All checks are passed. Now we can rename the part on disk.
     /// So, we maintain invariant: if a non-temporary part in filesystem then it is in data_parts
     ///
@@ -2155,7 +2181,7 @@ bool MergeTreeData::renameTempPartAndReplace(
 }
 
 MergeTreeData::DataPartsVector MergeTreeData::renameTempPartAndReplace(
-    MutableDataPartPtr & part, SimpleIncrement * increment, Transaction * out_transaction)
+    MutableDataPartPtr & part, SimpleIncrement * increment, Transaction * out_transaction, MergeTreeDeduplicationLog * deduplication_log)
 {
     if (out_transaction && &out_transaction->data != this)
         throw Exception("MergeTreeData::Transaction for one table cannot be used with another. It is a bug.",
@@ -2164,7 +2190,7 @@ MergeTreeData::DataPartsVector MergeTreeData::renameTempPartAndReplace(
     DataPartsVector covered_parts;
     {
         auto lock = lockParts();
-        renameTempPartAndReplace(part, increment, out_transaction, lock, &covered_parts);
+        renameTempPartAndReplace(part, increment, out_transaction, lock, &covered_parts, deduplication_log);
     }
     return covered_parts;
 }
@@ -2521,7 +2547,7 @@ void MergeTreeData::delayInsertOrThrowIfNeeded(Poco::Event * until) const
     if (settings->inactive_parts_to_throw_insert > 0 || settings->inactive_parts_to_delay_insert > 0)
     {
         size_t inactive_parts_count_in_partition = getMaxInactivePartsCountForPartition();
-        if (inactive_parts_count_in_partition >= settings->inactive_parts_to_throw_insert)
+        if (settings->inactive_parts_to_throw_insert > 0 && inactive_parts_count_in_partition >= settings->inactive_parts_to_throw_insert)
         {
             ProfileEvents::increment(ProfileEvents::RejectedInserts);
             throw Exception(
@@ -2732,7 +2758,8 @@ void MergeTreeData::removePartContributionToColumnSizes(const DataPartPtr & part
     }
 }
 
-void MergeTreeData::checkAlterPartitionIsPossible(const PartitionCommands & commands, const StorageMetadataPtr & /*metadata_snapshot*/, const Settings & settings) const
+void MergeTreeData::checkAlterPartitionIsPossible(
+    const PartitionCommands & commands, const StorageMetadataPtr & /*metadata_snapshot*/, const Settings & settings) const
 {
     for (const auto & command : commands)
     {
@@ -2752,7 +2779,7 @@ void MergeTreeData::checkAlterPartitionIsPossible(const PartitionCommands & comm
             else
             {
                 /// We are able to parse it
-                getPartitionIDFromQuery(command.partition, global_context);
+                getPartitionIDFromQuery(command.partition, getContext());
             }
         }
     }
@@ -2760,7 +2787,7 @@ void MergeTreeData::checkAlterPartitionIsPossible(const PartitionCommands & comm
 
 void MergeTreeData::checkPartitionCanBeDropped(const ASTPtr & partition)
 {
-    const String partition_id = getPartitionIDFromQuery(partition, global_context);
+    const String partition_id = getPartitionIDFromQuery(partition, getContext());
     auto parts_to_remove = getDataPartsVectorInPartition(MergeTreeDataPartState::Committed, partition_id);
 
     UInt64 partition_size = 0;
@@ -2769,7 +2796,7 @@ void MergeTreeData::checkPartitionCanBeDropped(const ASTPtr & partition)
         partition_size += part->getBytesOnDisk();
 
     auto table_id = getStorageID();
-    global_context.checkPartitionCanBeDropped(table_id.database_name, table_id.table_name, partition_size);
+    getContext()->checkPartitionCanBeDropped(table_id.database_name, table_id.table_name, partition_size);
 }
 
 void MergeTreeData::checkPartCanBeDropped(const ASTPtr & part_ast)
@@ -2780,17 +2807,17 @@ void MergeTreeData::checkPartCanBeDropped(const ASTPtr & part_ast)
         throw Exception(ErrorCodes::NO_SUCH_DATA_PART, "No part {} in committed state", part_name);
 
     auto table_id = getStorageID();
-    global_context.checkPartitionCanBeDropped(table_id.database_name, table_id.table_name, part->getBytesOnDisk());
+    getContext()->checkPartitionCanBeDropped(table_id.database_name, table_id.table_name, part->getBytesOnDisk());
 }
 
-void MergeTreeData::movePartitionToDisk(const ASTPtr & partition, const String & name, bool moving_part, const Context & context)
+void MergeTreeData::movePartitionToDisk(const ASTPtr & partition, const String & name, bool moving_part, ContextPtr local_context)
 {
     String partition_id;
 
     if (moving_part)
         partition_id = partition->as<ASTLiteral &>().value.safeGet<String>();
     else
-        partition_id = getPartitionIDFromQuery(partition, context);
+        partition_id = getPartitionIDFromQuery(partition, local_context);
 
     DataPartsVector parts;
     if (moving_part)
@@ -2828,14 +2855,14 @@ void MergeTreeData::movePartitionToDisk(const ASTPtr & partition, const String &
 }
 
 
-void MergeTreeData::movePartitionToVolume(const ASTPtr & partition, const String & name, bool moving_part, const Context & context)
+void MergeTreeData::movePartitionToVolume(const ASTPtr & partition, const String & name, bool moving_part, ContextPtr local_context)
 {
     String partition_id;
 
     if (moving_part)
         partition_id = partition->as<ASTLiteral &>().value.safeGet<String>();
     else
-        partition_id = getPartitionIDFromQuery(partition, context);
+        partition_id = getPartitionIDFromQuery(partition, local_context);
 
     DataPartsVector parts;
     if (moving_part)
@@ -2853,7 +2880,7 @@ void MergeTreeData::movePartitionToVolume(const ASTPtr & partition, const String
         throw Exception("Volume " + name + " does not exists on policy " + getStoragePolicy()->getName(), ErrorCodes::UNKNOWN_DISK);
 
     if (parts.empty())
-        throw Exception("Nothing to move", ErrorCodes::NO_SUCH_DATA_PART);
+        throw Exception("Nothing to move (сheck that the partition exists).", ErrorCodes::NO_SUCH_DATA_PART);
 
     parts.erase(std::remove_if(parts.begin(), parts.end(), [&](auto part_ptr)
         {
@@ -2882,7 +2909,7 @@ void MergeTreeData::movePartitionToVolume(const ASTPtr & partition, const String
         throw Exception("Cannot move parts because moves are manually disabled", ErrorCodes::ABORTED);
 }
 
-void MergeTreeData::fetchPartition(const ASTPtr & /*partition*/, const StorageMetadataPtr & /*metadata_snapshot*/, const String & /*from*/, const Context & /*query_context*/)
+void MergeTreeData::fetchPartition(const ASTPtr & /*partition*/, const StorageMetadataPtr & /*metadata_snapshot*/, const String & /*from*/, ContextPtr /*query_context*/)
 {
     throw Exception(ErrorCodes::NOT_IMPLEMENTED, "FETCH PARTITION is not supported by storage {}", getName());
 }
@@ -2890,7 +2917,7 @@ void MergeTreeData::fetchPartition(const ASTPtr & /*partition*/, const StorageMe
 Pipe MergeTreeData::alterPartition(
     const StorageMetadataPtr & metadata_snapshot,
     const PartitionCommands & commands,
-    const Context & query_context)
+    ContextPtr query_context)
 {
     PartitionCommandsResultInfo result;
     for (const PartitionCommand & command : commands)
@@ -2927,7 +2954,7 @@ Pipe MergeTreeData::alterPartition(
 
                     case PartitionCommand::MoveDestinationType::TABLE:
                         checkPartitionCanBeDropped(command.partition);
-                        String dest_database = query_context.resolveDatabase(command.to_database);
+                        String dest_database = query_context->resolveDatabase(command.to_database);
                         auto dest_storage = DatabaseCatalog::instance().getTable({dest_database, command.to_table}, query_context);
                         movePartitionToTable(dest_storage, command.partition, query_context);
                         break;
@@ -2938,7 +2965,7 @@ Pipe MergeTreeData::alterPartition(
             case PartitionCommand::REPLACE_PARTITION:
             {
                 checkPartitionCanBeDropped(command.partition);
-                String from_database = query_context.resolveDatabase(command.from_database);
+                String from_database = query_context->resolveDatabase(command.from_database);
                 auto from_storage = DatabaseCatalog::instance().getTable({from_database, command.from_table}, query_context);
                 replacePartitionFrom(from_storage, command.partition, command.replace, query_context);
             }
@@ -2950,28 +2977,28 @@ Pipe MergeTreeData::alterPartition(
 
             case PartitionCommand::FREEZE_PARTITION:
             {
-                auto lock = lockForShare(query_context.getCurrentQueryId(), query_context.getSettingsRef().lock_acquire_timeout);
+                auto lock = lockForShare(query_context->getCurrentQueryId(), query_context->getSettingsRef().lock_acquire_timeout);
                 current_command_results = freezePartition(command.partition, metadata_snapshot, command.with_name, query_context, lock);
             }
             break;
 
             case PartitionCommand::FREEZE_ALL_PARTITIONS:
             {
-                auto lock = lockForShare(query_context.getCurrentQueryId(), query_context.getSettingsRef().lock_acquire_timeout);
+                auto lock = lockForShare(query_context->getCurrentQueryId(), query_context->getSettingsRef().lock_acquire_timeout);
                 current_command_results = freezeAll(command.with_name, metadata_snapshot, query_context, lock);
             }
             break;
 
             case PartitionCommand::UNFREEZE_PARTITION:
             {
-                auto lock = lockForShare(query_context.getCurrentQueryId(), query_context.getSettingsRef().lock_acquire_timeout);
+                auto lock = lockForShare(query_context->getCurrentQueryId(), query_context->getSettingsRef().lock_acquire_timeout);
                 current_command_results = unfreezePartition(command.partition, command.with_name, query_context, lock);
             }
             break;
 
             case PartitionCommand::UNFREEZE_ALL_PARTITIONS:
             {
-                auto lock = lockForShare(query_context.getCurrentQueryId(), query_context.getSettingsRef().lock_acquire_timeout);
+                auto lock = lockForShare(query_context->getCurrentQueryId(), query_context->getSettingsRef().lock_acquire_timeout);
                 current_command_results = unfreezeAll(command.with_name, query_context, lock);
             }
 
@@ -2982,13 +3009,13 @@ Pipe MergeTreeData::alterPartition(
         result.insert(result.end(), current_command_results.begin(), current_command_results.end());
     }
 
-    if (query_context.getSettingsRef().alter_partition_verbose_result)
+    if (query_context->getSettingsRef().alter_partition_verbose_result)
         return convertCommandsResultToSource(result);
 
     return {};
 }
 
-String MergeTreeData::getPartitionIDFromQuery(const ASTPtr & ast, const Context & context) const
+String MergeTreeData::getPartitionIDFromQuery(const ASTPtr & ast, ContextPtr local_context) const
 {
     const auto & partition_ast = ast->as<ASTPartition &>();
 
@@ -3030,7 +3057,12 @@ String MergeTreeData::getPartitionIDFromQuery(const ASTPtr & ast, const Context
         ReadBufferFromMemory right_paren_buf(")", 1);
         ConcatReadBuffer buf({&left_paren_buf, &fields_buf, &right_paren_buf});
 
-        auto input_format = FormatFactory::instance().getInput("Values", buf, metadata_snapshot->getPartitionKey().sample_block, context, context.getSettingsRef().max_block_size);
+        auto input_format = FormatFactory::instance().getInput(
+            "Values",
+            buf,
+            metadata_snapshot->getPartitionKey().sample_block,
+            local_context,
+            local_context->getSettingsRef().max_block_size);
         auto input_stream = std::make_shared<InputStreamFromInputFormat>(input_format);
 
         auto block = input_stream->read();
@@ -3143,7 +3175,7 @@ void MergeTreeData::validateDetachedPartName(const String & name) const
                             ErrorCodes::BAD_DATA_PART_NAME);
 }
 
-void MergeTreeData::dropDetached(const ASTPtr & partition, bool part, const Context & context)
+void MergeTreeData::dropDetached(const ASTPtr & partition, bool part, ContextPtr local_context)
 {
     PartsTemporaryRename renamed_parts(*this, "detached/");
 
@@ -3155,7 +3187,7 @@ void MergeTreeData::dropDetached(const ASTPtr & partition, bool part, const Cont
     }
     else
     {
-        String partition_id = getPartitionIDFromQuery(partition, context);
+        String partition_id = getPartitionIDFromQuery(partition, local_context);
         DetachedPartsInfo detached_parts = getDetachedParts();
         for (const auto & part_info : detached_parts)
             if (part_info.valid_name && part_info.partition_id == partition_id
@@ -3177,7 +3209,7 @@ void MergeTreeData::dropDetached(const ASTPtr & partition, bool part, const Cont
 }
 
 MergeTreeData::MutableDataPartsVector MergeTreeData::tryLoadPartsToAttach(const ASTPtr & partition, bool attach_part,
-        const Context & context, PartsTemporaryRename & renamed_parts)
+        ContextPtr local_context, PartsTemporaryRename & renamed_parts)
 {
     const String source_dir = "detached/";
 
@@ -3196,7 +3228,7 @@ MergeTreeData::MutableDataPartsVector MergeTreeData::tryLoadPartsToAttach(const
     }
     else
     {
-        String partition_id = getPartitionIDFromQuery(partition, context);
+        String partition_id = getPartitionIDFromQuery(partition, local_context);
         LOG_DEBUG(log, "Looking for parts for partition {} in {}", partition_id, source_dir);
         ActiveDataPartSet active_parts(format_version);
 
@@ -3422,7 +3454,7 @@ CompressionCodecPtr MergeTreeData::getCompressionCodecForPart(size_t part_size_c
     if (best_ttl_entry)
         return CompressionCodecFactory::instance().get(best_ttl_entry->recompression_codec, {});
 
-    return global_context.chooseCompressionCodec(
+    return getContext()->chooseCompressionCodec(
         part_size_compressed,
         static_cast<double>(part_size_compressed) / getTotalActiveSizeInBytes());
 }
@@ -3583,7 +3615,7 @@ bool MergeTreeData::isPrimaryOrMinMaxKeyColumnPossiblyWrappedInFunctions(
 }
 
 bool MergeTreeData::mayBenefitFromIndexForIn(
-    const ASTPtr & left_in_operand, const Context &, const StorageMetadataPtr & metadata_snapshot) const
+    const ASTPtr & left_in_operand, ContextPtr, const StorageMetadataPtr & metadata_snapshot) const
 {
     /// Make sure that the left side of the IN operator contain part of the key.
     /// If there is a tuple on the left side of the IN operator, at least one item of the tuple
@@ -3747,7 +3779,7 @@ MergeTreeData::PathsWithDisks MergeTreeData::getRelativeDataPathsWithDisks() con
     return res;
 }
 
-MergeTreeData::MatcherFn MergeTreeData::getPartitionMatcher(const ASTPtr & partition_ast, const Context & context) const
+MergeTreeData::MatcherFn MergeTreeData::getPartitionMatcher(const ASTPtr & partition_ast, ContextPtr local_context) const
 {
     bool prefixed = false;
     String id;
@@ -3763,10 +3795,10 @@ MergeTreeData::MatcherFn MergeTreeData::getPartitionMatcher(const ASTPtr & parti
             prefixed = true;
         }
         else
-            id = getPartitionIDFromQuery(partition_ast, context);
+            id = getPartitionIDFromQuery(partition_ast, local_context);
     }
     else
-        id = getPartitionIDFromQuery(partition_ast, context);
+        id = getPartitionIDFromQuery(partition_ast, local_context);
 
     return [prefixed, id](const String & partition_id)
     {
@@ -3781,28 +3813,28 @@ PartitionCommandsResultInfo MergeTreeData::freezePartition(
     const ASTPtr & partition_ast,
     const StorageMetadataPtr & metadata_snapshot,
     const String & with_name,
-    const Context & context,
+    ContextPtr local_context,
     TableLockHolder &)
 {
-    return freezePartitionsByMatcher(getPartitionMatcher(partition_ast, context), metadata_snapshot, with_name, context);
+    return freezePartitionsByMatcher(getPartitionMatcher(partition_ast, local_context), metadata_snapshot, with_name, local_context);
 }
 
 PartitionCommandsResultInfo MergeTreeData::freezeAll(
     const String & with_name,
     const StorageMetadataPtr & metadata_snapshot,
-    const Context & context,
+    ContextPtr local_context,
     TableLockHolder &)
 {
-    return freezePartitionsByMatcher([] (const String &) { return true; }, metadata_snapshot, with_name, context);
+    return freezePartitionsByMatcher([] (const String &) { return true; }, metadata_snapshot, with_name, local_context);
 }
 
 PartitionCommandsResultInfo MergeTreeData::freezePartitionsByMatcher(
     MatcherFn matcher,
     const StorageMetadataPtr & metadata_snapshot,
     const String & with_name,
-    const Context & context)
+    ContextPtr local_context)
 {
-    String clickhouse_path = Poco::Path(context.getPath()).makeAbsolute().toString();
+    String clickhouse_path = Poco::Path(local_context->getPath()).makeAbsolute().toString();
     String default_shadow_path = clickhouse_path + "shadow/";
     Poco::File(default_shadow_path).createDirectories();
     auto increment = Increment(default_shadow_path + "increment.txt").get(true);
@@ -3856,21 +3888,21 @@ PartitionCommandsResultInfo MergeTreeData::freezePartitionsByMatcher(
 PartitionCommandsResultInfo MergeTreeData::unfreezePartition(
     const ASTPtr & partition,
     const String & backup_name,
-    const Context & context,
+    ContextPtr local_context,
     TableLockHolder &)
 {
-    return unfreezePartitionsByMatcher(getPartitionMatcher(partition, context), backup_name, context);
+    return unfreezePartitionsByMatcher(getPartitionMatcher(partition, local_context), backup_name, local_context);
 }
 
 PartitionCommandsResultInfo MergeTreeData::unfreezeAll(
     const String & backup_name,
-    const Context & context,
+    ContextPtr local_context,
     TableLockHolder &)
 {
-    return unfreezePartitionsByMatcher([] (const String &) { return true; }, backup_name, context);
+    return unfreezePartitionsByMatcher([] (const String &) { return true; }, backup_name, local_context);
 }
 
-PartitionCommandsResultInfo MergeTreeData::unfreezePartitionsByMatcher(MatcherFn matcher, const String & backup_name, const Context &)
+PartitionCommandsResultInfo MergeTreeData::unfreezePartitionsByMatcher(MatcherFn matcher, const String & backup_name, ContextPtr)
 {
     auto backup_path = std::filesystem::path("shadow") / escapeForFileName(backup_name) / relative_data_path;
 
@@ -3953,7 +3985,7 @@ void MergeTreeData::writePartLog(
 try
 {
     auto table_id = getStorageID();
-    auto part_log = global_context.getPartLog(table_id.database_name);
+    auto part_log = getContext()->getPartLog(table_id.database_name);
     if (!part_log)
         return;
 
@@ -4220,7 +4252,7 @@ NamesAndTypesList MergeTreeData::getVirtuals() const
 
 size_t MergeTreeData::getTotalMergesWithTTLInMergeList() const
 {
-    return global_context.getMergeList().getMergesWithTTLCount();
+    return getContext()->getMergeList().getMergesWithTTLCount();
 }
 
 void MergeTreeData::addPartContributionToDataVolume(const DataPartPtr & part)
diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h
index 63d776a838c..6c0bda07bb1 100644
--- a/src/Storages/MergeTree/MergeTreeData.h
+++ b/src/Storages/MergeTree/MergeTreeData.h
@@ -54,6 +54,7 @@ struct CurrentlySubmergingEmergingTagger;
 class ExpressionActions;
 using ExpressionActionsPtr = std::shared_ptr<ExpressionActions>;
 using ManyExpressionActions = std::vector<ExpressionActionsPtr>;
+class MergeTreeDeduplicationLog;
 
 namespace ErrorCodes
 {
@@ -110,7 +111,7 @@ namespace ErrorCodes
 /// - MergeTreeDataWriter
 /// - MergeTreeDataMergerMutator
 
-class MergeTreeData : public IStorage
+class MergeTreeData : public IStorage, public WithContext
 {
 public:
     /// Function to call if the part is suspected to contain corrupt data.
@@ -348,7 +349,7 @@ public:
     MergeTreeData(const StorageID & table_id_,
                   const String & relative_data_path_,
                   const StorageInMemoryMetadata & metadata_,
-                  Context & context_,
+                  ContextPtr context_,
                   const String & date_column_name,
                   const MergingParams & merging_params_,
                   std::unique_ptr<MergeTreeSettings> settings_,
@@ -374,7 +375,7 @@ public:
 
     NamesAndTypesList getVirtuals() const override;
 
-    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, const Context &, const StorageMetadataPtr & metadata_snapshot) const override;
+    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, ContextPtr, const StorageMetadataPtr & metadata_snapshot) const override;
 
     /// Load the set of data parts from disk. Call once - immediately after the object is created.
     void loadDataParts(bool skip_sanity_checks);
@@ -397,10 +398,10 @@ public:
 
     void validateDetachedPartName(const String & name) const;
 
-    void dropDetached(const ASTPtr & partition, bool part, const Context & context);
+    void dropDetached(const ASTPtr & partition, bool part, ContextPtr context);
 
     MutableDataPartsVector tryLoadPartsToAttach(const ASTPtr & partition, bool attach_part,
-            const Context & context, PartsTemporaryRename & renamed_parts);
+            ContextPtr context, PartsTemporaryRename & renamed_parts);
 
     /// Returns Committed parts
     DataParts getDataParts() const;
@@ -447,18 +448,18 @@ public:
     /// active set later with out_transaction->commit()).
     /// Else, commits the part immediately.
     /// Returns true if part was added. Returns false if part is covered by bigger part.
-    bool renameTempPartAndAdd(MutableDataPartPtr & part, SimpleIncrement * increment = nullptr, Transaction * out_transaction = nullptr);
+    bool renameTempPartAndAdd(MutableDataPartPtr & part, SimpleIncrement * increment = nullptr, Transaction * out_transaction = nullptr, MergeTreeDeduplicationLog * deduplication_log = nullptr);
 
     /// The same as renameTempPartAndAdd but the block range of the part can contain existing parts.
     /// Returns all parts covered by the added part (in ascending order).
     /// If out_transaction == nullptr, marks covered parts as Outdated.
     DataPartsVector renameTempPartAndReplace(
-        MutableDataPartPtr & part, SimpleIncrement * increment = nullptr, Transaction * out_transaction = nullptr);
+        MutableDataPartPtr & part, SimpleIncrement * increment = nullptr, Transaction * out_transaction = nullptr, MergeTreeDeduplicationLog * deduplication_log = nullptr);
 
     /// Low-level version of previous one, doesn't lock mutex
     bool renameTempPartAndReplace(
             MutableDataPartPtr & part, SimpleIncrement * increment, Transaction * out_transaction, DataPartsLock & lock,
-            DataPartsVector * out_covered_parts = nullptr);
+            DataPartsVector * out_covered_parts = nullptr, MergeTreeDeduplicationLog * deduplication_log = nullptr);
 
 
     /// Remove parts from working set immediately (without wait for background
@@ -530,7 +531,7 @@ public:
     /// - all type conversions can be done.
     /// - columns corresponding to primary key, indices, sign, sampling expression and date are not affected.
     /// If something is wrong, throws an exception.
-    void checkAlterIsPossible(const AlterCommands & commands, const Context & context) const override;
+    void checkAlterIsPossible(const AlterCommands & commands, ContextPtr context) const override;
 
     /// Checks if the Mutation can be performed.
     /// (currently no additional checks: always ok)
@@ -565,35 +566,34 @@ public:
         const ASTPtr & partition,
         const StorageMetadataPtr & metadata_snapshot,
         const String & with_name,
-        const Context & context,
+        ContextPtr context,
         TableLockHolder & table_lock_holder);
 
     /// Freezes all parts.
     PartitionCommandsResultInfo freezeAll(
         const String & with_name,
         const StorageMetadataPtr & metadata_snapshot,
-        const Context & context,
+        ContextPtr context,
         TableLockHolder & table_lock_holder);
 
     /// Unfreezes particular partition.
     PartitionCommandsResultInfo unfreezePartition(
         const ASTPtr & partition,
         const String & backup_name,
-        const Context & context,
+        ContextPtr context,
         TableLockHolder & table_lock_holder);
 
     /// Unfreezes all parts.
     PartitionCommandsResultInfo unfreezeAll(
         const String & backup_name,
-        const Context & context,
+        ContextPtr context,
         TableLockHolder & table_lock_holder);
 
-public:
     /// Moves partition to specified Disk
-    void movePartitionToDisk(const ASTPtr & partition, const String & name, bool moving_part, const Context & context);
+    void movePartitionToDisk(const ASTPtr & partition, const String & name, bool moving_part, ContextPtr context);
 
     /// Moves partition to specified Volume
-    void movePartitionToVolume(const ASTPtr & partition, const String & name, bool moving_part, const Context & context);
+    void movePartitionToVolume(const ASTPtr & partition, const String & name, bool moving_part, ContextPtr context);
 
     void checkPartitionCanBeDropped(const ASTPtr & partition) override;
 
@@ -602,7 +602,7 @@ public:
     Pipe alterPartition(
         const StorageMetadataPtr & metadata_snapshot,
         const PartitionCommands & commands,
-        const Context & query_context) override;
+        ContextPtr query_context) override;
 
     size_t getColumnCompressedSize(const std::string & name) const
     {
@@ -618,7 +618,7 @@ public:
     }
 
     /// For ATTACH/DETACH/DROP PARTITION.
-    String getPartitionIDFromQuery(const ASTPtr & ast, const Context & context) const;
+    String getPartitionIDFromQuery(const ASTPtr & ast, ContextPtr context) const;
 
     /// Extracts MergeTreeData of other *MergeTree* storage
     ///  and checks that their structure suitable for ALTER TABLE ATTACH PARTITION FROM
@@ -709,12 +709,12 @@ public:
 
     /// Choose disk with max available free space
     /// Reserves 0 bytes
-    ReservationPtr makeEmptyReservationOnLargestDisk() { return getStoragePolicy()->makeEmptyReservationOnLargestDisk(); }
+    ReservationPtr makeEmptyReservationOnLargestDisk() const { return getStoragePolicy()->makeEmptyReservationOnLargestDisk(); }
 
     Disks getDisksByType(DiskType::Type type) const { return getStoragePolicy()->getDisksByType(type); }
 
     /// Return alter conversions for part which must be applied on fly.
-    AlterConversions getAlterConversionsForPart(const MergeTreeDataPartPtr part) const;
+    AlterConversions getAlterConversionsForPart(MergeTreeDataPartPtr part) const;
     /// Returns destination disk or volume for the TTL rule according to current storage policy
     /// 'is_insert' - is TTL move performed on new data part insert.
     SpacePtr getDestinationForMoveTTL(const TTLDescription & move_ttl, bool is_insert = false) const;
@@ -733,8 +733,6 @@ public:
 
     MergeTreeDataFormatVersion format_version;
 
-    Context & global_context;
-
     /// Merging params - what additional actions to perform during merge.
     const MergingParams merging_params;
 
@@ -894,7 +892,7 @@ protected:
     }
 
     std::optional<UInt64> totalRowsByPartitionPredicateImpl(
-        const SelectQueryInfo & query_info, const Context & context, const DataPartsVector & parts) const;
+        const SelectQueryInfo & query_info, ContextPtr context, const DataPartsVector & parts) const;
 
     static decltype(auto) getStateModifier(DataPartState state)
     {
@@ -960,19 +958,19 @@ protected:
 
     /// Common part for |freezePartition()| and |freezeAll()|.
     using MatcherFn = std::function<bool(const String &)>;
-    PartitionCommandsResultInfo freezePartitionsByMatcher(MatcherFn matcher, const StorageMetadataPtr & metadata_snapshot, const String & with_name, const Context & context);
-    PartitionCommandsResultInfo unfreezePartitionsByMatcher(MatcherFn matcher, const String & backup_name, const Context & context);
+    PartitionCommandsResultInfo freezePartitionsByMatcher(MatcherFn matcher, const StorageMetadataPtr & metadata_snapshot, const String & with_name, ContextPtr context);
+    PartitionCommandsResultInfo unfreezePartitionsByMatcher(MatcherFn matcher, const String & backup_name, ContextPtr context);
 
     // Partition helpers
     bool canReplacePartition(const DataPartPtr & src_part) const;
 
-    virtual void dropPartition(const ASTPtr & partition, bool detach, bool drop_part, const Context & context, bool throw_if_noop = true) = 0;
-    virtual PartitionCommandsResultInfo attachPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, bool part, const Context & context) = 0;
-    virtual void replacePartitionFrom(const StoragePtr & source_table, const ASTPtr & partition, bool replace, const Context & context) = 0;
-    virtual void movePartitionToTable(const StoragePtr & dest_table, const ASTPtr & partition, const Context & context) = 0;
+    virtual void dropPartition(const ASTPtr & partition, bool detach, bool drop_part, ContextPtr context, bool throw_if_noop = true) = 0;
+    virtual PartitionCommandsResultInfo attachPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, bool part, ContextPtr context) = 0;
+    virtual void replacePartitionFrom(const StoragePtr & source_table, const ASTPtr & partition, bool replace, ContextPtr context) = 0;
+    virtual void movePartitionToTable(const StoragePtr & dest_table, const ASTPtr & partition, ContextPtr context) = 0;
 
     /// Makes sense only for replicated tables
-    virtual void fetchPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, const String & from, const Context & query_context);
+    virtual void fetchPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, const String & from, ContextPtr query_context);
 
     void writePartLog(
         PartLogElement::Type type,
@@ -1047,7 +1045,7 @@ private:
     mutable std::mutex query_id_set_mutex;
 
     // Get partition matcher for FREEZE / UNFREEZE queries.
-    MatcherFn getPartitionMatcher(const ASTPtr & partition, const Context & context) const;
+    MatcherFn getPartitionMatcher(const ASTPtr & partition, ContextPtr context) const;
 };
 
 /// RAII struct to record big parts that are submerging or emerging.
diff --git a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp
index 4269aa89ad1..dfebd88abe9 100644
--- a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp
@@ -651,7 +651,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor
     MergeList::Entry & merge_entry,
     TableLockHolder &,
     time_t time_of_merge,
-    const Context & context,
+    ContextPtr context,
     const ReservationPtr & space_reservation,
     bool deduplicate,
     const Names & deduplicate_by_columns)
@@ -751,7 +751,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor
     /// deadlock is impossible.
     auto compression_codec = data.getCompressionCodecForPart(merge_entry->total_size_bytes_compressed, new_data_part->ttl_infos, time_of_merge);
 
-    auto tmp_disk = context.getTemporaryVolume()->getDisk();
+    auto tmp_disk = context->getTemporaryVolume()->getDisk();
     String rows_sources_file_path;
     std::unique_ptr<WriteBufferFromFileBase> rows_sources_uncompressed_write_buf;
     std::unique_ptr<WriteBuffer> rows_sources_write_buf;
@@ -910,7 +910,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor
     {
         const auto & indices = metadata_snapshot->getSecondaryIndices();
         merged_stream = std::make_shared<ExpressionBlockInputStream>(
-            merged_stream, indices.getSingleExpressionForIndices(metadata_snapshot->getColumns(), data.global_context));
+            merged_stream, indices.getSingleExpressionForIndices(metadata_snapshot->getColumns(), data.getContext()));
         merged_stream = std::make_shared<MaterializingBlockInputStream>(merged_stream);
     }
 
@@ -1099,7 +1099,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mutatePartToTempor
     const MutationCommands & commands,
     MergeListEntry & merge_entry,
     time_t time_of_mutation,
-    const Context & context,
+    ContextPtr context,
     const ReservationPtr & space_reservation,
     TableLockHolder &)
 {
@@ -1113,12 +1113,12 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mutatePartToTempor
     const auto & source_part = future_part.parts[0];
     auto storage_from_source_part = StorageFromMergeTreeDataPart::create(source_part);
 
-    auto context_for_reading = context;
-    context_for_reading.setSetting("max_streams_to_max_threads_ratio", 1);
-    context_for_reading.setSetting("max_threads", 1);
+    auto context_for_reading = Context::createCopy(context);
+    context_for_reading->setSetting("max_streams_to_max_threads_ratio", 1);
+    context_for_reading->setSetting("max_threads", 1);
     /// Allow mutations to work when force_index_by_date or force_primary_key is on.
-    context_for_reading.setSetting("force_index_by_date", Field(0));
-    context_for_reading.setSetting("force_primary_key", Field(0));
+    context_for_reading->setSetting("force_index_by_date", Field(0));
+    context_for_reading->setSetting("force_primary_key", Field(0));
 
     MutationCommands commands_for_part;
     for (const auto & command : commands)
@@ -1129,7 +1129,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mutatePartToTempor
     }
 
     if (source_part->isStoredOnDisk() && !isStorageTouchedByMutations(
-        storage_from_source_part, metadata_snapshot, commands_for_part, context_for_reading))
+        storage_from_source_part, metadata_snapshot, commands_for_part, Context::createCopy(context_for_reading)))
     {
         LOG_TRACE(log, "Part {} doesn't change up to mutation version {}", source_part->name, future_part.part_info.mutation);
         return data.cloneAndLoadDataPartOnSameDisk(source_part, "tmp_clone_", future_part.part_info, metadata_snapshot);
@@ -1690,7 +1690,7 @@ std::set<MergeTreeIndexPtr> MergeTreeDataMergerMutator::getIndicesToRecalculate(
     BlockInputStreamPtr & input_stream,
     const NamesAndTypesList & updated_columns,
     const StorageMetadataPtr & metadata_snapshot,
-    const Context & context)
+    ContextPtr context)
 {
     /// Checks if columns used in skipping indexes modified.
     const auto & index_factory = MergeTreeIndexFactory::instance();
diff --git a/src/Storages/MergeTree/MergeTreeDataMergerMutator.h b/src/Storages/MergeTree/MergeTreeDataMergerMutator.h
index 2f3a898ba84..d4dc0ce8499 100644
--- a/src/Storages/MergeTree/MergeTreeDataMergerMutator.h
+++ b/src/Storages/MergeTree/MergeTreeDataMergerMutator.h
@@ -125,7 +125,7 @@ public:
         MergeListEntry & merge_entry,
         TableLockHolder & table_lock_holder,
         time_t time_of_merge,
-        const Context & context,
+        ContextPtr context,
         const ReservationPtr & space_reservation,
         bool deduplicate,
         const Names & deduplicate_by_columns);
@@ -137,7 +137,7 @@ public:
         const MutationCommands & commands,
         MergeListEntry & merge_entry,
         time_t time_of_mutation,
-        const Context & context,
+        ContextPtr context,
         const ReservationPtr & space_reservation,
         TableLockHolder & table_lock_holder);
 
@@ -199,7 +199,7 @@ private:
         BlockInputStreamPtr & input_stream,
         const NamesAndTypesList & updated_columns,
         const StorageMetadataPtr & metadata_snapshot,
-        const Context & context);
+        ContextPtr context);
 
     /// Override all columns of new part using mutating_stream
     void mutateAllPartColumns(
diff --git a/src/Storages/MergeTree/MergeTreeDataPartInMemory.cpp b/src/Storages/MergeTree/MergeTreeDataPartInMemory.cpp
index 96fa411339c..045ab488ada 100644
--- a/src/Storages/MergeTree/MergeTreeDataPartInMemory.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataPartInMemory.cpp
@@ -88,7 +88,7 @@ void MergeTreeDataPartInMemory::flushToDisk(const String & base_path, const Stri
 
     disk->createDirectories(destination_path);
 
-    auto compression_codec = storage.global_context.chooseCompressionCodec(0, 0);
+    auto compression_codec = storage.getContext()->chooseCompressionCodec(0, 0);
     auto indices = MergeTreeIndexFactory::instance().getMany(metadata_snapshot->getSecondaryIndices());
     MergedBlockOutputStream out(new_data_part, metadata_snapshot, columns, indices, compression_codec);
     out.writePrefix();
diff --git a/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp b/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp
index a2f7440b2e3..a1691fe7931 100644
--- a/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp
@@ -337,7 +337,7 @@ void MergeTreeDataPartWriterWide::writeColumn(
         serializations[name]->serializeBinaryBulkStatePrefix(serialize_settings, it->second);
     }
 
-    const auto & global_settings = storage.global_context.getSettingsRef();
+    const auto & global_settings = storage.getContext()->getSettingsRef();
     ISerialization::SerializeBinaryBulkSettings serialize_settings;
     serialize_settings.getter = createStreamGetter(name_and_type, offset_columns);
     serialize_settings.low_cardinality_max_dictionary_size = global_settings.low_cardinality_max_dictionary_size;
@@ -501,7 +501,7 @@ void MergeTreeDataPartWriterWide::validateColumnOfFixedSize(const String & name,
 
 void MergeTreeDataPartWriterWide::finishDataSerialization(IMergeTreeDataPart::Checksums & checksums, bool sync)
 {
-    const auto & global_settings = storage.global_context.getSettingsRef();
+    const auto & global_settings = storage.getContext()->getSettingsRef();
     ISerialization::SerializeBinaryBulkSettings serialize_settings;
     serialize_settings.low_cardinality_max_dictionary_size = global_settings.low_cardinality_max_dictionary_size;
     serialize_settings.low_cardinality_use_single_dictionary_for_part = global_settings.low_cardinality_use_single_dictionary_for_part != 0;
diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
index f3759107912..ddb140989f6 100644
--- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
@@ -1,5 +1,5 @@
 #include <boost/rational.hpp>   /// For calculations related to sampling coefficients.
-#include <ext/scope_guard.h>
+#include <ext/scope_guard_safe.h>
 #include <optional>
 #include <unordered_set>
 
@@ -152,7 +152,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::read(
     const Names & column_names_to_return,
     const StorageMetadataPtr & metadata_snapshot,
     const SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     const UInt64 max_block_size,
     const unsigned num_streams,
     const PartitionIdToMaxBlock * max_block_numbers_to_read) const
@@ -168,7 +168,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts(
     const Names & column_names_to_return,
     const StorageMetadataPtr & metadata_snapshot,
     const SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     const UInt64 max_block_size,
     const unsigned num_streams,
     const PartitionIdToMaxBlock * max_block_numbers_to_read) const
@@ -238,7 +238,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts(
 
     metadata_snapshot->check(real_column_names, data.getVirtuals(), data.getStorageID());
 
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
     const auto & primary_key = metadata_snapshot->getPrimaryKey();
     Names primary_key_columns = primary_key.column_names;
 
@@ -280,9 +280,9 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts(
         }
     }
 
-    const Context & query_context = context.hasQueryContext() ? context.getQueryContext() : context;
+    auto query_context = context->hasQueryContext() ? context->getQueryContext() : context;
 
-    if (query_context.getSettingsRef().allow_experimental_query_deduplication)
+    if (query_context->getSettingsRef().allow_experimental_query_deduplication)
         selectPartsToReadWithUUIDFilter(parts, part_values, minmax_idx_condition, minmax_columns_types, partition_pruner, max_block_numbers_to_read, query_context);
     else
         selectPartsToRead(parts, part_values, minmax_idx_condition, minmax_columns_types, partition_pruner, max_block_numbers_to_read);
@@ -556,7 +556,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts(
     {
         .min_bytes_to_use_direct_io = settings.min_bytes_to_use_direct_io,
         .min_bytes_to_use_mmap_io = settings.min_bytes_to_use_mmap_io,
-        .mmap_cache = context.getMMappedFileCache(),
+        .mmap_cache = context->getMMappedFileCache(),
         .max_read_buffer_size = settings.max_read_buffer_size,
         .save_marks_in_cache = true,
         .checksum_on_read = settings.checksum_on_read,
@@ -704,7 +704,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts(
 
             for (size_t part_index = 0; part_index < parts.size(); ++part_index)
                 pool.scheduleOrThrowOnError([&, part_index, thread_group = CurrentThread::getGroup()] {
-                    SCOPE_EXIT(
+                    SCOPE_EXIT_SAFE(
                         if (thread_group)
                             CurrentThread::detachQueryIfNotDetached();
                     );
@@ -776,7 +776,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts(
         if (data_settings->min_marks_to_honor_max_concurrent_queries > 0
             && sum_marks >= data_settings->min_marks_to_honor_max_concurrent_queries)
         {
-            query_id = context.getCurrentQueryId();
+            query_id = context->getCurrentQueryId();
             if (!query_id.empty())
                 data.insertQueryIdOrThrow(query_id, data_settings->max_concurrent_queries);
         }
@@ -1360,8 +1360,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::spreadMarkRangesAmongStreamsWithOrder(
     for (const auto & plan : plans)
         input_streams.emplace_back(plan->getCurrentDataStream());
 
-    const auto & common_header = plans.front()->getCurrentDataStream().header;
-    auto union_step = std::make_unique<UnionStep>(std::move(input_streams), common_header);
+    auto union_step = std::make_unique<UnionStep>(std::move(input_streams));
 
     auto plan = std::make_unique<QueryPlan>();
     plan->unitePlans(std::move(union_step), std::move(plans));
@@ -1938,16 +1937,13 @@ void MergeTreeDataSelectExecutor::selectPartsToReadWithUUIDFilter(
     const DataTypes & minmax_columns_types,
     std::optional<PartitionPruner> & partition_pruner,
     const PartitionIdToMaxBlock * max_block_numbers_to_read,
-    const Context & query_context) const
+    ContextPtr query_context) const
 {
-    /// const_cast to add UUIDs to context. Bad practice.
-    Context & non_const_context = const_cast<Context &>(query_context);
-
     /// process_parts prepare parts that have to be read for the query,
     /// returns false if duplicated parts' UUID have been met
     auto select_parts = [&] (MergeTreeData::DataPartsVector & selected_parts) -> bool
     {
-        auto ignored_part_uuids = non_const_context.getIgnoredPartUUIDs();
+        auto ignored_part_uuids = query_context->getIgnoredPartUUIDs();
         std::unordered_set<UUID> temp_part_uuids;
 
         auto prev_parts = selected_parts;
@@ -1996,12 +1992,12 @@ void MergeTreeDataSelectExecutor::selectPartsToReadWithUUIDFilter(
 
         if (!temp_part_uuids.empty())
         {
-            auto duplicates = non_const_context.getPartUUIDs()->add(std::vector<UUID>{temp_part_uuids.begin(), temp_part_uuids.end()});
+            auto duplicates = query_context->getPartUUIDs()->add(std::vector<UUID>{temp_part_uuids.begin(), temp_part_uuids.end()});
             if (!duplicates.empty())
             {
                 /// on a local replica with prefer_localhost_replica=1 if any duplicates appeared during the first pass,
                 /// adding them to the exclusion, so they will be skipped on second pass
-                non_const_context.getIgnoredPartUUIDs()->add(duplicates);
+                query_context->getIgnoredPartUUIDs()->add(duplicates);
                 return false;
             }
         }
diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
index 0702605a539..927a82b738f 100644
--- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
+++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
@@ -29,7 +29,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         UInt64 max_block_size,
         unsigned num_streams,
         const PartitionIdToMaxBlock * max_block_numbers_to_read = nullptr) const;
@@ -39,7 +39,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         UInt64 max_block_size,
         unsigned num_streams,
         const PartitionIdToMaxBlock * max_block_numbers_to_read = nullptr) const;
@@ -141,7 +141,7 @@ private:
         const DataTypes & minmax_columns_types,
         std::optional<PartitionPruner> & partition_pruner,
         const PartitionIdToMaxBlock * max_block_numbers_to_read,
-        const Context & query_context) const;
+        ContextPtr query_context) const;
 };
 
 }
diff --git a/src/Storages/MergeTree/MergeTreeDataWriter.cpp b/src/Storages/MergeTree/MergeTreeDataWriter.cpp
index 3b4cb385a34..79d95eb03ee 100644
--- a/src/Storages/MergeTree/MergeTreeDataWriter.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataWriter.cpp
@@ -396,7 +396,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataWriter::writeTempPart(BlockWithPa
 
     /// This effectively chooses minimal compression method:
     ///  either default lz4 or compression method with zero thresholds on absolute and relative part size.
-    auto compression_codec = data.global_context.chooseCompressionCodec(0, 0);
+    auto compression_codec = data.getContext()->chooseCompressionCodec(0, 0);
 
     const auto & index_factory = MergeTreeIndexFactory::instance();
     MergedBlockOutputStream out(new_data_part, metadata_snapshot, columns, index_factory.getMany(metadata_snapshot->getSecondaryIndices()), compression_codec);
diff --git a/src/Storages/MergeTree/MergeTreeDeduplicationLog.cpp b/src/Storages/MergeTree/MergeTreeDeduplicationLog.cpp
new file mode 100644
index 00000000000..33960e2e1ff
--- /dev/null
+++ b/src/Storages/MergeTree/MergeTreeDeduplicationLog.cpp
@@ -0,0 +1,311 @@
+#include <Storages/MergeTree/MergeTreeDeduplicationLog.h>
+#include <filesystem>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/join.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <IO/ReadBufferFromFile.h>
+#include <IO/WriteHelpers.h>
+#include <IO/ReadHelpers.h>
+
+namespace DB
+{
+
+namespace
+{
+
+/// Deduplication operation part was dropped or added
+enum class MergeTreeDeduplicationOp : uint8_t
+{
+    ADD = 1,
+    DROP = 2,
+};
+
+/// Record for deduplication on disk
+struct MergeTreeDeduplicationLogRecord
+{
+    MergeTreeDeduplicationOp operation;
+    std::string part_name;
+    std::string block_id;
+};
+
+void writeRecord(const MergeTreeDeduplicationLogRecord & record, WriteBuffer & out)
+{
+    writeIntText(static_cast<uint8_t>(record.operation), out);
+    writeChar('\t', out);
+    writeString(record.part_name, out);
+    writeChar('\t', out);
+    writeString(record.block_id, out);
+    writeChar('\n', out);
+    out.next();
+}
+
+void readRecord(MergeTreeDeduplicationLogRecord & record, ReadBuffer & in)
+{
+    uint8_t op;
+    readIntText(op, in);
+    record.operation = static_cast<MergeTreeDeduplicationOp>(op);
+    assertChar('\t', in);
+    readString(record.part_name, in);
+    assertChar('\t', in);
+    readString(record.block_id, in);
+    assertChar('\n', in);
+}
+
+
+std::string getLogPath(const std::string & prefix, size_t number)
+{
+    std::filesystem::path path(prefix);
+    path /= std::filesystem::path(std::string{"deduplication_log_"} + std::to_string(number) + ".txt");
+    return path;
+}
+
+size_t getLogNumber(const std::string & path_str)
+{
+    std::filesystem::path path(path_str);
+    std::string filename = path.stem();
+    Strings filename_parts;
+    boost::split(filename_parts, filename, boost::is_any_of("_"));
+
+    return parse<size_t>(filename_parts[2]);
+}
+
+}
+
+MergeTreeDeduplicationLog::MergeTreeDeduplicationLog(
+    const std::string & logs_dir_,
+    size_t deduplication_window_,
+    const MergeTreeDataFormatVersion & format_version_)
+    : logs_dir(logs_dir_)
+    , deduplication_window(deduplication_window_)
+    , rotate_interval(deduplication_window_ * 2) /// actually it doesn't matter
+    , format_version(format_version_)
+    , deduplication_map(deduplication_window)
+{
+    namespace fs = std::filesystem;
+    if (deduplication_window != 0 && !fs::exists(logs_dir))
+        fs::create_directories(logs_dir);
+}
+
+void MergeTreeDeduplicationLog::load()
+{
+    namespace fs = std::filesystem;
+    if (!fs::exists(logs_dir))
+        return;
+
+    for (const auto & p : fs::directory_iterator(logs_dir))
+    {
+        const auto & path = p.path();
+        auto log_number = getLogNumber(path);
+        existing_logs[log_number] = {path, 0};
+    }
+
+    /// We should know which logs are exist even in case
+    /// of deduplication_window = 0
+    if (!existing_logs.empty())
+        current_log_number = existing_logs.rbegin()->first;
+
+    if (deduplication_window != 0)
+    {
+        /// Order important, we load history from the begging to the end
+        for (auto & [log_number, desc] : existing_logs)
+        {
+            try
+            {
+                desc.entries_count = loadSingleLog(desc.path);
+            }
+            catch (...)
+            {
+                tryLogCurrentException(__PRETTY_FUNCTION__, "Error while loading MergeTree deduplication log on path " + desc.path);
+            }
+        }
+
+        /// Start new log, drop previous
+        rotateAndDropIfNeeded();
+
+        /// Can happen in case we have unfinished log
+        if (!current_writer)
+            current_writer = std::make_unique<WriteBufferFromFile>(existing_logs.rbegin()->second.path, DBMS_DEFAULT_BUFFER_SIZE, O_APPEND | O_CREAT | O_WRONLY);
+    }
+}
+
+size_t MergeTreeDeduplicationLog::loadSingleLog(const std::string & path)
+{
+    ReadBufferFromFile read_buf(path);
+
+    size_t total_entries = 0;
+    while (!read_buf.eof())
+    {
+        MergeTreeDeduplicationLogRecord record;
+        readRecord(record, read_buf);
+        if (record.operation == MergeTreeDeduplicationOp::DROP)
+            deduplication_map.erase(record.block_id);
+        else
+            deduplication_map.insert(record.block_id, MergeTreePartInfo::fromPartName(record.part_name, format_version));
+        total_entries++;
+    }
+    return total_entries;
+}
+
+void MergeTreeDeduplicationLog::rotate()
+{
+    /// We don't deduplicate anything so we don't need any writers
+    if (deduplication_window == 0)
+        return;
+
+    current_log_number++;
+    auto new_path = getLogPath(logs_dir, current_log_number);
+    MergeTreeDeduplicationLogNameDescription log_description{new_path, 0};
+    existing_logs.emplace(current_log_number, log_description);
+
+    if (current_writer)
+        current_writer->sync();
+
+    current_writer = std::make_unique<WriteBufferFromFile>(log_description.path, DBMS_DEFAULT_BUFFER_SIZE, O_APPEND | O_CREAT | O_WRONLY);
+}
+
+void MergeTreeDeduplicationLog::dropOutdatedLogs()
+{
+    size_t current_sum = 0;
+    size_t remove_from_value = 0;
+    /// Go from end to the beginning
+    for (auto itr = existing_logs.rbegin(); itr != existing_logs.rend(); ++itr)
+    {
+        if (current_sum > deduplication_window)
+        {
+            /// We have more logs than required, all older files (including current) can be dropped
+            remove_from_value = itr->first;
+            break;
+        }
+
+        auto & description = itr->second;
+        current_sum += description.entries_count;
+    }
+
+    /// If we found some logs to drop
+    if (remove_from_value != 0)
+    {
+        /// Go from the beginning to the end and drop all outdated logs
+        for (auto itr = existing_logs.begin(); itr != existing_logs.end();)
+        {
+            size_t number = itr->first;
+            std::filesystem::remove(itr->second.path);
+            itr = existing_logs.erase(itr);
+            if (remove_from_value == number)
+                break;
+        }
+    }
+
+}
+
+void MergeTreeDeduplicationLog::rotateAndDropIfNeeded()
+{
+    /// If we don't have logs at all or already have enough records in current
+    if (existing_logs.empty() || existing_logs[current_log_number].entries_count >= rotate_interval)
+    {
+        rotate();
+        dropOutdatedLogs();
+    }
+}
+
+std::pair<MergeTreePartInfo, bool> MergeTreeDeduplicationLog::addPart(const std::string & block_id, const MergeTreePartInfo & part_info)
+{
+    std::lock_guard lock(state_mutex);
+
+    /// We support zero case because user may want to disable deduplication with
+    /// ALTER MODIFY SETTING query. It's much more simpler to handle zero case
+    /// here then destroy whole object, check for null pointer from different
+    /// threads and so on.
+    if (deduplication_window == 0)
+        return std::make_pair(part_info, true);
+
+    /// If we already have this block let's deduplicate it
+    if (deduplication_map.contains(block_id))
+    {
+        auto info = deduplication_map.get(block_id);
+        return std::make_pair(info, false);
+    }
+
+    assert(current_writer != nullptr);
+
+    /// Create new record
+    MergeTreeDeduplicationLogRecord record;
+    record.operation = MergeTreeDeduplicationOp::ADD;
+    record.part_name = part_info.getPartName();
+    record.block_id = block_id;
+    /// Write it to disk
+    writeRecord(record, *current_writer);
+    /// We have one more record in current log
+    existing_logs[current_log_number].entries_count++;
+    /// Add to deduplication map
+    deduplication_map.insert(record.block_id, part_info);
+    /// Rotate and drop old logs if needed
+    rotateAndDropIfNeeded();
+
+    return std::make_pair(part_info, true);
+}
+
+void MergeTreeDeduplicationLog::dropPart(const MergeTreePartInfo & drop_part_info)
+{
+    std::lock_guard lock(state_mutex);
+
+    /// We support zero case because user may want to disable deduplication with
+    /// ALTER MODIFY SETTING query. It's much more simpler to handle zero case
+    /// here then destroy whole object, check for null pointer from different
+    /// threads and so on.
+    if (deduplication_window == 0)
+        return;
+
+    assert(current_writer != nullptr);
+
+    for (auto itr = deduplication_map.begin(); itr != deduplication_map.end(); /* no increment here, we erasing from map */)
+    {
+        const auto & part_info = itr->value;
+        /// Part is covered by dropped part, let's remove it from
+        /// deduplication history
+        if (drop_part_info.contains(part_info))
+        {
+            /// Create drop record
+            MergeTreeDeduplicationLogRecord record;
+            record.operation = MergeTreeDeduplicationOp::DROP;
+            record.part_name = part_info.getPartName();
+            record.block_id = itr->key;
+            /// Write it to disk
+            writeRecord(record, *current_writer);
+            /// We have one more record on disk
+            existing_logs[current_log_number].entries_count++;
+
+            /// Increment itr before erase, otherwise it will invalidated
+            ++itr;
+            /// Remove block_id from in-memory table
+            deduplication_map.erase(record.block_id);
+
+            /// Rotate and drop old logs if needed
+            rotateAndDropIfNeeded();
+        }
+        else
+        {
+            ++itr;
+        }
+    }
+}
+
+void MergeTreeDeduplicationLog::setDeduplicationWindowSize(size_t deduplication_window_)
+{
+    std::lock_guard lock(state_mutex);
+
+    deduplication_window = deduplication_window_;
+    rotate_interval = deduplication_window * 2;
+
+    /// If settings was set for the first time with ALTER MODIFY SETTING query
+    if (deduplication_window != 0 && !std::filesystem::exists(logs_dir))
+        std::filesystem::create_directories(logs_dir);
+
+    deduplication_map.setMaxSize(deduplication_window);
+    rotateAndDropIfNeeded();
+
+    /// Can happen in case we have unfinished log
+    if (!current_writer)
+        current_writer = std::make_unique<WriteBufferFromFile>(existing_logs.rbegin()->second.path, DBMS_DEFAULT_BUFFER_SIZE, O_APPEND | O_CREAT | O_WRONLY);
+}
+
+}
diff --git a/src/Storages/MergeTree/MergeTreeDeduplicationLog.h b/src/Storages/MergeTree/MergeTreeDeduplicationLog.h
new file mode 100644
index 00000000000..281a76050a2
--- /dev/null
+++ b/src/Storages/MergeTree/MergeTreeDeduplicationLog.h
@@ -0,0 +1,192 @@
+#pragma once
+#include <Core/Types.h>
+#include <common/StringRef.h>
+#include <IO/WriteBufferFromFile.h>
+#include <Storages/MergeTree/MergeTreePartInfo.h>
+#include <map>
+#include <list>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+namespace DB
+{
+
+/// Description of dedupliction log
+struct MergeTreeDeduplicationLogNameDescription
+{
+    /// Path to log
+    std::string path;
+
+    /// How many entries we have in log
+    size_t entries_count;
+};
+
+/// Simple string-key HashTable with fixed size based on STL containers.
+/// Preserves order using linked list and remove elements
+/// on overflow in FIFO order.
+template <typename V>
+class LimitedOrderedHashMap
+{
+private:
+    struct ListNode
+    {
+        std::string key;
+        V value;
+    };
+    using Queue = std::list<ListNode>;
+    using IndexMap = std::unordered_map<StringRef, typename Queue::iterator, StringRefHash>;
+
+    Queue queue;
+    IndexMap map;
+    size_t max_size;
+public:
+    using iterator = typename Queue::iterator;
+    using const_iterator = typename Queue::const_iterator;
+    using reverse_iterator = typename Queue::reverse_iterator;
+    using const_reverse_iterator = typename Queue::const_reverse_iterator;
+
+    explicit LimitedOrderedHashMap(size_t max_size_)
+        : max_size(max_size_)
+    {}
+
+    bool contains(const std::string & key) const
+    {
+        return map.find(key) != map.end();
+    }
+
+    V get(const std::string & key) const
+    {
+        return map.at(key)->value;
+    }
+
+    size_t size() const
+    {
+        return queue.size();
+    }
+
+    void setMaxSize(size_t max_size_)
+    {
+        max_size = max_size_;
+        while (size() > max_size)
+        {
+            map.erase(queue.front().key);
+            queue.pop_front();
+        }
+    }
+
+    bool erase(const std::string & key)
+    {
+        auto it = map.find(key);
+        if (it == map.end())
+            return false;
+
+        auto queue_itr = it->second;
+        map.erase(it);
+        queue.erase(queue_itr);
+
+        return true;
+    }
+
+    bool insert(const std::string & key, const V & value)
+    {
+        auto it = map.find(key);
+        if (it != map.end())
+            return false;
+
+        if (size() == max_size)
+        {
+            map.erase(queue.front().key);
+            queue.pop_front();
+        }
+
+        ListNode elem{key, value};
+        auto itr = queue.insert(queue.end(), elem);
+        map.emplace(itr->key, itr);
+        return true;
+    }
+
+    void clear()
+    {
+        map.clear();
+        queue.clear();
+    }
+
+    iterator begin() { return queue.begin(); }
+    const_iterator begin() const { return queue.cbegin(); }
+    iterator end() { return queue.end(); }
+    const_iterator end() const { return queue.cend(); }
+
+    reverse_iterator rbegin() { return queue.rbegin(); }
+    const_reverse_iterator rbegin() const { return queue.crbegin(); }
+    reverse_iterator rend() { return queue.rend(); }
+    const_reverse_iterator rend() const { return queue.crend(); }
+};
+
+/// Fixed-size log for deduplication in non-replicated MergeTree.
+/// Stores records on disk for zero-level parts in human-readable format:
+///  operation   part_name       partition_id_check_sum
+///  1           88_18_18_0      88_10619499460461868496_9553701830997749308
+///  2           77_14_14_0      77_15147918179036854170_6725063583757244937
+///  2           77_15_15_0      77_14977227047908934259_8047656067364802772
+///  1           77_20_20_0      77_15147918179036854170_6725063583757244937
+/// Also stores them in memory in hash table with limited size.
+class MergeTreeDeduplicationLog
+{
+public:
+    MergeTreeDeduplicationLog(
+        const std::string & logs_dir_,
+        size_t deduplication_window_,
+        const MergeTreeDataFormatVersion & format_version_);
+
+    /// Add part into in-memory hash table and to disk
+    /// Return true and part info if insertion was successful.
+    /// Otherwise, in case of duplicate, return false and previous part name with same hash (useful for logging)
+    std::pair<MergeTreePartInfo, bool> addPart(const std::string & block_id, const MergeTreePartInfo & part);
+
+    /// Remove all covered parts from in memory table and add DROP records to the disk
+    void dropPart(const MergeTreePartInfo & drop_part_info);
+
+    /// Load history from disk. Ignores broken logs.
+    void load();
+
+    void setDeduplicationWindowSize(size_t deduplication_window_);
+private:
+    const std::string logs_dir;
+    /// Size of deduplication window
+    size_t deduplication_window;
+
+    /// How often we create new logs. Not very important,
+    /// default value equals deduplication_window * 2
+    size_t rotate_interval;
+    const MergeTreeDataFormatVersion format_version;
+
+    /// Current log number. Always growing number.
+    size_t current_log_number = 0;
+
+    /// All existing logs in order of their numbers
+    std::map<size_t, MergeTreeDeduplicationLogNameDescription> existing_logs;
+
+    /// In memory hash-table
+    LimitedOrderedHashMap<MergeTreePartInfo> deduplication_map;
+
+    /// Writer to the current log file
+    std::unique_ptr<WriteBufferFromFile> current_writer;
+
+    /// Overall mutex because we can have a lot of cocurrent inserts
+    std::mutex state_mutex;
+
+    /// Start new log
+    void rotate();
+
+    /// Remove all old logs with non-needed records for deduplication_window
+    void dropOutdatedLogs();
+
+    /// Execute both previous methods if needed
+    void rotateAndDropIfNeeded();
+
+    /// Load single log from disk. In case of corruption throws exceptions
+    size_t loadSingleLog(const std::string & path);
+};
+
+}
diff --git a/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp b/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp
index a98ba16978d..c37d710ec8f 100644
--- a/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp
+++ b/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp
@@ -67,7 +67,7 @@ MergeTreeIndexAggregatorPtr MergeTreeIndexBloomFilter::createIndexAggregator() c
     return std::make_shared<MergeTreeIndexAggregatorBloomFilter>(bits_per_row, hash_functions, index.column_names);
 }
 
-MergeTreeIndexConditionPtr MergeTreeIndexBloomFilter::createIndexCondition(const SelectQueryInfo & query_info, const Context & context) const
+MergeTreeIndexConditionPtr MergeTreeIndexBloomFilter::createIndexCondition(const SelectQueryInfo & query_info, ContextPtr context) const
 {
     return std::make_shared<MergeTreeIndexConditionBloomFilter>(query_info, context, index.sample_block, hash_functions);
 }
diff --git a/src/Storages/MergeTree/MergeTreeIndexBloomFilter.h b/src/Storages/MergeTree/MergeTreeIndexBloomFilter.h
index 1aac2c22aa0..9112f23ee64 100644
--- a/src/Storages/MergeTree/MergeTreeIndexBloomFilter.h
+++ b/src/Storages/MergeTree/MergeTreeIndexBloomFilter.h
@@ -20,7 +20,7 @@ public:
 
     MergeTreeIndexAggregatorPtr createIndexAggregator() const override;
 
-    MergeTreeIndexConditionPtr createIndexCondition(const SelectQueryInfo & query_info, const Context & context) const override;
+    MergeTreeIndexConditionPtr createIndexCondition(const SelectQueryInfo & query_info, ContextPtr context) const override;
 
     bool mayBenefitFromIndexForIn(const ASTPtr & node) const override;
 
diff --git a/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.cpp b/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.cpp
index a9915f01645..031129a35f4 100644
--- a/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.cpp
+++ b/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.cpp
@@ -87,11 +87,11 @@ bool maybeTrueOnBloomFilter(const IColumn * hash_column, const BloomFilterPtr &
 }
 
 MergeTreeIndexConditionBloomFilter::MergeTreeIndexConditionBloomFilter(
-    const SelectQueryInfo & info_, const Context & context_, const Block & header_, size_t hash_functions_)
-    : header(header_), context(context_), query_info(info_), hash_functions(hash_functions_)
+    const SelectQueryInfo & info_, ContextPtr context_, const Block & header_, size_t hash_functions_)
+    : WithContext(context_), header(header_), query_info(info_), hash_functions(hash_functions_)
 {
-    auto atom_from_ast = [this](auto & node, auto &, auto & constants, auto & out) { return traverseAtomAST(node, constants, out); };
-    rpn = std::move(RPNBuilder<RPNElement>(info_, context, atom_from_ast).extractRPN());
+    auto atom_from_ast = [this](auto & node, auto, auto & constants, auto & out) { return traverseAtomAST(node, constants, out); };
+    rpn = std::move(RPNBuilder<RPNElement>(info_, getContext(), atom_from_ast).extractRPN());
 }
 
 bool MergeTreeIndexConditionBloomFilter::alwaysUnknownOrTrue() const
diff --git a/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.h b/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.h
index 0b02e64d43c..61e796fb6f7 100644
--- a/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.h
+++ b/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.h
@@ -13,7 +13,7 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
-class MergeTreeIndexConditionBloomFilter final : public IMergeTreeIndexCondition
+class MergeTreeIndexConditionBloomFilter final : public IMergeTreeIndexCondition, WithContext
 {
 public:
     struct RPNElement
@@ -42,7 +42,7 @@ public:
         std::vector<std::pair<size_t, ColumnPtr>> predicate;
     };
 
-    MergeTreeIndexConditionBloomFilter(const SelectQueryInfo & info_, const Context & context_, const Block & header_, size_t hash_functions_);
+    MergeTreeIndexConditionBloomFilter(const SelectQueryInfo & info_, ContextPtr context_, const Block & header_, size_t hash_functions_);
 
     bool alwaysUnknownOrTrue() const override;
 
@@ -56,7 +56,6 @@ public:
 
 private:
     const Block & header;
-    const Context & context;
     const SelectQueryInfo & query_info;
     const size_t hash_functions;
     std::vector<RPNElement> rpn;
diff --git a/src/Storages/MergeTree/MergeTreeIndexFullText.cpp b/src/Storages/MergeTree/MergeTreeIndexFullText.cpp
index 419a417c3e8..10136cd1069 100644
--- a/src/Storages/MergeTree/MergeTreeIndexFullText.cpp
+++ b/src/Storages/MergeTree/MergeTreeIndexFullText.cpp
@@ -166,7 +166,7 @@ void MergeTreeIndexAggregatorFullText::update(const Block & block, size_t * pos,
 
 MergeTreeConditionFullText::MergeTreeConditionFullText(
     const SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     const Block & index_sample_block,
     const BloomFilterParameters & params_,
     TokenExtractorPtr token_extactor_)
@@ -179,7 +179,7 @@ MergeTreeConditionFullText::MergeTreeConditionFullText(
     rpn = std::move(
             RPNBuilder<RPNElement>(
                     query_info, context,
-                    [this] (const ASTPtr & node, const Context & /* context */, Block & block_with_constants, RPNElement & out) -> bool
+                    [this] (const ASTPtr & node, ContextPtr /* context */, Block & block_with_constants, RPNElement & out) -> bool
                     {
                         return this->atomFromAST(node, block_with_constants, out);
                     }).extractRPN());
@@ -566,7 +566,7 @@ MergeTreeIndexAggregatorPtr MergeTreeIndexFullText::createIndexAggregator() cons
 }
 
 MergeTreeIndexConditionPtr MergeTreeIndexFullText::createIndexCondition(
-        const SelectQueryInfo & query, const Context & context) const
+        const SelectQueryInfo & query, ContextPtr context) const
 {
     return std::make_shared<MergeTreeConditionFullText>(query, context, index.sample_block, params, token_extractor.get());
 };
diff --git a/src/Storages/MergeTree/MergeTreeIndexFullText.h b/src/Storages/MergeTree/MergeTreeIndexFullText.h
index d861751c7df..1385621f97f 100644
--- a/src/Storages/MergeTree/MergeTreeIndexFullText.h
+++ b/src/Storages/MergeTree/MergeTreeIndexFullText.h
@@ -87,7 +87,7 @@ class MergeTreeConditionFullText final : public IMergeTreeIndexCondition
 public:
     MergeTreeConditionFullText(
             const SelectQueryInfo & query_info,
-            const Context & context,
+            ContextPtr context,
             const Block & index_sample_block,
             const BloomFilterParameters & params_,
             TokenExtractorPtr token_extactor_);
@@ -208,7 +208,7 @@ public:
     MergeTreeIndexAggregatorPtr createIndexAggregator() const override;
 
     MergeTreeIndexConditionPtr createIndexCondition(
-            const SelectQueryInfo & query, const Context & context) const override;
+            const SelectQueryInfo & query, ContextPtr context) const override;
 
     bool mayBenefitFromIndexForIn(const ASTPtr & node) const override;
 
diff --git a/src/Storages/MergeTree/MergeTreeIndexMinMax.cpp b/src/Storages/MergeTree/MergeTreeIndexMinMax.cpp
index e8b526d1426..099d561cf80 100644
--- a/src/Storages/MergeTree/MergeTreeIndexMinMax.cpp
+++ b/src/Storages/MergeTree/MergeTreeIndexMinMax.cpp
@@ -138,7 +138,7 @@ void MergeTreeIndexAggregatorMinMax::update(const Block & block, size_t * pos, s
 MergeTreeIndexConditionMinMax::MergeTreeIndexConditionMinMax(
     const IndexDescription & index,
     const SelectQueryInfo & query,
-    const Context & context)
+    ContextPtr context)
     : index_data_types(index.data_types)
     , condition(query, context, index.column_names, index.expression)
 {
@@ -175,7 +175,7 @@ MergeTreeIndexAggregatorPtr MergeTreeIndexMinMax::createIndexAggregator() const
 }
 
 MergeTreeIndexConditionPtr MergeTreeIndexMinMax::createIndexCondition(
-    const SelectQueryInfo & query, const Context & context) const
+    const SelectQueryInfo & query, ContextPtr context) const
 {
     return std::make_shared<MergeTreeIndexConditionMinMax>(index, query, context);
 };
diff --git a/src/Storages/MergeTree/MergeTreeIndexMinMax.h b/src/Storages/MergeTree/MergeTreeIndexMinMax.h
index 8d782d9a7dc..97b9b874484 100644
--- a/src/Storages/MergeTree/MergeTreeIndexMinMax.h
+++ b/src/Storages/MergeTree/MergeTreeIndexMinMax.h
@@ -52,7 +52,7 @@ public:
     MergeTreeIndexConditionMinMax(
         const IndexDescription & index,
         const SelectQueryInfo & query,
-        const Context & context);
+        ContextPtr context);
 
     bool alwaysUnknownOrTrue() const override;
 
@@ -78,7 +78,7 @@ public:
     MergeTreeIndexAggregatorPtr createIndexAggregator() const override;
 
     MergeTreeIndexConditionPtr createIndexCondition(
-        const SelectQueryInfo & query, const Context & context) const override;
+        const SelectQueryInfo & query, ContextPtr context) const override;
 
     bool mayBenefitFromIndexForIn(const ASTPtr & node) const override;
 };
diff --git a/src/Storages/MergeTree/MergeTreeIndexSet.cpp b/src/Storages/MergeTree/MergeTreeIndexSet.cpp
index 4ab6ae01c8c..53ee063486b 100644
--- a/src/Storages/MergeTree/MergeTreeIndexSet.cpp
+++ b/src/Storages/MergeTree/MergeTreeIndexSet.cpp
@@ -241,7 +241,7 @@ MergeTreeIndexConditionSet::MergeTreeIndexConditionSet(
     const Block & index_sample_block_,
     size_t max_rows_,
     const SelectQueryInfo & query,
-    const Context & context)
+    ContextPtr context)
     : index_name(index_name_)
     , max_rows(max_rows_)
     , index_sample_block(index_sample_block_)
@@ -299,6 +299,10 @@ bool MergeTreeIndexConditionSet::mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx
 
     auto column
         = result.getByName(expression_ast->getColumnName()).column->convertToFullColumnIfConst()->convertToFullColumnIfLowCardinality();
+
+    if (column->onlyNull())
+        return false;
+
     const auto * col_uint8 = typeid_cast<const ColumnUInt8 *>(column.get());
 
     const NullMap * null_map = nullptr;
@@ -474,7 +478,7 @@ MergeTreeIndexAggregatorPtr MergeTreeIndexSet::createIndexAggregator() const
 }
 
 MergeTreeIndexConditionPtr MergeTreeIndexSet::createIndexCondition(
-    const SelectQueryInfo & query, const Context & context) const
+    const SelectQueryInfo & query, ContextPtr context) const
 {
     return std::make_shared<MergeTreeIndexConditionSet>(index.name, index.sample_block, max_rows, query, context);
 };
diff --git a/src/Storages/MergeTree/MergeTreeIndexSet.h b/src/Storages/MergeTree/MergeTreeIndexSet.h
index 90389264d53..28afe4f714d 100644
--- a/src/Storages/MergeTree/MergeTreeIndexSet.h
+++ b/src/Storages/MergeTree/MergeTreeIndexSet.h
@@ -87,7 +87,7 @@ public:
         const Block & index_sample_block_,
         size_t max_rows_,
         const SelectQueryInfo & query,
-        const Context & context);
+        ContextPtr context);
 
     bool alwaysUnknownOrTrue() const override;
 
@@ -129,7 +129,7 @@ public:
     MergeTreeIndexAggregatorPtr createIndexAggregator() const override;
 
     MergeTreeIndexConditionPtr createIndexCondition(
-            const SelectQueryInfo & query, const Context & context) const override;
+            const SelectQueryInfo & query, ContextPtr context) const override;
 
     bool mayBenefitFromIndexForIn(const ASTPtr & node) const override;
 
diff --git a/src/Storages/MergeTree/MergeTreeIndices.h b/src/Storages/MergeTree/MergeTreeIndices.h
index c7b9dfb123e..674daeb480d 100644
--- a/src/Storages/MergeTree/MergeTreeIndices.h
+++ b/src/Storages/MergeTree/MergeTreeIndices.h
@@ -84,7 +84,7 @@ struct IMergeTreeIndex
     virtual MergeTreeIndexAggregatorPtr createIndexAggregator() const = 0;
 
     virtual MergeTreeIndexConditionPtr createIndexCondition(
-            const SelectQueryInfo & query_info, const Context & context) const = 0;
+            const SelectQueryInfo & query_info, ContextPtr context) const = 0;
 
     Names getColumnsRequiredForIndexCalc() const { return index.expression->getRequiredColumns(); }
 
diff --git a/src/Storages/MergeTree/MergeTreeRangeReader.cpp b/src/Storages/MergeTree/MergeTreeRangeReader.cpp
index e72039f7172..d373c004d10 100644
--- a/src/Storages/MergeTree/MergeTreeRangeReader.cpp
+++ b/src/Storages/MergeTree/MergeTreeRangeReader.cpp
@@ -486,9 +486,13 @@ void MergeTreeRangeReader::ReadResult::setFilter(const ColumnPtr & new_filter)
 
     ConstantFilterDescription const_description(*new_filter);
     if (const_description.always_true)
+    {
         setFilterConstTrue();
+    }
     else if (const_description.always_false)
+    {
         clear();
+    }
     else
     {
         FilterDescription filter_description(*new_filter);
diff --git a/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp b/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp
index ee0a77ba3cf..1d3bb55eace 100644
--- a/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp
+++ b/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp
@@ -44,12 +44,11 @@ MergeTreeReverseSelectProcessor::MergeTreeReverseSelectProcessor(
     for (const auto & range : all_mark_ranges)
         total_marks_count += range.end - range.begin;
 
-    size_t total_rows = data_part->index_granularity.getTotalRows();
+    size_t total_rows = data_part->index_granularity.getRowsCountInRanges(all_mark_ranges);
 
     if (!quiet)
-        LOG_TRACE(log, "Reading {} ranges in reverse order from part {}, approx. {}, up to {} rows starting from {}",
+        LOG_TRACE(log, "Reading {} ranges in reverse order from part {}, approx. {} rows starting from {}",
             all_mark_ranges.size(), data_part->name, total_rows,
-            data_part->index_granularity.getRowsCountInRanges(all_mark_ranges),
             data_part->index_granularity.getMarkStartingRow(all_mark_ranges.front().begin));
 
     addTotalRowsApprox(total_rows);
@@ -63,9 +62,9 @@ MergeTreeReverseSelectProcessor::MergeTreeReverseSelectProcessor(
     column_name_set = NameSet{column_names.begin(), column_names.end()};
 
     if (use_uncompressed_cache)
-        owned_uncompressed_cache = storage.global_context.getUncompressedCache();
+        owned_uncompressed_cache = storage.getContext()->getUncompressedCache();
 
-    owned_mark_cache = storage.global_context.getMarkCache();
+    owned_mark_cache = storage.getContext()->getMarkCache();
 
     reader = data_part->getReader(task_columns.columns, metadata_snapshot,
         all_mark_ranges, owned_uncompressed_cache.get(),
diff --git a/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp b/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp
index 65f9b1eba3b..47429745b0d 100644
--- a/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp
+++ b/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp
@@ -87,9 +87,9 @@ try
     if (!reader)
     {
         if (use_uncompressed_cache)
-            owned_uncompressed_cache = storage.global_context.getUncompressedCache();
+            owned_uncompressed_cache = storage.getContext()->getUncompressedCache();
 
-        owned_mark_cache = storage.global_context.getMarkCache();
+        owned_mark_cache = storage.getContext()->getMarkCache();
 
         reader = data_part->getReader(task_columns.columns, metadata_snapshot, all_mark_ranges,
             owned_uncompressed_cache.get(), owned_mark_cache.get(), reader_settings);
diff --git a/src/Storages/MergeTree/MergeTreeSequentialSource.cpp b/src/Storages/MergeTree/MergeTreeSequentialSource.cpp
index edd63aadd29..745a2860c56 100644
--- a/src/Storages/MergeTree/MergeTreeSequentialSource.cpp
+++ b/src/Storages/MergeTree/MergeTreeSequentialSource.cpp
@@ -23,7 +23,7 @@ MergeTreeSequentialSource::MergeTreeSequentialSource(
     , data_part(std::move(data_part_))
     , columns_to_read(std::move(columns_to_read_))
     , read_with_direct_io(read_with_direct_io_)
-    , mark_cache(storage.global_context.getMarkCache())
+    , mark_cache(storage.getContext()->getMarkCache())
 {
     if (!quiet)
     {
diff --git a/src/Storages/MergeTree/MergeTreeSettings.h b/src/Storages/MergeTree/MergeTreeSettings.h
index 7a1ef8aeed6..f422f00f4dc 100644
--- a/src/Storages/MergeTree/MergeTreeSettings.h
+++ b/src/Storages/MergeTree/MergeTreeSettings.h
@@ -2,6 +2,7 @@
 
 #include <Core/Defines.h>
 #include <Core/BaseSettings.h>
+#include <Storages/MergeTree/MergeTreeDataFormatVersion.h>
 
 
 namespace Poco::Util
@@ -54,6 +55,7 @@ struct Settings;
     M(UInt64, write_ahead_log_bytes_to_fsync, 100ULL * 1024 * 1024, "Amount of bytes, accumulated in WAL to do fsync.", 0) \
     M(UInt64, write_ahead_log_interval_ms_to_fsync, 100, "Interval in milliseconds after which fsync for WAL is being done.", 0) \
     M(Bool, in_memory_parts_insert_sync, false, "If true insert of part with in-memory format will wait for fsync of WAL", 0) \
+    M(UInt64, non_replicated_deduplication_window, 0, "How many last blocks of hashes should be kept on disk (0 - disabled).", 0) \
     \
     /** Inserts settings. */ \
     M(UInt64, parts_to_delay_insert, 150, "If table contains at least that many active parts in single partition, artificially slow down insert into table.", 0) \
diff --git a/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.cpp b/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.cpp
index f57247e39ab..ba9216ac1b0 100644
--- a/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.cpp
+++ b/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.cpp
@@ -71,8 +71,8 @@ bool MergeTreeThreadSelectBlockInputProcessor::getNewTask()
         auto rest_mark_ranges = pool->getRestMarks(*task->data_part, task->mark_ranges[0]);
 
         if (use_uncompressed_cache)
-            owned_uncompressed_cache = storage.global_context.getUncompressedCache();
-        owned_mark_cache = storage.global_context.getMarkCache();
+            owned_uncompressed_cache = storage.getContext()->getUncompressedCache();
+        owned_mark_cache = storage.getContext()->getMarkCache();
 
         reader = task->data_part->getReader(task->columns, metadata_snapshot, rest_mark_ranges,
             owned_uncompressed_cache.get(), owned_mark_cache.get(), reader_settings,
diff --git a/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp b/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
index f0f178cb71c..50f8266a2a0 100644
--- a/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
+++ b/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
@@ -29,7 +29,7 @@ static constexpr auto threshold = 2;
 
 MergeTreeWhereOptimizer::MergeTreeWhereOptimizer(
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     std::unordered_map<std::string, UInt64> column_sizes_,
     const StorageMetadataPtr & metadata_snapshot,
     const Names & queried_columns_,
diff --git a/src/Storages/MergeTree/MergeTreeWhereOptimizer.h b/src/Storages/MergeTree/MergeTreeWhereOptimizer.h
index 8fd973e9ba3..0559fdee2ae 100644
--- a/src/Storages/MergeTree/MergeTreeWhereOptimizer.h
+++ b/src/Storages/MergeTree/MergeTreeWhereOptimizer.h
@@ -1,12 +1,15 @@
 #pragma once
 
-#include <memory>
-#include <unordered_map>
-#include <set>
-#include <boost/noncopyable.hpp>
 #include <Core/Block.h>
+#include <Interpreters/Context_fwd.h>
 #include <Storages/SelectQueryInfo.h>
 
+#include <boost/noncopyable.hpp>
+
+#include <memory>
+#include <set>
+#include <unordered_map>
+
 
 namespace Poco { class Logger; }
 
@@ -32,7 +35,7 @@ class MergeTreeWhereOptimizer : private boost::noncopyable
 public:
     MergeTreeWhereOptimizer(
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         std::unordered_map<std::string, UInt64> column_sizes_,
         const StorageMetadataPtr & metadata_snapshot,
         const Names & queried_columns_,
diff --git a/src/Storages/MergeTree/MergeTreeWriteAheadLog.cpp b/src/Storages/MergeTree/MergeTreeWriteAheadLog.cpp
index 4ca20572e90..4c92d4f6136 100644
--- a/src/Storages/MergeTree/MergeTreeWriteAheadLog.cpp
+++ b/src/Storages/MergeTree/MergeTreeWriteAheadLog.cpp
@@ -30,7 +30,7 @@ MergeTreeWriteAheadLog::MergeTreeWriteAheadLog(
     , disk(disk_)
     , name(name_)
     , path(storage.getRelativeDataPath() + name_)
-    , pool(storage.global_context.getSchedulePool())
+    , pool(storage.getContext()->getSchedulePool())
 {
     init();
     sync_task = pool.createTask("MergeTreeWriteAheadLog::sync", [this]
diff --git a/src/Storages/MergeTree/MergedBlockOutputStream.cpp b/src/Storages/MergeTree/MergedBlockOutputStream.cpp
index 6988d48b18c..ab364e0e5aa 100644
--- a/src/Storages/MergeTree/MergedBlockOutputStream.cpp
+++ b/src/Storages/MergeTree/MergedBlockOutputStream.cpp
@@ -26,7 +26,7 @@ MergedBlockOutputStream::MergedBlockOutputStream(
     , default_codec(default_codec_)
 {
     MergeTreeWriterSettings writer_settings(
-        storage.global_context.getSettings(),
+        storage.getContext()->getSettings(),
         storage.getSettings(),
         data_part->index_granularity_info.is_adaptive,
         /* rewrite_primary_key = */ true,
diff --git a/src/Storages/MergeTree/MergedColumnOnlyOutputStream.cpp b/src/Storages/MergeTree/MergedColumnOnlyOutputStream.cpp
index 41479f104f3..298c550d496 100644
--- a/src/Storages/MergeTree/MergedColumnOnlyOutputStream.cpp
+++ b/src/Storages/MergeTree/MergedColumnOnlyOutputStream.cpp
@@ -21,7 +21,7 @@ MergedColumnOnlyOutputStream::MergedColumnOnlyOutputStream(
     : IMergedBlockOutputStream(data_part, metadata_snapshot_)
     , header(header_)
 {
-    const auto & global_settings = data_part->storage.global_context.getSettings();
+    const auto & global_settings = data_part->storage.getContext()->getSettings();
     const auto & storage_settings = data_part->storage.getSettings();
 
     MergeTreeWriterSettings writer_settings(
diff --git a/src/Storages/MergeTree/PartitionPruner.h b/src/Storages/MergeTree/PartitionPruner.h
index 3cb7552c427..944461f4403 100644
--- a/src/Storages/MergeTree/PartitionPruner.h
+++ b/src/Storages/MergeTree/PartitionPruner.h
@@ -21,7 +21,7 @@ private:
     using DataPartPtr = std::shared_ptr<const DataPart>;
 
 public:
-    PartitionPruner(const KeyDescription & partition_key_, const SelectQueryInfo & query_info, const Context & context, bool strict)
+    PartitionPruner(const KeyDescription & partition_key_, const SelectQueryInfo & query_info, ContextPtr context, bool strict)
         : partition_key(partition_key_)
         , partition_condition(
               query_info, context, partition_key.column_names, partition_key.expression, true /* single_point */, strict)
diff --git a/src/Storages/MergeTree/RPNBuilder.h b/src/Storages/MergeTree/RPNBuilder.h
index 292a120d28a..d41c53eb106 100644
--- a/src/Storages/MergeTree/RPNBuilder.h
+++ b/src/Storages/MergeTree/RPNBuilder.h
@@ -1,35 +1,34 @@
 #pragma once
 
-#include <Common/typeid_cast.h>
 #include <Core/Block.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <Parsers/ASTExpressionList.h>
-#include <Parsers/ASTSelectQuery.h>
 #include <Parsers/ASTFunction.h>
-#include <Storages/SelectQueryInfo.h>
+#include <Parsers/ASTSelectQuery.h>
 #include <Storages/MergeTree/KeyCondition.h>
+#include <Storages/SelectQueryInfo.h>
+#include <Common/typeid_cast.h>
 
 
 namespace DB
 {
-class Context;
 
 /// Builds reverse polish notation
 template <typename RPNElement>
-class RPNBuilder
+class RPNBuilder : WithContext
 {
 public:
     using RPN = std::vector<RPNElement>;
     using AtomFromASTFunc = std::function<
-            bool(const ASTPtr & node, const Context & context, Block & block_with_constants, RPNElement & out)>;
+            bool(const ASTPtr & node, ContextPtr context, Block & block_with_constants, RPNElement & out)>;
 
-    RPNBuilder(const SelectQueryInfo & query_info, const Context & context_, const AtomFromASTFunc & atomFromAST_)
-        : context(context_), atomFromAST(atomFromAST_)
+    RPNBuilder(const SelectQueryInfo & query_info, ContextPtr context_, const AtomFromASTFunc & atomFromAST_)
+        : WithContext(context_), atomFromAST(atomFromAST_)
     {
         /** Evaluation of expressions that depend only on constants.
           * For the index to be used, if it is written, for example `WHERE Date = toDate(now())`.
           */
-        block_with_constants = KeyCondition::getBlockWithConstants(query_info.query, query_info.syntax_analyzer_result, context);
+        block_with_constants = KeyCondition::getBlockWithConstants(query_info.query, query_info.syntax_analyzer_result, getContext());
 
         /// Transform WHERE section to Reverse Polish notation
         const ASTSelectQuery & select = typeid_cast<const ASTSelectQuery &>(*query_info.query);
@@ -80,7 +79,7 @@ private:
             }
         }
 
-        if (!atomFromAST(node, context, block_with_constants, element))
+        if (!atomFromAST(node, getContext(), block_with_constants, element))
         {
             element.function = RPNElement::FUNCTION_UNKNOWN;
         }
@@ -113,7 +112,6 @@ private:
         return true;
     }
 
-    const Context & context;
     const AtomFromASTFunc & atomFromAST;
     Block block_with_constants;
     RPN rpn;
diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.cpp b/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.cpp
index 529e3d2ab49..df4f9124980 100644
--- a/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.cpp
+++ b/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.cpp
@@ -155,18 +155,9 @@ void ReplicatedMergeTreeBlockOutputStream::write(const Block & block)
 
         if (deduplicate)
         {
-            SipHash hash;
-            part->checksums.computeTotalChecksumDataOnly(hash);
-            union
-            {
-                char bytes[16];
-                UInt64 words[2];
-            } hash_value;
-            hash.get128(hash_value.bytes);
-
             /// We add the hash from the data and partition identifier to deduplication ID.
             /// That is, do not insert the same data to the same partition twice.
-            block_id = part->info.partition_id + "_" + toString(hash_value.words[0]) + "_" + toString(hash_value.words[1]);
+            block_id = part->getZeroLevelPartBlockID();
 
             LOG_DEBUG(log, "Wrote block with ID '{}', {} rows", block_id, current_block.block.rows());
         }
@@ -181,11 +172,11 @@ void ReplicatedMergeTreeBlockOutputStream::write(const Block & block)
 
             /// Set a special error code if the block is duplicate
             int error = (deduplicate && last_block_is_duplicate) ? ErrorCodes::INSERT_WAS_DEDUPLICATED : 0;
-            PartLog::addNewPart(storage.global_context, part, watch.elapsed(), ExecutionStatus(error));
+            PartLog::addNewPart(storage.getContext(), part, watch.elapsed(), ExecutionStatus(error));
         }
         catch (...)
         {
-            PartLog::addNewPart(storage.global_context, part, watch.elapsed(), ExecutionStatus::fromCurrentException(__PRETTY_FUNCTION__));
+            PartLog::addNewPart(storage.getContext(), part, watch.elapsed(), ExecutionStatus::fromCurrentException(__PRETTY_FUNCTION__));
             throw;
         }
     }
@@ -209,11 +200,11 @@ void ReplicatedMergeTreeBlockOutputStream::writeExistingPart(MergeTreeData::Muta
     try
     {
         commitPart(zookeeper, part, "");
-        PartLog::addNewPart(storage.global_context, part, watch.elapsed());
+        PartLog::addNewPart(storage.getContext(), part, watch.elapsed());
     }
     catch (...)
     {
-        PartLog::addNewPart(storage.global_context, part, watch.elapsed(), ExecutionStatus::fromCurrentException(__PRETTY_FUNCTION__));
+        PartLog::addNewPart(storage.getContext(), part, watch.elapsed(), ExecutionStatus::fromCurrentException(__PRETTY_FUNCTION__));
         throw;
     }
 }
@@ -350,13 +341,28 @@ void ReplicatedMergeTreeBlockOutputStream::commitPart(
             /// If it exists on our replica, ignore it.
             if (storage.getActiveContainingPart(existing_part_name))
             {
-                LOG_INFO(log, "Block with ID {} already exists locally as part {}; ignoring it.", block_id, existing_part_name);
                 part->is_duplicate = true;
                 last_block_is_duplicate = true;
                 ProfileEvents::increment(ProfileEvents::DuplicatedInsertedBlocks);
+                if (quorum)
+                {
+                    LOG_INFO(log, "Block with ID {} already exists locally as part {}; ignoring it, but checking quorum.", block_id, existing_part_name);
+
+                    std::string quorum_path;
+                    if (quorum_parallel)
+                        quorum_path = storage.zookeeper_path + "/quorum/parallel/" + existing_part_name;
+                    else
+                        quorum_path = storage.zookeeper_path + "/quorum/status";
+
+                    waitForQuorum(zookeeper, existing_part_name, quorum_path, quorum_info.is_active_node_value);
+                }
+                else
+                {
+                    LOG_INFO(log, "Block with ID {} already exists locally as part {}; ignoring it.", block_id, existing_part_name);
+                }
+
                 return;
             }
-
             LOG_INFO(log, "Block with ID {} already exists on other replicas as part {}; will write it locally with that name.",
                 block_id, existing_part_name);
 
@@ -495,50 +501,7 @@ void ReplicatedMergeTreeBlockOutputStream::commitPart(
                 storage.updateQuorum(part->name, false);
         }
 
-        /// We are waiting for quorum to be satisfied.
-        LOG_TRACE(log, "Waiting for quorum");
-
-        try
-        {
-            while (true)
-            {
-                zkutil::EventPtr event = std::make_shared<Poco::Event>();
-
-                std::string value;
-                /// `get` instead of `exists` so that `watch` does not leak if the node is no longer there.
-                if (!zookeeper->tryGet(quorum_info.status_path, value, nullptr, event))
-                    break;
-
-                LOG_TRACE(log, "Quorum node {} still exists, will wait for updates", quorum_info.status_path);
-
-                ReplicatedMergeTreeQuorumEntry quorum_entry(value);
-
-                /// If the node has time to disappear, and then appear again for the next insert.
-                if (quorum_entry.part_name != part->name)
-                    break;
-
-                if (!event->tryWait(quorum_timeout_ms))
-                    throw Exception("Timeout while waiting for quorum", ErrorCodes::TIMEOUT_EXCEEDED);
-
-                LOG_TRACE(log, "Quorum {} updated, will check quorum node still exists", quorum_info.status_path);
-            }
-
-            /// And what if it is possible that the current replica at this time has ceased to be active
-            /// and the quorum is marked as failed and deleted?
-            String value;
-            if (!zookeeper->tryGet(storage.replica_path + "/is_active", value, nullptr)
-                || value != quorum_info.is_active_node_value)
-                throw Exception("Replica become inactive while waiting for quorum", ErrorCodes::NO_ACTIVE_REPLICAS);
-        }
-        catch (...)
-        {
-            /// We do not know whether or not data has been inserted
-            /// - whether other replicas have time to download the part and mark the quorum as done.
-            throw Exception("Unknown status, client must retry. Reason: " + getCurrentExceptionMessage(false),
-                ErrorCodes::UNKNOWN_STATUS_OF_INSERT);
-        }
-
-        LOG_TRACE(log, "Quorum satisfied");
+        waitForQuorum(zookeeper, part->name, quorum_info.status_path, quorum_info.is_active_node_value);
     }
 }
 
@@ -550,4 +513,57 @@ void ReplicatedMergeTreeBlockOutputStream::writePrefix()
 }
 
 
+void ReplicatedMergeTreeBlockOutputStream::waitForQuorum(
+    zkutil::ZooKeeperPtr & zookeeper,
+    const std::string & part_name,
+    const std::string & quorum_path,
+    const std::string & is_active_node_value) const
+{
+    /// We are waiting for quorum to be satisfied.
+    LOG_TRACE(log, "Waiting for quorum");
+
+    try
+    {
+        while (true)
+        {
+            zkutil::EventPtr event = std::make_shared<Poco::Event>();
+
+            std::string value;
+            /// `get` instead of `exists` so that `watch` does not leak if the node is no longer there.
+            if (!zookeeper->tryGet(quorum_path, value, nullptr, event))
+                break;
+
+            LOG_TRACE(log, "Quorum node {} still exists, will wait for updates", quorum_path);
+
+            ReplicatedMergeTreeQuorumEntry quorum_entry(value);
+
+            /// If the node has time to disappear, and then appear again for the next insert.
+            if (quorum_entry.part_name != part_name)
+                break;
+
+            if (!event->tryWait(quorum_timeout_ms))
+                throw Exception("Timeout while waiting for quorum", ErrorCodes::TIMEOUT_EXCEEDED);
+
+            LOG_TRACE(log, "Quorum {} updated, will check quorum node still exists", quorum_path);
+        }
+
+        /// And what if it is possible that the current replica at this time has ceased to be active
+        /// and the quorum is marked as failed and deleted?
+        String value;
+        if (!zookeeper->tryGet(storage.replica_path + "/is_active", value, nullptr)
+            || value != is_active_node_value)
+            throw Exception("Replica become inactive while waiting for quorum", ErrorCodes::NO_ACTIVE_REPLICAS);
+    }
+    catch (...)
+    {
+        /// We do not know whether or not data has been inserted
+        /// - whether other replicas have time to download the part and mark the quorum as done.
+        throw Exception("Unknown status, client must retry. Reason: " + getCurrentExceptionMessage(false),
+            ErrorCodes::UNKNOWN_STATUS_OF_INSERT);
+    }
+
+    LOG_TRACE(log, "Quorum satisfied");
+}
+
+
 }
diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.h b/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.h
index 860b0c4ed12..6ea16491d64 100644
--- a/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.h
+++ b/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.h
@@ -63,6 +63,12 @@ private:
     /// Rename temporary part and commit to ZooKeeper.
     void commitPart(zkutil::ZooKeeperPtr & zookeeper, MergeTreeData::MutableDataPartPtr & part, const String & block_id);
 
+    /// Wait for quorum to be satisfied on path (quorum_path) form part (part_name)
+    /// Also checks that replica still alive.
+    void waitForQuorum(
+        zkutil::ZooKeeperPtr & zookeeper, const std::string & part_name,
+        const std::string & quorum_path, const std::string & is_active_node_value) const;
+
     StorageReplicatedMergeTree & storage;
     StorageMetadataPtr metadata_snapshot;
     size_t quorum;
diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp b/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
index 701cb2fa1ed..792a77d5e1a 100644
--- a/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
+++ b/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
@@ -24,7 +24,7 @@ ReplicatedMergeTreeCleanupThread::ReplicatedMergeTreeCleanupThread(StorageReplic
     , log_name(storage.getStorageID().getFullTableName() + " (ReplicatedMergeTreeCleanupThread)")
     , log(&Poco::Logger::get(log_name))
 {
-    task = storage.global_context.getSchedulePool().createTask(log_name, [this]{ run(); });
+    task = storage.getContext()->getSchedulePool().createTask(log_name, [this]{ run(); });
 }
 
 void ReplicatedMergeTreeCleanupThread::run()
diff --git a/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp b/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp
index 95883c65abb..09b2a23767c 100644
--- a/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp
+++ b/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp
@@ -28,7 +28,7 @@ ReplicatedMergeTreePartCheckThread::ReplicatedMergeTreePartCheckThread(StorageRe
     , log_name(storage.getStorageID().getFullTableName() + " (ReplicatedMergeTreePartCheckThread)")
     , log(&Poco::Logger::get(log_name))
 {
-    task = storage.global_context.getSchedulePool().createTask(log_name, [this] { run(); });
+    task = storage.getContext()->getSchedulePool().createTask(log_name, [this] { run(); });
     task->schedule();
 }
 
diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp b/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp
index b3cb7c92def..ca6ea3103d1 100644
--- a/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp
+++ b/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp
@@ -47,7 +47,7 @@ ReplicatedMergeTreeRestartingThread::ReplicatedMergeTreeRestartingThread(Storage
     const auto storage_settings = storage.getSettings();
     check_period_ms = storage_settings->zookeeper_session_expiration_check_period.totalSeconds() * 1000;
 
-    task = storage.global_context.getSchedulePool().createTask(log_name, [this]{ run(); });
+    task = storage.getContext()->getSchedulePool().createTask(log_name, [this]{ run(); });
 }
 
 void ReplicatedMergeTreeRestartingThread::run()
diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeTableMetadata.cpp b/src/Storages/MergeTree/ReplicatedMergeTreeTableMetadata.cpp
index ac1c92849d5..de72ad1168b 100644
--- a/src/Storages/MergeTree/ReplicatedMergeTreeTableMetadata.cpp
+++ b/src/Storages/MergeTree/ReplicatedMergeTreeTableMetadata.cpp
@@ -205,7 +205,7 @@ void ReplicatedMergeTreeTableMetadata::checkImmutableFieldsEquals(const Replicat
 
 }
 
-void ReplicatedMergeTreeTableMetadata::checkEquals(const ReplicatedMergeTreeTableMetadata & from_zk, const ColumnsDescription & columns, const Context & context) const
+void ReplicatedMergeTreeTableMetadata::checkEquals(const ReplicatedMergeTreeTableMetadata & from_zk, const ColumnsDescription & columns, ContextPtr context) const
 {
 
     checkImmutableFieldsEquals(from_zk);
diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeTableMetadata.h b/src/Storages/MergeTree/ReplicatedMergeTreeTableMetadata.h
index c1c34637664..f398547e992 100644
--- a/src/Storages/MergeTree/ReplicatedMergeTreeTableMetadata.h
+++ b/src/Storages/MergeTree/ReplicatedMergeTreeTableMetadata.h
@@ -63,7 +63,7 @@ struct ReplicatedMergeTreeTableMetadata
         }
     };
 
-    void checkEquals(const ReplicatedMergeTreeTableMetadata & from_zk, const ColumnsDescription & columns, const Context & context) const;
+    void checkEquals(const ReplicatedMergeTreeTableMetadata & from_zk, const ColumnsDescription & columns, ContextPtr context) const;
 
     Diff checkAndFindDiff(const ReplicatedMergeTreeTableMetadata & from_zk) const;
 
diff --git a/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h b/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h
index b7579a3b7ea..9f1a28a1522 100644
--- a/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h
+++ b/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h
@@ -26,7 +26,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum /*processed_stage*/,
         size_t max_block_size,
         unsigned num_streams) override
@@ -42,7 +42,7 @@ public:
     bool supportsIndexForIn() const override { return true; }
 
     bool mayBenefitFromIndexForIn(
-        const ASTPtr & left_in_operand, const Context & query_context, const StorageMetadataPtr & metadata_snapshot) const override
+        const ASTPtr & left_in_operand, ContextPtr query_context, const StorageMetadataPtr & metadata_snapshot) const override
     {
         return part->storage.mayBenefitFromIndexForIn(left_in_operand, query_context, metadata_snapshot);
     }
@@ -57,7 +57,7 @@ public:
         return part->info.partition_id;
     }
 
-    String getPartitionIDFromQuery(const ASTPtr & ast, const Context & context) const
+    String getPartitionIDFromQuery(const ASTPtr & ast, ContextPtr context) const
     {
         return part->storage.getPartitionIDFromQuery(ast, context);
     }
diff --git a/src/Storages/MergeTree/registerStorageMergeTree.cpp b/src/Storages/MergeTree/registerStorageMergeTree.cpp
index 6dd005736f0..862747abcb9 100644
--- a/src/Storages/MergeTree/registerStorageMergeTree.cpp
+++ b/src/Storages/MergeTree/registerStorageMergeTree.cpp
@@ -184,9 +184,9 @@ appendGraphitePattern(const Poco::Util::AbstractConfiguration & config, const St
     patterns.emplace_back(pattern);
 }
 
-static void setGraphitePatternsFromConfig(const Context & context, const String & config_element, Graphite::Params & params)
+static void setGraphitePatternsFromConfig(ContextPtr context, const String & config_element, Graphite::Params & params)
 {
-    const auto & config = context.getConfigRef();
+    const auto & config = context->getConfigRef();
 
     if (!config.has(config_element))
         throw Exception("No '" + config_element + "' element in configuration file", ErrorCodes::NO_ELEMENTS_IN_CONFIG);
@@ -429,7 +429,7 @@ static StoragePtr create(const StorageFactory::Arguments & args)
                 /// Do not try evaluate array or tuple, because it's array or tuple of column identifiers.
                 if (arg_func->name == "array" || arg_func->name == "tuple")
                     continue;
-                Field value = evaluateConstantExpression(arg, args.local_context).first;
+                Field value = evaluateConstantExpression(arg, args.getLocalContext()).first;
                 arg = std::make_shared<ASTLiteral>(value);
             }
         }
@@ -481,9 +481,9 @@ static StoragePtr create(const StorageFactory::Arguments & args)
         {
             /// Try use default values if arguments are not specified.
             /// Note: {uuid} macro works for ON CLUSTER queries when database engine is Atomic.
-            zookeeper_path = args.context.getConfigRef().getString("default_replica_path", "/clickhouse/tables/{uuid}/{shard}");
+            zookeeper_path = args.getContext()->getConfigRef().getString("default_replica_path", "/clickhouse/tables/{uuid}/{shard}");
             /// TODO maybe use hostname if {replica} is not defined?
-            replica_name = args.context.getConfigRef().getString("default_replica_name", "{replica}");
+            replica_name = args.getContext()->getConfigRef().getString("default_replica_name", "{replica}");
 
             /// Modify query, so default values will be written to metadata
             assert(arg_num == 0);
@@ -503,8 +503,8 @@ static StoragePtr create(const StorageFactory::Arguments & args)
             throw Exception("Expected two string literal arguments: zookeeper_path and replica_name", ErrorCodes::BAD_ARGUMENTS);
 
         /// Allow implicit {uuid} macros only for zookeeper_path in ON CLUSTER queries
-        bool is_on_cluster = args.local_context.getClientInfo().query_kind == ClientInfo::QueryKind::SECONDARY_QUERY;
-        bool is_replicated_database = args.local_context.getClientInfo().query_kind == ClientInfo::QueryKind::SECONDARY_QUERY &&
+        bool is_on_cluster = args.getLocalContext()->getClientInfo().query_kind == ClientInfo::QueryKind::SECONDARY_QUERY;
+        bool is_replicated_database = args.getLocalContext()->getClientInfo().query_kind == ClientInfo::QueryKind::SECONDARY_QUERY &&
                                       DatabaseCatalog::instance().getDatabase(args.table_id.database_name)->getEngineName() == "Replicated";
         bool allow_uuid_macro = is_on_cluster || is_replicated_database || args.query.attach;
 
@@ -521,11 +521,11 @@ static StoragePtr create(const StorageFactory::Arguments & args)
             info.table_id = args.table_id;
             if (!allow_uuid_macro)
                 info.table_id.uuid = UUIDHelpers::Nil;
-            zookeeper_path = args.context.getMacros()->expand(zookeeper_path, info);
+            zookeeper_path = args.getContext()->getMacros()->expand(zookeeper_path, info);
 
             info.level = 0;
             info.table_id.uuid = UUIDHelpers::Nil;
-            replica_name = args.context.getMacros()->expand(replica_name, info);
+            replica_name = args.getContext()->getMacros()->expand(replica_name, info);
         }
 
         ast_zk_path->value = zookeeper_path;
@@ -537,11 +537,11 @@ static StoragePtr create(const StorageFactory::Arguments & args)
         info.table_id = args.table_id;
         if (!allow_uuid_macro)
             info.table_id.uuid = UUIDHelpers::Nil;
-        zookeeper_path = args.context.getMacros()->expand(zookeeper_path, info);
+        zookeeper_path = args.getContext()->getMacros()->expand(zookeeper_path, info);
 
         info.level = 0;
         info.table_id.uuid = UUIDHelpers::Nil;
-        replica_name = args.context.getMacros()->expand(replica_name, info);
+        replica_name = args.getContext()->getMacros()->expand(replica_name, info);
 
         /// We do not allow renaming table with these macros in metadata, because zookeeper_path will be broken after RENAME TABLE.
         /// NOTE: it may happen if table was created by older version of ClickHouse (< 20.10) and macros was not unfolded on table creation
@@ -600,7 +600,7 @@ static StoragePtr create(const StorageFactory::Arguments & args)
             throw Exception(error_msg, ErrorCodes::BAD_ARGUMENTS);
 
         --arg_cnt;
-        setGraphitePatternsFromConfig(args.context, graphite_config_name, merging_params.graphite_params);
+        setGraphitePatternsFromConfig(args.getContext(), graphite_config_name, merging_params.graphite_params);
     }
     else if (merging_params.mode == MergeTreeData::MergingParams::VersionedCollapsing)
     {
@@ -629,9 +629,9 @@ static StoragePtr create(const StorageFactory::Arguments & args)
 
     std::unique_ptr<MergeTreeSettings> storage_settings;
     if (replicated)
-        storage_settings = std::make_unique<MergeTreeSettings>(args.context.getReplicatedMergeTreeSettings());
+        storage_settings = std::make_unique<MergeTreeSettings>(args.getContext()->getReplicatedMergeTreeSettings());
     else
-        storage_settings = std::make_unique<MergeTreeSettings>(args.context.getMergeTreeSettings());
+        storage_settings = std::make_unique<MergeTreeSettings>(args.getContext()->getMergeTreeSettings());
 
     if (is_extended_storage_def)
     {
@@ -642,7 +642,7 @@ static StoragePtr create(const StorageFactory::Arguments & args)
         /// Partition key may be undefined, but despite this we store it's empty
         /// value in partition_key structure. MergeTree checks this case and use
         /// single default partition with name "all".
-        metadata.partition_key = KeyDescription::getKeyFromAST(partition_by_key, metadata.columns, args.context);
+        metadata.partition_key = KeyDescription::getKeyFromAST(partition_by_key, metadata.columns, args.getContext());
 
         /// PRIMARY KEY without ORDER BY is allowed and considered as ORDER BY.
         if (!args.storage_def->order_by && args.storage_def->primary_key)
@@ -660,33 +660,33 @@ static StoragePtr create(const StorageFactory::Arguments & args)
         /// before storage creation. After that storage will just copy this
         /// column if sorting key will be changed.
         metadata.sorting_key = KeyDescription::getSortingKeyFromAST(
-            args.storage_def->order_by->ptr(), metadata.columns, args.context, merging_param_key_arg);
+            args.storage_def->order_by->ptr(), metadata.columns, args.getContext(), merging_param_key_arg);
 
         /// If primary key explicitly defined, than get it from AST
         if (args.storage_def->primary_key)
         {
-            metadata.primary_key = KeyDescription::getKeyFromAST(args.storage_def->primary_key->ptr(), metadata.columns, args.context);
+            metadata.primary_key = KeyDescription::getKeyFromAST(args.storage_def->primary_key->ptr(), metadata.columns, args.getContext());
         }
         else /// Otherwise we don't have explicit primary key and copy it from order by
         {
-            metadata.primary_key = KeyDescription::getKeyFromAST(args.storage_def->order_by->ptr(), metadata.columns, args.context);
+            metadata.primary_key = KeyDescription::getKeyFromAST(args.storage_def->order_by->ptr(), metadata.columns, args.getContext());
             /// and set it's definition_ast to nullptr (so isPrimaryKeyDefined()
             /// will return false but hasPrimaryKey() will return true.
             metadata.primary_key.definition_ast = nullptr;
         }
 
         if (args.storage_def->sample_by)
-            metadata.sampling_key = KeyDescription::getKeyFromAST(args.storage_def->sample_by->ptr(), metadata.columns, args.context);
+            metadata.sampling_key = KeyDescription::getKeyFromAST(args.storage_def->sample_by->ptr(), metadata.columns, args.getContext());
 
         if (args.storage_def->ttl_table)
         {
             metadata.table_ttl = TTLTableDescription::getTTLForTableFromAST(
-                args.storage_def->ttl_table->ptr(), metadata.columns, args.context, metadata.primary_key);
+                args.storage_def->ttl_table->ptr(), metadata.columns, args.getContext(), metadata.primary_key);
         }
 
         if (args.query.columns_list && args.query.columns_list->indices)
             for (auto & index : args.query.columns_list->indices->children)
-                metadata.secondary_indices.push_back(IndexDescription::getIndexFromAST(index, args.columns, args.context));
+                metadata.secondary_indices.push_back(IndexDescription::getIndexFromAST(index, args.columns, args.getContext()));
 
         if (args.query.columns_list && args.query.columns_list->constraints)
             for (auto & constraint : args.query.columns_list->constraints->children)
@@ -695,7 +695,7 @@ static StoragePtr create(const StorageFactory::Arguments & args)
         auto column_ttl_asts = args.columns.getColumnTTLs();
         for (const auto & [name, ast] : column_ttl_asts)
         {
-            auto new_ttl_entry = TTLDescription::getTTLFromAST(ast, args.columns, args.context, metadata.primary_key);
+            auto new_ttl_entry = TTLDescription::getTTLFromAST(ast, args.columns, args.getContext(), metadata.primary_key);
             metadata.column_ttls_by_name[name] = new_ttl_entry;
         }
 
@@ -716,7 +716,7 @@ static StoragePtr create(const StorageFactory::Arguments & args)
 
         auto partition_by_ast = makeASTFunction("toYYYYMM", std::make_shared<ASTIdentifier>(date_column_name));
 
-        metadata.partition_key = KeyDescription::getKeyFromAST(partition_by_ast, metadata.columns, args.context);
+        metadata.partition_key = KeyDescription::getKeyFromAST(partition_by_ast, metadata.columns, args.getContext());
 
 
         ++arg_num;
@@ -724,7 +724,7 @@ static StoragePtr create(const StorageFactory::Arguments & args)
         /// If there is an expression for sampling
         if (arg_cnt - arg_num == 3)
         {
-            metadata.sampling_key = KeyDescription::getKeyFromAST(engine_args[arg_num], metadata.columns, args.context);
+            metadata.sampling_key = KeyDescription::getKeyFromAST(engine_args[arg_num], metadata.columns, args.getContext());
             ++arg_num;
         }
 
@@ -734,10 +734,10 @@ static StoragePtr create(const StorageFactory::Arguments & args)
         /// before storage creation. After that storage will just copy this
         /// column if sorting key will be changed.
         metadata.sorting_key
-            = KeyDescription::getSortingKeyFromAST(engine_args[arg_num], metadata.columns, args.context, merging_param_key_arg);
+            = KeyDescription::getSortingKeyFromAST(engine_args[arg_num], metadata.columns, args.getContext(), merging_param_key_arg);
 
         /// In old syntax primary_key always equals to sorting key.
-        metadata.primary_key = KeyDescription::getKeyFromAST(engine_args[arg_num], metadata.columns, args.context);
+        metadata.primary_key = KeyDescription::getKeyFromAST(engine_args[arg_num], metadata.columns, args.getContext());
         /// But it's not explicitly defined, so we evaluate definition to
         /// nullptr
         metadata.primary_key.definition_ast = nullptr;
@@ -777,7 +777,7 @@ static StoragePtr create(const StorageFactory::Arguments & args)
             args.table_id,
             args.relative_data_path,
             metadata,
-            args.context,
+            args.getContext(),
             date_column_name,
             merging_params,
             std::move(storage_settings),
@@ -789,7 +789,7 @@ static StoragePtr create(const StorageFactory::Arguments & args)
             args.relative_data_path,
             metadata,
             args.attach,
-            args.context,
+            args.getContext(),
             date_column_name,
             merging_params,
             std::move(storage_settings),
diff --git a/src/Storages/PostgreSQL/PostgreSQLConnection.cpp b/src/Storages/PostgreSQL/PostgreSQLConnection.cpp
index 61caba8ac81..53cf5159c5a 100644
--- a/src/Storages/PostgreSQL/PostgreSQLConnection.cpp
+++ b/src/Storages/PostgreSQL/PostgreSQLConnection.cpp
@@ -8,10 +8,10 @@
 #include <IO/Operators.h>
 
 
-namespace DB
+namespace postgres
 {
 
-PostgreSQLConnection::PostgreSQLConnection(
+Connection::Connection(
         const String & connection_str_,
         const String & address_)
     : connection_str(connection_str_)
@@ -20,14 +20,14 @@ PostgreSQLConnection::PostgreSQLConnection(
 }
 
 
-PostgreSQLConnection::ConnectionPtr PostgreSQLConnection::get()
+pqxx::ConnectionPtr Connection::get()
 {
     connectIfNeeded();
     return connection;
 }
 
 
-PostgreSQLConnection::ConnectionPtr PostgreSQLConnection::tryGet()
+pqxx::ConnectionPtr Connection::tryGet()
 {
     if (tryConnectIfNeeded())
         return connection;
@@ -35,7 +35,7 @@ PostgreSQLConnection::ConnectionPtr PostgreSQLConnection::tryGet()
 }
 
 
-void PostgreSQLConnection::connectIfNeeded()
+void Connection::connectIfNeeded()
 {
     if (!connection || !connection->is_open())
     {
@@ -45,7 +45,7 @@ void PostgreSQLConnection::connectIfNeeded()
 }
 
 
-bool PostgreSQLConnection::tryConnectIfNeeded()
+bool Connection::tryConnectIfNeeded()
 {
     try
     {
diff --git a/src/Storages/PostgreSQL/PostgreSQLConnection.h b/src/Storages/PostgreSQL/PostgreSQLConnection.h
index c8e1c3dcc91..488f45a068d 100644
--- a/src/Storages/PostgreSQL/PostgreSQLConnection.h
+++ b/src/Storages/PostgreSQL/PostgreSQLConnection.h
@@ -10,24 +10,27 @@
 #include <Common/ConcurrentBoundedQueue.h>
 
 
-namespace DB
+namespace pqxx
+{
+    using ConnectionPtr = std::shared_ptr<pqxx::connection>;
+}
+
+namespace postgres
 {
 
-class PostgreSQLConnection
+class Connection
 {
 
-using ConnectionPtr = std::shared_ptr<pqxx::connection>;
-
 public:
-    PostgreSQLConnection(
+    Connection(
         const String & connection_str_,
         const String & address_);
 
-    PostgreSQLConnection(const PostgreSQLConnection & other) = delete;
+    Connection(const Connection & other) = delete;
 
-    ConnectionPtr get();
+    pqxx::ConnectionPtr get();
 
-    ConnectionPtr tryGet();
+    pqxx::ConnectionPtr tryGet();
 
     bool isConnected() { return tryConnectIfNeeded(); }
 
@@ -38,40 +41,40 @@ private:
 
     const std::string & getAddress() { return address; }
 
-    ConnectionPtr connection;
+    pqxx::ConnectionPtr connection;
     std::string connection_str, address;
 };
 
-using PostgreSQLConnectionPtr = std::shared_ptr<PostgreSQLConnection>;
+using ConnectionPtr = std::shared_ptr<Connection>;
 
 
-class PostgreSQLConnectionHolder
+class ConnectionHolder
 {
 
-using Pool = ConcurrentBoundedQueue<PostgreSQLConnectionPtr>;
+using Pool = ConcurrentBoundedQueue<ConnectionPtr>;
 static constexpr inline auto POSTGRESQL_POOL_WAIT_MS = 50;
 
 public:
-    PostgreSQLConnectionHolder(PostgreSQLConnectionPtr connection_, Pool & pool_)
+    ConnectionHolder(ConnectionPtr connection_, Pool & pool_)
         : connection(std::move(connection_))
         , pool(pool_)
     {
     }
 
-    PostgreSQLConnectionHolder(const PostgreSQLConnectionHolder & other) = delete;
+    ConnectionHolder(const ConnectionHolder & other) = delete;
 
-    ~PostgreSQLConnectionHolder() { pool.tryPush(connection, POSTGRESQL_POOL_WAIT_MS); }
+    ~ConnectionHolder() { pool.tryPush(connection, POSTGRESQL_POOL_WAIT_MS); }
 
     pqxx::connection & conn() const { return *connection->get(); }
 
     bool isConnected() { return connection->isConnected(); }
 
 private:
-    PostgreSQLConnectionPtr connection;
+    ConnectionPtr connection;
     Pool & pool;
 };
 
-using PostgreSQLConnectionHolderPtr = std::shared_ptr<PostgreSQLConnectionHolder>;
+using ConnectionHolderPtr = std::shared_ptr<ConnectionHolder>;
 
 }
 
diff --git a/src/Storages/PostgreSQL/PostgreSQLConnectionPool.cpp b/src/Storages/PostgreSQL/PostgreSQLConnectionPool.cpp
index 659877b6b49..42c716dcf14 100644
--- a/src/Storages/PostgreSQL/PostgreSQLConnectionPool.cpp
+++ b/src/Storages/PostgreSQL/PostgreSQLConnectionPool.cpp
@@ -10,10 +10,10 @@
 #include <common/logger_useful.h>
 
 
-namespace DB
+namespace postgres
 {
 
-PostgreSQLConnectionPool::PostgreSQLConnectionPool(
+ConnectionPool::ConnectionPool(
         std::string dbname,
         std::string host,
         UInt16 port,
@@ -37,7 +37,7 @@ PostgreSQLConnectionPool::PostgreSQLConnectionPool(
 }
 
 
-PostgreSQLConnectionPool::PostgreSQLConnectionPool(const PostgreSQLConnectionPool & other)
+ConnectionPool::ConnectionPool(const ConnectionPool & other)
         : pool(std::make_shared<Pool>(other.pool_size))
         , connection_str(other.connection_str)
         , address(other.address)
@@ -49,46 +49,46 @@ PostgreSQLConnectionPool::PostgreSQLConnectionPool(const PostgreSQLConnectionPoo
 }
 
 
-void PostgreSQLConnectionPool::initialize()
+void ConnectionPool::initialize()
 {
     /// No connection is made, just fill pool with non-connected connection objects.
     for (size_t i = 0; i < pool_size; ++i)
-        pool->push(std::make_shared<PostgreSQLConnection>(connection_str, address));
+        pool->push(std::make_shared<Connection>(connection_str, address));
 }
 
 
-std::string PostgreSQLConnectionPool::formatConnectionString(
+std::string ConnectionPool::formatConnectionString(
     std::string dbname, std::string host, UInt16 port, std::string user, std::string password)
 {
-    WriteBufferFromOwnString out;
-    out << "dbname=" << quote << dbname
-        << " host=" << quote << host
+    DB::WriteBufferFromOwnString out;
+    out << "dbname=" << DB::quote << dbname
+        << " host=" << DB::quote << host
         << " port=" << port
-        << " user=" << quote << user
-        << " password=" << quote << password;
+        << " user=" << DB::quote << user
+        << " password=" << DB::quote << password;
     return out.str();
 }
 
 
-PostgreSQLConnectionHolderPtr PostgreSQLConnectionPool::get()
+ConnectionHolderPtr ConnectionPool::get()
 {
-    PostgreSQLConnectionPtr connection;
+    ConnectionPtr connection;
 
     /// Always blocks by default.
     if (block_on_empty_pool)
     {
         /// pop to ConcurrentBoundedQueue will block until it is non-empty.
         pool->pop(connection);
-        return std::make_shared<PostgreSQLConnectionHolder>(connection, *pool);
+        return std::make_shared<ConnectionHolder>(connection, *pool);
     }
 
     if (pool->tryPop(connection, pool_wait_timeout))
     {
-        return std::make_shared<PostgreSQLConnectionHolder>(connection, *pool);
+        return std::make_shared<ConnectionHolder>(connection, *pool);
     }
 
-    connection = std::make_shared<PostgreSQLConnection>(connection_str, address);
-    return std::make_shared<PostgreSQLConnectionHolder>(connection, *pool);
+    connection = std::make_shared<Connection>(connection_str, address);
+    return std::make_shared<ConnectionHolder>(connection, *pool);
 }
 
 }
diff --git a/src/Storages/PostgreSQL/PostgreSQLConnectionPool.h b/src/Storages/PostgreSQL/PostgreSQLConnectionPool.h
index a66254f81af..f1239fc78b5 100644
--- a/src/Storages/PostgreSQL/PostgreSQLConnectionPool.h
+++ b/src/Storages/PostgreSQL/PostgreSQLConnectionPool.h
@@ -8,42 +8,41 @@
 #include "PostgreSQLConnection.h"
 
 
-namespace DB
+namespace postgres
 {
 
-class PostgreSQLReplicaConnection;
-
+class PoolWithFailover;
 
 /// Connection pool size is defined by user with setting `postgresql_connection_pool_size` (default 16).
 /// If pool is empty, it will block until there are available connections.
 /// If setting `connection_pool_wait_timeout` is defined, it will not block on empty pool and will
 /// wait until the timeout and then create a new connection. (only for storage/db engine)
-class PostgreSQLConnectionPool
+class ConnectionPool
 {
 
-friend class PostgreSQLReplicaConnection;
+friend class PoolWithFailover;
 
 static constexpr inline auto POSTGRESQL_POOL_DEFAULT_SIZE = 16;
 
 public:
 
-    PostgreSQLConnectionPool(
-            std::string dbname,
-            std::string host,
-            UInt16 port,
-            std::string user,
-            std::string password,
-            size_t pool_size_ = POSTGRESQL_POOL_DEFAULT_SIZE,
-            int64_t pool_wait_timeout_ = -1);
+    ConnectionPool(
+        std::string dbname,
+        std::string host,
+        UInt16 port,
+        std::string user,
+        std::string password,
+        size_t pool_size_ = POSTGRESQL_POOL_DEFAULT_SIZE,
+        int64_t pool_wait_timeout_ = -1);
 
-    PostgreSQLConnectionPool(const PostgreSQLConnectionPool & other);
+    ConnectionPool(const ConnectionPool & other);
 
-    PostgreSQLConnectionPool operator =(const PostgreSQLConnectionPool &) = delete;
+    ConnectionPool operator =(const ConnectionPool &) = delete;
 
-    PostgreSQLConnectionHolderPtr get();
+    ConnectionHolderPtr get();
 
 private:
-    using Pool = ConcurrentBoundedQueue<PostgreSQLConnectionPtr>;
+    using Pool = ConcurrentBoundedQueue<ConnectionPtr>;
     using PoolPtr = std::shared_ptr<Pool>;
 
     static std::string formatConnectionString(
@@ -58,7 +57,7 @@ private:
     bool block_on_empty_pool;
 };
 
-using PostgreSQLConnectionPoolPtr = std::shared_ptr<PostgreSQLConnectionPool>;
+using ConnectionPoolPtr = std::shared_ptr<ConnectionPool>;
 
 }
 
diff --git a/src/Storages/PostgreSQL/PostgreSQLPoolWithFailover.cpp b/src/Storages/PostgreSQL/PostgreSQLPoolWithFailover.cpp
new file mode 100644
index 00000000000..6230bb4bc3b
--- /dev/null
+++ b/src/Storages/PostgreSQL/PostgreSQLPoolWithFailover.cpp
@@ -0,0 +1,110 @@
+#include "PostgreSQLPoolWithFailover.h"
+#include "PostgreSQLConnection.h"
+#include <Common/parseRemoteDescription.h>
+#include <Common/Exception.h>
+#include <common/logger_useful.h>
+
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int POSTGRESQL_CONNECTION_FAILURE;
+}
+}
+
+namespace postgres
+{
+
+PoolWithFailover::PoolWithFailover(
+        const Poco::Util::AbstractConfiguration & config,
+        const std::string & config_prefix,
+        const size_t max_tries_)
+        : max_tries(max_tries_)
+{
+    auto db = config.getString(config_prefix + ".db", "");
+    auto host = config.getString(config_prefix + ".host", "");
+    auto port = config.getUInt(config_prefix + ".port", 0);
+    auto user = config.getString(config_prefix + ".user", "");
+    auto password = config.getString(config_prefix + ".password", "");
+
+    if (config.has(config_prefix + ".replica"))
+    {
+        Poco::Util::AbstractConfiguration::Keys config_keys;
+        config.keys(config_prefix, config_keys);
+
+        for (const auto & config_key : config_keys)
+        {
+            if (config_key.starts_with("replica"))
+            {
+                std::string replica_name = config_prefix + "." + config_key;
+                size_t priority = config.getInt(replica_name + ".priority", 0);
+
+                auto replica_host = config.getString(replica_name + ".host", host);
+                auto replica_port = config.getUInt(replica_name + ".port", port);
+                auto replica_user = config.getString(replica_name + ".user", user);
+                auto replica_password = config.getString(replica_name + ".password", password);
+
+                replicas_with_priority[priority].emplace_back(std::make_shared<ConnectionPool>(db, replica_host, replica_port, replica_user, replica_password));
+            }
+        }
+    }
+    else
+    {
+        replicas_with_priority[0].emplace_back(std::make_shared<ConnectionPool>(db, host, port, user, password));
+    }
+}
+
+
+PoolWithFailover::PoolWithFailover(
+        const std::string & database,
+        const RemoteDescription & addresses,
+        const std::string & user,
+        const std::string & password,
+        size_t pool_size,
+        int64_t pool_wait_timeout,
+        size_t max_tries_)
+    : max_tries(max_tries_)
+{
+    /// Replicas have the same priority, but traversed replicas are moved to the end of the queue.
+    for (const auto & [host, port] : addresses)
+    {
+        LOG_DEBUG(&Poco::Logger::get("PostgreSQLPoolWithFailover"), "Adding address host: {}, port: {} to connection pool", host, port);
+        replicas_with_priority[0].emplace_back(std::make_shared<ConnectionPool>(database, host, port, user, password, pool_size, pool_wait_timeout));
+    }
+}
+
+
+PoolWithFailover::PoolWithFailover(const PoolWithFailover & other)
+        : replicas_with_priority(other.replicas_with_priority)
+        , max_tries(other.max_tries)
+{
+}
+
+
+ConnectionHolderPtr PoolWithFailover::get()
+{
+    std::lock_guard lock(mutex);
+
+    for (size_t try_idx = 0; try_idx < max_tries; ++try_idx)
+    {
+        for (auto & priority : replicas_with_priority)
+        {
+            auto & replicas = priority.second;
+            for (size_t i = 0; i < replicas.size(); ++i)
+            {
+                auto connection = replicas[i]->get();
+                if (connection->isConnected())
+                {
+                    /// Move all traversed replicas to the end.
+                    std::rotate(replicas.begin(), replicas.begin() + i + 1, replicas.end());
+                    return connection;
+                }
+            }
+        }
+    }
+
+    throw DB::Exception(DB::ErrorCodes::POSTGRESQL_CONNECTION_FAILURE, "Unable to connect to any of the replicas");
+}
+
+}
diff --git a/src/Storages/PostgreSQL/PostgreSQLPoolWithFailover.h b/src/Storages/PostgreSQL/PostgreSQLPoolWithFailover.h
new file mode 100644
index 00000000000..8f6027c2c0d
--- /dev/null
+++ b/src/Storages/PostgreSQL/PostgreSQLPoolWithFailover.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <Core/Types.h>
+#include <Poco/Util/AbstractConfiguration.h>
+#include "PostgreSQLConnectionPool.h"
+
+
+namespace postgres
+{
+
+class PoolWithFailover
+{
+
+using RemoteDescription = std::vector<std::pair<String, uint16_t>>;
+
+public:
+    static constexpr inline auto POSTGRESQL_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES = 5;
+    static constexpr inline auto POSTGRESQL_POOL_DEFAULT_SIZE = 16;
+
+    PoolWithFailover(
+        const Poco::Util::AbstractConfiguration & config,
+        const std::string & config_prefix,
+        const size_t max_tries_ = POSTGRESQL_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES);
+
+    PoolWithFailover(
+        const std::string & database,
+        const RemoteDescription & addresses,
+        const std::string & user,
+        const std::string & password,
+        size_t pool_size = POSTGRESQL_POOL_DEFAULT_SIZE,
+        int64_t pool_wait_timeout = -1,
+        size_t max_tries_ = POSTGRESQL_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES);
+
+    PoolWithFailover(const PoolWithFailover & other);
+
+    ConnectionHolderPtr get();
+
+
+private:
+    /// Highest priority is 0, the bigger the number in map, the less the priority
+    using Replicas = std::vector<ConnectionPoolPtr>;
+    using ReplicasWithPriority = std::map<size_t, Replicas>;
+
+    ReplicasWithPriority replicas_with_priority;
+    size_t max_tries;
+    std::mutex mutex;
+};
+
+using PoolWithFailoverPtr = std::shared_ptr<PoolWithFailover>;
+
+}
diff --git a/src/Storages/PostgreSQL/PostgreSQLReplicaConnection.cpp b/src/Storages/PostgreSQL/PostgreSQLReplicaConnection.cpp
deleted file mode 100644
index 30e06d4c17c..00000000000
--- a/src/Storages/PostgreSQL/PostgreSQLReplicaConnection.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include "PostgreSQLReplicaConnection.h"
-#include "PostgreSQLConnection.h"
-#include <Common/Exception.h>
-
-
-namespace DB
-{
-
-namespace ErrorCodes
-{
-    extern const int POSTGRESQL_CONNECTION_FAILURE;
-}
-
-
-PostgreSQLReplicaConnection::PostgreSQLReplicaConnection(
-        const Poco::Util::AbstractConfiguration & config,
-        const String & config_prefix,
-        const size_t num_retries_)
-        : num_retries(num_retries_)
-{
-    auto db = config.getString(config_prefix + ".db", "");
-    auto host = config.getString(config_prefix + ".host", "");
-    auto port = config.getUInt(config_prefix + ".port", 0);
-    auto user = config.getString(config_prefix + ".user", "");
-    auto password = config.getString(config_prefix + ".password", "");
-
-    if (config.has(config_prefix + ".replica"))
-    {
-        Poco::Util::AbstractConfiguration::Keys config_keys;
-        config.keys(config_prefix, config_keys);
-
-        for (const auto & config_key : config_keys)
-        {
-            if (config_key.starts_with("replica"))
-            {
-                std::string replica_name = config_prefix + "." + config_key;
-                size_t priority = config.getInt(replica_name + ".priority", 0);
-
-                auto replica_host = config.getString(replica_name + ".host", host);
-                auto replica_port = config.getUInt(replica_name + ".port", port);
-                auto replica_user = config.getString(replica_name + ".user", user);
-                auto replica_password = config.getString(replica_name + ".password", password);
-
-                replicas[priority] = std::make_shared<PostgreSQLConnectionPool>(db, replica_host, replica_port, replica_user, replica_password);
-            }
-        }
-    }
-    else
-    {
-        replicas[0] = std::make_shared<PostgreSQLConnectionPool>(db, host, port, user, password);
-    }
-}
-
-
-PostgreSQLReplicaConnection::PostgreSQLReplicaConnection(const PostgreSQLReplicaConnection & other)
-        : replicas(other.replicas)
-        , num_retries(other.num_retries)
-{
-}
-
-
-PostgreSQLConnectionHolderPtr PostgreSQLReplicaConnection::get()
-{
-    std::lock_guard lock(mutex);
-
-    for (size_t i = 0; i < num_retries; ++i)
-    {
-        for (auto & replica : replicas)
-        {
-            auto connection = replica.second->get();
-            if (connection->isConnected())
-                return connection;
-        }
-    }
-
-    throw Exception(ErrorCodes::POSTGRESQL_CONNECTION_FAILURE, "Unable to connect to any of the replicas");
-}
-
-}
diff --git a/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp b/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp
index c5c43440228..6c3d3a53c21 100644
--- a/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp
+++ b/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp
@@ -16,7 +16,7 @@ namespace DB
 RabbitMQBlockInputStream::RabbitMQBlockInputStream(
     StorageRabbitMQ & storage_,
     const StorageMetadataPtr & metadata_snapshot_,
-    std::shared_ptr<Context> context_,
+    ContextPtr context_,
     const Names & columns,
     size_t max_block_size_,
     bool ack_in_suffix_)
@@ -91,7 +91,7 @@ Block RabbitMQBlockInputStream::readImpl()
     MutableColumns virtual_columns = virtual_header.cloneEmptyColumns();
 
     auto input_format = FormatFactory::instance().getInputFormat(
-            storage.getFormatName(), *buffer, non_virtual_header, *context, max_block_size);
+            storage.getFormatName(), *buffer, non_virtual_header, context, max_block_size);
 
     InputPort port(input_format->getPort().getHeader(), input_format.get());
     connect(input_format->getPort(), port);
diff --git a/src/Storages/RabbitMQ/RabbitMQBlockInputStream.h b/src/Storages/RabbitMQ/RabbitMQBlockInputStream.h
index 8b93ca4e911..5ce1c96bf33 100644
--- a/src/Storages/RabbitMQ/RabbitMQBlockInputStream.h
+++ b/src/Storages/RabbitMQ/RabbitMQBlockInputStream.h
@@ -15,7 +15,7 @@ public:
     RabbitMQBlockInputStream(
             StorageRabbitMQ & storage_,
             const StorageMetadataPtr & metadata_snapshot_,
-            std::shared_ptr<Context> context_,
+            ContextPtr context_,
             const Names & columns,
             size_t max_block_size_,
             bool ack_in_suffix = true);
@@ -38,7 +38,7 @@ public:
 private:
     StorageRabbitMQ & storage;
     StorageMetadataPtr metadata_snapshot;
-    std::shared_ptr<Context> context;
+    ContextPtr context;
     Names column_names;
     const size_t max_block_size;
     bool ack_in_suffix;
diff --git a/src/Storages/RabbitMQ/RabbitMQBlockOutputStream.cpp b/src/Storages/RabbitMQ/RabbitMQBlockOutputStream.cpp
index a987fff3c64..3c837cb95b1 100644
--- a/src/Storages/RabbitMQ/RabbitMQBlockOutputStream.cpp
+++ b/src/Storages/RabbitMQ/RabbitMQBlockOutputStream.cpp
@@ -11,7 +11,7 @@ namespace DB
 RabbitMQBlockOutputStream::RabbitMQBlockOutputStream(
     StorageRabbitMQ & storage_,
     const StorageMetadataPtr & metadata_snapshot_,
-    const Context & context_)
+    ContextPtr context_)
     : storage(storage_)
     , metadata_snapshot(metadata_snapshot_)
     , context(context_)
diff --git a/src/Storages/RabbitMQ/RabbitMQBlockOutputStream.h b/src/Storages/RabbitMQ/RabbitMQBlockOutputStream.h
index 7e5c22f9f39..3941875ea86 100644
--- a/src/Storages/RabbitMQ/RabbitMQBlockOutputStream.h
+++ b/src/Storages/RabbitMQ/RabbitMQBlockOutputStream.h
@@ -11,7 +11,7 @@ class RabbitMQBlockOutputStream : public IBlockOutputStream
 {
 
 public:
-    explicit RabbitMQBlockOutputStream(StorageRabbitMQ & storage_, const StorageMetadataPtr & metadata_snapshot_, const Context & context_);
+    explicit RabbitMQBlockOutputStream(StorageRabbitMQ & storage_, const StorageMetadataPtr & metadata_snapshot_, ContextPtr context_);
 
     Block getHeader() const override;
 
@@ -22,7 +22,7 @@ public:
 private:
     StorageRabbitMQ & storage;
     StorageMetadataPtr metadata_snapshot;
-    const Context & context;
+    ContextPtr context;
     ProducerBufferPtr buffer;
     BlockOutputStreamPtr child;
 };
diff --git a/src/Storages/RabbitMQ/StorageRabbitMQ.cpp b/src/Storages/RabbitMQ/StorageRabbitMQ.cpp
index 0ecf85e5c3d..55629f2a205 100644
--- a/src/Storages/RabbitMQ/StorageRabbitMQ.cpp
+++ b/src/Storages/RabbitMQ/StorageRabbitMQ.cpp
@@ -70,31 +70,31 @@ namespace ExchangeType
 
 StorageRabbitMQ::StorageRabbitMQ(
         const StorageID & table_id_,
-        const Context & context_,
+        ContextPtr context_,
         const ColumnsDescription & columns_,
         std::unique_ptr<RabbitMQSettings> rabbitmq_settings_)
         : IStorage(table_id_)
-        , global_context(context_.getGlobalContext())
+        , WithContext(context_->getGlobalContext())
         , rabbitmq_settings(std::move(rabbitmq_settings_))
-        , exchange_name(global_context.getMacros()->expand(rabbitmq_settings->rabbitmq_exchange_name.value))
-        , format_name(global_context.getMacros()->expand(rabbitmq_settings->rabbitmq_format.value))
-        , exchange_type(defineExchangeType(global_context.getMacros()->expand(rabbitmq_settings->rabbitmq_exchange_type.value)))
-        , routing_keys(parseRoutingKeys(global_context.getMacros()->expand(rabbitmq_settings->rabbitmq_routing_key_list.value)))
+        , exchange_name(getContext()->getMacros()->expand(rabbitmq_settings->rabbitmq_exchange_name.value))
+        , format_name(getContext()->getMacros()->expand(rabbitmq_settings->rabbitmq_format.value))
+        , exchange_type(defineExchangeType(getContext()->getMacros()->expand(rabbitmq_settings->rabbitmq_exchange_type.value)))
+        , routing_keys(parseRoutingKeys(getContext()->getMacros()->expand(rabbitmq_settings->rabbitmq_routing_key_list.value)))
         , row_delimiter(rabbitmq_settings->rabbitmq_row_delimiter.value)
-        , schema_name(global_context.getMacros()->expand(rabbitmq_settings->rabbitmq_schema.value))
+        , schema_name(getContext()->getMacros()->expand(rabbitmq_settings->rabbitmq_schema.value))
         , num_consumers(rabbitmq_settings->rabbitmq_num_consumers.value)
         , num_queues(rabbitmq_settings->rabbitmq_num_queues.value)
-        , queue_base(global_context.getMacros()->expand(rabbitmq_settings->rabbitmq_queue_base.value))
-        , deadletter_exchange(global_context.getMacros()->expand(rabbitmq_settings->rabbitmq_deadletter_exchange.value))
+        , queue_base(getContext()->getMacros()->expand(rabbitmq_settings->rabbitmq_queue_base.value))
+        , deadletter_exchange(getContext()->getMacros()->expand(rabbitmq_settings->rabbitmq_deadletter_exchange.value))
         , persistent(rabbitmq_settings->rabbitmq_persistent.value)
         , hash_exchange(num_consumers > 1 || num_queues > 1)
         , log(&Poco::Logger::get("StorageRabbitMQ (" + table_id_.table_name + ")"))
-        , address(global_context.getMacros()->expand(rabbitmq_settings->rabbitmq_host_port.value))
+        , address(getContext()->getMacros()->expand(rabbitmq_settings->rabbitmq_host_port.value))
         , parsed_address(parseAddress(address, 5672))
         , login_password(std::make_pair(
-                    global_context.getConfigRef().getString("rabbitmq.username"),
-                    global_context.getConfigRef().getString("rabbitmq.password")))
-        , vhost(global_context.getConfigRef().getString("rabbitmq.vhost", "/"))
+                    getContext()->getConfigRef().getString("rabbitmq.username"),
+                    getContext()->getConfigRef().getString("rabbitmq.password")))
+        , vhost(getContext()->getConfigRef().getString("rabbitmq.vhost", "/"))
         , semaphore(0, num_consumers)
         , unique_strbase(getRandomName())
         , queue_size(std::max(QUEUE_SIZE, static_cast<uint32_t>(getMaxBlockSize())))
@@ -106,18 +106,18 @@ StorageRabbitMQ::StorageRabbitMQ(
     storage_metadata.setColumns(columns_);
     setInMemoryMetadata(storage_metadata);
 
-    rabbitmq_context = addSettings(global_context);
+    rabbitmq_context = addSettings(getContext());
     rabbitmq_context->makeQueryContext();
 
     /// One looping task for all consumers as they share the same connection == the same handler == the same event loop
     event_handler->updateLoopState(Loop::STOP);
-    looping_task = global_context.getMessageBrokerSchedulePool().createTask("RabbitMQLoopingTask", [this]{ loopingFunc(); });
+    looping_task = getContext()->getMessageBrokerSchedulePool().createTask("RabbitMQLoopingTask", [this]{ loopingFunc(); });
     looping_task->deactivate();
 
-    streaming_task = global_context.getMessageBrokerSchedulePool().createTask("RabbitMQStreamingTask", [this]{ streamingToViewsFunc(); });
+    streaming_task = getContext()->getMessageBrokerSchedulePool().createTask("RabbitMQStreamingTask", [this]{ streamingToViewsFunc(); });
     streaming_task->deactivate();
 
-    connection_task = global_context.getMessageBrokerSchedulePool().createTask("RabbitMQConnectionTask", [this]{ connectionFunc(); });
+    connection_task = getContext()->getMessageBrokerSchedulePool().createTask("RabbitMQConnectionTask", [this]{ connectionFunc(); });
     connection_task->deactivate();
 
     if (queue_base.empty())
@@ -188,9 +188,9 @@ String StorageRabbitMQ::getTableBasedName(String name, const StorageID & table_i
 }
 
 
-std::shared_ptr<Context> StorageRabbitMQ::addSettings(const Context & context) const
+std::shared_ptr<Context> StorageRabbitMQ::addSettings(ContextPtr local_context) const
 {
-    auto modified_context = std::make_shared<Context>(context);
+    auto modified_context = Context::createCopy(local_context);
     modified_context->setSetting("input_format_skip_unknown_fields", true);
     modified_context->setSetting("input_format_allow_errors_ratio", 0.);
     modified_context->setSetting("input_format_allow_errors_num", rabbitmq_settings->rabbitmq_skip_broken_messages.value);
@@ -253,7 +253,7 @@ size_t StorageRabbitMQ::getMaxBlockSize() const
  {
      return rabbitmq_settings->rabbitmq_max_block_size.changed
          ? rabbitmq_settings->rabbitmq_max_block_size.value
-         : (global_context.getSettingsRef().max_insert_block_size.value / num_consumers);
+         : (getContext()->getSettingsRef().max_insert_block_size.value / num_consumers);
  }
 
 
@@ -562,7 +562,7 @@ Pipe StorageRabbitMQ::read(
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & /* query_info */,
-        const Context & context,
+        ContextPtr local_context,
         QueryProcessingStage::Enum /* processed_stage */,
         size_t /* max_block_size */,
         unsigned /* num_streams */)
@@ -574,7 +574,7 @@ Pipe StorageRabbitMQ::read(
         return {};
 
     auto sample_block = metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID());
-    auto modified_context = addSettings(context);
+    auto modified_context = addSettings(local_context);
     auto block_size = getMaxBlockSize();
 
     if (!event_handler->connectionRunning())
@@ -607,9 +607,9 @@ Pipe StorageRabbitMQ::read(
 }
 
 
-BlockOutputStreamPtr StorageRabbitMQ::write(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr StorageRabbitMQ::write(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr local_context)
 {
-    return std::make_shared<RabbitMQBlockOutputStream>(*this, metadata_snapshot, context);
+    return std::make_shared<RabbitMQBlockOutputStream>(*this, metadata_snapshot, local_context);
 }
 
 
@@ -712,7 +712,7 @@ ConsumerBufferPtr StorageRabbitMQ::createReadBuffer()
 ProducerBufferPtr StorageRabbitMQ::createWriteBuffer()
 {
     return std::make_shared<WriteBufferToRabbitMQProducer>(
-        parsed_address, global_context, login_password, vhost, routing_keys, exchange_name, exchange_type,
+        parsed_address, getContext(), login_password, vhost, routing_keys, exchange_name, exchange_type,
         producer_id.fetch_add(1), persistent, wait_confirm, log,
         row_delimiter ? std::optional<char>{row_delimiter} : std::nullopt, 1, 1024);
 }
@@ -728,7 +728,7 @@ bool StorageRabbitMQ::checkDependencies(const StorageID & table_id)
     // Check the dependencies are ready?
     for (const auto & db_tab : dependencies)
     {
-        auto table = DatabaseCatalog::instance().tryGetTable(db_tab, global_context);
+        auto table = DatabaseCatalog::instance().tryGetTable(db_tab, getContext());
         if (!table)
             return false;
 
@@ -798,7 +798,7 @@ void StorageRabbitMQ::streamingToViewsFunc()
 bool StorageRabbitMQ::streamToViews()
 {
     auto table_id = getStorageID();
-    auto table = DatabaseCatalog::instance().getTable(table_id, global_context);
+    auto table = DatabaseCatalog::instance().getTable(table_id, getContext());
     if (!table)
         throw Exception("Engine table " + table_id.getNameForLogs() + " doesn't exist.", ErrorCodes::LOGICAL_ERROR);
 
@@ -807,7 +807,7 @@ bool StorageRabbitMQ::streamToViews()
     insert->table_id = table_id;
 
     // Only insert into dependent views and expect that input blocks contain virtual columns
-    InterpreterInsertQuery interpreter(insert, *rabbitmq_context, false, true, true);
+    InterpreterInsertQuery interpreter(insert, rabbitmq_context, false, true, true);
     auto block_io = interpreter.execute();
 
     auto metadata_snapshot = getInMemoryMetadataPtr();
@@ -831,7 +831,7 @@ bool StorageRabbitMQ::streamToViews()
 
         limits.speed_limits.max_execution_time = rabbitmq_settings->rabbitmq_flush_interval_ms.changed
                                                   ? rabbitmq_settings->rabbitmq_flush_interval_ms
-                                                  : global_context.getSettingsRef().stream_flush_interval_ms;
+                                                  : getContext()->getSettingsRef().stream_flush_interval_ms;
 
         limits.timeout_overflow_mode = OverflowMode::BREAK;
 
@@ -990,7 +990,7 @@ void registerStorageRabbitMQ(StorageFactory & factory)
 
         #undef CHECK_RABBITMQ_STORAGE_ARGUMENT
 
-        return StorageRabbitMQ::create(args.table_id, args.context, args.columns, std::move(rabbitmq_settings));
+        return StorageRabbitMQ::create(args.table_id, args.getContext(), args.columns, std::move(rabbitmq_settings));
     };
 
     factory.registerStorage("RabbitMQ", creator_fn, StorageFactory::StorageFeatures{ .supports_settings = true, });
diff --git a/src/Storages/RabbitMQ/StorageRabbitMQ.h b/src/Storages/RabbitMQ/StorageRabbitMQ.h
index 9f573ea4a3e..eeda6b9fdca 100644
--- a/src/Storages/RabbitMQ/StorageRabbitMQ.h
+++ b/src/Storages/RabbitMQ/StorageRabbitMQ.h
@@ -19,11 +19,9 @@
 namespace DB
 {
 
-class Context;
-
 using ChannelPtr = std::shared_ptr<AMQP::TcpChannel>;
 
-class StorageRabbitMQ final: public ext::shared_ptr_helper<StorageRabbitMQ>, public IStorage
+class StorageRabbitMQ final: public ext::shared_ptr_helper<StorageRabbitMQ>, public IStorage, WithContext
 {
     friend struct ext::shared_ptr_helper<StorageRabbitMQ>;
 
@@ -40,7 +38,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -48,7 +46,7 @@ public:
     BlockOutputStreamPtr write(
         const ASTPtr & query,
         const StorageMetadataPtr & metadata_snapshot,
-        const Context & context) override;
+        ContextPtr context) override;
 
     void pushReadBuffer(ConsumerBufferPtr buf);
     ConsumerBufferPtr popReadBuffer();
@@ -59,7 +57,7 @@ public:
     const String & getFormatName() const { return format_name; }
     NamesAndTypesList getVirtuals() const override;
 
-    const String getExchange() const { return exchange_name; }
+    String getExchange() const { return exchange_name; }
     void unbindExchange();
     bool exchangeRemoved() { return exchange_removed.load(); }
 
@@ -69,13 +67,12 @@ public:
 protected:
     StorageRabbitMQ(
             const StorageID & table_id_,
-            const Context & context_,
+            ContextPtr context_,
             const ColumnsDescription & columns_,
             std::unique_ptr<RabbitMQSettings> rabbitmq_settings_);
 
 private:
-    const Context & global_context;
-    std::shared_ptr<Context> rabbitmq_context;
+    ContextPtr rabbitmq_context;
     std::unique_ptr<RabbitMQSettings> rabbitmq_settings;
 
     const String exchange_name;
@@ -139,7 +136,7 @@ private:
     static AMQP::ExchangeType defineExchangeType(String exchange_type_);
     static String getTableBasedName(String name, const StorageID & table_id);
 
-    std::shared_ptr<Context> addSettings(const Context & context) const;
+    std::shared_ptr<Context> addSettings(ContextPtr context) const;
     size_t getMaxBlockSize() const;
     void deactivateTask(BackgroundSchedulePool::TaskHolder & task, bool wait, bool stop_loop);
 
diff --git a/src/Storages/RabbitMQ/WriteBufferToRabbitMQProducer.cpp b/src/Storages/RabbitMQ/WriteBufferToRabbitMQProducer.cpp
index ebee27faf17..b9af60eb66f 100644
--- a/src/Storages/RabbitMQ/WriteBufferToRabbitMQProducer.cpp
+++ b/src/Storages/RabbitMQ/WriteBufferToRabbitMQProducer.cpp
@@ -27,7 +27,7 @@ namespace ErrorCodes
 
 WriteBufferToRabbitMQProducer::WriteBufferToRabbitMQProducer(
         std::pair<String, UInt16> & parsed_address_,
-        const Context & global_context,
+        ContextPtr global_context,
         const std::pair<String, String> & login_password_,
         const String & vhost_,
         const Names & routing_keys_,
@@ -72,7 +72,7 @@ WriteBufferToRabbitMQProducer::WriteBufferToRabbitMQProducer(
                 ErrorCodes::CANNOT_CONNECT_RABBITMQ);
     }
 
-    writing_task = global_context.getSchedulePool().createTask("RabbitMQWritingTask", [this]{ writingFunc(); });
+    writing_task = global_context->getSchedulePool().createTask("RabbitMQWritingTask", [this]{ writingFunc(); });
     writing_task->deactivate();
 
     if (exchange_type == AMQP::ExchangeType::headers)
diff --git a/src/Storages/RabbitMQ/WriteBufferToRabbitMQProducer.h b/src/Storages/RabbitMQ/WriteBufferToRabbitMQProducer.h
index e88f5e10e74..452cc38d751 100644
--- a/src/Storages/RabbitMQ/WriteBufferToRabbitMQProducer.h
+++ b/src/Storages/RabbitMQ/WriteBufferToRabbitMQProducer.h
@@ -20,7 +20,7 @@ class WriteBufferToRabbitMQProducer : public WriteBuffer
 public:
     WriteBufferToRabbitMQProducer(
             std::pair<String, UInt16> & parsed_address_,
-            const Context & global_context,
+            ContextPtr global_context,
             const std::pair<String, String> & login_password_,
             const String & vhost_,
             const Names & routing_keys_,
diff --git a/src/Storages/ReadInOrderOptimizer.cpp b/src/Storages/ReadInOrderOptimizer.cpp
index 2b751329208..5f2b5f4db96 100644
--- a/src/Storages/ReadInOrderOptimizer.cpp
+++ b/src/Storages/ReadInOrderOptimizer.cpp
@@ -34,7 +34,7 @@ ReadInOrderOptimizer::ReadInOrderOptimizer(
     forbidden_columns = syntax_result->getArrayJoinSourceNameSet();
 }
 
-InputOrderInfoPtr ReadInOrderOptimizer::getInputOrder(const StorageMetadataPtr & metadata_snapshot, const Context & context) const
+InputOrderInfoPtr ReadInOrderOptimizer::getInputOrder(const StorageMetadataPtr & metadata_snapshot, ContextPtr context) const
 {
     Names sorting_key_columns = metadata_snapshot->getSortingKeyColumns();
     if (!metadata_snapshot->hasSortingKey())
@@ -125,7 +125,7 @@ InputOrderInfoPtr ReadInOrderOptimizer::getInputOrder(const StorageMetadataPtr &
         /// currently we only support alias column without any function wrapper
         /// ie: `order by aliased_column` can have this optimization, but `order by function(aliased_column)` can not.
         /// This suits most cases.
-        if (context.getSettingsRef().optimize_respect_aliases && aliase_columns.contains(required_sort_description[i].column_name))
+        if (context->getSettingsRef().optimize_respect_aliases && aliase_columns.contains(required_sort_description[i].column_name))
         {
             auto column_expr = metadata_snapshot->getColumns().get(required_sort_description[i].column_name).default_desc.expression->clone();
             replaceAliasColumnsInQuery(column_expr, metadata_snapshot->getColumns(), forbidden_columns, context);
diff --git a/src/Storages/ReadInOrderOptimizer.h b/src/Storages/ReadInOrderOptimizer.h
index 3676f4cc88c..0af1121db32 100644
--- a/src/Storages/ReadInOrderOptimizer.h
+++ b/src/Storages/ReadInOrderOptimizer.h
@@ -22,7 +22,7 @@ public:
         const SortDescription & required_sort_description,
         const TreeRewriterResultPtr & syntax_result);
 
-    InputOrderInfoPtr getInputOrder(const StorageMetadataPtr & metadata_snapshot, const Context & context) const;
+    InputOrderInfoPtr getInputOrder(const StorageMetadataPtr & metadata_snapshot, ContextPtr context) const;
 
 private:
     /// Actions for every element of order expression to analyze functions for monotonicity
diff --git a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp
index 9b0a0c36b45..9173c23ec5a 100644
--- a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp
+++ b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp
@@ -245,12 +245,12 @@ StorageEmbeddedRocksDB::StorageEmbeddedRocksDB(const StorageID & table_id_,
         const String & relative_data_path_,
         const StorageInMemoryMetadata & metadata_,
         bool attach,
-        Context & context_,
+        ContextPtr context_,
         const String & primary_key_)
     : IStorage(table_id_), primary_key{primary_key_}
 {
     setInMemoryMetadata(metadata_);
-    rocksdb_dir = context_.getPath() + relative_data_path_;
+    rocksdb_dir = context_->getPath() + relative_data_path_;
     if (!attach)
     {
         Poco::File(rocksdb_dir).createDirectories();
@@ -258,7 +258,7 @@ StorageEmbeddedRocksDB::StorageEmbeddedRocksDB(const StorageID & table_id_,
     initDb();
 }
 
-void StorageEmbeddedRocksDB::truncate(const ASTPtr &, const StorageMetadataPtr & , const Context &, TableExclusiveLockHolder &)
+void StorageEmbeddedRocksDB::truncate(const ASTPtr &, const StorageMetadataPtr & , ContextPtr, TableExclusiveLockHolder &)
 {
     rocksdb_ptr->Close();
     Poco::File(rocksdb_dir).remove(true);
@@ -284,7 +284,7 @@ Pipe StorageEmbeddedRocksDB::read(
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         QueryProcessingStage::Enum /*processed_stage*/,
         size_t max_block_size,
         unsigned num_streams)
@@ -331,7 +331,7 @@ Pipe StorageEmbeddedRocksDB::read(
 }
 
 BlockOutputStreamPtr StorageEmbeddedRocksDB::write(
-    const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & /*context*/)
+    const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr /*context*/)
 {
     return std::make_shared<EmbeddedRocksDBBlockOutputStream>(*this, metadata_snapshot);
 }
@@ -352,13 +352,13 @@ static StoragePtr create(const StorageFactory::Arguments & args)
     if (!args.storage_def->primary_key)
         throw Exception("StorageEmbeddedRocksDB must require one column in primary key", ErrorCodes::BAD_ARGUMENTS);
 
-    metadata.primary_key = KeyDescription::getKeyFromAST(args.storage_def->primary_key->ptr(), metadata.columns, args.context);
+    metadata.primary_key = KeyDescription::getKeyFromAST(args.storage_def->primary_key->ptr(), metadata.columns, args.getContext());
     auto primary_key_names = metadata.getColumnsRequiredForPrimaryKey();
     if (primary_key_names.size() != 1)
     {
         throw Exception("StorageEmbeddedRocksDB must require one column in primary key", ErrorCodes::BAD_ARGUMENTS);
     }
-    return StorageEmbeddedRocksDB::create(args.table_id, args.relative_data_path, metadata, args.attach, args.context, primary_key_names[0]);
+    return StorageEmbeddedRocksDB::create(args.table_id, args.relative_data_path, metadata, args.attach, args.getContext(), primary_key_names[0]);
 }
 
 
diff --git a/src/Storages/RocksDB/StorageEmbeddedRocksDB.h b/src/Storages/RocksDB/StorageEmbeddedRocksDB.h
index f1a8c4713eb..64255392c35 100644
--- a/src/Storages/RocksDB/StorageEmbeddedRocksDB.h
+++ b/src/Storages/RocksDB/StorageEmbeddedRocksDB.h
@@ -29,18 +29,18 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
-    void truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context &, TableExclusiveLockHolder &) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr, TableExclusiveLockHolder &) override;
 
     bool supportsParallelInsert() const override { return true; }
     bool supportsIndexForIn() const override { return true; }
     bool mayBenefitFromIndexForIn(
-        const ASTPtr & node, const Context & /*query_context*/, const StorageMetadataPtr & /*metadata_snapshot*/) const override
+        const ASTPtr & node, ContextPtr /*query_context*/, const StorageMetadataPtr & /*metadata_snapshot*/) const override
     {
         return node->getColumnName() == primary_key;
     }
@@ -53,7 +53,7 @@ protected:
         const String & relative_data_path_,
         const StorageInMemoryMetadata & metadata,
         bool attach,
-        Context & context_,
+        ContextPtr context_,
         const String & primary_key_);
 
 private:
diff --git a/src/Storages/SelectQueryDescription.cpp b/src/Storages/SelectQueryDescription.cpp
index c11e6bd74f8..05747a9a260 100644
--- a/src/Storages/SelectQueryDescription.cpp
+++ b/src/Storages/SelectQueryDescription.cpp
@@ -44,11 +44,11 @@ SelectQueryDescription & SelectQueryDescription::SelectQueryDescription::operato
 namespace
 {
 
-StorageID extractDependentTableFromSelectQuery(ASTSelectQuery & query, const Context & context, bool add_default_db = true)
+StorageID extractDependentTableFromSelectQuery(ASTSelectQuery & query, ContextPtr context, bool add_default_db = true)
 {
     if (add_default_db)
     {
-        AddDefaultDatabaseVisitor visitor(context.getCurrentDatabase(), false, nullptr);
+        AddDefaultDatabaseVisitor visitor(context->getCurrentDatabase(), false, nullptr);
         visitor.visit(query);
     }
 
@@ -114,7 +114,7 @@ static bool isSingleSelect(const ASTPtr & select, ASTPtr & res)
         return isSingleSelect(new_inner_query, res);
 }
 
-SelectQueryDescription SelectQueryDescription::getSelectQueryFromASTForMatView(const ASTPtr & select, const Context & context)
+SelectQueryDescription SelectQueryDescription::getSelectQueryFromASTForMatView(const ASTPtr & select, ContextPtr context)
 {
     ASTPtr new_inner_query;
 
diff --git a/src/Storages/SelectQueryDescription.h b/src/Storages/SelectQueryDescription.h
index ce3ca44c147..28a0a186a07 100644
--- a/src/Storages/SelectQueryDescription.h
+++ b/src/Storages/SelectQueryDescription.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <Interpreters/Context_fwd.h>
 #include <Interpreters/StorageID.h>
 
 namespace DB
@@ -17,7 +18,7 @@ struct SelectQueryDescription
 
     /// Parse description from select query for materialized view. Also
     /// validates query.
-    static SelectQueryDescription getSelectQueryFromASTForMatView(const ASTPtr & select, const Context & context);
+    static SelectQueryDescription getSelectQueryFromASTForMatView(const ASTPtr & select, ContextPtr context);
 
     SelectQueryDescription() = default;
     SelectQueryDescription(const SelectQueryDescription & other);
diff --git a/src/Storages/SelectQueryInfo.h b/src/Storages/SelectQueryInfo.h
index fea9a7bad68..b4ac07c612a 100644
--- a/src/Storages/SelectQueryInfo.h
+++ b/src/Storages/SelectQueryInfo.h
@@ -119,9 +119,13 @@ struct SelectQueryInfo
     ASTPtr query;
     ASTPtr view_query; /// Optimized VIEW query
 
-    /// For optimize_skip_unused_shards.
-    /// Can be modified in getQueryProcessingStage()
+    /// Cluster for the query.
     ClusterPtr cluster;
+    /// Optimized cluster for the query.
+    /// In case of optimize_skip_unused_shards it may differs from original cluster.
+    ///
+    /// Configured in StorageDistributed::getQueryProcessingStage()
+    ClusterPtr optimized_cluster;
 
     TreeRewriterResultPtr syntax_analyzer_result;
 
@@ -134,6 +138,8 @@ struct SelectQueryInfo
     /// Prepared sets are used for indices by storage engine.
     /// Example: x IN (1, 2, 3)
     PreparedSets sets;
+
+    ClusterPtr getCluster() const { return !optimized_cluster ? cluster : optimized_cluster; }
 };
 
 }
diff --git a/src/Storages/StorageBuffer.cpp b/src/Storages/StorageBuffer.cpp
index 6dc32f4c880..5c4b4e7d1d8 100644
--- a/src/Storages/StorageBuffer.cpp
+++ b/src/Storages/StorageBuffer.cpp
@@ -40,6 +40,8 @@ namespace ProfileEvents
     extern const Event StorageBufferPassedTimeMaxThreshold;
     extern const Event StorageBufferPassedRowsMaxThreshold;
     extern const Event StorageBufferPassedBytesMaxThreshold;
+    extern const Event StorageBufferLayerLockReadersWaitMilliseconds;
+    extern const Event StorageBufferLayerLockWritersWaitMilliseconds;
 }
 
 namespace CurrentMetrics
@@ -63,25 +65,55 @@ namespace ErrorCodes
 }
 
 
+std::unique_lock<std::mutex> StorageBuffer::Buffer::lockForReading() const
+{
+    return lockImpl(/* read= */true);
+}
+std::unique_lock<std::mutex> StorageBuffer::Buffer::lockForWriting() const
+{
+    return lockImpl(/* read= */false);
+}
+std::unique_lock<std::mutex> StorageBuffer::Buffer::tryLock() const
+{
+    std::unique_lock lock(mutex, std::try_to_lock);
+    return lock;
+}
+std::unique_lock<std::mutex> StorageBuffer::Buffer::lockImpl(bool read) const
+{
+    std::unique_lock lock(mutex, std::defer_lock);
+
+    Stopwatch watch(CLOCK_MONOTONIC_COARSE);
+    lock.lock();
+    UInt64 elapsed = watch.elapsedMilliseconds();
+
+    if (read)
+        ProfileEvents::increment(ProfileEvents::StorageBufferLayerLockReadersWaitMilliseconds, elapsed);
+    else
+        ProfileEvents::increment(ProfileEvents::StorageBufferLayerLockWritersWaitMilliseconds, elapsed);
+
+    return lock;
+}
+
+
 StorageBuffer::StorageBuffer(
     const StorageID & table_id_,
     const ColumnsDescription & columns_,
     const ConstraintsDescription & constraints_,
-    const Context & context_,
+    ContextPtr context_,
     size_t num_shards_,
     const Thresholds & min_thresholds_,
     const Thresholds & max_thresholds_,
     const StorageID & destination_id_,
     bool allow_materialized_)
     : IStorage(table_id_)
-    , buffer_context(context_.getBufferContext())
+    , WithContext(context_->getBufferContext())
     , num_shards(num_shards_), buffers(num_shards_)
     , min_thresholds(min_thresholds_)
     , max_thresholds(max_thresholds_)
     , destination_id(destination_id_)
     , allow_materialized(allow_materialized_)
     , log(&Poco::Logger::get("StorageBuffer (" + table_id_.getFullTableName() + ")"))
-    , bg_pool(buffer_context.getBufferFlushSchedulePool())
+    , bg_pool(getContext()->getBufferFlushSchedulePool())
 {
     StorageInMemoryMetadata storage_metadata;
     storage_metadata.setColumns(columns_);
@@ -111,7 +143,7 @@ protected:
             return res;
         has_been_read = true;
 
-        std::lock_guard lock(buffer.mutex);
+        std::unique_lock lock(buffer.lockForReading());
 
         if (!buffer.data.rows())
             return res;
@@ -141,16 +173,16 @@ private:
 };
 
 
-QueryProcessingStage::Enum StorageBuffer::getQueryProcessingStage(const Context & context, QueryProcessingStage::Enum to_stage, SelectQueryInfo & query_info) const
+QueryProcessingStage::Enum StorageBuffer::getQueryProcessingStage(ContextPtr local_context, QueryProcessingStage::Enum to_stage, SelectQueryInfo & query_info) const
 {
     if (destination_id)
     {
-        auto destination = DatabaseCatalog::instance().getTable(destination_id, context);
+        auto destination = DatabaseCatalog::instance().getTable(destination_id, local_context);
 
         if (destination.get() == this)
             throw Exception("Destination table is myself. Read will cause infinite loop.", ErrorCodes::INFINITE_LOOP);
 
-        return destination->getQueryProcessingStage(context, to_stage, query_info);
+        return destination->getQueryProcessingStage(local_context, to_stage, query_info);
     }
 
     return QueryProcessingStage::FetchColumns;
@@ -161,16 +193,16 @@ Pipe StorageBuffer::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     const size_t max_block_size,
     const unsigned num_streams)
 {
     QueryPlan plan;
-    read(plan, column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams);
+    read(plan, column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams);
     return plan.convertToPipe(
-        QueryPlanOptimizationSettings::fromContext(context),
-        BuildQueryPipelineSettings::fromContext(context));
+        QueryPlanOptimizationSettings::fromContext(local_context),
+        BuildQueryPipelineSettings::fromContext(local_context));
 }
 
 void StorageBuffer::read(
@@ -178,19 +210,19 @@ void StorageBuffer::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     size_t max_block_size,
     unsigned num_streams)
 {
     if (destination_id)
     {
-        auto destination = DatabaseCatalog::instance().getTable(destination_id, context);
+        auto destination = DatabaseCatalog::instance().getTable(destination_id, local_context);
 
         if (destination.get() == this)
             throw Exception("Destination table is myself. Read will cause infinite loop.", ErrorCodes::INFINITE_LOOP);
 
-        auto destination_lock = destination->lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+        auto destination_lock = destination->lockForShare(local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout);
 
         auto destination_metadata_snapshot = destination->getInMemoryMetadataPtr();
 
@@ -205,12 +237,12 @@ void StorageBuffer::read(
         if (dst_has_same_structure)
         {
             if (query_info.order_optimizer)
-                query_info.input_order_info = query_info.order_optimizer->getInputOrder(destination_metadata_snapshot, context);
+                query_info.input_order_info = query_info.order_optimizer->getInputOrder(destination_metadata_snapshot, local_context);
 
             /// The destination table has the same structure of the requested columns and we can simply read blocks from there.
             destination->read(
                 query_plan, column_names, destination_metadata_snapshot, query_info,
-                context, processed_stage, max_block_size, num_streams);
+                local_context, processed_stage, max_block_size, num_streams);
         }
         else
         {
@@ -245,7 +277,7 @@ void StorageBuffer::read(
             {
                 destination->read(
                         query_plan, columns_intersection, destination_metadata_snapshot, query_info,
-                        context, processed_stage, max_block_size, num_streams);
+                        local_context, processed_stage, max_block_size, num_streams);
 
                 if (query_plan.isInitialized())
                 {
@@ -254,7 +286,7 @@ void StorageBuffer::read(
                             query_plan.getCurrentDataStream().header,
                             header_after_adding_defaults.getNamesAndTypesList(),
                             metadata_snapshot->getColumns(),
-                            context);
+                            local_context);
 
                     auto adding_missed = std::make_unique<ExpressionStep>(
                             query_plan.getCurrentDataStream(),
@@ -317,7 +349,7 @@ void StorageBuffer::read(
     if (processed_stage > QueryProcessingStage::FetchColumns)
     {
         auto interpreter = InterpreterSelectQuery(
-                query_info.query, context, std::move(pipe_from_buffers),
+                query_info.query, local_context, std::move(pipe_from_buffers),
                 SelectQueryOptions(processed_stage));
         interpreter.buildQueryPlan(buffers_plan);
     }
@@ -391,7 +423,7 @@ void StorageBuffer::read(
     plans.emplace_back(std::make_unique<QueryPlan>(std::move(buffers_plan)));
     query_plan = QueryPlan();
 
-    auto union_step = std::make_unique<UnionStep>(std::move(input_streams), result_header);
+    auto union_step = std::make_unique<UnionStep>(std::move(input_streams));
     union_step->setStepDescription("Unite sources from Buffer table");
     query_plan.unitePlans(std::move(union_step), std::move(plans));
 }
@@ -495,7 +527,7 @@ public:
         StoragePtr destination;
         if (storage.destination_id)
         {
-            destination = DatabaseCatalog::instance().tryGetTable(storage.destination_id, storage.buffer_context);
+            destination = DatabaseCatalog::instance().tryGetTable(storage.destination_id, storage.getContext());
             if (destination.get() == &storage)
                 throw Exception("Destination table is myself. Write will cause infinite loop.", ErrorCodes::INFINITE_LOOP);
         }
@@ -528,7 +560,7 @@ public:
 
         for (size_t try_no = 0; try_no < storage.num_shards; ++try_no)
         {
-            std::unique_lock lock(storage.buffers[shard_num].mutex, std::try_to_lock);
+            std::unique_lock lock(storage.buffers[shard_num].tryLock());
 
             if (lock.owns_lock())
             {
@@ -548,7 +580,7 @@ public:
         if (!least_busy_buffer)
         {
             least_busy_buffer = &storage.buffers[start_shard_num];
-            least_busy_lock = std::unique_lock(least_busy_buffer->mutex);
+            least_busy_lock = least_busy_buffer->lockForWriting();
         }
         insertIntoBuffer(block, *least_busy_buffer);
         least_busy_lock.unlock();
@@ -588,14 +620,14 @@ private:
 };
 
 
-BlockOutputStreamPtr StorageBuffer::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & /*context*/)
+BlockOutputStreamPtr StorageBuffer::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr /*context*/)
 {
     return std::make_shared<BufferBlockOutputStream>(*this, metadata_snapshot);
 }
 
 
 bool StorageBuffer::mayBenefitFromIndexForIn(
-    const ASTPtr & left_in_operand, const Context & query_context, const StorageMetadataPtr & /*metadata_snapshot*/) const
+    const ASTPtr & left_in_operand, ContextPtr query_context, const StorageMetadataPtr & /*metadata_snapshot*/) const
 {
     if (!destination_id)
         return false;
@@ -611,7 +643,7 @@ bool StorageBuffer::mayBenefitFromIndexForIn(
 
 void StorageBuffer::startup()
 {
-    if (buffer_context.getSettingsRef().readonly)
+    if (getContext()->getSettingsRef().readonly)
     {
         LOG_WARNING(log, "Storage {} is run with readonly settings, it will not be able to insert data. Set appropriate buffer_profile to fix this.", getName());
     }
@@ -630,7 +662,7 @@ void StorageBuffer::shutdown()
 
     try
     {
-        optimize(nullptr /*query*/, getInMemoryMetadataPtr(), {} /*partition*/, false /*final*/, false /*deduplicate*/, {}, buffer_context);
+        optimize(nullptr /*query*/, getInMemoryMetadataPtr(), {} /*partition*/, false /*final*/, false /*deduplicate*/, {}, getContext());
     }
     catch (...)
     {
@@ -656,7 +688,7 @@ bool StorageBuffer::optimize(
     bool final,
     bool deduplicate,
     const Names & /* deduplicate_by_columns */,
-    const Context & /*context*/)
+    ContextPtr /*context*/)
 {
     if (partition)
         throw Exception("Partition cannot be specified when optimizing table of type Buffer", ErrorCodes::NOT_IMPLEMENTED);
@@ -675,7 +707,7 @@ bool StorageBuffer::supportsPrewhere() const
 {
     if (!destination_id)
         return false;
-    auto dest = DatabaseCatalog::instance().tryGetTable(destination_id, buffer_context);
+    auto dest = DatabaseCatalog::instance().tryGetTable(destination_id, getContext());
     if (dest && dest.get() != this)
         return dest->supportsPrewhere();
     return false;
@@ -740,9 +772,9 @@ void StorageBuffer::flushBuffer(Buffer & buffer, bool check_thresholds, bool loc
     size_t bytes = 0;
     time_t time_passed = 0;
 
-    std::unique_lock lock(buffer.mutex, std::defer_lock);
+    std::optional<std::unique_lock<std::mutex>> lock;
     if (!locked)
-        lock.lock();
+        lock.emplace(buffer.lockForReading());
 
     block_to_write = buffer.data.cloneEmpty();
 
@@ -786,7 +818,7 @@ void StorageBuffer::flushBuffer(Buffer & buffer, bool check_thresholds, bool loc
     Stopwatch watch;
     try
     {
-        writeBlockToDestination(block_to_write, DatabaseCatalog::instance().tryGetTable(destination_id, buffer_context));
+        writeBlockToDestination(block_to_write, DatabaseCatalog::instance().tryGetTable(destination_id, getContext()));
         if (reset_block_structure)
             buffer.data.clear();
     }
@@ -868,8 +900,8 @@ void StorageBuffer::writeBlockToDestination(const Block & block, StoragePtr tabl
     for (const auto & column : block_to_write)
         list_of_columns->children.push_back(std::make_shared<ASTIdentifier>(column.name));
 
-    auto insert_context = Context(buffer_context);
-    insert_context.makeQueryContext();
+    auto insert_context = Context::createCopy(getContext());
+    insert_context->makeQueryContext();
 
     InterpreterInsertQuery interpreter{insert, insert_context, allow_materialized};
 
@@ -910,7 +942,7 @@ void StorageBuffer::reschedule()
         /// try_to_lock is also ok for background flush, since if there is
         /// INSERT contended, then the reschedule will be done after
         /// INSERT will be done.
-        std::unique_lock lock(buffer.mutex, std::try_to_lock);
+        std::unique_lock lock(buffer.tryLock());
         if (lock.owns_lock())
         {
             min_first_write_time = buffer.first_write_time;
@@ -930,9 +962,9 @@ void StorageBuffer::reschedule()
     flush_handle->scheduleAfter(std::min(min, max) * 1000);
 }
 
-void StorageBuffer::checkAlterIsPossible(const AlterCommands & commands, const Context & context) const
+void StorageBuffer::checkAlterIsPossible(const AlterCommands & commands, ContextPtr local_context) const
 {
-    auto name_deps = getDependentViewsByColumn(context);
+    auto name_deps = getDependentViewsByColumn(local_context);
     for (const auto & command : commands)
     {
         if (command.type != AlterCommand::Type::ADD_COLUMN && command.type != AlterCommand::Type::MODIFY_COLUMN
@@ -957,7 +989,7 @@ void StorageBuffer::checkAlterIsPossible(const AlterCommands & commands, const C
 std::optional<UInt64> StorageBuffer::totalRows(const Settings & settings) const
 {
     std::optional<UInt64> underlying_rows;
-    auto underlying = DatabaseCatalog::instance().tryGetTable(destination_id, buffer_context);
+    auto underlying = DatabaseCatalog::instance().tryGetTable(destination_id, getContext());
 
     if (underlying)
         underlying_rows = underlying->totalRows(settings);
@@ -967,7 +999,7 @@ std::optional<UInt64> StorageBuffer::totalRows(const Settings & settings) const
     UInt64 rows = 0;
     for (const auto & buffer : buffers)
     {
-        std::lock_guard lock(buffer.mutex);
+        const auto lock(buffer.lockForReading());
         rows += buffer.data.rows();
     }
     return rows + *underlying_rows;
@@ -978,26 +1010,26 @@ std::optional<UInt64> StorageBuffer::totalBytes(const Settings & /*settings*/) c
     UInt64 bytes = 0;
     for (const auto & buffer : buffers)
     {
-        std::lock_guard lock(buffer.mutex);
+        const auto lock(buffer.lockForReading());
         bytes += buffer.data.allocatedBytes();
     }
     return bytes;
 }
 
-void StorageBuffer::alter(const AlterCommands & params, const Context & context, TableLockHolder &)
+void StorageBuffer::alter(const AlterCommands & params, ContextPtr local_context, TableLockHolder &)
 {
     auto table_id = getStorageID();
-    checkAlterIsPossible(params, context);
+    checkAlterIsPossible(params, local_context);
     auto metadata_snapshot = getInMemoryMetadataPtr();
 
     /// Flush all buffers to storages, so that no non-empty blocks of the old
     /// structure remain. Structure of empty blocks will be updated during first
     /// insert.
-    optimize({} /*query*/, metadata_snapshot, {} /*partition_id*/, false /*final*/, false /*deduplicate*/, {}, context);
+    optimize({} /*query*/, metadata_snapshot, {} /*partition_id*/, false /*final*/, false /*deduplicate*/, {}, local_context);
 
     StorageInMemoryMetadata new_metadata = *metadata_snapshot;
-    params.apply(new_metadata, context);
-    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id, new_metadata);
+    params.apply(new_metadata, local_context);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(local_context, table_id, new_metadata);
     setInMemoryMetadata(new_metadata);
 }
 
@@ -1021,8 +1053,8 @@ void registerStorageBuffer(StorageFactory & factory)
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
         // Table and database name arguments accept expressions, evaluate them.
-        engine_args[0] = evaluateConstantExpressionForDatabaseName(engine_args[0], args.local_context);
-        engine_args[1] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[1], args.local_context);
+        engine_args[0] = evaluateConstantExpressionForDatabaseName(engine_args[0], args.getLocalContext());
+        engine_args[1] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[1], args.getLocalContext());
 
         // After we evaluated all expressions, check that all arguments are
         // literals.
@@ -1052,7 +1084,7 @@ void registerStorageBuffer(StorageFactory & factory)
         StorageID destination_id = StorageID::createEmpty();
         if (!destination_table.empty())
         {
-            destination_id.database_name = args.context.resolveDatabase(destination_database);
+            destination_id.database_name = args.getContext()->resolveDatabase(destination_database);
             destination_id.table_name = destination_table;
         }
 
@@ -1060,12 +1092,12 @@ void registerStorageBuffer(StorageFactory & factory)
             args.table_id,
             args.columns,
             args.constraints,
-            args.context,
+            args.getContext(),
             num_buckets,
             StorageBuffer::Thresholds{min_time, min_rows, min_bytes},
             StorageBuffer::Thresholds{max_time, max_rows, max_bytes},
             destination_id,
-            static_cast<bool>(args.local_context.getSettingsRef().insert_allow_materialized_columns));
+            static_cast<bool>(args.getLocalContext()->getSettingsRef().insert_allow_materialized_columns));
     },
     {
         .supports_parallel_insert = true,
diff --git a/src/Storages/StorageBuffer.h b/src/Storages/StorageBuffer.h
index f6904ddb0e4..b29bbf179f4 100644
--- a/src/Storages/StorageBuffer.h
+++ b/src/Storages/StorageBuffer.h
@@ -1,15 +1,17 @@
 #pragma once
 
-#include <mutex>
-#include <atomic>
-#include <thread>
-#include <ext/shared_ptr_helper.h>
-#include <Core/NamesAndTypes.h>
 #include <Core/BackgroundSchedulePool.h>
-#include <Storages/IStorage.h>
+#include <Core/NamesAndTypes.h>
 #include <DataStreams/IBlockOutputStream.h>
+#include <Storages/IStorage.h>
+#include <ext/shared_ptr_helper.h>
+
 #include <Poco/Event.h>
 
+#include <atomic>
+#include <mutex>
+#include <thread>
+
 
 namespace Poco { class Logger; }
 
@@ -36,7 +38,7 @@ namespace DB
   * When you destroy a Buffer table, all remaining data is flushed to the subordinate table.
   * The data in the buffer is not replicated, not logged to disk, not indexed. With a rough restart of the server, the data is lost.
   */
-class StorageBuffer final : public ext::shared_ptr_helper<StorageBuffer>, public IStorage
+class StorageBuffer final : public ext::shared_ptr_helper<StorageBuffer>, public IStorage, WithContext
 {
 friend struct ext::shared_ptr_helper<StorageBuffer>;
 friend class BufferSource;
@@ -53,13 +55,13 @@ public:
 
     std::string getName() const override { return "Buffer"; }
 
-    QueryProcessingStage::Enum getQueryProcessingStage(const Context &, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const override;
+    QueryProcessingStage::Enum getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const override;
 
     Pipe read(
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -69,7 +71,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -78,7 +80,7 @@ public:
 
     bool supportsSubcolumns() const override { return true; }
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     void startup() override;
     /// Flush all buffers into the subordinate table and stop background thread.
@@ -90,19 +92,19 @@ public:
         bool final,
         bool deduplicate,
         const Names & deduplicate_by_columns,
-        const Context & context) override;
+        ContextPtr context) override;
 
     bool supportsSampling() const override { return true; }
     bool supportsPrewhere() const override;
     bool supportsFinal() const override { return true; }
     bool supportsIndexForIn() const override { return true; }
 
-    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, const Context & query_context, const StorageMetadataPtr & metadata_snapshot) const override;
+    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, ContextPtr query_context, const StorageMetadataPtr & metadata_snapshot) const override;
 
-    void checkAlterIsPossible(const AlterCommands & commands, const Context & context) const override;
+    void checkAlterIsPossible(const AlterCommands & commands, ContextPtr context) const override;
 
     /// The structure of the subordinate table is not checked and does not change.
-    void alter(const AlterCommands & params, const Context & context, TableLockHolder & table_lock_holder) override;
+    void alter(const AlterCommands & params, ContextPtr context, TableLockHolder & table_lock_holder) override;
 
     std::optional<UInt64> totalRows(const Settings & settings) const override;
     std::optional<UInt64> totalBytes(const Settings & settings) const override;
@@ -112,13 +114,19 @@ public:
 
 
 private:
-    const Context & buffer_context;
-
     struct Buffer
     {
         time_t first_write_time = 0;
         Block data;
+
+        std::unique_lock<std::mutex> lockForReading() const;
+        std::unique_lock<std::mutex> lockForWriting() const;
+        std::unique_lock<std::mutex> tryLock() const;
+
+    private:
         mutable std::mutex mutex;
+
+        std::unique_lock<std::mutex> lockImpl(bool read) const;
     };
 
     /// There are `num_shards` of independent buffers.
@@ -165,7 +173,7 @@ protected:
         const StorageID & table_id_,
         const ColumnsDescription & columns_,
         const ConstraintsDescription & constraints_,
-        const Context & context_,
+        ContextPtr context_,
         size_t num_shards_,
         const Thresholds & min_thresholds_,
         const Thresholds & max_thresholds_,
diff --git a/src/Storages/StorageDictionary.cpp b/src/Storages/StorageDictionary.cpp
index 36241cd5582..e2cab153092 100644
--- a/src/Storages/StorageDictionary.cpp
+++ b/src/Storages/StorageDictionary.cpp
@@ -128,12 +128,12 @@ Pipe StorageDictionary::read(
     const Names & column_names,
     const StorageMetadataPtr & /*metadata_snapshot*/,
     SelectQueryInfo & /*query_info*/,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t max_block_size,
     const unsigned /*threads*/)
 {
-    auto dictionary = context.getExternalDictionariesLoader().getDictionary(dictionary_name, context);
+    auto dictionary = context->getExternalDictionariesLoader().getDictionary(dictionary_name, context);
     auto stream = dictionary->getBlockInputStream(column_names, max_block_size);
     /// TODO: update dictionary interface for processors.
     return Pipe(std::make_shared<SourceFromInputStream>(stream));
@@ -148,13 +148,12 @@ void registerStorageDictionary(StorageFactory & factory)
             throw Exception("Storage Dictionary requires single parameter: name of dictionary",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        args.engine_args[0] = evaluateConstantExpressionOrIdentifierAsLiteral(args.engine_args[0], args.local_context);
+        args.engine_args[0] = evaluateConstantExpressionOrIdentifierAsLiteral(args.engine_args[0], args.getLocalContext());
         String dictionary_name = args.engine_args[0]->as<ASTLiteral &>().value.safeGet<String>();
 
         if (!args.attach)
         {
-            const auto & context = args.context;
-            const auto & dictionary = context.getExternalDictionariesLoader().getDictionary(dictionary_name, context);
+            const auto & dictionary = args.getContext()->getExternalDictionariesLoader().getDictionary(dictionary_name, args.getContext());
             const DictionaryStructure & dictionary_structure = dictionary->getStructure();
             checkNamesAndTypesCompatibleWithDictionary(dictionary_name, args.columns, dictionary_structure);
         }
diff --git a/src/Storages/StorageDictionary.h b/src/Storages/StorageDictionary.h
index 563def8672b..9e8564d4349 100644
--- a/src/Storages/StorageDictionary.h
+++ b/src/Storages/StorageDictionary.h
@@ -23,7 +23,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned threads) override;
diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp
index 28156458342..e42e53d3f1b 100644
--- a/src/Storages/StorageDistributed.cpp
+++ b/src/Storages/StorageDistributed.cpp
@@ -1,8 +1,11 @@
 #include <Storages/StorageDistributed.h>
 
 #include <Databases/IDatabase.h>
+
 #include <Disks/IDisk.h>
 
+#include <DataStreams/RemoteBlockInputStream.h>
+
 #include <DataTypes/DataTypeFactory.h>
 #include <DataTypes/DataTypeUUID.h>
 #include <DataTypes/DataTypesNumber.h>
@@ -31,9 +34,7 @@
 #include <Parsers/ParserAlterQuery.h>
 #include <Parsers/TablePropertiesQueriesASTs.h>
 #include <Parsers/parseQuery.h>
-
-#include <Processors/QueryPlan/BuildQueryPipelineSettings.h>
-#include <Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.h>
+#include <Parsers/queryToString.h>
 
 #include <Interpreters/ClusterProxy/SelectStreamFactory.h>
 #include <Interpreters/ClusterProxy/executeQuery.h>
@@ -42,6 +43,7 @@
 #include <Interpreters/InterpreterAlterQuery.h>
 #include <Interpreters/InterpreterDescribeQuery.h>
 #include <Interpreters/InterpreterSelectQuery.h>
+#include <Interpreters/JoinedTables.h>
 #include <Interpreters/TranslateQualifiedNamesVisitor.h>
 #include <Interpreters/TreeRewriter.h>
 #include <Interpreters/Context.h>
@@ -51,8 +53,12 @@
 #include <Interpreters/getTableExpressions.h>
 #include <Functions/IFunction.h>
 
+#include <Processors/QueryPlan/BuildQueryPipelineSettings.h>
+#include <Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.h>
 #include <Processors/QueryPlan/ReadFromPreparedSource.h>
 #include <Processors/Sources/NullSource.h>
+#include <Processors/Sources/SourceFromInputStream.h>
+#include <Processors/NullSink.h>
 
 #include <Core/Field.h>
 #include <Core/Settings.h>
@@ -60,6 +66,7 @@
 #include <IO/ReadHelpers.h>
 #include <IO/WriteBufferFromString.h>
 #include <IO/Operators.h>
+#include <IO/ConnectionTimeoutsContext.h>
 
 #include <Poco/DirectoryIterator.h>
 
@@ -75,6 +82,8 @@ const UInt64 FORCE_OPTIMIZE_SKIP_UNUSED_SHARDS_HAS_SHARDING_KEY = 1;
 const UInt64 FORCE_OPTIMIZE_SKIP_UNUSED_SHARDS_ALWAYS           = 2;
 
 const UInt64 DISTRIBUTED_GROUP_BY_NO_MERGE_AFTER_AGGREGATION = 2;
+
+const UInt64 PARALLEL_DISTRIBUTED_INSERT_SELECT_ALL = 2;
 }
 
 namespace ProfileEvents
@@ -212,7 +221,7 @@ std::string makeFormattedListOfShards(const ClusterPtr & cluster)
     return buf.str();
 }
 
-ExpressionActionsPtr buildShardingKeyExpression(const ASTPtr & sharding_key, const Context & context, const NamesAndTypesList & columns, bool project)
+ExpressionActionsPtr buildShardingKeyExpression(const ASTPtr & sharding_key, ContextPtr context, const NamesAndTypesList & columns, bool project)
 {
     ASTPtr query = sharding_key;
     auto syntax_result = TreeRewriter(context).analyze(query, columns);
@@ -260,7 +269,7 @@ public:
 
 void replaceConstantExpressions(
     ASTPtr & node,
-    const Context & context,
+    ContextPtr context,
     const NamesAndTypesList & columns,
     ConstStoragePtr storage,
     const StorageMetadataPtr & metadata_snapshot)
@@ -380,7 +389,7 @@ StorageDistributed::StorageDistributed(
     const String & remote_database_,
     const String & remote_table_,
     const String & cluster_name_,
-    const Context & context_,
+    ContextPtr context_,
     const ASTPtr & sharding_key_,
     const String & storage_policy_name_,
     const String & relative_data_path_,
@@ -388,12 +397,12 @@ StorageDistributed::StorageDistributed(
     bool attach_,
     ClusterPtr owned_cluster_)
     : IStorage(id_)
+    , WithContext(context_->getGlobalContext())
     , remote_database(remote_database_)
     , remote_table(remote_table_)
-    , global_context(context_.getGlobalContext())
     , log(&Poco::Logger::get("StorageDistributed (" + id_.table_name + ")"))
     , owned_cluster(std::move(owned_cluster_))
-    , cluster_name(global_context.getMacros()->expand(cluster_name_))
+    , cluster_name(getContext()->getMacros()->expand(cluster_name_))
     , has_sharding_key(sharding_key_)
     , relative_data_path(relative_data_path_)
     , distributed_settings(distributed_settings_)
@@ -406,14 +415,14 @@ StorageDistributed::StorageDistributed(
 
     if (sharding_key_)
     {
-        sharding_key_expr = buildShardingKeyExpression(sharding_key_, global_context, storage_metadata.getColumns().getAllPhysical(), false);
+        sharding_key_expr = buildShardingKeyExpression(sharding_key_, getContext(), storage_metadata.getColumns().getAllPhysical(), false);
         sharding_key_column_name = sharding_key_->getColumnName();
         sharding_key_is_deterministic = isExpressionActionsDeterministics(sharding_key_expr);
     }
 
     if (!relative_data_path.empty())
     {
-        storage_policy = global_context.getStoragePolicy(storage_policy_name_);
+        storage_policy = getContext()->getStoragePolicy(storage_policy_name_);
         data_volume = storage_policy->getVolume(0);
         if (storage_policy->getVolumes().size() > 1)
             LOG_WARNING(log, "Storage policy for Distributed table has multiple volumes. "
@@ -423,7 +432,7 @@ StorageDistributed::StorageDistributed(
     /// Sanity check. Skip check if the table is already created to allow the server to start.
     if (!attach_ && !cluster_name.empty())
     {
-        size_t num_local_shards = global_context.getCluster(cluster_name)->getLocalShardCount();
+        size_t num_local_shards = getContext()->getCluster(cluster_name)->getLocalShardCount();
         if (num_local_shards && remote_database == id_.database_name && remote_table == id_.table_name)
             throw Exception("Distributed table " + id_.table_name + " looks at itself", ErrorCodes::INFINITE_LOOP);
     }
@@ -436,7 +445,7 @@ StorageDistributed::StorageDistributed(
     const ConstraintsDescription & constraints_,
     ASTPtr remote_table_function_ptr_,
     const String & cluster_name_,
-    const Context & context_,
+    ContextPtr context_,
     const ASTPtr & sharding_key_,
     const String & storage_policy_name_,
     const String & relative_data_path_,
@@ -449,9 +458,9 @@ StorageDistributed::StorageDistributed(
 }
 
 QueryProcessingStage::Enum StorageDistributed::getQueryProcessingStage(
-    const Context & context, QueryProcessingStage::Enum to_stage, SelectQueryInfo & query_info) const
+    ContextPtr local_context, QueryProcessingStage::Enum to_stage, SelectQueryInfo & query_info) const
 {
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = local_context->getSettingsRef();
     auto metadata_snapshot = getInMemoryMetadataPtr();
 
     ClusterPtr cluster = getCluster();
@@ -461,16 +470,23 @@ QueryProcessingStage::Enum StorageDistributed::getQueryProcessingStage(
     /// (Anyway it will be calculated in the read())
     if (settings.optimize_skip_unused_shards)
     {
-        ClusterPtr optimized_cluster = getOptimizedCluster(context, metadata_snapshot, query_info.query);
+        ClusterPtr optimized_cluster = getOptimizedCluster(local_context, metadata_snapshot, query_info.query);
         if (optimized_cluster)
         {
-            LOG_DEBUG(log, "Skipping irrelevant shards - the query will be sent to the following shards of the cluster (shard numbers): {}", makeFormattedListOfShards(optimized_cluster));
+            LOG_DEBUG(
+                log,
+                "Skipping irrelevant shards - the query will be sent to the following shards of the cluster (shard numbers): {}",
+                makeFormattedListOfShards(optimized_cluster));
             cluster = optimized_cluster;
-            query_info.cluster = cluster;
+            query_info.optimized_cluster = cluster;
         }
         else
         {
-            LOG_DEBUG(log, "Unable to figure out irrelevant shards from WHERE/PREWHERE clauses - the query will be sent to all shards of the cluster{}", has_sharding_key ? "" : " (no sharding key)");
+            LOG_DEBUG(
+                log,
+                "Unable to figure out irrelevant shards from WHERE/PREWHERE clauses - the query will be sent to all shards of the "
+                "cluster{}",
+                has_sharding_key ? "" : " (no sharding key)");
         }
     }
 
@@ -513,16 +529,16 @@ Pipe StorageDistributed::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     const size_t max_block_size,
     const unsigned num_streams)
 {
     QueryPlan plan;
-    read(plan, column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams);
+    read(plan, column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams);
     return plan.convertToPipe(
-        QueryPlanOptimizationSettings::fromContext(context),
-        BuildQueryPipelineSettings::fromContext(context));
+        QueryPlanOptimizationSettings::fromContext(local_context),
+        BuildQueryPipelineSettings::fromContext(local_context));
 }
 
 void StorageDistributed::read(
@@ -530,7 +546,7 @@ void StorageDistributed::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     const size_t /*max_block_size*/,
     const unsigned /*num_streams*/)
@@ -539,10 +555,10 @@ void StorageDistributed::read(
         query_info.query, remote_database, remote_table, remote_table_function_ptr);
 
     Block header =
-        InterpreterSelectQuery(query_info.query, context, SelectQueryOptions(processed_stage).analyze()).getSampleBlock();
+        InterpreterSelectQuery(query_info.query, local_context, SelectQueryOptions(processed_stage).analyze()).getSampleBlock();
 
     /// Return directly (with correct header) if no shard to query.
-    if (query_info.cluster->getShardsInfo().empty())
+    if (query_info.getCluster()->getShardsInfo().empty())
     {
         Pipe pipe(std::make_shared<NullSource>(header));
         auto read_from_pipe = std::make_unique<ReadFromPreparedSource>(std::move(pipe));
@@ -552,7 +568,7 @@ void StorageDistributed::read(
         return;
     }
 
-    const Scalars & scalars = context.hasQueryContext() ? context.getQueryContext().getScalars() : Scalars{};
+    const Scalars & scalars = local_context->hasQueryContext() ? local_context->getQueryContext()->getScalars() : Scalars{};
 
     bool has_virtual_shard_num_column = std::find(column_names.begin(), column_names.end(), "_shard_num") != column_names.end();
     if (has_virtual_shard_num_column && !isVirtualColumn("_shard_num", metadata_snapshot))
@@ -560,12 +576,19 @@ void StorageDistributed::read(
 
     ClusterProxy::SelectStreamFactory select_stream_factory = remote_table_function_ptr
         ? ClusterProxy::SelectStreamFactory(
-            header, processed_stage, remote_table_function_ptr, scalars, has_virtual_shard_num_column, context.getExternalTables())
+            header, processed_stage, remote_table_function_ptr, scalars, has_virtual_shard_num_column, local_context->getExternalTables())
         : ClusterProxy::SelectStreamFactory(
-            header, processed_stage, StorageID{remote_database, remote_table}, scalars, has_virtual_shard_num_column, context.getExternalTables());
+            header,
+            processed_stage,
+            StorageID{remote_database, remote_table},
+            scalars,
+            has_virtual_shard_num_column,
+            local_context->getExternalTables());
 
     ClusterProxy::executeQuery(query_plan, select_stream_factory, log,
-        modified_query_ast, context, query_info);
+        modified_query_ast, local_context, query_info,
+        sharding_key_expr, sharding_key_column_name,
+        getCluster());
 
     /// This is a bug, it is possible only when there is no shards to query, and this is handled earlier.
     if (!query_plan.isInitialized())
@@ -573,10 +596,10 @@ void StorageDistributed::read(
 }
 
 
-BlockOutputStreamPtr StorageDistributed::write(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr StorageDistributed::write(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr local_context)
 {
     auto cluster = getCluster();
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = local_context->getSettingsRef();
 
     /// Ban an attempt to make async insert into the table belonging to DatabaseMemory
     if (!storage_policy && !owned_cluster && !settings.insert_distributed_sync && !settings.insert_shard_id)
@@ -606,16 +629,94 @@ BlockOutputStreamPtr StorageDistributed::write(const ASTPtr &, const StorageMeta
 
     /// DistributedBlockOutputStream will not own cluster, but will own ConnectionPools of the cluster
     return std::make_shared<DistributedBlockOutputStream>(
-        context, *this, metadata_snapshot,
+        local_context, *this, metadata_snapshot,
         createInsertToRemoteTableQuery(
             remote_database, remote_table, metadata_snapshot->getSampleBlockNonMaterialized()),
         cluster, insert_sync, timeout);
 }
 
 
-void StorageDistributed::checkAlterIsPossible(const AlterCommands & commands, const Context & context) const
+QueryPipelinePtr StorageDistributed::distributedWrite(const ASTInsertQuery & query, ContextPtr local_context)
 {
-    auto name_deps = getDependentViewsByColumn(context);
+    const Settings & settings = local_context->getSettingsRef();
+    std::shared_ptr<StorageDistributed> storage_src;
+    auto & select = query.select->as<ASTSelectWithUnionQuery &>();
+    auto new_query = std::dynamic_pointer_cast<ASTInsertQuery>(query.clone());
+    if (select.list_of_selects->children.size() == 1)
+    {
+        if (auto * select_query = select.list_of_selects->children.at(0)->as<ASTSelectQuery>())
+        {
+            JoinedTables joined_tables(Context::createCopy(local_context), *select_query);
+
+            if (joined_tables.tablesCount() == 1)
+            {
+                storage_src = std::dynamic_pointer_cast<StorageDistributed>(joined_tables.getLeftTableStorage());
+                if (storage_src)
+                {
+                    const auto select_with_union_query = std::make_shared<ASTSelectWithUnionQuery>();
+                    select_with_union_query->list_of_selects = std::make_shared<ASTExpressionList>();
+
+                    auto new_select_query = std::dynamic_pointer_cast<ASTSelectQuery>(select_query->clone());
+                    select_with_union_query->list_of_selects->children.push_back(new_select_query);
+
+                    new_select_query->replaceDatabaseAndTable(storage_src->getRemoteDatabaseName(), storage_src->getRemoteTableName());
+
+                    new_query->select = select_with_union_query;
+                }
+            }
+        }
+    }
+
+    if (!storage_src || storage_src->getClusterName() != getClusterName())
+    {
+        return nullptr;
+    }
+
+    if (settings.parallel_distributed_insert_select == PARALLEL_DISTRIBUTED_INSERT_SELECT_ALL)
+    {
+        new_query->table_id = StorageID(getRemoteDatabaseName(), getRemoteTableName());
+    }
+
+    const auto & cluster = getCluster();
+    const auto & shards_info = cluster->getShardsInfo();
+
+    std::vector<std::unique_ptr<QueryPipeline>> pipelines;
+
+    String new_query_str = queryToString(new_query);
+    for (size_t shard_index : ext::range(0, shards_info.size()))
+    {
+        const auto & shard_info = shards_info[shard_index];
+        if (shard_info.isLocal())
+        {
+            InterpreterInsertQuery interpreter(new_query, local_context);
+            pipelines.emplace_back(std::make_unique<QueryPipeline>(interpreter.execute().pipeline));
+        }
+        else
+        {
+            auto timeouts = ConnectionTimeouts::getTCPTimeoutsWithFailover(settings);
+            auto connections = shard_info.pool->getMany(timeouts, &settings, PoolMode::GET_ONE);
+            if (connections.empty() || connections.front().isNull())
+                throw Exception(
+                    "Expected exactly one connection for shard " + toString(shard_info.shard_num), ErrorCodes::LOGICAL_ERROR);
+
+            ///  INSERT SELECT query returns empty block
+            auto in_stream = std::make_shared<RemoteBlockInputStream>(std::move(connections), new_query_str, Block{}, local_context);
+            pipelines.emplace_back(std::make_unique<QueryPipeline>());
+            pipelines.back()->init(Pipe(std::make_shared<SourceFromInputStream>(std::move(in_stream))));
+            pipelines.back()->setSinks([](const Block & header, QueryPipeline::StreamType) -> ProcessorPtr
+            {
+                return std::make_shared<EmptySink>(header);
+            });
+        }
+    }
+
+    return std::make_unique<QueryPipeline>(QueryPipeline::unitePipelines(std::move(pipelines)));
+}
+
+
+void StorageDistributed::checkAlterIsPossible(const AlterCommands & commands, ContextPtr local_context) const
+{
+    auto name_deps = getDependentViewsByColumn(local_context);
     for (const auto & command : commands)
     {
         if (command.type != AlterCommand::Type::ADD_COLUMN
@@ -640,21 +741,21 @@ void StorageDistributed::checkAlterIsPossible(const AlterCommands & commands, co
     }
 }
 
-void StorageDistributed::alter(const AlterCommands & params, const Context & context, TableLockHolder &)
+void StorageDistributed::alter(const AlterCommands & params, ContextPtr local_context, TableLockHolder &)
 {
     auto table_id = getStorageID();
 
-    checkAlterIsPossible(params, context);
+    checkAlterIsPossible(params, local_context);
     StorageInMemoryMetadata new_metadata = getInMemoryMetadata();
-    params.apply(new_metadata, context);
-    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id, new_metadata);
+    params.apply(new_metadata, local_context);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(local_context, table_id, new_metadata);
     setInMemoryMetadata(new_metadata);
 }
 
 
 void StorageDistributed::startup()
 {
-    if (remote_database.empty() && !remote_table_function_ptr)
+    if (remote_database.empty() && !remote_table_function_ptr && !getCluster()->maybeCrossReplication())
         LOG_WARNING(log, "Name of remote database is empty. Default database will be used implicitly.");
 
     if (!storage_policy)
@@ -721,7 +822,7 @@ Strings StorageDistributed::getDataPaths() const
     return paths;
 }
 
-void StorageDistributed::truncate(const ASTPtr &, const StorageMetadataPtr &, const Context &, TableExclusiveLockHolder &)
+void StorageDistributed::truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr, TableExclusiveLockHolder &)
 {
     std::lock_guard lock(cluster_nodes_mutex);
 
@@ -788,7 +889,7 @@ StorageDistributedDirectoryMonitor& StorageDistributed::requireDirectoryMonitor(
             *this, disk, relative_data_path + name,
             node_data.connection_pool,
             monitors_blocker,
-            global_context.getDistributedSchedulePool());
+            getContext()->getDistributedSchedulePool());
     }
     return *node_data.directory_monitor;
 }
@@ -818,19 +919,20 @@ size_t StorageDistributed::getShardCount() const
 
 ClusterPtr StorageDistributed::getCluster() const
 {
-    return owned_cluster ? owned_cluster : global_context.getCluster(cluster_name);
+    return owned_cluster ? owned_cluster : getContext()->getCluster(cluster_name);
 }
 
-ClusterPtr StorageDistributed::getOptimizedCluster(const Context & context, const StorageMetadataPtr & metadata_snapshot, const ASTPtr & query_ptr) const
+ClusterPtr StorageDistributed::getOptimizedCluster(
+    ContextPtr local_context, const StorageMetadataPtr & metadata_snapshot, const ASTPtr & query_ptr) const
 {
     ClusterPtr cluster = getCluster();
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = local_context->getSettingsRef();
 
     bool sharding_key_is_usable = settings.allow_nondeterministic_optimize_skip_unused_shards || sharding_key_is_deterministic;
 
     if (has_sharding_key && sharding_key_is_usable)
     {
-        ClusterPtr optimized = skipUnusedShards(cluster, query_ptr, metadata_snapshot, context);
+        ClusterPtr optimized = skipUnusedShards(cluster, query_ptr, metadata_snapshot, local_context);
         if (optimized)
             return optimized;
     }
@@ -852,7 +954,7 @@ ClusterPtr StorageDistributed::getOptimizedCluster(const Context & context, cons
             throw Exception(exception_message.str(), ErrorCodes::UNABLE_TO_SKIP_UNUSED_SHARDS);
     }
 
-    return cluster;
+    return {};
 }
 
 IColumn::Selector StorageDistributed::createSelector(const ClusterPtr cluster, const ColumnWithTypeAndName & result)
@@ -887,7 +989,7 @@ ClusterPtr StorageDistributed::skipUnusedShards(
     ClusterPtr cluster,
     const ASTPtr & query_ptr,
     const StorageMetadataPtr & metadata_snapshot,
-    const Context & context) const
+    ContextPtr local_context) const
 {
     const auto & select = query_ptr->as<ASTSelectQuery &>();
 
@@ -906,9 +1008,9 @@ ClusterPtr StorageDistributed::skipUnusedShards(
         condition_ast = select.prewhere() ? select.prewhere()->clone() : select.where()->clone();
     }
 
-    replaceConstantExpressions(condition_ast, context, metadata_snapshot->getColumns().getAll(), shared_from_this(), metadata_snapshot);
+    replaceConstantExpressions(condition_ast, local_context, metadata_snapshot->getColumns().getAll(), shared_from_this(), metadata_snapshot);
 
-    size_t limit = context.getSettingsRef().optimize_skip_unused_shards_limit;
+    size_t limit = local_context->getSettingsRef().optimize_skip_unused_shards_limit;
     if (!limit || limit > SSIZE_MAX)
     {
         throw Exception("optimize_skip_unused_shards_limit out of range (0, {}]", ErrorCodes::ARGUMENT_OUT_OF_BOUND, SSIZE_MAX);
@@ -922,7 +1024,7 @@ ClusterPtr StorageDistributed::skipUnusedShards(
         LOG_TRACE(log,
             "Number of values for sharding key exceeds optimize_skip_unused_shards_limit={}, "
             "try to increase it, but note that this may increase query processing time.",
-            context.getSettingsRef().optimize_skip_unused_shards_limit);
+            local_context->getSettingsRef().optimize_skip_unused_shards_limit);
         return nullptr;
     }
 
@@ -955,10 +1057,10 @@ ActionLock StorageDistributed::getActionLock(StorageActionBlockType type)
     return {};
 }
 
-void StorageDistributed::flushClusterNodesAllData(const Context & context)
+void StorageDistributed::flushClusterNodesAllData(ContextPtr local_context)
 {
     /// Sync SYSTEM FLUSH DISTRIBUTED with TRUNCATE
-    auto table_lock = lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+    auto table_lock = lockForShare(local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout);
 
     std::vector<std::shared_ptr<StorageDistributedDirectoryMonitor>> directory_monitors;
 
@@ -1033,7 +1135,7 @@ void StorageDistributed::delayInsertOrThrowIfNeeded() const
         !distributed_settings.bytes_to_delay_insert)
         return;
 
-    UInt64 total_bytes = *totalBytes(global_context.getSettingsRef());
+    UInt64 total_bytes = *totalBytes(getContext()->getSettingsRef());
 
     if (distributed_settings.bytes_to_throw_insert && total_bytes > distributed_settings.bytes_to_throw_insert)
     {
@@ -1054,12 +1156,12 @@ void StorageDistributed::delayInsertOrThrowIfNeeded() const
         do {
             delayed_ms += step_ms;
             std::this_thread::sleep_for(std::chrono::milliseconds(step_ms));
-        } while (*totalBytes(global_context.getSettingsRef()) > distributed_settings.bytes_to_delay_insert && delayed_ms < distributed_settings.max_delay_to_insert*1000);
+        } while (*totalBytes(getContext()->getSettingsRef()) > distributed_settings.bytes_to_delay_insert && delayed_ms < distributed_settings.max_delay_to_insert*1000);
 
         ProfileEvents::increment(ProfileEvents::DistributedDelayedInserts);
         ProfileEvents::increment(ProfileEvents::DistributedDelayedInsertsMilliseconds, delayed_ms);
 
-        UInt64 new_total_bytes = *totalBytes(global_context.getSettingsRef());
+        UInt64 new_total_bytes = *totalBytes(getContext()->getSettingsRef());
         LOG_INFO(log, "Too many bytes pending for async INSERT: was {}, now {}, INSERT was delayed to {} ms",
             formatReadableSizeWithBinarySuffix(total_bytes),
             formatReadableSizeWithBinarySuffix(new_total_bytes),
@@ -1109,8 +1211,8 @@ void registerStorageDistributed(StorageFactory & factory)
 
         String cluster_name = getClusterNameAndMakeLiteral(engine_args[0]);
 
-        engine_args[1] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[1], args.local_context);
-        engine_args[2] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[2], args.local_context);
+        engine_args[1] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[1], args.getLocalContext());
+        engine_args[2] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[2], args.getLocalContext());
 
         String remote_database = engine_args[1]->as<ASTLiteral &>().value.safeGet<String>();
         String remote_table = engine_args[2]->as<ASTLiteral &>().value.safeGet<String>();
@@ -1121,7 +1223,7 @@ void registerStorageDistributed(StorageFactory & factory)
         /// Check that sharding_key exists in the table and has numeric type.
         if (sharding_key)
         {
-            auto sharding_expr = buildShardingKeyExpression(sharding_key, args.context, args.columns.getAllPhysical(), true);
+            auto sharding_expr = buildShardingKeyExpression(sharding_key, args.getContext(), args.columns.getAllPhysical(), true);
             const Block & block = sharding_expr->getSampleBlock();
 
             if (block.columns() != 1)
@@ -1155,7 +1257,7 @@ void registerStorageDistributed(StorageFactory & factory)
         return StorageDistributed::create(
             args.table_id, args.columns, args.constraints,
             remote_database, remote_table, cluster_name,
-            args.context,
+            args.getContext(),
             sharding_key,
             storage_policy,
             args.relative_data_path,
diff --git a/src/Storages/StorageDistributed.h b/src/Storages/StorageDistributed.h
index 5904124505a..886a8e032de 100644
--- a/src/Storages/StorageDistributed.h
+++ b/src/Storages/StorageDistributed.h
@@ -36,7 +36,7 @@ using ExpressionActionsPtr = std::shared_ptr<ExpressionActions>;
   * You can pass one address, not several.
   * In this case, the table can be considered remote, rather than distributed.
   */
-class StorageDistributed final : public ext::shared_ptr_helper<StorageDistributed>, public IStorage
+class StorageDistributed final : public ext::shared_ptr_helper<StorageDistributed>, public IStorage, WithContext
 {
     friend struct ext::shared_ptr_helper<StorageDistributed>;
     friend class DistributedBlockOutputStream;
@@ -55,13 +55,13 @@ public:
 
     bool isRemote() const override { return true; }
 
-    QueryProcessingStage::Enum getQueryProcessingStage(const Context &, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const override;
+    QueryProcessingStage::Enum getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const override;
 
     Pipe read(
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -71,7 +71,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t /*max_block_size*/,
         unsigned /*num_streams*/) override;
@@ -79,18 +79,20 @@ public:
     bool supportsParallelInsert() const override { return true; }
     std::optional<UInt64> totalBytes(const Settings &) const override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
+
+    QueryPipelinePtr distributedWrite(const ASTInsertQuery & query, ContextPtr context) override;
 
     /// Removes temporary data in local filesystem.
-    void truncate(const ASTPtr &, const StorageMetadataPtr &, const Context &, TableExclusiveLockHolder &) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr, TableExclusiveLockHolder &) override;
 
     void rename(const String & new_path_to_table_data, const StorageID & new_table_id) override;
 
-    void checkAlterIsPossible(const AlterCommands & commands, const Context & context) const override;
+    void checkAlterIsPossible(const AlterCommands & commands, ContextPtr context) const override;
 
     /// in the sub-tables, you need to manually add and delete columns
     /// the structure of the sub-table is not checked
-    void alter(const AlterCommands & params, const Context & context, TableLockHolder & table_lock_holder) override;
+    void alter(const AlterCommands & params, ContextPtr context, TableLockHolder & table_lock_holder) override;
 
     void startup() override;
     void shutdown() override;
@@ -111,7 +113,7 @@ public:
     ClusterPtr getCluster() const;
 
     /// Used by InterpreterSystemQuery
-    void flushClusterNodesAllData(const Context & context);
+    void flushClusterNodesAllData(ContextPtr context);
 
     /// Used by ClusterCopier
     size_t getShardCount() const;
@@ -124,7 +126,7 @@ private:
         const String & remote_database_,
         const String & remote_table_,
         const String & cluster_name_,
-        const Context & context_,
+        ContextPtr context_,
         const ASTPtr & sharding_key_,
         const String & storage_policy_name_,
         const String & relative_data_path_,
@@ -138,7 +140,7 @@ private:
         const ConstraintsDescription & constraints_,
         ASTPtr remote_table_function_ptr_,
         const String & cluster_name_,
-        const Context & context_,
+        ContextPtr context_,
         const ASTPtr & sharding_key_,
         const String & storage_policy_name_,
         const String & relative_data_path_,
@@ -163,12 +165,13 @@ private:
     /// Used by StorageSystemDistributionQueue
     std::vector<StorageDistributedDirectoryMonitor::Status> getDirectoryMonitorsStatuses() const;
 
-    static IColumn::Selector createSelector(const ClusterPtr cluster, const ColumnWithTypeAndName & result);
+    static IColumn::Selector createSelector(ClusterPtr cluster, const ColumnWithTypeAndName & result);
     /// Apply the following settings:
     /// - optimize_skip_unused_shards
     /// - force_optimize_skip_unused_shards
-    ClusterPtr getOptimizedCluster(const Context &, const StorageMetadataPtr & metadata_snapshot, const ASTPtr & query_ptr) const;
-    ClusterPtr skipUnusedShards(ClusterPtr cluster, const ASTPtr & query_ptr, const StorageMetadataPtr & metadata_snapshot, const Context & context) const;
+    ClusterPtr getOptimizedCluster(ContextPtr, const StorageMetadataPtr & metadata_snapshot, const ASTPtr & query_ptr) const;
+    ClusterPtr
+    skipUnusedShards(ClusterPtr cluster, const ASTPtr & query_ptr, const StorageMetadataPtr & metadata_snapshot, ContextPtr context) const;
 
     size_t getRandomShardIndex(const Cluster::ShardsInfo & shards);
 
@@ -176,12 +179,10 @@ private:
 
     void delayInsertOrThrowIfNeeded() const;
 
-private:
     String remote_database;
     String remote_table;
     ASTPtr remote_table_function_ptr;
 
-    const Context & global_context;
     Poco::Logger * log;
 
     /// Used to implement TableFunctionRemote.
diff --git a/src/Storages/StorageExternalDistributed.cpp b/src/Storages/StorageExternalDistributed.cpp
new file mode 100644
index 00000000000..3489de0161a
--- /dev/null
+++ b/src/Storages/StorageExternalDistributed.cpp
@@ -0,0 +1,189 @@
+#include "StorageExternalDistributed.h"
+
+#if USE_MYSQL || USE_LIBPQXX
+
+#include <Storages/StorageFactory.h>
+#include <Interpreters/evaluateConstantExpression.h>
+#include <Core/Settings.h>
+#include <Interpreters/Context.h>
+#include <DataTypes/DataTypeString.h>
+#include <Formats/FormatFactory.h>
+#include <Parsers/ASTLiteral.h>
+#include <Common/parseAddress.h>
+#include <Processors/Pipe.h>
+#include <Common/parseRemoteDescription.h>
+#include <Storages/StorageMySQL.h>
+#include <Storages/StoragePostgreSQL.h>
+#include <common/logger_useful.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int BAD_ARGUMENTS;
+}
+
+StorageExternalDistributed::StorageExternalDistributed(
+    const StorageID & table_id_,
+    ExternalStorageEngine table_engine,
+    const String & cluster_description,
+    const String & remote_database,
+    const String & remote_table,
+    const String & username,
+    const String & password,
+    const ColumnsDescription & columns_,
+    const ConstraintsDescription & constraints_,
+    ContextPtr context)
+    : IStorage(table_id_)
+{
+    StorageInMemoryMetadata storage_metadata;
+    storage_metadata.setColumns(columns_);
+    storage_metadata.setConstraints(constraints_);
+    setInMemoryMetadata(storage_metadata);
+
+    size_t max_addresses = context->getSettingsRef().glob_expansion_max_elements;
+    std::vector<String> shards_descriptions = parseRemoteDescription(cluster_description, 0, cluster_description.size(), ',', max_addresses);
+    std::vector<std::pair<std::string, UInt16>> addresses;
+
+    /// For each shard pass replicas description into storage, replicas are managed by storage's PoolWithFailover.
+    for (const auto & shard_description : shards_descriptions)
+    {
+        StoragePtr shard;
+
+        switch (table_engine)
+        {
+#if USE_MYSQL
+            case ExternalStorageEngine::MySQL:
+            {
+                addresses = parseRemoteDescriptionForExternalDatabase(shard_description, max_addresses, 3306);
+
+                mysqlxx::PoolWithFailover pool(
+                    remote_database,
+                    addresses,
+                    username, password);
+
+                shard = StorageMySQL::create(
+                    table_id_,
+                    std::move(pool),
+                    remote_database,
+                    remote_table,
+                    /* replace_query = */ false,
+                    /* on_duplicate_clause = */ "",
+                    columns_, constraints_,
+                    context);
+                break;
+            }
+#endif
+#if USE_LIBPQXX
+
+            case ExternalStorageEngine::PostgreSQL:
+            {
+                addresses = parseRemoteDescriptionForExternalDatabase(shard_description, max_addresses, 5432);
+
+                postgres::PoolWithFailover pool(
+                    remote_database,
+                    addresses,
+                    username, password,
+                    context->getSettingsRef().postgresql_connection_pool_size,
+                    context->getSettingsRef().postgresql_connection_pool_wait_timeout);
+
+                shard = StoragePostgreSQL::create(
+                    table_id_,
+                    std::move(pool),
+                    remote_table,
+                    columns_, constraints_,
+                    context);
+                break;
+            }
+#endif
+            default:
+                throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                    "Unsupported table engine. Supported engines are: MySQL, PostgreSQL");
+        }
+
+        shards.emplace(std::move(shard));
+    }
+}
+
+
+Pipe StorageExternalDistributed::read(
+    const Names & column_names,
+    const StorageMetadataPtr & metadata_snapshot,
+    SelectQueryInfo & query_info,
+    ContextPtr context,
+    QueryProcessingStage::Enum processed_stage,
+    size_t max_block_size,
+    unsigned num_streams)
+{
+    Pipes pipes;
+    for (const auto & shard : shards)
+    {
+        pipes.emplace_back(shard->read(
+            column_names,
+            metadata_snapshot,
+            query_info,
+            context,
+            processed_stage,
+            max_block_size,
+            num_streams
+        ));
+    }
+
+    return Pipe::unitePipes(std::move(pipes));
+}
+
+
+void registerStorageExternalDistributed(StorageFactory & factory)
+{
+    factory.registerStorage("ExternalDistributed", [](const StorageFactory::Arguments & args)
+    {
+        ASTs & engine_args = args.engine_args;
+
+        if (engine_args.size() != 6)
+            throw Exception(
+                "Storage MySQLiDistributed requires 5 parameters: ExternalDistributed('engine_name', 'cluster_description', database, table, 'user', 'password').",
+                ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
+        for (auto & engine_arg : engine_args)
+            engine_arg = evaluateConstantExpressionOrIdentifierAsLiteral(engine_arg, args.getLocalContext());
+
+        const String & engine_name = engine_args[0]->as<ASTLiteral &>().value.safeGet<String>();
+        const String & cluster_description = engine_args[1]->as<ASTLiteral &>().value.safeGet<String>();
+        const String & remote_database = engine_args[2]->as<ASTLiteral &>().value.safeGet<String>();
+        const String & remote_table = engine_args[3]->as<ASTLiteral &>().value.safeGet<String>();
+        const String & username = engine_args[4]->as<ASTLiteral &>().value.safeGet<String>();
+        const String & password = engine_args[5]->as<ASTLiteral &>().value.safeGet<String>();
+
+        StorageExternalDistributed::ExternalStorageEngine table_engine;
+        if (engine_name == "MySQL")
+            table_engine = StorageExternalDistributed::ExternalStorageEngine::MySQL;
+        else if (engine_name == "PostgreSQL")
+            table_engine = StorageExternalDistributed::ExternalStorageEngine::PostgreSQL;
+        else
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                "External storage engine {} is not supported for StorageExternalDistributed. Supported engines are: MySQL, PostgreSQL",
+                engine_name);
+
+        return StorageExternalDistributed::create(
+            args.table_id,
+            table_engine,
+            cluster_description,
+            remote_database,
+            remote_table,
+            username,
+            password,
+            args.columns,
+            args.constraints,
+            args.getContext());
+    },
+    {
+        .source_access_type = AccessType::MYSQL,
+    });
+}
+
+}
+
+#endif
diff --git a/src/Storages/StorageExternalDistributed.h b/src/Storages/StorageExternalDistributed.h
new file mode 100644
index 00000000000..71022f5eaa3
--- /dev/null
+++ b/src/Storages/StorageExternalDistributed.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#if !defined(ARCADIA_BUILD)
+#include "config_core.h"
+#endif
+
+#if USE_MYSQL || USE_LIBPQXX
+
+#include <ext/shared_ptr_helper.h>
+#include <Storages/IStorage.h>
+#include <mysqlxx/PoolWithFailover.h>
+
+
+namespace DB
+{
+
+/// Storages MySQL and PostgreSQL use ConnectionPoolWithFailover and support multiple replicas.
+/// This class unites multiple storages with replicas into multiple shards with replicas.
+/// A query to external database is passed to one replica on each shard, the result is united.
+/// Replicas on each shard have the same priority, traversed replicas are moved to the end of the queue.
+/// TODO: try `load_balancing` setting for replicas priorities same way as for table function `remote`
+class StorageExternalDistributed final : public ext::shared_ptr_helper<StorageExternalDistributed>, public DB::IStorage
+{
+    friend struct ext::shared_ptr_helper<StorageExternalDistributed>;
+
+public:
+    enum class ExternalStorageEngine
+    {
+        MySQL,
+        PostgreSQL,
+        Default
+    };
+
+    std::string getName() const override { return "ExternalDistributed"; }
+
+    Pipe read(
+        const Names & column_names,
+        const StorageMetadataPtr & /*metadata_snapshot*/,
+        SelectQueryInfo & query_info,
+        ContextPtr context,
+        QueryProcessingStage::Enum processed_stage,
+        size_t max_block_size,
+        unsigned num_streams) override;
+
+protected:
+    StorageExternalDistributed(
+        const StorageID & table_id_,
+        ExternalStorageEngine table_engine,
+        const String & cluster_description,
+        const String & remote_database_,
+        const String & remote_table_,
+        const String & username,
+        const String & password,
+        const ColumnsDescription & columns_,
+        const ConstraintsDescription & constraints_,
+        ContextPtr context_);
+
+private:
+    using Shards = std::unordered_set<StoragePtr>;
+    Shards shards;
+};
+
+}
+
+#endif
diff --git a/src/Storages/StorageFactory.cpp b/src/Storages/StorageFactory.cpp
index 7aaec9b7e76..3a57c8ab4f6 100644
--- a/src/Storages/StorageFactory.cpp
+++ b/src/Storages/StorageFactory.cpp
@@ -31,6 +31,23 @@ static void checkAllTypesAreAllowedInTable(const NamesAndTypesList & names_and_t
 }
 
 
+ContextPtr StorageFactory::Arguments::getContext() const
+{
+    auto ptr = context.lock();
+    if (!ptr)
+        throw Exception("Context has expired", ErrorCodes::LOGICAL_ERROR);
+    return ptr;
+}
+
+ContextPtr StorageFactory::Arguments::getLocalContext() const
+{
+    auto ptr = local_context.lock();
+    if (!ptr)
+        throw Exception("Context has expired", ErrorCodes::LOGICAL_ERROR);
+    return ptr;
+}
+
+
 void StorageFactory::registerStorage(const std::string & name, CreatorFn creator_fn, StorageFeatures features)
 {
     if (!storages.emplace(name, Creator{std::move(creator_fn), features}).second)
@@ -42,8 +59,8 @@ void StorageFactory::registerStorage(const std::string & name, CreatorFn creator
 StoragePtr StorageFactory::get(
     const ASTCreateQuery & query,
     const String & relative_data_path,
-    Context & local_context,
-    Context & context,
+    ContextPtr local_context,
+    ContextPtr context,
     const ColumnsDescription & columns,
     const ConstraintsDescription & constraints,
     bool has_force_restore_data_flag) const
@@ -179,7 +196,7 @@ StoragePtr StorageFactory::get(
         .attach = query.attach,
         .has_force_restore_data_flag = has_force_restore_data_flag
     };
-    assert(&arguments.context == &arguments.context.getGlobalContext());
+    assert(arguments.getContext() == arguments.getContext()->getGlobalContext());
 
     auto res = storages.at(name).creator_fn(arguments);
     if (!empty_engine_args.empty())
@@ -191,8 +208,8 @@ StoragePtr StorageFactory::get(
         storage_def->engine->arguments->children = empty_engine_args;
     }
 
-    if (local_context.hasQueryContext() && context.getSettingsRef().log_queries)
-        local_context.getQueryContext().addQueryFactoriesInfo(Context::QueryLogFactories::Storage, name);
+    if (local_context->hasQueryContext() && context->getSettingsRef().log_queries)
+        local_context->getQueryContext()->addQueryFactoriesInfo(Context::QueryLogFactories::Storage, name);
 
     return res;
 }
diff --git a/src/Storages/StorageFactory.h b/src/Storages/StorageFactory.h
index 18dd24e10db..43f6a6d6f7d 100644
--- a/src/Storages/StorageFactory.h
+++ b/src/Storages/StorageFactory.h
@@ -39,12 +39,15 @@ public:
         /// Relative to <path> from server config (possibly <path> of some <disk> of some <volume> for *MergeTree)
         const String & relative_data_path;
         const StorageID & table_id;
-        Context & local_context;
-        Context & context;
+        ContextWeakPtr local_context;
+        ContextWeakPtr context;
         const ColumnsDescription & columns;
         const ConstraintsDescription & constraints;
         bool attach;
         bool has_force_restore_data_flag;
+
+        ContextPtr getContext() const;
+        ContextPtr getLocalContext() const;
     };
 
     /// Analog of the IStorage::supports*() helpers
@@ -76,8 +79,8 @@ public:
     StoragePtr get(
         const ASTCreateQuery & query,
         const String & relative_data_path,
-        Context & local_context,
-        Context & context,
+        ContextPtr local_context,
+        ContextPtr context,
         const ColumnsDescription & columns,
         const ConstraintsDescription & constraints,
         bool has_force_restore_data_flag) const;
diff --git a/src/Storages/StorageFile.cpp b/src/Storages/StorageFile.cpp
index 5524569e1f0..14b91d29805 100644
--- a/src/Storages/StorageFile.cpp
+++ b/src/Storages/StorageFile.cpp
@@ -22,6 +22,8 @@
 #include <Common/escapeForFileName.h>
 #include <Common/typeid_cast.h>
 #include <Common/parseGlobs.h>
+#include <Storages/ColumnsDescription.h>
+#include <Storages/StorageInMemoryMetadata.h>
 
 #include <fcntl.h>
 #include <unistd.h>
@@ -114,9 +116,9 @@ std::string getTablePath(const std::string & table_dir_path, const std::string &
 }
 
 /// Both db_dir_path and table_path must be converted to absolute paths (in particular, path cannot contain '..').
-void checkCreationIsAllowed(const Context & context_global, const std::string & db_dir_path, const std::string & table_path)
+void checkCreationIsAllowed(ContextPtr context_global, const std::string & db_dir_path, const std::string & table_path)
 {
-    if (context_global.getApplicationType() != Context::ApplicationType::SERVER)
+    if (context_global->getApplicationType() != Context::ApplicationType::SERVER)
         return;
 
     /// "/dev/null" is allowed for perf testing
@@ -129,7 +131,7 @@ void checkCreationIsAllowed(const Context & context_global, const std::string &
 }
 }
 
-Strings StorageFile::getPathsList(const String & table_path, const String & user_files_path, const Context & context)
+Strings StorageFile::getPathsList(const String & table_path, const String & user_files_path, ContextPtr context)
 {
     String user_files_absolute_path = Poco::Path(user_files_path).makeAbsolute().makeDirectory().toString();
     Poco::Path poco_path = Poco::Path(table_path);
@@ -149,10 +151,15 @@ Strings StorageFile::getPathsList(const String & table_path, const String & user
     return paths;
 }
 
+bool StorageFile::isColumnOriented() const
+{
+    return format_name != "Distributed" && FormatFactory::instance().checkIfFormatIsColumnOriented(format_name);
+}
+
 StorageFile::StorageFile(int table_fd_, CommonArguments args)
     : StorageFile(args)
 {
-    if (args.context.getApplicationType() == Context::ApplicationType::SERVER)
+    if (args.getContext()->getApplicationType() == Context::ApplicationType::SERVER)
         throw Exception("Using file descriptor as source of storage isn't allowed for server daemons", ErrorCodes::DATABASE_ACCESS_DENIED);
     if (args.format_name == "Distributed")
         throw Exception("Distributed format is allowed only with explicit file path", ErrorCodes::INCORRECT_FILE_NAME);
@@ -170,7 +177,7 @@ StorageFile::StorageFile(const std::string & table_path_, const std::string & us
     : StorageFile(args)
 {
     is_db_table = false;
-    paths = getPathsList(table_path_, user_files_path, args.context);
+    paths = getPathsList(table_path_, user_files_path, args.getContext());
 
     if (args.format_name == "Distributed")
     {
@@ -207,7 +214,7 @@ StorageFile::StorageFile(CommonArguments args)
     , format_name(args.format_name)
     , format_settings(args.format_settings)
     , compression_method(args.compression_method)
-    , base_path(args.context.getPath())
+    , base_path(args.getContext()->getPath())
 {
     StorageInMemoryMetadata storage_metadata;
     if (args.format_name != "Distributed")
@@ -218,15 +225,17 @@ StorageFile::StorageFile(CommonArguments args)
 }
 
 
-static std::chrono::seconds getLockTimeout(const Context & context)
+static std::chrono::seconds getLockTimeout(ContextPtr context)
 {
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
     Int64 lock_timeout = settings.lock_acquire_timeout.totalSeconds();
     if (settings.max_execution_time.totalSeconds() != 0 && settings.max_execution_time.totalSeconds() < lock_timeout)
         lock_timeout = settings.max_execution_time.totalSeconds();
     return std::chrono::seconds{lock_timeout};
 }
 
+using StorageFilePtr = std::shared_ptr<StorageFile>;
+
 
 class StorageFileSource : public SourceWithProgress
 {
@@ -257,14 +266,26 @@ public:
         return header;
     }
 
+    static Block getBlockForSource(
+        const StorageFilePtr & storage,
+        const StorageMetadataPtr & metadata_snapshot,
+        const ColumnsDescription & columns_description,
+        const FilesInfoPtr & files_info)
+    {
+        if (storage->isColumnOriented())
+            return metadata_snapshot->getSampleBlockForColumns(columns_description.getNamesOfPhysical(), storage->getVirtuals(), storage->getStorageID());
+        else
+            return getHeader(metadata_snapshot, files_info->need_path_column, files_info->need_file_column);
+    }
+
     StorageFileSource(
         std::shared_ptr<StorageFile> storage_,
         const StorageMetadataPtr & metadata_snapshot_,
-        const Context & context_,
+        ContextPtr context_,
         UInt64 max_block_size_,
         FilesInfoPtr files_info_,
         ColumnsDescription columns_description_)
-        : SourceWithProgress(getHeader(metadata_snapshot_, files_info_->need_path_column, files_info_->need_file_column))
+        : SourceWithProgress(getBlockForSource(storage_, metadata_snapshot_, columns_description_, files_info_))
         , storage(std::move(storage_))
         , metadata_snapshot(metadata_snapshot_)
         , files_info(std::move(files_info_))
@@ -344,8 +365,16 @@ public:
                 }
 
                 read_buf = wrapReadBufferWithCompressionMethod(std::move(nested_buffer), method);
+
+                auto get_block_for_format = [&]() -> Block
+                {
+                    if (storage->isColumnOriented())
+                        return metadata_snapshot->getSampleBlockForColumns(columns_description.getNamesOfPhysical());
+                    return metadata_snapshot->getSampleBlock();
+                };
+
                 auto format = FormatFactory::instance().getInput(
-                        storage->format_name, *read_buf, metadata_snapshot->getSampleBlock(), context, max_block_size, storage->format_settings);
+                    storage->format_name, *read_buf, get_block_for_format(), context, max_block_size, storage->format_settings);
 
                 reader = std::make_shared<InputStreamFromInputFormat>(format);
 
@@ -403,7 +432,7 @@ private:
 
     ColumnsDescription columns_description;
 
-    const Context & context;    /// TODO Untangle potential issues with context lifetime.
+    ContextPtr context;    /// TODO Untangle potential issues with context lifetime.
     UInt64 max_block_size;
 
     bool finished_generate = false;
@@ -412,12 +441,11 @@ private:
     std::unique_lock<std::shared_timed_mutex> unique_lock;
 };
 
-
 Pipe StorageFile::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size,
     unsigned num_streams)
@@ -429,7 +457,7 @@ Pipe StorageFile::read(
     else
         if (paths.size() == 1 && !Poco::File(paths[0]).exists())
         {
-            if (context.getSettingsRef().engine_file_empty_if_not_exists)
+            if (context->getSettingsRef().engine_file_empty_if_not_exists)
                 return Pipe(std::make_shared<NullSource>(metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID())));
             else
                 throw Exception("File " + paths[0] + " doesn't exist", ErrorCodes::FILE_DOESNT_EXIST);
@@ -457,9 +485,16 @@ Pipe StorageFile::read(
 
     for (size_t i = 0; i < num_streams; ++i)
     {
+        const auto get_columns_for_format = [&]() -> ColumnsDescription
+        {
+            if (isColumnOriented())
+                return ColumnsDescription{
+                    metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()).getNamesAndTypesList()};
+            else
+                return metadata_snapshot->getColumns();
+        };
         pipes.emplace_back(std::make_shared<StorageFileSource>(
-            this_ptr, metadata_snapshot, context, max_block_size, files_info,
-            metadata_snapshot->getColumns()));
+            this_ptr, metadata_snapshot, context, max_block_size, files_info, get_columns_for_format()));
     }
 
     return Pipe::unitePipes(std::move(pipes));
@@ -474,7 +509,7 @@ public:
         const StorageMetadataPtr & metadata_snapshot_,
         std::unique_lock<std::shared_timed_mutex> && lock_,
         const CompressionMethod compression_method,
-        const Context & context,
+        ContextPtr context,
         const std::optional<FormatSettings> & format_settings,
         int & flags)
         : storage(storage_)
@@ -549,7 +584,7 @@ private:
 BlockOutputStreamPtr StorageFile::write(
     const ASTPtr & /*query*/,
     const StorageMetadataPtr & metadata_snapshot,
-    const Context & context)
+    ContextPtr context)
 {
     if (format_name == "Distributed")
         throw Exception("Method write is not implemented for Distributed format", ErrorCodes::NOT_IMPLEMENTED);
@@ -557,7 +592,7 @@ BlockOutputStreamPtr StorageFile::write(
     int flags = 0;
 
     std::string path;
-    if (context.getSettingsRef().engine_file_truncate_on_insert)
+    if (context->getSettingsRef().engine_file_truncate_on_insert)
         flags |= O_TRUNC;
 
     if (!paths.empty())
@@ -610,7 +645,7 @@ void StorageFile::rename(const String & new_path_to_table_data, const StorageID
 void StorageFile::truncate(
     const ASTPtr & /*query*/,
     const StorageMetadataPtr & /* metadata_snapshot */,
-    const Context & /* context */,
+    ContextPtr /* context */,
     TableExclusiveLockHolder &)
 {
     if (paths.size() != 1)
@@ -643,11 +678,15 @@ void registerStorageFile(StorageFactory & factory)
         "File",
         [](const StorageFactory::Arguments & factory_args)
         {
-            StorageFile::CommonArguments storage_args{
-                .table_id = factory_args.table_id,
-                .columns = factory_args.columns,
-                .constraints = factory_args.constraints,
-                .context = factory_args.context
+            StorageFile::CommonArguments storage_args
+            {
+                WithContext(factory_args.getContext()),
+                factory_args.table_id,
+                {},
+                {},
+                {},
+                factory_args.columns,
+                factory_args.constraints,
             };
 
             ASTs & engine_args_ast = factory_args.engine_args;
@@ -657,7 +696,7 @@ void registerStorageFile(StorageFactory & factory)
                     "Storage File requires from 1 to 3 arguments: name of used format, source and compression_method.",
                     ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-            engine_args_ast[0] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args_ast[0], factory_args.local_context);
+            engine_args_ast[0] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args_ast[0], factory_args.getLocalContext());
             storage_args.format_name = engine_args_ast[0]->as<ASTLiteral &>().value.safeGet<String>();
 
             // Use format settings from global server context + settings from
@@ -669,7 +708,7 @@ void registerStorageFile(StorageFactory & factory)
 
                 // Apply changed settings from global context, but ignore the
                 // unknown ones, because we only have the format settings here.
-                const auto & changes = factory_args.context.getSettingsRef().changes();
+                const auto & changes = factory_args.getContext()->getSettingsRef().changes();
                 for (const auto & change : changes)
                 {
                     if (user_format_settings.has(change.name))
@@ -683,12 +722,12 @@ void registerStorageFile(StorageFactory & factory)
                     factory_args.storage_def->settings->changes);
 
                 storage_args.format_settings = getFormatSettings(
-                    factory_args.context, user_format_settings);
+                    factory_args.getContext(), user_format_settings);
             }
             else
             {
                 storage_args.format_settings = getFormatSettings(
-                    factory_args.context);
+                    factory_args.getContext());
             }
 
             if (engine_args_ast.size() == 1) /// Table in database
@@ -725,7 +764,7 @@ void registerStorageFile(StorageFactory & factory)
 
             if (engine_args_ast.size() == 3)
             {
-                engine_args_ast[2] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args_ast[2], factory_args.local_context);
+                engine_args_ast[2] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args_ast[2], factory_args.getLocalContext());
                 storage_args.compression_method = engine_args_ast[2]->as<ASTLiteral &>().value.safeGet<String>();
             }
             else
@@ -734,7 +773,7 @@ void registerStorageFile(StorageFactory & factory)
             if (0 <= source_fd) /// File descriptor
                 return StorageFile::create(source_fd, storage_args);
             else /// User's file
-                return StorageFile::create(source_path, factory_args.context.getUserFilesPath(), storage_args);
+                return StorageFile::create(source_path, factory_args.getContext()->getUserFilesPath(), storage_args);
         },
         storage_features);
 }
diff --git a/src/Storages/StorageFile.h b/src/Storages/StorageFile.h
index c316412f808..a277dda7cc0 100644
--- a/src/Storages/StorageFile.h
+++ b/src/Storages/StorageFile.h
@@ -28,7 +28,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -36,12 +36,12 @@ public:
     BlockOutputStreamPtr write(
         const ASTPtr & query,
         const StorageMetadataPtr & /*metadata_snapshot*/,
-        const Context & context) override;
+        ContextPtr context) override;
 
     void truncate(
         const ASTPtr & /*query*/,
         const StorageMetadataPtr & /* metadata_snapshot */,
-        const Context & /* context */,
+        ContextPtr /* context */,
         TableExclusiveLockHolder &) override;
 
     void rename(const String & new_path_to_table_data, const StorageID & new_table_id) override;
@@ -49,7 +49,7 @@ public:
     bool storesDataOnDisk() const override;
     Strings getDataPaths() const override;
 
-    struct CommonArguments
+    struct CommonArguments : public WithContext
     {
         StorageID table_id;
         std::string format_name;
@@ -57,12 +57,17 @@ public:
         std::string compression_method;
         const ColumnsDescription & columns;
         const ConstraintsDescription & constraints;
-        const Context & context;
     };
 
     NamesAndTypesList getVirtuals() const override;
 
-    static Strings getPathsList(const String & table_path, const String & user_files_path, const Context & context);
+    static Strings getPathsList(const String & table_path, const String & user_files_path, ContextPtr context);
+
+    /// Check if the format is column-oriented.
+    /// Is is useful because column oriented formats could effectively skip unknown columns
+    /// So we can create a header of only required columns in read method and ask
+    /// format to read only them. Note: this hack cannot be done with ordinary formats like TSV.
+    bool isColumnOriented() const;
 
 protected:
     friend class StorageFileSource;
diff --git a/src/Storages/StorageGenerateRandom.cpp b/src/Storages/StorageGenerateRandom.cpp
index f06daa3a2bd..bc158c38f37 100644
--- a/src/Storages/StorageGenerateRandom.cpp
+++ b/src/Storages/StorageGenerateRandom.cpp
@@ -65,7 +65,7 @@ ColumnPtr fillColumnWithRandomData(
     UInt64 max_array_length,
     UInt64 max_string_length,
     pcg64 & rng,
-    const Context & context)
+    ContextPtr context)
 {
     TypeIndex idx = type->getTypeId();
 
@@ -339,7 +339,7 @@ ColumnPtr fillColumnWithRandomData(
 class GenerateSource : public SourceWithProgress
 {
 public:
-    GenerateSource(UInt64 block_size_, UInt64 max_array_length_, UInt64 max_string_length_, UInt64 random_seed_, Block block_header_, const Context & context_)
+    GenerateSource(UInt64 block_size_, UInt64 max_array_length_, UInt64 max_string_length_, UInt64 random_seed_, Block block_header_, ContextPtr context_)
         : SourceWithProgress(Nested::flatten(prepareBlockToFill(block_header_)))
         , block_size(block_size_), max_array_length(max_array_length_), max_string_length(max_string_length_)
         , block_to_fill(std::move(block_header_)), rng(random_seed_), context(context_) {}
@@ -367,7 +367,7 @@ private:
 
     pcg64 rng;
 
-    const Context & context;
+    ContextPtr context;
 
     static Block & prepareBlockToFill(Block & block)
     {
@@ -442,7 +442,7 @@ Pipe StorageGenerateRandom::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size,
     unsigned num_streams)
diff --git a/src/Storages/StorageGenerateRandom.h b/src/Storages/StorageGenerateRandom.h
index 965c5b3a9d3..d9c2acb782b 100644
--- a/src/Storages/StorageGenerateRandom.h
+++ b/src/Storages/StorageGenerateRandom.h
@@ -19,7 +19,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/StorageInMemoryMetadata.cpp b/src/Storages/StorageInMemoryMetadata.cpp
index 871ff38c07f..2f4a24a5c60 100644
--- a/src/Storages/StorageInMemoryMetadata.cpp
+++ b/src/Storages/StorageInMemoryMetadata.cpp
@@ -291,9 +291,10 @@ Block StorageInMemoryMetadata::getSampleBlockForColumns(
 {
     Block res;
 
-    std::unordered_map<String, DataTypePtr> columns_map;
-
     auto all_columns = getColumns().getAllWithSubcolumns();
+    std::unordered_map<String, DataTypePtr> columns_map;
+    columns_map.reserve(all_columns.size());
+
     for (const auto & elem : all_columns)
         columns_map.emplace(elem.name, elem.type);
 
@@ -306,15 +307,11 @@ Block StorageInMemoryMetadata::getSampleBlockForColumns(
     {
         auto it = columns_map.find(name);
         if (it != columns_map.end())
-        {
             res.insert({it->second->createColumn(), it->second, it->first});
-        }
         else
-        {
             throw Exception(
-                "Column " + backQuote(name) + " not found in table " + storage_id.getNameForLogs(),
+                "Column " + backQuote(name) + " not found in table " + (storage_id.empty() ? "" : storage_id.getNameForLogs()),
                 ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK);
-        }
     }
 
     return res;
diff --git a/src/Storages/StorageInMemoryMetadata.h b/src/Storages/StorageInMemoryMetadata.h
index 038416aff7d..00fb944c0b5 100644
--- a/src/Storages/StorageInMemoryMetadata.h
+++ b/src/Storages/StorageInMemoryMetadata.h
@@ -85,9 +85,10 @@ struct StorageInMemoryMetadata
 
     /// Returns combined set of columns
     const ColumnsDescription & getColumns() const;
-    /// Returns secondary indices
 
+    /// Returns secondary indices
     const IndicesDescription & getSecondaryIndices() const;
+
     /// Has at least one non primary index
     bool hasSecondaryIndices() const;
 
@@ -146,8 +147,7 @@ struct StorageInMemoryMetadata
     /// Storage metadata. StorageID required only for more clear exception
     /// message.
     Block getSampleBlockForColumns(
-        const Names & column_names, const NamesAndTypesList & virtuals, const StorageID & storage_id) const;
-
+        const Names & column_names, const NamesAndTypesList & virtuals = {}, const StorageID & storage_id = StorageID::createEmpty()) const;
     /// Returns structure with partition key.
     const KeyDescription & getPartitionKey() const;
     /// Returns ASTExpressionList of partition key expression for storage or nullptr if there is none.
diff --git a/src/Storages/StorageInput.cpp b/src/Storages/StorageInput.cpp
index 1f881bccf07..63b440aff08 100644
--- a/src/Storages/StorageInput.cpp
+++ b/src/Storages/StorageInput.cpp
@@ -27,17 +27,14 @@ StorageInput::StorageInput(const StorageID & table_id, const ColumnsDescription
 }
 
 
-class StorageInputSource : public SourceWithProgress
+class StorageInputSource : public SourceWithProgress, WithContext
 {
 public:
-    StorageInputSource(Context & context_, Block sample_block)
-        : SourceWithProgress(std::move(sample_block)), context(context_)
-    {
-    }
+    StorageInputSource(ContextPtr context_, Block sample_block) : SourceWithProgress(std::move(sample_block)), WithContext(context_) {}
 
     Chunk generate() override
     {
-        auto block = context.getInputBlocksReaderCallback()(context);
+        auto block = getContext()->getInputBlocksReaderCallback()(getContext());
         if (!block)
             return {};
 
@@ -46,9 +43,6 @@ public:
     }
 
     String getName() const override { return "Input"; }
-
-private:
-    Context & context;
 };
 
 
@@ -62,18 +56,18 @@ Pipe StorageInput::read(
     const Names & /*column_names*/,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t /*max_block_size*/,
     unsigned /*num_streams*/)
 {
     Pipes pipes;
-    Context & query_context = const_cast<Context &>(context).getQueryContext();
+    auto query_context = context->getQueryContext();
     /// It is TCP request if we have callbacks for input().
-    if (query_context.getInputBlocksReaderCallback())
+    if (query_context->getInputBlocksReaderCallback())
     {
         /// Send structure to the client.
-        query_context.initializeInput(shared_from_this());
+        query_context->initializeInput(shared_from_this());
         return Pipe(std::make_shared<StorageInputSource>(query_context, metadata_snapshot->getSampleBlock()));
     }
 
diff --git a/src/Storages/StorageInput.h b/src/Storages/StorageInput.h
index 3cb64993d45..106c22db385 100644
--- a/src/Storages/StorageInput.h
+++ b/src/Storages/StorageInput.h
@@ -21,7 +21,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/StorageJoin.cpp b/src/Storages/StorageJoin.cpp
index a449cebba51..983b9213a35 100644
--- a/src/Storages/StorageJoin.cpp
+++ b/src/Storages/StorageJoin.cpp
@@ -68,7 +68,7 @@ StorageJoin::StorageJoin(
 
 
 void StorageJoin::truncate(
-    const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context &, TableExclusiveLockHolder&)
+    const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr, TableExclusiveLockHolder&)
 {
     disk->removeRecursive(path);
     disk->createDirectories(path);
@@ -146,7 +146,7 @@ void registerStorageJoin(StorageFactory & factory)
 
         ASTs & engine_args = args.engine_args;
 
-        const auto & settings = args.context.getSettingsRef();
+        const auto & settings = args.getContext()->getSettingsRef();
 
         auto join_use_nulls = settings.join_use_nulls;
         auto max_rows_in_join = settings.max_rows_in_join;
@@ -186,7 +186,7 @@ void registerStorageJoin(StorageFactory & factory)
             }
         }
 
-        DiskPtr disk = args.context.getDisk(disk_name);
+        DiskPtr disk = args.getContext()->getDisk(disk_name);
 
         if (engine_args.size() < 3)
             throw Exception(
@@ -492,7 +492,7 @@ Pipe StorageJoin::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size,
     unsigned /*num_streams*/)
diff --git a/src/Storages/StorageJoin.h b/src/Storages/StorageJoin.h
index 5f0f9f92404..4baac53c69c 100644
--- a/src/Storages/StorageJoin.h
+++ b/src/Storages/StorageJoin.h
@@ -27,7 +27,7 @@ class StorageJoin final : public ext::shared_ptr_helper<StorageJoin>, public Sto
 public:
     String getName() const override { return "Join"; }
 
-    void truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context &, TableExclusiveLockHolder &) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr, TableExclusiveLockHolder &) override;
 
     /// Return instance of HashJoin holding lock that protects from insertions to StorageJoin.
     /// HashJoin relies on structure of hash table that's why we need to return it with locked mutex.
@@ -45,7 +45,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/StorageLog.cpp b/src/Storages/StorageLog.cpp
index 9fdd466e792..8ed68e0b44d 100644
--- a/src/Storages/StorageLog.cpp
+++ b/src/Storages/StorageLog.cpp
@@ -591,7 +591,7 @@ void StorageLog::rename(const String & new_path_to_table_data, const StorageID &
     renameInMemory(new_table_id);
 }
 
-void StorageLog::truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context &, TableExclusiveLockHolder &)
+void StorageLog::truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr, TableExclusiveLockHolder &)
 {
     files.clear();
     file_count = 0;
@@ -633,9 +633,9 @@ const StorageLog::Marks & StorageLog::getMarksWithRealRowCount(const StorageMeta
 }
 
 
-static std::chrono::seconds getLockTimeout(const Context & context)
+static std::chrono::seconds getLockTimeout(ContextPtr context)
 {
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
     Int64 lock_timeout = settings.lock_acquire_timeout.totalSeconds();
     if (settings.max_execution_time.totalSeconds() != 0 && settings.max_execution_time.totalSeconds() < lock_timeout)
         lock_timeout = settings.max_execution_time.totalSeconds();
@@ -647,7 +647,7 @@ Pipe StorageLog::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size,
     unsigned num_streams)
@@ -672,7 +672,7 @@ Pipe StorageLog::read(
     if (num_streams > marks_size)
         num_streams = marks_size;
 
-    size_t max_read_buffer_size = context.getSettingsRef().max_read_buffer_size;
+    size_t max_read_buffer_size = context->getSettingsRef().max_read_buffer_size;
 
     for (size_t stream = 0; stream < num_streams; ++stream)
     {
@@ -695,7 +695,7 @@ Pipe StorageLog::read(
     return Pipe::unitePipes(std::move(pipes));
 }
 
-BlockOutputStreamPtr StorageLog::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr StorageLog::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr context)
 {
     auto lock_timeout = getLockTimeout(context);
     loadMarks(lock_timeout);
@@ -707,7 +707,7 @@ BlockOutputStreamPtr StorageLog::write(const ASTPtr & /*query*/, const StorageMe
     return std::make_shared<LogBlockOutputStream>(*this, metadata_snapshot, std::move(lock));
 }
 
-CheckResults StorageLog::checkData(const ASTPtr & /* query */, const Context & context)
+CheckResults StorageLog::checkData(const ASTPtr & /* query */, ContextPtr context)
 {
     std::shared_lock lock(rwlock, getLockTimeout(context));
     if (!lock)
@@ -731,11 +731,11 @@ void registerStorageLog(StorageFactory & factory)
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
         String disk_name = getDiskName(*args.storage_def);
-        DiskPtr disk = args.context.getDisk(disk_name);
+        DiskPtr disk = args.getContext()->getDisk(disk_name);
 
         return StorageLog::create(
             disk, args.relative_data_path, args.table_id, args.columns, args.constraints,
-            args.attach, args.context.getSettings().max_compress_block_size);
+            args.attach, args.getContext()->getSettings().max_compress_block_size);
     }, features);
 }
 
diff --git a/src/Storages/StorageLog.h b/src/Storages/StorageLog.h
index a08e0f9a629..4fbaf53529f 100644
--- a/src/Storages/StorageLog.h
+++ b/src/Storages/StorageLog.h
@@ -29,18 +29,18 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     void rename(const String & new_path_to_table_data, const StorageID & new_table_id) override;
 
-    CheckResults checkData(const ASTPtr & /* query */, const Context & /* context */) override;
+    CheckResults checkData(const ASTPtr & /* query */, ContextPtr /* context */) override;
 
-    void truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context &, TableExclusiveLockHolder &) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr, TableExclusiveLockHolder &) override;
 
     bool storesDataOnDisk() const override { return true; }
     Strings getDataPaths() const override { return {DB::fullPath(disk, table_path)}; }
diff --git a/src/Storages/StorageMaterializeMySQL.cpp b/src/Storages/StorageMaterializeMySQL.cpp
index e59f1e22958..a15e4957abe 100644
--- a/src/Storages/StorageMaterializeMySQL.cpp
+++ b/src/Storages/StorageMaterializeMySQL.cpp
@@ -39,7 +39,7 @@ Pipe StorageMaterializeMySQL::read(
     const Names & column_names,
     const StorageMetadataPtr & /*metadata_snapshot*/,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum processed_stage,
     size_t max_block_size,
     unsigned int num_streams)
@@ -48,7 +48,7 @@ Pipe StorageMaterializeMySQL::read(
     rethrowSyncExceptionIfNeed(database);
 
     NameSet column_names_set = NameSet(column_names.begin(), column_names.end());
-    auto lock = nested_storage->lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+    auto lock = nested_storage->lockForShare(context->getCurrentQueryId(), context->getSettingsRef().lock_acquire_timeout);
     const StorageMetadataPtr & nested_metadata = nested_storage->getInMemoryMetadataPtr();
 
     Block nested_header = nested_metadata->getSampleBlock();
diff --git a/src/Storages/StorageMaterializeMySQL.h b/src/Storages/StorageMaterializeMySQL.h
index f787470e2d2..8a4b88cbbb4 100644
--- a/src/Storages/StorageMaterializeMySQL.h
+++ b/src/Storages/StorageMaterializeMySQL.h
@@ -26,9 +26,9 @@ public:
 
     Pipe read(
         const Names & column_names, const StorageMetadataPtr & metadata_snapshot, SelectQueryInfo & query_info,
-        const Context & context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, unsigned num_streams) override;
+        ContextPtr context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, unsigned num_streams) override;
 
-    BlockOutputStreamPtr write(const ASTPtr &, const StorageMetadataPtr &, const Context &) override { throwNotAllowed(); }
+    BlockOutputStreamPtr write(const ASTPtr &, const StorageMetadataPtr &, ContextPtr) override { throwNotAllowed(); }
 
     NamesAndTypesList getVirtuals() const override;
     ColumnSizeByName getColumnSizes() const override;
diff --git a/src/Storages/StorageMaterializedView.cpp b/src/Storages/StorageMaterializedView.cpp
index c89187a46e2..ffd57008e6e 100644
--- a/src/Storages/StorageMaterializedView.cpp
+++ b/src/Storages/StorageMaterializedView.cpp
@@ -50,11 +50,11 @@ static inline String generateInnerTableName(const StorageID & view_id)
 
 StorageMaterializedView::StorageMaterializedView(
     const StorageID & table_id_,
-    Context & local_context,
+    ContextPtr local_context,
     const ASTCreateQuery & query,
     const ColumnsDescription & columns_,
     bool attach_)
-    : IStorage(table_id_), global_context(local_context.getGlobalContext())
+    : IStorage(table_id_), WithContext(local_context->getGlobalContext())
 {
     StorageInMemoryMetadata storage_metadata;
     storage_metadata.setColumns(columns_);
@@ -90,7 +90,7 @@ StorageMaterializedView::StorageMaterializedView(
     else
     {
         /// We will create a query to create an internal table.
-        auto create_context = Context(local_context);
+        auto create_context = Context::createCopy(local_context);
         auto manual_create_query = std::make_shared<ASTCreateQuery>();
         manual_create_query->database = getStorageID().database_name;
         manual_create_query->table = generateInnerTableName(getStorageID());
@@ -106,32 +106,33 @@ StorageMaterializedView::StorageMaterializedView(
         create_interpreter.setInternal(true);
         create_interpreter.execute();
 
-        target_table_id = DatabaseCatalog::instance().getTable({manual_create_query->database, manual_create_query->table}, global_context)->getStorageID();
+        target_table_id = DatabaseCatalog::instance().getTable({manual_create_query->database, manual_create_query->table}, getContext())->getStorageID();
     }
 
     if (!select.select_table_id.empty())
         DatabaseCatalog::instance().addDependency(select.select_table_id, getStorageID());
 }
 
-QueryProcessingStage::Enum StorageMaterializedView::getQueryProcessingStage(const Context & context, QueryProcessingStage::Enum to_stage, SelectQueryInfo & query_info) const
+QueryProcessingStage::Enum StorageMaterializedView::getQueryProcessingStage(
+    ContextPtr local_context, QueryProcessingStage::Enum to_stage, SelectQueryInfo & query_info) const
 {
-    return getTargetTable()->getQueryProcessingStage(context, to_stage, query_info);
+    return getTargetTable()->getQueryProcessingStage(local_context, to_stage, query_info);
 }
 
 Pipe StorageMaterializedView::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     const size_t max_block_size,
     const unsigned num_streams)
 {
     QueryPlan plan;
-    read(plan, column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams);
+    read(plan, column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams);
     return plan.convertToPipe(
-        QueryPlanOptimizationSettings::fromContext(context),
-        BuildQueryPipelineSettings::fromContext(context));
+        QueryPlanOptimizationSettings::fromContext(local_context),
+        BuildQueryPipelineSettings::fromContext(local_context));
 }
 
 void StorageMaterializedView::read(
@@ -139,23 +140,23 @@ void StorageMaterializedView::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     const size_t max_block_size,
     const unsigned num_streams)
 {
     auto storage = getTargetTable();
-    auto lock = storage->lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+    auto lock = storage->lockForShare(local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout);
     auto target_metadata_snapshot = storage->getInMemoryMetadataPtr();
 
     if (query_info.order_optimizer)
-        query_info.input_order_info = query_info.order_optimizer->getInputOrder(target_metadata_snapshot, context);
+        query_info.input_order_info = query_info.order_optimizer->getInputOrder(target_metadata_snapshot, local_context);
 
-    storage->read(query_plan, column_names, target_metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams);
+    storage->read(query_plan, column_names, target_metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams);
 
     if (query_plan.isInitialized())
     {
-        auto mv_header = getHeaderForProcessingStage(*this, column_names, metadata_snapshot, query_info, context, processed_stage);
+        auto mv_header = getHeaderForProcessingStage(*this, column_names, metadata_snapshot, query_info, local_context, processed_stage);
         auto target_header = query_plan.getCurrentDataStream().header;
         if (!blocksHaveEqualStructure(mv_header, target_header))
         {
@@ -185,20 +186,20 @@ void StorageMaterializedView::read(
     }
 }
 
-BlockOutputStreamPtr StorageMaterializedView::write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context)
+BlockOutputStreamPtr StorageMaterializedView::write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr local_context)
 {
     auto storage = getTargetTable();
-    auto lock = storage->lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+    auto lock = storage->lockForShare(local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout);
 
     auto metadata_snapshot = storage->getInMemoryMetadataPtr();
-    auto stream = storage->write(query, metadata_snapshot, context);
+    auto stream = storage->write(query, metadata_snapshot, local_context);
 
     stream->addTableLock(lock);
     return stream;
 }
 
 
-static void executeDropQuery(ASTDropQuery::Kind kind, const Context & global_context, const Context & current_context, const StorageID & target_table_id, bool no_delay)
+static void executeDropQuery(ASTDropQuery::Kind kind, ContextPtr global_context, ContextPtr current_context, const StorageID & target_table_id, bool no_delay)
 {
     if (DatabaseCatalog::instance().tryGetTable(target_table_id, current_context))
     {
@@ -214,13 +215,13 @@ static void executeDropQuery(ASTDropQuery::Kind kind, const Context & global_con
         /// to avoid "Not enough privileges" error if current user has only DROP VIEW ON mat_view_name privilege
         /// and not allowed to drop inner table explicitly. Allowing to drop inner table without explicit grant
         /// looks like expected behaviour and we have tests for it.
-        auto drop_context = Context(global_context);
-        drop_context.getClientInfo().query_kind = ClientInfo::QueryKind::SECONDARY_QUERY;
-        if (auto txn = current_context.getZooKeeperMetadataTransaction())
+        auto drop_context = Context::createCopy(global_context);
+        drop_context->getClientInfo().query_kind = ClientInfo::QueryKind::SECONDARY_QUERY;
+        if (auto txn = current_context->getZooKeeperMetadataTransaction())
         {
             /// For Replicated database
-            drop_context.setQueryContext(const_cast<Context &>(current_context));
-            drop_context.initZooKeeperMetadataTransaction(txn, true);
+            drop_context->setQueryContext(current_context);
+            drop_context->initZooKeeperMetadataTransaction(txn, true);
         }
         InterpreterDropQuery drop_interpreter(ast_drop_query, drop_context);
         drop_interpreter.execute();
@@ -235,19 +236,19 @@ void StorageMaterializedView::drop()
     if (!select_query.select_table_id.empty())
         DatabaseCatalog::instance().removeDependency(select_query.select_table_id, table_id);
 
-    dropInnerTable(true, global_context);
+    dropInnerTable(true, getContext());
 }
 
-void StorageMaterializedView::dropInnerTable(bool no_delay, const Context & context)
+void StorageMaterializedView::dropInnerTable(bool no_delay, ContextPtr local_context)
 {
     if (has_inner_table && tryGetTargetTable())
-        executeDropQuery(ASTDropQuery::Kind::Drop, global_context, context, target_table_id, no_delay);
+        executeDropQuery(ASTDropQuery::Kind::Drop, getContext(), local_context, target_table_id, no_delay);
 }
 
-void StorageMaterializedView::truncate(const ASTPtr &, const StorageMetadataPtr &, const Context & context, TableExclusiveLockHolder &)
+void StorageMaterializedView::truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr local_context, TableExclusiveLockHolder &)
 {
     if (has_inner_table)
-        executeDropQuery(ASTDropQuery::Kind::Truncate, global_context, context, target_table_id, true);
+        executeDropQuery(ASTDropQuery::Kind::Truncate, getContext(), local_context, target_table_id, true);
 }
 
 void StorageMaterializedView::checkStatementCanBeForwarded() const
@@ -265,26 +266,26 @@ bool StorageMaterializedView::optimize(
     bool final,
     bool deduplicate,
     const Names & deduplicate_by_columns,
-    const Context & context)
+    ContextPtr local_context)
 {
     checkStatementCanBeForwarded();
     auto storage_ptr = getTargetTable();
     auto metadata_snapshot = storage_ptr->getInMemoryMetadataPtr();
-    return getTargetTable()->optimize(query, metadata_snapshot, partition, final, deduplicate, deduplicate_by_columns, context);
+    return getTargetTable()->optimize(query, metadata_snapshot, partition, final, deduplicate, deduplicate_by_columns, local_context);
 }
 
 void StorageMaterializedView::alter(
     const AlterCommands & params,
-    const Context & context,
+    ContextPtr local_context,
     TableLockHolder &)
 {
     auto table_id = getStorageID();
     StorageInMemoryMetadata new_metadata = getInMemoryMetadata();
     StorageInMemoryMetadata old_metadata = getInMemoryMetadata();
-    params.apply(new_metadata, context);
+    params.apply(new_metadata, local_context);
 
     /// start modify query
-    if (context.getSettingsRef().allow_experimental_alter_materialized_view_structure)
+    if (local_context->getSettingsRef().allow_experimental_alter_materialized_view_structure)
     {
         const auto & new_select = new_metadata.select;
         const auto & old_select = old_metadata.getSelectQuery();
@@ -295,14 +296,14 @@ void StorageMaterializedView::alter(
     }
     /// end modify query
 
-    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id, new_metadata);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(local_context, table_id, new_metadata);
     setInMemoryMetadata(new_metadata);
 }
 
 
-void StorageMaterializedView::checkAlterIsPossible(const AlterCommands & commands, const Context & context) const
+void StorageMaterializedView::checkAlterIsPossible(const AlterCommands & commands, ContextPtr local_context) const
 {
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = local_context->getSettingsRef();
     if (settings.allow_experimental_alter_materialized_view_structure)
     {
         for (const auto & command : commands)
@@ -332,10 +333,10 @@ void StorageMaterializedView::checkMutationIsPossible(const MutationCommands & c
 }
 
 Pipe StorageMaterializedView::alterPartition(
-    const StorageMetadataPtr & metadata_snapshot, const PartitionCommands & commands, const Context & context)
+    const StorageMetadataPtr & metadata_snapshot, const PartitionCommands & commands, ContextPtr local_context)
 {
     checkStatementCanBeForwarded();
-    return getTargetTable()->alterPartition(metadata_snapshot, commands, context);
+    return getTargetTable()->alterPartition(metadata_snapshot, commands, local_context);
 }
 
 void StorageMaterializedView::checkAlterPartitionIsPossible(
@@ -345,10 +346,10 @@ void StorageMaterializedView::checkAlterPartitionIsPossible(
     getTargetTable()->checkAlterPartitionIsPossible(commands, metadata_snapshot, settings);
 }
 
-void StorageMaterializedView::mutate(const MutationCommands & commands, const Context & context)
+void StorageMaterializedView::mutate(const MutationCommands & commands, ContextPtr local_context)
 {
     checkStatementCanBeForwarded();
-    getTargetTable()->mutate(commands, context);
+    getTargetTable()->mutate(commands, local_context);
 }
 
 void StorageMaterializedView::renameInMemory(const StorageID & new_table_id)
@@ -375,7 +376,7 @@ void StorageMaterializedView::renameInMemory(const StorageID & new_table_id)
         elem.to = to;
         rename->elements.emplace_back(elem);
 
-        InterpreterRenameQuery(rename, global_context).execute();
+        InterpreterRenameQuery(rename, getContext()).execute();
         target_table_id.table_name = new_target_table_name;
     }
 
@@ -397,13 +398,13 @@ void StorageMaterializedView::shutdown()
 StoragePtr StorageMaterializedView::getTargetTable() const
 {
     checkStackSize();
-    return DatabaseCatalog::instance().getTable(target_table_id, global_context);
+    return DatabaseCatalog::instance().getTable(target_table_id, getContext());
 }
 
 StoragePtr StorageMaterializedView::tryGetTargetTable() const
 {
     checkStackSize();
-    return DatabaseCatalog::instance().tryGetTable(target_table_id, global_context);
+    return DatabaseCatalog::instance().tryGetTable(target_table_id, getContext());
 }
 
 Strings StorageMaterializedView::getDataPaths() const
@@ -424,7 +425,7 @@ void registerStorageMaterializedView(StorageFactory & factory)
     {
         /// Pass local_context here to convey setting for inner table
         return StorageMaterializedView::create(
-            args.table_id, args.local_context, args.query,
+            args.table_id, args.getLocalContext(), args.query,
             args.columns, args.attach);
     });
 }
diff --git a/src/Storages/StorageMaterializedView.h b/src/Storages/StorageMaterializedView.h
index a5dc089d68e..cda8112a8c3 100644
--- a/src/Storages/StorageMaterializedView.h
+++ b/src/Storages/StorageMaterializedView.h
@@ -12,7 +12,7 @@
 namespace DB
 {
 
-class StorageMaterializedView final : public ext::shared_ptr_helper<StorageMaterializedView>, public IStorage
+class StorageMaterializedView final : public ext::shared_ptr_helper<StorageMaterializedView>, public IStorage, WithContext
 {
     friend struct ext::shared_ptr_helper<StorageMaterializedView>;
 public:
@@ -27,19 +27,19 @@ public:
     bool supportsIndexForIn() const override { return getTargetTable()->supportsIndexForIn(); }
     bool supportsParallelInsert() const override { return getTargetTable()->supportsParallelInsert(); }
     bool supportsSubcolumns() const override { return getTargetTable()->supportsSubcolumns(); }
-    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, const Context & query_context, const StorageMetadataPtr & /* metadata_snapshot */) const override
+    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, ContextPtr query_context, const StorageMetadataPtr & /* metadata_snapshot */) const override
     {
         auto target_table = getTargetTable();
         auto metadata_snapshot = target_table->getInMemoryMetadataPtr();
         return target_table->mayBenefitFromIndexForIn(left_in_operand, query_context, metadata_snapshot);
     }
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     void drop() override;
-    void dropInnerTable(bool no_delay, const Context & context);
+    void dropInnerTable(bool no_delay, ContextPtr context);
 
-    void truncate(const ASTPtr &, const StorageMetadataPtr &, const Context &, TableExclusiveLockHolder &) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr, TableExclusiveLockHolder &) override;
 
     bool optimize(
         const ASTPtr & query,
@@ -48,25 +48,25 @@ public:
         bool final,
         bool deduplicate,
         const Names & deduplicate_by_columns,
-        const Context & context) override;
+        ContextPtr context) override;
 
-    void alter(const AlterCommands & params, const Context & context, TableLockHolder & table_lock_holder) override;
+    void alter(const AlterCommands & params, ContextPtr context, TableLockHolder & table_lock_holder) override;
 
     void checkMutationIsPossible(const MutationCommands & commands, const Settings & settings) const override;
 
-    void checkAlterIsPossible(const AlterCommands & commands, const Context & context) const override;
+    void checkAlterIsPossible(const AlterCommands & commands, ContextPtr context) const override;
 
-    Pipe alterPartition(const StorageMetadataPtr & metadata_snapshot, const PartitionCommands & commands, const Context & context) override;
+    Pipe alterPartition(const StorageMetadataPtr & metadata_snapshot, const PartitionCommands & commands, ContextPtr context) override;
 
     void checkAlterPartitionIsPossible(const PartitionCommands & commands, const StorageMetadataPtr & metadata_snapshot, const Settings & settings) const override;
 
-    void mutate(const MutationCommands & commands, const Context & context) override;
+    void mutate(const MutationCommands & commands, ContextPtr context) override;
 
     void renameInMemory(const StorageID & new_table_id) override;
 
     void shutdown() override;
 
-    QueryProcessingStage::Enum getQueryProcessingStage(const Context &, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const override;
+    QueryProcessingStage::Enum getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const override;
 
     StoragePtr getTargetTable() const;
     StoragePtr tryGetTargetTable() const;
@@ -77,7 +77,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -87,7 +87,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -98,7 +98,6 @@ private:
     /// Will be initialized in constructor
     StorageID target_table_id = StorageID::createEmpty();
 
-    Context & global_context;
     bool has_inner_table = false;
 
     void checkStatementCanBeForwarded() const;
@@ -106,7 +105,7 @@ private:
 protected:
     StorageMaterializedView(
         const StorageID & table_id_,
-        Context & local_context,
+        ContextPtr local_context,
         const ASTCreateQuery & query,
         const ColumnsDescription & columns_,
         bool attach_);
diff --git a/src/Storages/StorageMemory.cpp b/src/Storages/StorageMemory.cpp
index d98cd4212e9..4cae7367606 100644
--- a/src/Storages/StorageMemory.cpp
+++ b/src/Storages/StorageMemory.cpp
@@ -26,10 +26,6 @@ class MemorySource : public SourceWithProgress
 {
     using InitializerFunc = std::function<void(std::shared_ptr<const Blocks> &)>;
 public:
-    /// Blocks are stored in std::list which may be appended in another thread.
-    /// We use pointer to the beginning of the list and its current size.
-    /// We don't need synchronisation in this reader, because while we hold SharedLock on storage,
-    /// only new elements can be added to the back of the list, so our iterators remain valid
 
     MemorySource(
         Names column_names_,
@@ -59,7 +55,7 @@ protected:
 
         size_t current_index = getAndIncrementExecutionIndex();
 
-        if (current_index >= data->size())
+        if (!data || current_index >= data->size())
         {
             return {};
         }
@@ -182,7 +178,7 @@ Pipe StorageMemory::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t /*max_block_size*/,
     unsigned num_streams)
@@ -230,7 +226,7 @@ Pipe StorageMemory::read(
 }
 
 
-BlockOutputStreamPtr StorageMemory::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & /*context*/)
+BlockOutputStreamPtr StorageMemory::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr /*context*/)
 {
     return std::make_shared<MemoryBlockOutputStream>(*this, metadata_snapshot);
 }
@@ -258,7 +254,7 @@ void StorageMemory::checkMutationIsPossible(const MutationCommands & /*commands*
     /// Some validation will be added
 }
 
-void StorageMemory::mutate(const MutationCommands & commands, const Context & context)
+void StorageMemory::mutate(const MutationCommands & commands, ContextPtr context)
 {
     std::lock_guard lock(mutex);
     auto metadata_snapshot = getInMemoryMetadataPtr();
@@ -320,7 +316,7 @@ void StorageMemory::mutate(const MutationCommands & commands, const Context & co
 
 
 void StorageMemory::truncate(
-    const ASTPtr &, const StorageMetadataPtr &, const Context &, TableExclusiveLockHolder &)
+    const ASTPtr &, const StorageMetadataPtr &, ContextPtr, TableExclusiveLockHolder &)
 {
     data.set(std::make_unique<Blocks>());
     total_size_bytes.store(0, std::memory_order_relaxed);
diff --git a/src/Storages/StorageMemory.h b/src/Storages/StorageMemory.h
index b7fa4d7b222..1118474deee 100644
--- a/src/Storages/StorageMemory.h
+++ b/src/Storages/StorageMemory.h
@@ -34,7 +34,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -47,14 +47,14 @@ public:
 
     bool hasEvenlyDistributedRead() const override { return true; }
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & metadata_snapshot, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & metadata_snapshot, ContextPtr context) override;
 
     void drop() override;
 
     void checkMutationIsPossible(const MutationCommands & commands, const Settings & settings) const override;
-    void mutate(const MutationCommands & commands, const Context & context) override;
+    void mutate(const MutationCommands & commands, ContextPtr context) override;
 
-    void truncate(const ASTPtr &, const StorageMetadataPtr &, const Context &, TableExclusiveLockHolder &) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr, TableExclusiveLockHolder &) override;
 
     std::optional<UInt64> totalRows(const Settings &) const override;
     std::optional<UInt64> totalBytes(const Settings &) const override;
@@ -97,7 +97,7 @@ public:
     void delayReadForGlobalSubqueries() { delay_read_for_global_subqueries = true; }
 
 private:
-    /// MultiVersion data storage, so that we can copy the list of blocks to readers.
+    /// MultiVersion data storage, so that we can copy the vector of blocks to readers.
 
     MultiVersion<Blocks> data;
 
diff --git a/src/Storages/StorageMerge.cpp b/src/Storages/StorageMerge.cpp
index b8aaa52f92c..6ad7b0bce6e 100644
--- a/src/Storages/StorageMerge.cpp
+++ b/src/Storages/StorageMerge.cpp
@@ -9,6 +9,7 @@
 #include <Interpreters/ExpressionActions.h>
 #include <Interpreters/evaluateConstantExpression.h>
 #include <Interpreters/InterpreterSelectQuery.h>
+#include <Interpreters/IdentifierSemantic.h>
 #include <Interpreters/getHeaderForProcessingStage.h>
 #include <Parsers/ASTSelectQuery.h>
 #include <Parsers/ASTLiteral.h>
@@ -43,12 +44,15 @@ namespace ErrorCodes
 namespace
 {
 
-void modifySelect(ASTSelectQuery & select, const TreeRewriterResult & rewriter_result)
+TreeRewriterResult modifySelect(ASTSelectQuery & select, const TreeRewriterResult & rewriter_result, ContextPtr context)
 {
+
+    TreeRewriterResult new_rewriter_result = rewriter_result;
     if (removeJoin(select))
     {
         /// Also remove GROUP BY cause ExpressionAnalyzer would check if it has all aggregate columns but joined columns would be missed.
         select.setExpression(ASTSelectQuery::Expression::GROUP_BY, {});
+        new_rewriter_result.aggregates.clear();
 
         /// Replace select list to remove joined columns
         auto select_list = std::make_shared<ASTExpressionList>();
@@ -57,12 +61,40 @@ void modifySelect(ASTSelectQuery & select, const TreeRewriterResult & rewriter_r
 
         select.setExpression(ASTSelectQuery::Expression::SELECT, select_list);
 
-        /// TODO: keep WHERE/PREWHERE. We have to remove joined columns and their expressions but keep others.
-        select.setExpression(ASTSelectQuery::Expression::WHERE, {});
-        select.setExpression(ASTSelectQuery::Expression::PREWHERE, {});
+        const DB::IdentifierMembershipCollector membership_collector{select, context};
+
+        /// Remove unknown identifiers from where, leave only ones from left table
+        auto replace_where = [&membership_collector](ASTSelectQuery & query, ASTSelectQuery::Expression expr)
+        {
+            auto where = query.getExpression(expr, false);
+            if (!where)
+                return;
+
+            const size_t left_table_pos = 0;
+            /// Test each argument of `and` function and select ones related to only left table
+            std::shared_ptr<ASTFunction> new_conj = makeASTFunction("and");
+            for (const auto & node : collectConjunctions(where))
+            {
+                if (membership_collector.getIdentsMembership(node) == left_table_pos)
+                    new_conj->arguments->children.push_back(std::move(node));
+            }
+
+            if (new_conj->arguments->children.empty())
+                /// No identifiers from left table
+                query.setExpression(expr, {});
+            else if (new_conj->arguments->children.size() == 1)
+                /// Only one expression, lift from `and`
+                query.setExpression(expr, std::move(new_conj->arguments->children[0]));
+            else
+                /// Set new expression
+                query.setExpression(expr, std::move(new_conj));
+        };
+        replace_where(select,ASTSelectQuery::Expression::WHERE);
+        replace_where(select,ASTSelectQuery::Expression::PREWHERE);
         select.setExpression(ASTSelectQuery::Expression::HAVING, {});
         select.setExpression(ASTSelectQuery::Expression::ORDER_BY, {});
     }
+    return new_rewriter_result;
 }
 
 }
@@ -72,11 +104,11 @@ StorageMerge::StorageMerge(
     const ColumnsDescription & columns_,
     const String & source_database_,
     const Strings & source_tables_,
-    const Context & context_)
+    ContextPtr context_)
     : IStorage(table_id_)
+    , WithContext(context_->getGlobalContext())
     , source_database(source_database_)
     , source_tables(std::in_place, source_tables_.begin(), source_tables_.end())
-    , global_context(context_.getGlobalContext())
 {
     StorageInMemoryMetadata storage_metadata;
     storage_metadata.setColumns(columns_);
@@ -88,11 +120,11 @@ StorageMerge::StorageMerge(
     const ColumnsDescription & columns_,
     const String & source_database_,
     const String & source_table_regexp_,
-    const Context & context_)
+    ContextPtr context_)
     : IStorage(table_id_)
+    , WithContext(context_->getGlobalContext())
     , source_database(source_database_)
     , source_table_regexp(source_table_regexp_)
-    , global_context(context_.getGlobalContext())
 {
     StorageInMemoryMetadata storage_metadata;
     storage_metadata.setColumns(columns_);
@@ -102,7 +134,7 @@ StorageMerge::StorageMerge(
 template <typename F>
 StoragePtr StorageMerge::getFirstTable(F && predicate) const
 {
-    auto iterator = getDatabaseIterator(global_context);
+    auto iterator = getDatabaseIterator(getContext());
 
     while (iterator->isValid())
     {
@@ -124,11 +156,10 @@ bool StorageMerge::isRemote() const
 }
 
 
-bool StorageMerge::mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, const Context & query_context, const StorageMetadataPtr & /*metadata_snapshot*/) const
+bool StorageMerge::mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, ContextPtr query_context, const StorageMetadataPtr & /*metadata_snapshot*/) const
 {
     /// It's beneficial if it is true for at least one table.
-    StorageListWithLocks selected_tables = getSelectedTables(
-            query_context.getCurrentQueryId(), query_context.getSettingsRef());
+    StorageListWithLocks selected_tables = getSelectedTables(query_context);
 
     size_t i = 0;
     for (const auto & table : selected_tables)
@@ -148,10 +179,9 @@ bool StorageMerge::mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, cons
 }
 
 
-QueryProcessingStage::Enum StorageMerge::getQueryProcessingStage(const Context & context, QueryProcessingStage::Enum to_stage, SelectQueryInfo & query_info) const
+QueryProcessingStage::Enum
+StorageMerge::getQueryProcessingStage(ContextPtr local_context, QueryProcessingStage::Enum to_stage, SelectQueryInfo & query_info) const
 {
-    ASTPtr modified_query = query_info.query->clone();
-    auto & modified_select = modified_query->as<ASTSelectQuery &>();
     /// In case of JOIN the first stage (which includes JOIN)
     /// should be done on the initiator always.
     ///
@@ -159,12 +189,12 @@ QueryProcessingStage::Enum StorageMerge::getQueryProcessingStage(const Context &
     /// (see modifySelect()/removeJoin())
     ///
     /// And for this we need to return FetchColumns.
-    if (removeJoin(modified_select))
+    if (const auto * select = query_info.query->as<ASTSelectQuery>(); select && hasJoin(*select))
         return QueryProcessingStage::FetchColumns;
 
     auto stage_in_source_tables = QueryProcessingStage::FetchColumns;
 
-    DatabaseTablesIteratorPtr iterator = getDatabaseIterator(context);
+    DatabaseTablesIteratorPtr iterator = getDatabaseIterator(local_context);
 
     size_t selected_table_size = 0;
 
@@ -174,7 +204,7 @@ QueryProcessingStage::Enum StorageMerge::getQueryProcessingStage(const Context &
         if (table && table.get() != this)
         {
             ++selected_table_size;
-            stage_in_source_tables = std::max(stage_in_source_tables, table->getQueryProcessingStage(context, to_stage, query_info));
+            stage_in_source_tables = std::max(stage_in_source_tables, table->getQueryProcessingStage(local_context, to_stage, query_info));
         }
 
         iterator->next();
@@ -188,7 +218,7 @@ Pipe StorageMerge::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     const size_t max_block_size,
     unsigned num_streams)
@@ -210,17 +240,16 @@ Pipe StorageMerge::read(
     /** Just in case, turn off optimization "transfer to PREWHERE",
       * since there is no certainty that it works when one of table is MergeTree and other is not.
       */
-    auto modified_context = std::make_shared<Context>(context);
+    auto modified_context = Context::createCopy(local_context);
     modified_context->setSetting("optimize_move_to_prewhere", false);
 
     /// What will be result structure depending on query processed stage in source tables?
-    Block header = getHeaderForProcessingStage(*this, column_names, metadata_snapshot, query_info, context, processed_stage);
+    Block header = getHeaderForProcessingStage(*this, column_names, metadata_snapshot, query_info, local_context, processed_stage);
 
     /** First we make list of selected tables to find out its size.
       * This is necessary to correctly pass the recommended number of threads to each table.
       */
-    StorageListWithLocks selected_tables
-        = getSelectedTables(query_info, has_table_virtual_column, context.getCurrentQueryId(), context.getSettingsRef());
+    StorageListWithLocks selected_tables = getSelectedTables(local_context, query_info.query, has_table_virtual_column);
 
     if (selected_tables.empty())
         /// FIXME: do we support sampling in this case?
@@ -228,7 +257,8 @@ Pipe StorageMerge::read(
             {}, query_info, processed_stage, max_block_size, header, {}, real_column_names, modified_context, 0, has_table_virtual_column);
 
     size_t tables_count = selected_tables.size();
-    Float64 num_streams_multiplier = std::min(unsigned(tables_count), std::max(1U, unsigned(context.getSettingsRef().max_streams_multiplier_for_merge_tables)));
+    Float64 num_streams_multiplier
+        = std::min(unsigned(tables_count), std::max(1U, unsigned(local_context->getSettingsRef().max_streams_multiplier_for_merge_tables)));
     num_streams *= num_streams_multiplier;
     size_t remaining_streams = num_streams;
 
@@ -239,7 +269,7 @@ Pipe StorageMerge::read(
         {
             auto storage_ptr = std::get<0>(*it);
             auto storage_metadata_snapshot = storage_ptr->getInMemoryMetadataPtr();
-            auto current_info = query_info.order_optimizer->getInputOrder(storage_metadata_snapshot, context);
+            auto current_info = query_info.order_optimizer->getInputOrder(storage_metadata_snapshot, local_context);
             if (it == selected_tables.begin())
                 input_sorting_info = current_info;
             else if (!current_info || (input_sorting_info && *current_info != *input_sorting_info))
@@ -293,7 +323,7 @@ Pipe StorageMerge::createSources(
     const Block & header,
     const StorageWithLockAndName & storage_with_lock,
     Names & real_column_names,
-    const std::shared_ptr<Context> & modified_context,
+    ContextPtr modified_context,
     size_t streams_num,
     bool has_table_virtual_column,
     bool concat_streams)
@@ -304,7 +334,8 @@ Pipe StorageMerge::createSources(
 
     /// Original query could contain JOIN but we need only the first joined table and its columns.
     auto & modified_select = modified_query_info.query->as<ASTSelectQuery &>();
-    modifySelect(modified_select, *query_info.syntax_analyzer_result);
+    auto new_analyzer_res = modifySelect(modified_select, *query_info.syntax_analyzer_result, modified_context);
+    modified_query_info.syntax_analyzer_result = std::make_shared<TreeRewriterResult>(std::move(new_analyzer_res));
 
     VirtualColumnUtils::rewriteEntityInAst(modified_query_info.query, "_table", table_name);
 
@@ -313,7 +344,7 @@ Pipe StorageMerge::createSources(
     if (!storage)
     {
         pipe = QueryPipeline::getPipe(InterpreterSelectQuery(
-            modified_query_info.query, *modified_context,
+            modified_query_info.query, modified_context,
             std::make_shared<OneBlockInputStream>(header),
             SelectQueryOptions(processed_stage).analyze()).execute().pipeline);
 
@@ -321,15 +352,21 @@ Pipe StorageMerge::createSources(
         return pipe;
     }
 
-    auto storage_stage = storage->getQueryProcessingStage(*modified_context, QueryProcessingStage::Complete, modified_query_info);
+    auto storage_stage = storage->getQueryProcessingStage(modified_context, QueryProcessingStage::Complete, modified_query_info);
     if (processed_stage <= storage_stage)
     {
         /// If there are only virtual columns in query, you must request at least one other column.
         if (real_column_names.empty())
             real_column_names.push_back(ExpressionActions::getSmallestColumn(metadata_snapshot->getColumns().getAllPhysical()));
 
-
-        pipe = storage->read(real_column_names, metadata_snapshot, modified_query_info, *modified_context, processed_stage, max_block_size, UInt32(streams_num));
+        pipe = storage->read(
+            real_column_names,
+            metadata_snapshot,
+            modified_query_info,
+            modified_context,
+            processed_stage,
+            max_block_size,
+            UInt32(streams_num));
     }
     else if (processed_stage > storage_stage)
     {
@@ -339,7 +376,7 @@ Pipe StorageMerge::createSources(
         modified_context->setSetting("max_threads", streams_num);
         modified_context->setSetting("max_streams_to_max_threads_ratio", 1);
 
-        InterpreterSelectQuery interpreter{modified_query_info.query, *modified_context, SelectQueryOptions(processed_stage)};
+        InterpreterSelectQuery interpreter{modified_query_info.query, modified_context, SelectQueryOptions(processed_stage)};
 
 
         pipe = QueryPipeline::getPipe(interpreter.execute().pipeline);
@@ -368,7 +405,7 @@ Pipe StorageMerge::createSources(
             auto adding_column_dag = ActionsDAG::makeAddingColumnActions(std::move(column));
             auto adding_column_actions = std::make_shared<ExpressionActions>(
                 std::move(adding_column_dag),
-                ExpressionActionsSettings::fromContext(*modified_context));
+                ExpressionActionsSettings::fromContext(modified_context));
 
             pipe.addSimpleTransform([&](const Block & stream_header)
             {
@@ -378,7 +415,7 @@ Pipe StorageMerge::createSources(
 
         /// Subordinary tables could have different but convertible types, like numeric types of different width.
         /// We must return streams with structure equals to structure of Merge table.
-        convertingSourceStream(header, metadata_snapshot, *modified_context, modified_query_info.query, pipe, processed_stage);
+        convertingSourceStream(header, metadata_snapshot, modified_context, modified_query_info.query, pipe, processed_stage);
 
         pipe.addTableLock(struct_lock);
         pipe.addStorageHolder(storage);
@@ -388,34 +425,20 @@ Pipe StorageMerge::createSources(
     return pipe;
 }
 
-
-StorageMerge::StorageListWithLocks StorageMerge::getSelectedTables(const String & query_id, const Settings & settings) const
-{
-    StorageListWithLocks selected_tables;
-    auto iterator = getDatabaseIterator(global_context);
-
-    while (iterator->isValid())
-    {
-        const auto & table = iterator->table();
-        if (table && table.get() != this)
-            selected_tables.emplace_back(
-                    table, table->lockForShare(query_id, settings.lock_acquire_timeout), iterator->name());
-
-        iterator->next();
-    }
-
-    return selected_tables;
-}
-
-
 StorageMerge::StorageListWithLocks StorageMerge::getSelectedTables(
-        const SelectQueryInfo & query_info, bool has_virtual_column, const String & query_id, const Settings & settings) const
+        ContextPtr query_context,
+        const ASTPtr & query /* = nullptr */,
+        bool filter_by_virtual_column /* = false */) const
 {
-    const ASTPtr & query = query_info.query;
-    StorageListWithLocks selected_tables;
-    DatabaseTablesIteratorPtr iterator = getDatabaseIterator(global_context);
+    assert(!filter_by_virtual_column || query);
 
-    auto virtual_column = ColumnString::create();
+    const Settings & settings = query_context->getSettingsRef();
+    StorageListWithLocks selected_tables;
+    DatabaseTablesIteratorPtr iterator = getDatabaseIterator(getContext());
+
+    MutableColumnPtr table_name_virtual_column;
+    if (filter_by_virtual_column)
+        table_name_virtual_column = ColumnString::create();
 
     while (iterator->isValid())
     {
@@ -428,18 +451,20 @@ StorageMerge::StorageListWithLocks StorageMerge::getSelectedTables(
 
         if (storage.get() != this)
         {
-            selected_tables.emplace_back(
-                    storage, storage->lockForShare(query_id, settings.lock_acquire_timeout), iterator->name());
-            virtual_column->insert(iterator->name());
+            auto table_lock = storage->lockForShare(query_context->getCurrentQueryId(), settings.lock_acquire_timeout);
+            selected_tables.emplace_back(storage, std::move(table_lock), iterator->name());
+            if (filter_by_virtual_column)
+                table_name_virtual_column->insert(iterator->name());
         }
 
         iterator->next();
     }
 
-    if (has_virtual_column)
+    if (filter_by_virtual_column)
     {
-        Block virtual_columns_block = Block{ColumnWithTypeAndName(std::move(virtual_column), std::make_shared<DataTypeString>(), "_table")};
-        VirtualColumnUtils::filterBlockWithQuery(query_info.query, virtual_columns_block, global_context);
+        /// Filter names of selected tables if there is a condition on "_table" virtual column in WHERE clause
+        Block virtual_columns_block = Block{ColumnWithTypeAndName(std::move(table_name_virtual_column), std::make_shared<DataTypeString>(), "_table")};
+        VirtualColumnUtils::filterBlockWithQuery(query, virtual_columns_block, query_context);
         auto values = VirtualColumnUtils::extractSingleValueFromBlock<String>(virtual_columns_block, "_table");
 
         /// Remove unused tables from the list
@@ -449,8 +474,7 @@ StorageMerge::StorageListWithLocks StorageMerge::getSelectedTables(
     return selected_tables;
 }
 
-
-DatabaseTablesIteratorPtr StorageMerge::getDatabaseIterator(const Context & context) const
+DatabaseTablesIteratorPtr StorageMerge::getDatabaseIterator(ContextPtr local_context) const
 {
     try
     {
@@ -472,13 +496,13 @@ DatabaseTablesIteratorPtr StorageMerge::getDatabaseIterator(const Context & cont
             return source_table_regexp->match(table_name_);
     };
 
-    return database->getTablesIterator(context, table_name_match);
+    return database->getTablesIterator(local_context, table_name_match);
 }
 
 
-void StorageMerge::checkAlterIsPossible(const AlterCommands & commands, const Context & context) const
+void StorageMerge::checkAlterIsPossible(const AlterCommands & commands, ContextPtr local_context) const
 {
-    auto name_deps = getDependentViewsByColumn(context);
+    auto name_deps = getDependentViewsByColumn(local_context);
     for (const auto & command : commands)
     {
         if (command.type != AlterCommand::Type::ADD_COLUMN && command.type != AlterCommand::Type::MODIFY_COLUMN
@@ -501,20 +525,20 @@ void StorageMerge::checkAlterIsPossible(const AlterCommands & commands, const Co
 }
 
 void StorageMerge::alter(
-    const AlterCommands & params, const Context & context, TableLockHolder &)
+    const AlterCommands & params, ContextPtr local_context, TableLockHolder &)
 {
     auto table_id = getStorageID();
 
     StorageInMemoryMetadata storage_metadata = getInMemoryMetadata();
-    params.apply(storage_metadata, context);
-    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id, storage_metadata);
+    params.apply(storage_metadata, local_context);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(local_context, table_id, storage_metadata);
     setInMemoryMetadata(storage_metadata);
 }
 
 void StorageMerge::convertingSourceStream(
     const Block & header,
     const StorageMetadataPtr & metadata_snapshot,
-    const Context & context,
+    ContextPtr local_context,
     ASTPtr & query,
     Pipe & pipe,
     QueryProcessingStage::Enum processed_stage)
@@ -525,7 +549,7 @@ void StorageMerge::convertingSourceStream(
             pipe.getHeader().getColumnsWithTypeAndName(),
             header.getColumnsWithTypeAndName(),
             ActionsDAG::MatchColumnsMode::Name);
-    auto convert_actions = std::make_shared<ExpressionActions>(convert_actions_dag, ExpressionActionsSettings::fromContext(context));
+    auto convert_actions = std::make_shared<ExpressionActions>(convert_actions_dag, ExpressionActionsSettings::fromContext(local_context));
 
     pipe.addSimpleTransform([&](const Block & stream_header)
     {
@@ -549,8 +573,8 @@ void StorageMerge::convertingSourceStream(
             NamesAndTypesList source_columns = metadata_snapshot->getSampleBlock().getNamesAndTypesList();
             auto virtual_column = *getVirtuals().tryGetByName("_table");
             source_columns.emplace_back(NameAndTypePair{virtual_column.name, virtual_column.type});
-            auto syntax_result = TreeRewriter(context).analyze(where_expression, source_columns);
-            ExpressionActionsPtr actions = ExpressionAnalyzer{where_expression, syntax_result, context}.getActions(false, false);
+            auto syntax_result = TreeRewriter(local_context).analyze(where_expression, source_columns);
+            ExpressionActionsPtr actions = ExpressionAnalyzer{where_expression, syntax_result, local_context}.getActions(false, false);
             Names required_columns = actions->getRequiredColumns();
 
             for (const auto & required_column : required_columns)
@@ -587,15 +611,15 @@ void registerStorageMerge(StorageFactory & factory)
                 " - name of source database and regexp for table names.",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        engine_args[0] = evaluateConstantExpressionForDatabaseName(engine_args[0], args.local_context);
-        engine_args[1] = evaluateConstantExpressionAsLiteral(engine_args[1], args.local_context);
+        engine_args[0] = evaluateConstantExpressionForDatabaseName(engine_args[0], args.getLocalContext());
+        engine_args[1] = evaluateConstantExpressionAsLiteral(engine_args[1], args.getLocalContext());
 
         String source_database = engine_args[0]->as<ASTLiteral &>().value.safeGet<String>();
         String table_name_regexp = engine_args[1]->as<ASTLiteral &>().value.safeGet<String>();
 
         return StorageMerge::create(
             args.table_id, args.columns,
-            source_database, table_name_regexp, args.context);
+            source_database, table_name_regexp, args.getContext());
     });
 }
 
diff --git a/src/Storages/StorageMerge.h b/src/Storages/StorageMerge.h
index ea8667aa186..ff016952686 100644
--- a/src/Storages/StorageMerge.h
+++ b/src/Storages/StorageMerge.h
@@ -12,7 +12,7 @@ namespace DB
 /** A table that represents the union of an arbitrary number of other tables.
   * All tables must have the same structure.
   */
-class StorageMerge final : public ext::shared_ptr_helper<StorageMerge>, public IStorage
+class StorageMerge final : public ext::shared_ptr_helper<StorageMerge>, public IStorage, WithContext
 {
     friend struct ext::shared_ptr_helper<StorageMerge>;
 public:
@@ -27,44 +27,41 @@ public:
     bool supportsIndexForIn() const override { return true; }
     bool supportsSubcolumns() const override { return true; }
 
-    QueryProcessingStage::Enum getQueryProcessingStage(const Context &, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const override;
+    QueryProcessingStage::Enum getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum /*to_stage*/, SelectQueryInfo &) const override;
 
     Pipe read(
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
-    void checkAlterIsPossible(const AlterCommands & commands, const Context & context) const override;
+    void checkAlterIsPossible(const AlterCommands & commands, ContextPtr context) const override;
 
     /// you need to add and remove columns in the sub-tables manually
     /// the structure of sub-tables is not checked
-    void alter(const AlterCommands & params, const Context & context, TableLockHolder & table_lock_holder) override;
+    void alter(const AlterCommands & params, ContextPtr context, TableLockHolder & table_lock_holder) override;
 
     bool mayBenefitFromIndexForIn(
-        const ASTPtr & left_in_operand, const Context & query_context, const StorageMetadataPtr & metadata_snapshot) const override;
+        const ASTPtr & left_in_operand, ContextPtr query_context, const StorageMetadataPtr & metadata_snapshot) const override;
 
 private:
     String source_database;
     std::optional<std::unordered_set<String>> source_tables;
     std::optional<OptimizedRegularExpression> source_table_regexp;
-    const Context & global_context;
 
     using StorageWithLockAndName = std::tuple<StoragePtr, TableLockHolder, String>;
     using StorageListWithLocks = std::list<StorageWithLockAndName>;
 
-    StorageListWithLocks getSelectedTables(const String & query_id, const Settings & settings) const;
-
     StorageMerge::StorageListWithLocks getSelectedTables(
-        const SelectQueryInfo & query_info, bool has_virtual_column, const String & query_id, const Settings & settings) const;
+            ContextPtr query_context, const ASTPtr & query = nullptr, bool filter_by_virtual_column = false) const;
 
     template <typename F>
     StoragePtr getFirstTable(F && predicate) const;
 
-    DatabaseTablesIteratorPtr getDatabaseIterator(const Context & context) const;
+    DatabaseTablesIteratorPtr getDatabaseIterator(ContextPtr context) const;
 
     NamesAndTypesList getVirtuals() const override;
     ColumnSizeByName getColumnSizes() const override;
@@ -75,31 +72,31 @@ protected:
         const ColumnsDescription & columns_,
         const String & source_database_,
         const Strings & source_tables_,
-        const Context & context_);
+        ContextPtr context_);
 
     StorageMerge(
         const StorageID & table_id_,
         const ColumnsDescription & columns_,
         const String & source_database_,
         const String & source_table_regexp_,
-        const Context & context_);
+        ContextPtr context_);
 
     Pipe createSources(
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
         const QueryProcessingStage::Enum & processed_stage,
-        const UInt64 max_block_size,
+        UInt64 max_block_size,
         const Block & header,
         const StorageWithLockAndName & storage_with_lock,
         Names & real_column_names,
-        const std::shared_ptr<Context> & modified_context,
+        ContextPtr modified_context,
         size_t streams_num,
         bool has_table_virtual_column,
         bool concat_streams = false);
 
     void convertingSourceStream(
         const Block & header, const StorageMetadataPtr & metadata_snapshot,
-        const Context & context, ASTPtr & query,
+        ContextPtr context, ASTPtr & query,
         Pipe & pipe, QueryProcessingStage::Enum processed_stage);
 };
 
diff --git a/src/Storages/StorageMergeTree.cpp b/src/Storages/StorageMergeTree.cpp
index 10790057ac9..4d7f7d8c887 100644
--- a/src/Storages/StorageMergeTree.cpp
+++ b/src/Storages/StorageMergeTree.cpp
@@ -63,7 +63,7 @@ StorageMergeTree::StorageMergeTree(
     const String & relative_data_path_,
     const StorageInMemoryMetadata & metadata_,
     bool attach,
-    Context & context_,
+    ContextPtr context_,
     const String & date_column_name,
     const MergingParams & merging_params_,
     std::unique_ptr<MergeTreeSettings> storage_settings_,
@@ -80,9 +80,9 @@ StorageMergeTree::StorageMergeTree(
         attach)
     , reader(*this)
     , writer(*this)
-    , merger_mutator(*this, global_context.getSettingsRef().background_pool_size)
-    , background_executor(*this, global_context)
-    , background_moves_executor(*this, global_context)
+    , merger_mutator(*this, getContext()->getSettingsRef().background_pool_size)
+    , background_executor(*this, getContext())
+    , background_moves_executor(*this, getContext())
 
 {
     loadDataParts(has_force_restore_data_flag);
@@ -93,6 +93,8 @@ StorageMergeTree::StorageMergeTree(
     increment.set(getMaxBlockNumber());
 
     loadMutations();
+
+    loadDeduplicationLog();
 }
 
 
@@ -180,12 +182,12 @@ void StorageMergeTree::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size,
     unsigned num_streams)
 {
-    if (auto plan = reader.read(column_names, metadata_snapshot, query_info, context, max_block_size, num_streams))
+    if (auto plan = reader.read(column_names, metadata_snapshot, query_info, local_context, max_block_size, num_streams))
         query_plan = std::move(*plan);
 }
 
@@ -193,16 +195,16 @@ Pipe StorageMergeTree::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     const size_t max_block_size,
     const unsigned num_streams)
 {
     QueryPlan plan;
-    read(plan, column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams);
+    read(plan, column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams);
     return plan.convertToPipe(
-        QueryPlanOptimizationSettings::fromContext(context),
-        BuildQueryPipelineSettings::fromContext(context));
+        QueryPlanOptimizationSettings::fromContext(local_context),
+        BuildQueryPipelineSettings::fromContext(local_context));
 }
 
 std::optional<UInt64> StorageMergeTree::totalRows(const Settings &) const
@@ -210,10 +212,10 @@ std::optional<UInt64> StorageMergeTree::totalRows(const Settings &) const
     return getTotalActiveSizeInRows();
 }
 
-std::optional<UInt64> StorageMergeTree::totalRowsByPartitionPredicate(const SelectQueryInfo & query_info, const Context & context) const
+std::optional<UInt64> StorageMergeTree::totalRowsByPartitionPredicate(const SelectQueryInfo & query_info, ContextPtr local_context) const
 {
     auto parts = getDataPartsVector({DataPartState::Committed});
-    return totalRowsByPartitionPredicateImpl(query_info, context, parts);
+    return totalRowsByPartitionPredicateImpl(query_info, local_context, parts);
 }
 
 std::optional<UInt64> StorageMergeTree::totalBytes(const Settings &) const
@@ -221,18 +223,18 @@ std::optional<UInt64> StorageMergeTree::totalBytes(const Settings &) const
     return getTotalActiveSizeInBytes();
 }
 
-BlockOutputStreamPtr StorageMergeTree::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr
+StorageMergeTree::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr local_context)
 {
-
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = local_context->getSettingsRef();
     return std::make_shared<MergeTreeBlockOutputStream>(
-        *this, metadata_snapshot, settings.max_partitions_per_insert_block, context.getSettingsRef().optimize_on_insert);
+        *this, metadata_snapshot, settings.max_partitions_per_insert_block, local_context->getSettingsRef().optimize_on_insert);
 }
 
 void StorageMergeTree::checkTableCanBeDropped() const
 {
     auto table_id = getStorageID();
-    global_context.checkTableCanBeDropped(table_id.database_name, table_id.table_name, getTotalActiveSizeInBytes());
+    getContext()->checkTableCanBeDropped(table_id.database_name, table_id.table_name, getTotalActiveSizeInBytes());
 }
 
 void StorageMergeTree::drop()
@@ -241,7 +243,7 @@ void StorageMergeTree::drop()
     dropAllData();
 }
 
-void StorageMergeTree::truncate(const ASTPtr &, const StorageMetadataPtr &, const Context &, TableExclusiveLockHolder &)
+void StorageMergeTree::truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr, TableExclusiveLockHolder &)
 {
     {
         /// Asks to complete merges and does not allow them to start.
@@ -261,24 +263,25 @@ void StorageMergeTree::truncate(const ASTPtr &, const StorageMetadataPtr &, cons
 
 void StorageMergeTree::alter(
     const AlterCommands & commands,
-    const Context & context,
+    ContextPtr local_context,
     TableLockHolder & table_lock_holder)
 {
     auto table_id = getStorageID();
+    auto old_storage_settings = getSettings();
 
     StorageInMemoryMetadata new_metadata = getInMemoryMetadata();
     StorageInMemoryMetadata old_metadata = getInMemoryMetadata();
-    auto maybe_mutation_commands = commands.getMutationCommands(new_metadata, context.getSettingsRef().materialize_ttl_after_modify, context);
+    auto maybe_mutation_commands = commands.getMutationCommands(new_metadata, local_context->getSettingsRef().materialize_ttl_after_modify, local_context);
     String mutation_file_name;
     Int64 mutation_version = -1;
-    commands.apply(new_metadata, context);
+    commands.apply(new_metadata, local_context);
 
     /// This alter can be performed at new_metadata level only
     if (commands.isSettingsAlter())
     {
         changeSettings(new_metadata.settings_changes, table_lock_holder);
 
-        DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id, new_metadata);
+        DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(local_context, table_id, new_metadata);
     }
     else
     {
@@ -288,7 +291,7 @@ void StorageMergeTree::alter(
             /// Reinitialize primary key because primary key column types might have changed.
             setProperties(new_metadata, old_metadata);
 
-            DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id, new_metadata);
+            DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(local_context, table_id, new_metadata);
 
             if (!maybe_mutation_commands.empty())
                 mutation_version = startMutation(maybe_mutation_commands, mutation_file_name);
@@ -299,6 +302,21 @@ void StorageMergeTree::alter(
         if (!maybe_mutation_commands.empty())
             waitForMutation(mutation_version, mutation_file_name);
     }
+
+    {
+        /// Some additional changes in settings
+        auto new_storage_settings = getSettings();
+
+        if (old_storage_settings->non_replicated_deduplication_window != new_storage_settings->non_replicated_deduplication_window)
+        {
+            /// We cannot place this check into settings sanityCheck because it depends on format_version.
+            /// sanityCheck must work event without storage.
+            if (new_storage_settings->non_replicated_deduplication_window != 0 && format_version < MERGE_TREE_DATA_MIN_FORMAT_VERSION_WITH_CUSTOM_PARTITIONING)
+                throw Exception("Deduplication for non-replicated MergeTree in old syntax is not supported", ErrorCodes::BAD_ARGUMENTS);
+
+            deduplication_log->setDeduplicationWindowSize(new_storage_settings->non_replicated_deduplication_window);
+        }
+    }
 }
 
 
@@ -461,12 +479,12 @@ void StorageMergeTree::waitForMutation(Int64 version, const String & file_name)
     LOG_INFO(log, "Mutation {} done", file_name);
 }
 
-void StorageMergeTree::mutate(const MutationCommands & commands, const Context & query_context)
+void StorageMergeTree::mutate(const MutationCommands & commands, ContextPtr query_context)
 {
     String mutation_file_name;
     Int64 version = startMutation(commands, mutation_file_name);
 
-    if (query_context.getSettingsRef().mutations_sync > 0)
+    if (query_context->getSettingsRef().mutations_sync > 0)
         waitForMutation(version, mutation_file_name);
 }
 
@@ -600,7 +618,7 @@ CancellationCode StorageMergeTree::killMutation(const String & mutation_id)
     if (!to_kill)
         return CancellationCode::NotFound;
 
-    global_context.getMergeList().cancelPartMutations({}, to_kill->block_number);
+    getContext()->getMergeList().cancelPartMutations({}, to_kill->block_number);
     to_kill->removeFile();
     LOG_TRACE(log, "Cancelled part mutations and removed mutation file {}", mutation_id);
     {
@@ -614,6 +632,16 @@ CancellationCode StorageMergeTree::killMutation(const String & mutation_id)
     return CancellationCode::CancelSent;
 }
 
+void StorageMergeTree::loadDeduplicationLog()
+{
+    auto settings = getSettings();
+    if (settings->non_replicated_deduplication_window != 0 && format_version < MERGE_TREE_DATA_MIN_FORMAT_VERSION_WITH_CUSTOM_PARTITIONING)
+        throw Exception("Deduplication for non-replicated MergeTree in old syntax is not supported", ErrorCodes::BAD_ARGUMENTS);
+
+    std::string path = getDataPaths()[0] + "/deduplication_logs";
+    deduplication_log = std::make_unique<MergeTreeDeduplicationLog>(path, settings->non_replicated_deduplication_window, format_version);
+    deduplication_log->load();
+}
 
 void StorageMergeTree::loadMutations()
 {
@@ -740,7 +768,7 @@ std::shared_ptr<StorageMergeTree::MergeMutateSelectedEntry> StorageMergeTree::se
 
     /// Account TTL merge here to avoid exceeding the max_number_of_merges_with_ttl_in_pool limit
     if (isTTLMergeType(future_part.merge_type))
-        global_context.getMergeList().bookMergeWithTTL();
+        getContext()->getMergeList().bookMergeWithTTL();
 
     merging_tagger = std::make_unique<CurrentlyMergingPartsTagger>(future_part, MergeTreeDataMergerMutator::estimateNeededDiskSpace(future_part.parts), *this, metadata_snapshot, false);
     return std::make_shared<MergeMutateSelectedEntry>(future_part, std::move(merging_tagger), MutationCommands{});
@@ -784,7 +812,7 @@ bool StorageMergeTree::mergeSelectedParts(
     MutableDataPartPtr new_part;
     auto table_id = getStorageID();
 
-    auto merge_list_entry = global_context.getMergeList().insert(table_id.database_name, table_id.table_name, future_part);
+    auto merge_list_entry = getContext()->getMergeList().insert(table_id.database_name, table_id.table_name, future_part);
 
     auto write_part_log = [&] (const ExecutionStatus & execution_status)
     {
@@ -802,7 +830,7 @@ bool StorageMergeTree::mergeSelectedParts(
     {
         new_part = merger_mutator.mergePartsToTemporaryPart(
             future_part, metadata_snapshot, *(merge_list_entry), table_lock_holder, time(nullptr),
-            global_context, merge_mutate_entry.tagger->reserved_space, deduplicate, deduplicate_by_columns);
+            getContext(), merge_mutate_entry.tagger->reserved_space, deduplicate, deduplicate_by_columns);
 
         merger_mutator.renameMergedTemporaryPart(new_part, future_part.parts, nullptr);
         write_part_log({});
@@ -826,7 +854,7 @@ std::shared_ptr<StorageMergeTree::MergeMutateSelectedEntry> StorageMergeTree::se
     const StorageMetadataPtr & metadata_snapshot, String * /* disable_reason */, TableLockHolder & /* table_lock_holder */)
 {
     std::lock_guard lock(currently_processing_in_background_mutex);
-    size_t max_ast_elements = global_context.getSettingsRef().max_expanded_ast_elements;
+    size_t max_ast_elements = getContext()->getSettingsRef().max_expanded_ast_elements;
 
     FutureMergedMutatedPart future_part;
     if (storage_settings.get()->assign_part_uuids)
@@ -881,7 +909,7 @@ std::shared_ptr<StorageMergeTree::MergeMutateSelectedEntry> StorageMergeTree::se
             if (!commands_for_size_validation.empty())
             {
                 MutationsInterpreter interpreter(
-                    shared_from_this(), metadata_snapshot, commands_for_size_validation, global_context, false);
+                    shared_from_this(), metadata_snapshot, commands_for_size_validation, getContext(), false);
                 commands_size += interpreter.evaluateCommandsSize();
             }
 
@@ -911,7 +939,7 @@ bool StorageMergeTree::mutateSelectedPart(const StorageMetadataPtr & metadata_sn
     auto & future_part = merge_mutate_entry.future_part;
     auto table_id = getStorageID();
 
-    auto merge_list_entry = global_context.getMergeList().insert(table_id.database_name, table_id.table_name, future_part);
+    auto merge_list_entry = getContext()->getMergeList().insert(table_id.database_name, table_id.table_name, future_part);
     Stopwatch stopwatch;
     MutableDataPartPtr new_part;
 
@@ -931,7 +959,7 @@ bool StorageMergeTree::mutateSelectedPart(const StorageMetadataPtr & metadata_sn
     {
         new_part = merger_mutator.mutatePartToTemporaryPart(
             future_part, metadata_snapshot, merge_mutate_entry.commands, *(merge_list_entry),
-            time(nullptr), global_context, merge_mutate_entry.tagger->reserved_space, table_lock_holder);
+            time(nullptr), getContext(), merge_mutate_entry.tagger->reserved_space, table_lock_holder);
 
         renameTempPartAndReplace(new_part);
 
@@ -1056,7 +1084,7 @@ bool StorageMergeTree::optimize(
     bool final,
     bool deduplicate,
     const Names & deduplicate_by_columns,
-    const Context & context)
+    ContextPtr local_context)
 {
     if (deduplicate)
     {
@@ -1077,14 +1105,21 @@ bool StorageMergeTree::optimize(
 
         for (const String & partition_id : partition_ids)
         {
-            if (!merge(true, partition_id, true, deduplicate, deduplicate_by_columns, &disable_reason, context.getSettingsRef().optimize_skip_merged_partitions))
+            if (!merge(
+                    true,
+                    partition_id,
+                    true,
+                    deduplicate,
+                    deduplicate_by_columns,
+                    &disable_reason,
+                    local_context->getSettingsRef().optimize_skip_merged_partitions))
             {
                 constexpr const char * message = "Cannot OPTIMIZE table: {}";
                 if (disable_reason.empty())
                     disable_reason = "unknown reason";
                 LOG_INFO(log, message, disable_reason);
 
-                if (context.getSettingsRef().optimize_throw_if_noop)
+                if (local_context->getSettingsRef().optimize_throw_if_noop)
                     throw Exception(ErrorCodes::CANNOT_ASSIGN_OPTIMIZE, message, disable_reason);
                 return false;
             }
@@ -1094,16 +1129,23 @@ bool StorageMergeTree::optimize(
     {
         String partition_id;
         if (partition)
-            partition_id = getPartitionIDFromQuery(partition, context);
+            partition_id = getPartitionIDFromQuery(partition, local_context);
 
-        if (!merge(true, partition_id, final, deduplicate, deduplicate_by_columns, &disable_reason, context.getSettingsRef().optimize_skip_merged_partitions))
+        if (!merge(
+                true,
+                partition_id,
+                final,
+                deduplicate,
+                deduplicate_by_columns,
+                &disable_reason,
+                local_context->getSettingsRef().optimize_skip_merged_partitions))
         {
             constexpr const char * message = "Cannot OPTIMIZE table: {}";
             if (disable_reason.empty())
                 disable_reason = "unknown reason";
             LOG_INFO(log, message, disable_reason);
 
-            if (context.getSettingsRef().optimize_throw_if_noop)
+            if (local_context->getSettingsRef().optimize_throw_if_noop)
                 throw Exception(ErrorCodes::CANNOT_ASSIGN_OPTIMIZE, message, disable_reason);
             return false;
         }
@@ -1171,7 +1213,7 @@ MergeTreeDataPartPtr StorageMergeTree::outdatePart(const String & part_name, boo
     }
 }
 
-void StorageMergeTree::dropPartition(const ASTPtr & partition, bool detach, bool drop_part, const Context & context, bool throw_if_noop)
+void StorageMergeTree::dropPartition(const ASTPtr & partition, bool detach, bool drop_part, ContextPtr local_context, bool throw_if_noop)
 {
     {
         MergeTreeData::DataPartsVector parts_to_remove;
@@ -1191,7 +1233,7 @@ void StorageMergeTree::dropPartition(const ASTPtr & partition, bool detach, bool
             /// Asks to complete merges and does not allow them to start.
             /// This protects against "revival" of data for a removed partition after completion of merge.
             auto merge_blocker = stopMergesAndWait();
-            String partition_id = getPartitionIDFromQuery(partition, context);
+            String partition_id = getPartitionIDFromQuery(partition, local_context);
             parts_to_remove = getDataPartsVectorInPartition(MergeTreeDataPartState::Committed, partition_id);
 
             /// TODO should we throw an exception if parts_to_remove is empty?
@@ -1209,6 +1251,12 @@ void StorageMergeTree::dropPartition(const ASTPtr & partition, bool detach, bool
             }
         }
 
+        if (deduplication_log)
+        {
+            for (const auto & part : parts_to_remove)
+                deduplication_log->dropPart(part->info);
+        }
+
         if (detach)
             LOG_INFO(log, "Detached {} parts.", parts_to_remove.size());
         else
@@ -1221,11 +1269,11 @@ void StorageMergeTree::dropPartition(const ASTPtr & partition, bool detach, bool
 
 PartitionCommandsResultInfo StorageMergeTree::attachPartition(
     const ASTPtr & partition, const StorageMetadataPtr & /* metadata_snapshot */,
-    bool attach_part, const Context & context)
+    bool attach_part, ContextPtr local_context)
 {
     PartitionCommandsResultInfo results;
     PartsTemporaryRename renamed_parts(*this, "detached/");
-    MutableDataPartsVector loaded_parts = tryLoadPartsToAttach(partition, attach_part, context, renamed_parts);
+    MutableDataPartsVector loaded_parts = tryLoadPartsToAttach(partition, attach_part, local_context, renamed_parts);
 
     for (size_t i = 0; i < loaded_parts.size(); ++i)
     {
@@ -1244,20 +1292,20 @@ PartitionCommandsResultInfo StorageMergeTree::attachPartition(
     }
 
     /// New parts with other data may appear in place of deleted parts.
-    context.dropCaches();
+    local_context->dropCaches();
     return results;
 }
 
-void StorageMergeTree::replacePartitionFrom(const StoragePtr & source_table, const ASTPtr & partition, bool replace, const Context & context)
+void StorageMergeTree::replacePartitionFrom(const StoragePtr & source_table, const ASTPtr & partition, bool replace, ContextPtr local_context)
 {
-    auto lock1 = lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
-    auto lock2 = source_table->lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+    auto lock1 = lockForShare(local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout);
+    auto lock2 = source_table->lockForShare(local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout);
     auto source_metadata_snapshot = source_table->getInMemoryMetadataPtr();
     auto my_metadata_snapshot = getInMemoryMetadataPtr();
 
     Stopwatch watch;
     MergeTreeData & src_data = checkStructureAndGetMergeTreeData(source_table, source_metadata_snapshot, my_metadata_snapshot);
-    String partition_id = getPartitionIDFromQuery(partition, context);
+    String partition_id = getPartitionIDFromQuery(partition, local_context);
 
     DataPartsVector src_parts = src_data.getDataPartsVectorInPartition(MergeTreeDataPartState::Committed, partition_id);
     MutableDataPartsVector dst_parts;
@@ -1312,19 +1360,19 @@ void StorageMergeTree::replacePartitionFrom(const StoragePtr & source_table, con
                 removePartsInRangeFromWorkingSet(drop_range, true, false, data_parts_lock);
         }
 
-        PartLog::addNewParts(global_context, dst_parts, watch.elapsed());
+        PartLog::addNewParts(getContext(), dst_parts, watch.elapsed());
     }
     catch (...)
     {
-        PartLog::addNewParts(global_context, dst_parts, watch.elapsed(), ExecutionStatus::fromCurrentException());
+        PartLog::addNewParts(getContext(), dst_parts, watch.elapsed(), ExecutionStatus::fromCurrentException());
         throw;
     }
 }
 
-void StorageMergeTree::movePartitionToTable(const StoragePtr & dest_table, const ASTPtr & partition, const Context & context)
+void StorageMergeTree::movePartitionToTable(const StoragePtr & dest_table, const ASTPtr & partition, ContextPtr local_context)
 {
-    auto lock1 = lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
-    auto lock2 = dest_table->lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+    auto lock1 = lockForShare(local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout);
+    auto lock2 = dest_table->lockForShare(local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout);
 
     auto dest_table_storage = std::dynamic_pointer_cast<StorageMergeTree>(dest_table);
     if (!dest_table_storage)
@@ -1341,7 +1389,7 @@ void StorageMergeTree::movePartitionToTable(const StoragePtr & dest_table, const
     Stopwatch watch;
 
     MergeTreeData & src_data = dest_table_storage->checkStructureAndGetMergeTreeData(*this, metadata_snapshot, dest_metadata_snapshot);
-    String partition_id = getPartitionIDFromQuery(partition, context);
+    String partition_id = getPartitionIDFromQuery(partition, local_context);
 
     DataPartsVector src_parts = src_data.getDataPartsVectorInPartition(MergeTreeDataPartState::Committed, partition_id);
     MutableDataPartsVector dst_parts;
@@ -1388,11 +1436,11 @@ void StorageMergeTree::movePartitionToTable(const StoragePtr & dest_table, const
         clearOldMutations(true);
         clearOldPartsFromFilesystem();
 
-        PartLog::addNewParts(global_context, dst_parts, watch.elapsed());
+        PartLog::addNewParts(getContext(), dst_parts, watch.elapsed());
     }
     catch (...)
     {
-        PartLog::addNewParts(global_context, dst_parts, watch.elapsed(), ExecutionStatus::fromCurrentException());
+        PartLog::addNewParts(getContext(), dst_parts, watch.elapsed(), ExecutionStatus::fromCurrentException());
         throw;
     }
 }
@@ -1417,13 +1465,13 @@ void StorageMergeTree::onActionLockRemove(StorageActionBlockType action_type)
         background_moves_executor.triggerTask();
 }
 
-CheckResults StorageMergeTree::checkData(const ASTPtr & query, const Context & context)
+CheckResults StorageMergeTree::checkData(const ASTPtr & query, ContextPtr local_context)
 {
     CheckResults results;
     DataPartsVector data_parts;
     if (const auto & check_query = query->as<ASTCheckQuery &>(); check_query.partition)
     {
-        String partition_id = getPartitionIDFromQuery(check_query.partition, context);
+        String partition_id = getPartitionIDFromQuery(check_query.partition, local_context);
         data_parts = getDataPartsVectorInPartition(MergeTreeDataPartState::Committed, partition_id);
     }
     else
diff --git a/src/Storages/StorageMergeTree.h b/src/Storages/StorageMergeTree.h
index 246ce151a02..2a50cb33912 100644
--- a/src/Storages/StorageMergeTree.h
+++ b/src/Storages/StorageMergeTree.h
@@ -12,6 +12,8 @@
 #include <Storages/MergeTree/MergeTreePartsMover.h>
 #include <Storages/MergeTree/MergeTreeMutationEntry.h>
 #include <Storages/MergeTree/MergeTreeMutationStatus.h>
+#include <Storages/MergeTree/MergeTreeDeduplicationLog.h>
+
 #include <Disks/StoragePolicy.h>
 #include <Common/SimpleIncrement.h>
 #include <Storages/MergeTree/BackgroundJobsExecutor.h>
@@ -40,7 +42,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -50,16 +52,16 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
     std::optional<UInt64> totalRows(const Settings &) const override;
-    std::optional<UInt64> totalRowsByPartitionPredicate(const SelectQueryInfo &, const Context &) const override;
+    std::optional<UInt64> totalRowsByPartitionPredicate(const SelectQueryInfo &, ContextPtr) const override;
     std::optional<UInt64> totalBytes(const Settings &) const override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     /** Perform the next step in combining the parts.
       */
@@ -70,9 +72,9 @@ public:
         bool final,
         bool deduplicate,
         const Names & deduplicate_by_columns,
-        const Context & context) override;
+        ContextPtr context) override;
 
-    void mutate(const MutationCommands & commands, const Context & context) override;
+    void mutate(const MutationCommands & commands, ContextPtr context) override;
 
     /// Return introspection information about currently processing or recently processed mutations.
     std::vector<MergeTreeMutationStatus> getMutationsStatus() const override;
@@ -80,9 +82,9 @@ public:
     CancellationCode killMutation(const String & mutation_id) override;
 
     void drop() override;
-    void truncate(const ASTPtr &, const StorageMetadataPtr &, const Context &, TableExclusiveLockHolder &) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr, TableExclusiveLockHolder &) override;
 
-    void alter(const AlterCommands & commands, const Context & context, TableLockHolder & table_lock_holder) override;
+    void alter(const AlterCommands & commands, ContextPtr context, TableLockHolder & table_lock_holder) override;
 
     void checkTableCanBeDropped() const override;
 
@@ -90,9 +92,11 @@ public:
 
     void onActionLockRemove(StorageActionBlockType action_type) override;
 
-    CheckResults checkData(const ASTPtr & query, const Context & context) override;
+    CheckResults checkData(const ASTPtr & query, ContextPtr context) override;
 
     std::optional<JobAndPool> getDataProcessingJob() override;
+
+    MergeTreeDeduplicationLog * getDeduplicationLog() { return deduplication_log.get(); }
 private:
 
     /// Mutex and condvar for synchronous mutations wait
@@ -105,6 +109,8 @@ private:
     BackgroundJobsExecutor background_executor;
     BackgroundMovesExecutor background_moves_executor;
 
+    std::unique_ptr<MergeTreeDeduplicationLog> deduplication_log;
+
     /// For block numbers.
     SimpleIncrement increment;
 
@@ -128,6 +134,10 @@ private:
 
     void loadMutations();
 
+    /// Load and initialize deduplication logs. Even if deduplication setting
+    /// equals zero creates object with deduplication window equals zero.
+    void loadDeduplicationLog();
+
     /** Determines what parts should be merged and merges it.
       * If aggressive - when selects parts don't takes into account their ratio size and novelty (used for OPTIMIZE query).
       * Returns true if merge is finished successfully.
@@ -201,11 +211,11 @@ private:
     void clearOldMutations(bool truncate = false);
 
     // Partition helpers
-    void dropPartition(const ASTPtr & partition, bool detach, bool drop_part, const Context & context, bool throw_if_noop) override;
-    PartitionCommandsResultInfo attachPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, bool part, const Context & context) override;
+    void dropPartition(const ASTPtr & partition, bool detach, bool drop_part, ContextPtr context, bool throw_if_noop) override;
+    PartitionCommandsResultInfo attachPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, bool part, ContextPtr context) override;
 
-    void replacePartitionFrom(const StoragePtr & source_table, const ASTPtr & partition, bool replace, const Context & context) override;
-    void movePartitionToTable(const StoragePtr & dest_table, const ASTPtr & partition, const Context & context) override;
+    void replacePartitionFrom(const StoragePtr & source_table, const ASTPtr & partition, bool replace, ContextPtr context) override;
+    void movePartitionToTable(const StoragePtr & dest_table, const ASTPtr & partition, ContextPtr context) override;
     bool partIsAssignedToBackgroundOperation(const DataPartPtr & part) const override;
     /// Update mutation entries after part mutation execution. May reset old
     /// errors if mutation was successful. Otherwise update last_failed* fields
@@ -239,7 +249,7 @@ protected:
         const String & relative_data_path_,
         const StorageInMemoryMetadata & metadata,
         bool attach,
-        Context & context_,
+        ContextPtr context_,
         const String & date_column_name,
         const MergingParams & merging_params_,
         std::unique_ptr<MergeTreeSettings> settings_,
diff --git a/src/Storages/StorageMongoDB.cpp b/src/Storages/StorageMongoDB.cpp
index 09fd413af75..2b0200f3643 100644
--- a/src/Storages/StorageMongoDB.cpp
+++ b/src/Storages/StorageMongoDB.cpp
@@ -74,7 +74,7 @@ Pipe StorageMongoDB::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size,
     unsigned)
@@ -106,7 +106,7 @@ void registerStorageMongoDB(StorageFactory & factory)
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
         for (auto & engine_arg : engine_args)
-            engine_arg = evaluateConstantExpressionOrIdentifierAsLiteral(engine_arg, args.local_context);
+            engine_arg = evaluateConstantExpressionOrIdentifierAsLiteral(engine_arg, args.getLocalContext());
 
         /// 27017 is the default MongoDB port.
         auto parsed_host_port = parseAddress(engine_args[0]->as<ASTLiteral &>().value.safeGet<String>(), 27017);
diff --git a/src/Storages/StorageMongoDB.h b/src/Storages/StorageMongoDB.h
index 589ab276539..5e96d1543a2 100644
--- a/src/Storages/StorageMongoDB.h
+++ b/src/Storages/StorageMongoDB.h
@@ -35,7 +35,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/StorageMySQL.cpp b/src/Storages/StorageMySQL.cpp
index caac7c5d95e..c635b0e939c 100644
--- a/src/Storages/StorageMySQL.cpp
+++ b/src/Storages/StorageMySQL.cpp
@@ -18,6 +18,7 @@
 #include <mysqlxx/Transaction.h>
 #include <Processors/Sources/SourceFromInputStream.h>
 #include <Processors/Pipe.h>
+#include <Common/parseRemoteDescription.h>
 
 
 namespace DB
@@ -41,21 +42,21 @@ static String backQuoteMySQL(const String & x)
 
 StorageMySQL::StorageMySQL(
     const StorageID & table_id_,
-    mysqlxx::Pool && pool_,
+    mysqlxx::PoolWithFailover && pool_,
     const std::string & remote_database_name_,
     const std::string & remote_table_name_,
     const bool replace_query_,
     const std::string & on_duplicate_clause_,
     const ColumnsDescription & columns_,
     const ConstraintsDescription & constraints_,
-    const Context & context_)
+    ContextPtr context_)
     : IStorage(table_id_)
+    , WithContext(context_->getGlobalContext())
     , remote_database_name(remote_database_name_)
     , remote_table_name(remote_table_name_)
     , replace_query{replace_query_}
     , on_duplicate_clause{on_duplicate_clause_}
-    , pool(std::move(pool_))
-    , global_context(context_.getGlobalContext())
+    , pool(std::make_shared<mysqlxx::PoolWithFailover>(pool_))
 {
     StorageInMemoryMetadata storage_metadata;
     storage_metadata.setColumns(columns_);
@@ -68,7 +69,7 @@ Pipe StorageMySQL::read(
     const Names & column_names_,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info_,
-    const Context & context_,
+    ContextPtr context_,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size_,
     unsigned)
@@ -94,9 +95,8 @@ Pipe StorageMySQL::read(
         sample_block.insert({ column_data.type, column_data.name });
     }
 
-    /// TODO: rewrite MySQLBlockInputStream
     return Pipe(std::make_shared<SourceFromInputStream>(
-            std::make_shared<MySQLLazyBlockInputStream>(pool, query, sample_block, max_block_size_, /* auto_close = */ true)));
+            std::make_shared<MySQLWithFailoverBlockInputStream>(pool, query, sample_block, max_block_size_, /* auto_close = */ true)));
 }
 
 
@@ -147,7 +147,7 @@ public:
         sqlbuf << backQuoteMySQL(remote_database_name) << "." << backQuoteMySQL(remote_table_name);
         sqlbuf << " (" << dumpNamesWithBackQuote(block) << ") VALUES ";
 
-        auto writer = FormatFactory::instance().getOutputStream("Values", sqlbuf, metadata_snapshot->getSampleBlock(), storage.global_context);
+        auto writer = FormatFactory::instance().getOutputStream("Values", sqlbuf, metadata_snapshot->getSampleBlock(), storage.getContext());
         writer->write(block);
 
         if (!storage.on_duplicate_clause.empty())
@@ -211,9 +211,15 @@ private:
 };
 
 
-BlockOutputStreamPtr StorageMySQL::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr StorageMySQL::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr local_context)
 {
-    return std::make_shared<StorageMySQLBlockOutputStream>(*this, metadata_snapshot, remote_database_name, remote_table_name, pool.get(), context.getSettingsRef().mysql_max_rows_to_insert);
+    return std::make_shared<StorageMySQLBlockOutputStream>(
+        *this,
+        metadata_snapshot,
+        remote_database_name,
+        remote_table_name,
+        pool->get(),
+        local_context->getSettingsRef().mysql_max_rows_to_insert);
 }
 
 void registerStorageMySQL(StorageFactory & factory)
@@ -224,21 +230,22 @@ void registerStorageMySQL(StorageFactory & factory)
 
         if (engine_args.size() < 5 || engine_args.size() > 7)
             throw Exception(
-                "Storage MySQL requires 5-7 parameters: MySQL('host:port', database, table, 'user', 'password'[, replace_query, 'on_duplicate_clause']).",
+                "Storage MySQL requires 5-7 parameters: MySQL('host:port' (or 'addresses_pattern'), database, table, 'user', 'password'[, replace_query, 'on_duplicate_clause']).",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
         for (auto & engine_arg : engine_args)
-            engine_arg = evaluateConstantExpressionOrIdentifierAsLiteral(engine_arg, args.local_context);
+            engine_arg = evaluateConstantExpressionOrIdentifierAsLiteral(engine_arg, args.getLocalContext());
 
         /// 3306 is the default MySQL port.
-        auto parsed_host_port = parseAddress(engine_args[0]->as<ASTLiteral &>().value.safeGet<String>(), 3306);
-
+        const String & host_port = engine_args[0]->as<ASTLiteral &>().value.safeGet<String>();
         const String & remote_database = engine_args[1]->as<ASTLiteral &>().value.safeGet<String>();
         const String & remote_table = engine_args[2]->as<ASTLiteral &>().value.safeGet<String>();
         const String & username = engine_args[3]->as<ASTLiteral &>().value.safeGet<String>();
         const String & password = engine_args[4]->as<ASTLiteral &>().value.safeGet<String>();
+        size_t max_addresses = args.getContext()->getSettingsRef().glob_expansion_max_elements;
 
-        mysqlxx::Pool pool(remote_database, parsed_host_port.first, username, password, parsed_host_port.second);
+        auto addresses = parseRemoteDescriptionForExternalDatabase(host_port, max_addresses, 3306);
+        mysqlxx::PoolWithFailover pool(remote_database, addresses, username, password);
 
         bool replace_query = false;
         std::string on_duplicate_clause;
@@ -261,7 +268,7 @@ void registerStorageMySQL(StorageFactory & factory)
             on_duplicate_clause,
             args.columns,
             args.constraints,
-            args.context);
+            args.getContext());
     },
     {
         .source_access_type = AccessType::MYSQL,
diff --git a/src/Storages/StorageMySQL.h b/src/Storages/StorageMySQL.h
index 645f3600eee..a68c06c1abe 100644
--- a/src/Storages/StorageMySQL.h
+++ b/src/Storages/StorageMySQL.h
@@ -1,15 +1,15 @@
 #pragma once
 
 #if !defined(ARCADIA_BUILD)
-#    include "config_core.h"
+#include "config_core.h"
 #endif
 
 #if USE_MYSQL
 
-#    include <ext/shared_ptr_helper.h>
+#include <ext/shared_ptr_helper.h>
 
-#    include <Storages/IStorage.h>
-#    include <mysqlxx/Pool.h>
+#include <Storages/IStorage.h>
+#include <mysqlxx/PoolWithFailover.h>
 
 
 namespace DB
@@ -19,20 +19,20 @@ namespace DB
   * Use ENGINE = mysql(host_port, database_name, table_name, user_name, password)
   * Read only.
   */
-class StorageMySQL final : public ext::shared_ptr_helper<StorageMySQL>, public IStorage
+class StorageMySQL final : public ext::shared_ptr_helper<StorageMySQL>, public IStorage, WithContext
 {
     friend struct ext::shared_ptr_helper<StorageMySQL>;
 public:
     StorageMySQL(
         const StorageID & table_id_,
-        mysqlxx::Pool && pool_,
+        mysqlxx::PoolWithFailover && pool_,
         const std::string & remote_database_name_,
         const std::string & remote_table_name_,
-        const bool replace_query_,
+        bool replace_query_,
         const std::string & on_duplicate_clause_,
         const ColumnsDescription & columns_,
         const ConstraintsDescription & constraints_,
-        const Context & context_);
+        ContextPtr context_);
 
     std::string getName() const override { return "MySQL"; }
 
@@ -40,12 +40,12 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
 private:
     friend class StorageMySQLBlockOutputStream;
@@ -55,8 +55,7 @@ private:
     bool replace_query;
     std::string on_duplicate_clause;
 
-    mysqlxx::Pool pool;
-    const Context & global_context;
+    mysqlxx::PoolWithFailoverPtr pool;
 };
 
 }
diff --git a/src/Storages/StorageNull.cpp b/src/Storages/StorageNull.cpp
index ed9a7fffc63..46f88bbc7ac 100644
--- a/src/Storages/StorageNull.cpp
+++ b/src/Storages/StorageNull.cpp
@@ -36,7 +36,7 @@ void registerStorageNull(StorageFactory & factory)
     });
 }
 
-void StorageNull::checkAlterIsPossible(const AlterCommands & commands, const Context & context) const
+void StorageNull::checkAlterIsPossible(const AlterCommands & commands, ContextPtr context) const
 {
     auto name_deps = getDependentViewsByColumn(context);
     for (const auto & command : commands)
@@ -61,7 +61,7 @@ void StorageNull::checkAlterIsPossible(const AlterCommands & commands, const Con
 }
 
 
-void StorageNull::alter(const AlterCommands & params, const Context & context, TableLockHolder &)
+void StorageNull::alter(const AlterCommands & params, ContextPtr context, TableLockHolder &)
 {
     auto table_id = getStorageID();
 
diff --git a/src/Storages/StorageNull.h b/src/Storages/StorageNull.h
index 943c056a588..7fe65eb25dc 100644
--- a/src/Storages/StorageNull.h
+++ b/src/Storages/StorageNull.h
@@ -25,7 +25,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo &,
-        const Context & /*context*/,
+        ContextPtr /*context*/,
         QueryProcessingStage::Enum /*processing_stage*/,
         size_t,
         unsigned) override
@@ -36,14 +36,14 @@ public:
 
     bool supportsParallelInsert() const override { return true; }
 
-    BlockOutputStreamPtr write(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context &) override
+    BlockOutputStreamPtr write(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr) override
     {
         return std::make_shared<NullBlockOutputStream>(metadata_snapshot->getSampleBlock());
     }
 
-    void checkAlterIsPossible(const AlterCommands & commands, const Context & context) const override;
+    void checkAlterIsPossible(const AlterCommands & commands, ContextPtr context) const override;
 
-    void alter(const AlterCommands & params, const Context & context, TableLockHolder & table_lock_holder) override;
+    void alter(const AlterCommands & params, ContextPtr context, TableLockHolder & table_lock_holder) override;
 
     std::optional<UInt64> totalRows(const Settings &) const override
     {
diff --git a/src/Storages/StoragePostgreSQL.cpp b/src/Storages/StoragePostgreSQL.cpp
index e1b927027f9..a99568c0036 100644
--- a/src/Storages/StoragePostgreSQL.cpp
+++ b/src/Storages/StoragePostgreSQL.cpp
@@ -26,6 +26,7 @@
 #include <Formats/FormatFactory.h>
 #include <Formats/FormatSettings.h>
 #include <Processors/Sources/SourceFromInputStream.h>
+#include <Common/parseRemoteDescription.h>
 #include <Processors/Pipe.h>
 #include <IO/WriteHelpers.h>
 
@@ -41,17 +42,17 @@ namespace ErrorCodes
 
 StoragePostgreSQL::StoragePostgreSQL(
     const StorageID & table_id_,
+    const postgres::PoolWithFailover & pool_,
     const String & remote_table_name_,
-    PostgreSQLConnectionPoolPtr connection_pool_,
     const ColumnsDescription & columns_,
     const ConstraintsDescription & constraints_,
-    const Context & context_,
+    ContextPtr context_,
     const String & remote_table_schema_)
     : IStorage(table_id_)
     , remote_table_name(remote_table_name_)
     , remote_table_schema(remote_table_schema_)
     , global_context(context_)
-    , connection_pool(std::move(connection_pool_))
+    , pool(std::make_shared<postgres::PoolWithFailover>(pool_))
 {
     StorageInMemoryMetadata storage_metadata;
     storage_metadata.setColumns(columns_);
@@ -64,7 +65,7 @@ Pipe StoragePostgreSQL::read(
     const Names & column_names_,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info_,
-    const Context & context_,
+    ContextPtr context_,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size_,
     unsigned)
@@ -88,7 +89,7 @@ Pipe StoragePostgreSQL::read(
     }
 
     return Pipe(std::make_shared<SourceFromInputStream>(
-            std::make_shared<PostgreSQLBlockInputStream>(connection_pool->get(), query, sample_block, max_block_size_)));
+            std::make_shared<PostgreSQLBlockInputStream>(pool->get(), query, sample_block, max_block_size_)));
 }
 
 
@@ -97,7 +98,7 @@ class PostgreSQLBlockOutputStream : public IBlockOutputStream
 public:
     explicit PostgreSQLBlockOutputStream(
         const StorageMetadataPtr & metadata_snapshot_,
-        PostgreSQLConnectionHolderPtr connection_,
+        postgres::ConnectionHolderPtr connection_,
         const std::string & remote_table_name_)
         : metadata_snapshot(metadata_snapshot_)
         , connection(std::move(connection_))
@@ -276,7 +277,7 @@ public:
 
 private:
     StorageMetadataPtr metadata_snapshot;
-    PostgreSQLConnectionHolderPtr connection;
+    postgres::ConnectionHolderPtr connection;
     std::string remote_table_name;
 
     std::unique_ptr<pqxx::work> work;
@@ -285,9 +286,9 @@ private:
 
 
 BlockOutputStreamPtr StoragePostgreSQL::write(
-        const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & /* context */)
+        const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr /* context */)
 {
-    return std::make_shared<PostgreSQLBlockOutputStream>(metadata_snapshot, connection_pool->get(), remote_table_name);
+    return std::make_shared<PostgreSQLBlockOutputStream>(metadata_snapshot, pool->get(), remote_table_name);
 }
 
 
@@ -303,26 +304,33 @@ void registerStoragePostgreSQL(StorageFactory & factory)
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
         for (auto & engine_arg : engine_args)
-            engine_arg = evaluateConstantExpressionOrIdentifierAsLiteral(engine_arg, args.local_context);
+            engine_arg = evaluateConstantExpressionOrIdentifierAsLiteral(engine_arg, args.getLocalContext());
 
-        auto parsed_host_port = parseAddress(engine_args[0]->as<ASTLiteral &>().value.safeGet<String>(), 5432);
+        auto host_port = engine_args[0]->as<ASTLiteral &>().value.safeGet<String>();
+        /// Split into replicas if needed.
+        size_t max_addresses = args.getContext()->getSettingsRef().glob_expansion_max_elements;
+        auto addresses = parseRemoteDescriptionForExternalDatabase(host_port, max_addresses, 5432);
+
+        const String & remote_database = engine_args[1]->as<ASTLiteral &>().value.safeGet<String>();
         const String & remote_table = engine_args[2]->as<ASTLiteral &>().value.safeGet<String>();
+        const String & username = engine_args[3]->as<ASTLiteral &>().value.safeGet<String>();
+        const String & password = engine_args[4]->as<ASTLiteral &>().value.safeGet<String>();
 
         String remote_table_schema;
         if (engine_args.size() == 6)
             remote_table_schema = engine_args[5]->as<ASTLiteral &>().value.safeGet<String>();
 
-        auto connection_pool = std::make_shared<PostgreSQLConnectionPool>(
-            engine_args[1]->as<ASTLiteral &>().value.safeGet<String>(),
-            parsed_host_port.first,
-            parsed_host_port.second,
-            engine_args[3]->as<ASTLiteral &>().value.safeGet<String>(),
-            engine_args[4]->as<ASTLiteral &>().value.safeGet<String>(),
-            args.context.getSettingsRef().postgresql_connection_pool_size,
-            args.context.getSettingsRef().postgresql_connection_pool_wait_timeout);
+        postgres::PoolWithFailover pool(
+            remote_database,
+            addresses,
+            username,
+            password,
+            args.getContext()->getSettingsRef().postgresql_connection_pool_size,
+            args.getContext()->getSettingsRef().postgresql_connection_pool_wait_timeout);
 
         return StoragePostgreSQL::create(
-            args.table_id, remote_table, connection_pool, args.columns, args.constraints, args.context, remote_table_schema);
+            args.table_id, pool, remote_table,
+            args.columns, args.constraints, args.getContext(), remote_table_schema);
     },
     {
         .source_access_type = AccessType::POSTGRES,
diff --git a/src/Storages/StoragePostgreSQL.h b/src/Storages/StoragePostgreSQL.h
index fb80352f58d..e4ab59f7a06 100644
--- a/src/Storages/StoragePostgreSQL.h
+++ b/src/Storages/StoragePostgreSQL.h
@@ -9,8 +9,7 @@
 #include <Interpreters/Context.h>
 #include <Storages/IStorage.h>
 #include <DataStreams/IBlockOutputStream.h>
-#include <Storages/PostgreSQL/PostgreSQLConnectionPool.h>
-#include <pqxx/pqxx>
+#include <Storages/PostgreSQL/PostgreSQLPoolWithFailover.h>
 
 
 namespace DB
@@ -23,11 +22,11 @@ class StoragePostgreSQL final : public ext::shared_ptr_helper<StoragePostgreSQL>
 public:
     StoragePostgreSQL(
         const StorageID & table_id_,
+        const postgres::PoolWithFailover & pool_,
         const String & remote_table_name_,
-        PostgreSQLConnectionPoolPtr connection_pool_,
         const ColumnsDescription & columns_,
         const ConstraintsDescription & constraints_,
-        const Context & context_,
+        ContextPtr context_,
         const std::string & remote_table_schema_ = "");
 
     String getName() const override { return "PostgreSQL"; }
@@ -36,20 +35,20 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
 private:
     friend class PostgreSQLBlockOutputStream;
 
     String remote_table_name;
     String remote_table_schema;
-    Context global_context;
-    PostgreSQLConnectionPoolPtr connection_pool;
+    ContextPtr global_context;
+    postgres::PoolWithFailoverPtr pool;
 };
 
 }
diff --git a/src/Storages/StorageProxy.h b/src/Storages/StorageProxy.h
index 0349319d8fa..6fd2a86b6eb 100644
--- a/src/Storages/StorageProxy.h
+++ b/src/Storages/StorageProxy.h
@@ -32,7 +32,7 @@ public:
     NamesAndTypesList getVirtuals() const override { return getNested()->getVirtuals(); }
 
     QueryProcessingStage::Enum getQueryProcessingStage(
-        const Context & context, QueryProcessingStage::Enum to_stage, SelectQueryInfo & ast) const override
+        ContextPtr context, QueryProcessingStage::Enum to_stage, SelectQueryInfo & ast) const override
     {
         return getNested()->getQueryProcessingStage(context, to_stage, ast);
     }
@@ -40,7 +40,7 @@ public:
     BlockInputStreams watch(
         const Names & column_names,
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum & processed_stage,
         size_t max_block_size,
         unsigned num_streams) override
@@ -52,7 +52,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override
@@ -60,10 +60,7 @@ public:
         return getNested()->read(column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams);
     }
 
-    BlockOutputStreamPtr write(
-        const ASTPtr & query,
-        const StorageMetadataPtr & metadata_snapshot,
-        const Context & context) override
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & metadata_snapshot, ContextPtr context) override
     {
         return getNested()->write(query, metadata_snapshot, context);
     }
@@ -73,7 +70,7 @@ public:
     void truncate(
         const ASTPtr & query,
         const StorageMetadataPtr & metadata_snapshot,
-        const Context & context,
+        ContextPtr context,
         TableExclusiveLockHolder & lock) override
     {
         getNested()->truncate(query, metadata_snapshot, context, lock);
@@ -91,13 +88,13 @@ public:
         IStorage::renameInMemory(new_table_id);
     }
 
-    void alter(const AlterCommands & params, const Context & context, TableLockHolder & alter_lock_holder) override
+    void alter(const AlterCommands & params, ContextPtr context, TableLockHolder & alter_lock_holder) override
     {
         getNested()->alter(params, context, alter_lock_holder);
         IStorage::setInMemoryMetadata(getNested()->getInMemoryMetadata());
     }
 
-    void checkAlterIsPossible(const AlterCommands & commands, const Context & context) const override
+    void checkAlterIsPossible(const AlterCommands & commands, ContextPtr context) const override
     {
         getNested()->checkAlterIsPossible(commands, context);
     }
@@ -105,7 +102,7 @@ public:
     Pipe alterPartition(
             const StorageMetadataPtr & metadata_snapshot,
             const PartitionCommands & commands,
-            const Context & context) override
+            ContextPtr context) override
     {
         return getNested()->alterPartition(metadata_snapshot, commands, context);
     }
@@ -122,12 +119,12 @@ public:
             bool final,
             bool deduplicate,
             const Names & deduplicate_by_columns,
-            const Context & context) override
+            ContextPtr context) override
     {
         return getNested()->optimize(query, metadata_snapshot, partition, final, deduplicate, deduplicate_by_columns, context);
     }
 
-    void mutate(const MutationCommands & commands, const Context & context) override { getNested()->mutate(commands, context); }
+    void mutate(const MutationCommands & commands, ContextPtr context) override { getNested()->mutate(commands, context); }
 
     CancellationCode killMutation(const String & mutation_id) override { return getNested()->killMutation(mutation_id); }
 
@@ -137,12 +134,12 @@ public:
     ActionLock getActionLock(StorageActionBlockType action_type) override { return getNested()->getActionLock(action_type); }
 
     bool supportsIndexForIn() const override { return getNested()->supportsIndexForIn(); }
-    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, const Context & query_context, const StorageMetadataPtr & metadata_snapshot) const override
+    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, ContextPtr query_context, const StorageMetadataPtr & metadata_snapshot) const override
     {
         return getNested()->mayBenefitFromIndexForIn(left_in_operand, query_context, metadata_snapshot);
     }
 
-    CheckResults checkData(const ASTPtr & query , const Context & context) override { return getNested()->checkData(query, context); }
+    CheckResults checkData(const ASTPtr & query , ContextPtr context) override { return getNested()->checkData(query, context); }
     void checkTableCanBeDropped() const override { getNested()->checkTableCanBeDropped(); }
     void checkPartitionCanBeDropped(const ASTPtr & partition) override { getNested()->checkPartitionCanBeDropped(partition); }
     bool storesDataOnDisk() const override { return getNested()->storesDataOnDisk(); }
diff --git a/src/Storages/StorageReplicatedMergeTree.cpp b/src/Storages/StorageReplicatedMergeTree.cpp
index f9d63132a1b..a2b1f1737a2 100644
--- a/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/src/Storages/StorageReplicatedMergeTree.cpp
@@ -26,6 +26,7 @@
 #include <Storages/MergeTree/ReplicatedMergeTreeQuorumAddedParts.h>
 #include <Storages/MergeTree/ReplicatedMergeTreePartHeader.h>
 #include <Storages/VirtualColumnUtils.h>
+#include <Storages/MergeTree/MergeTreeReaderCompact.h>
 
 
 #include <Databases/IDatabase.h>
@@ -51,6 +52,7 @@
 #include <Interpreters/PartLog.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/DDLTask.h>
+#include <Interpreters/InterserverCredentials.h>
 
 #include <DataStreams/RemoteBlockInputStream.h>
 #include <DataStreams/copyData.h>
@@ -59,7 +61,7 @@
 
 #include <ext/range.h>
 #include <ext/scope_guard.h>
-#include "Storages/MergeTree/MergeTreeReaderCompact.h"
+#include <ext/scope_guard_safe.h>
 
 #include <ctime>
 #include <thread>
@@ -161,11 +163,11 @@ void StorageReplicatedMergeTree::setZooKeeper()
     std::lock_guard lock(current_zookeeper_mutex);
     if (zookeeper_name == default_zookeeper_name)
     {
-        current_zookeeper = global_context.getZooKeeper();
+        current_zookeeper = getContext()->getZooKeeper();
     }
     else
     {
-        current_zookeeper = global_context.getAuxiliaryZooKeeper(zookeeper_name);
+        current_zookeeper = getContext()->getAuxiliaryZooKeeper(zookeeper_name);
     }
 }
 
@@ -229,7 +231,7 @@ StorageReplicatedMergeTree::StorageReplicatedMergeTree(
     const StorageID & table_id_,
     const String & relative_data_path_,
     const StorageInMemoryMetadata & metadata_,
-    Context & context_,
+    ContextPtr context_,
     const String & date_column_name,
     const MergingParams & merging_params_,
     std::unique_ptr<MergeTreeSettings> settings_,
@@ -251,34 +253,34 @@ StorageReplicatedMergeTree::StorageReplicatedMergeTree(
     , replica_path(zookeeper_path + "/replicas/" + replica_name_)
     , reader(*this)
     , writer(*this)
-    , merger_mutator(*this, global_context.getSettingsRef().background_pool_size)
+    , merger_mutator(*this, getContext()->getSettingsRef().background_pool_size)
     , merge_strategy_picker(*this)
     , queue(*this, merge_strategy_picker)
     , fetcher(*this)
-    , background_executor(*this, global_context)
-    , background_moves_executor(*this, global_context)
+    , background_executor(*this, getContext())
+    , background_moves_executor(*this, getContext())
     , cleanup_thread(*this)
     , part_check_thread(*this)
     , restarting_thread(*this)
     , allow_renaming(allow_renaming_)
-    , replicated_fetches_pool_size(global_context.getSettingsRef().background_fetches_pool_size)
+    , replicated_fetches_pool_size(getContext()->getSettingsRef().background_fetches_pool_size)
 {
-    queue_updating_task = global_context.getSchedulePool().createTask(
+    queue_updating_task = getContext()->getSchedulePool().createTask(
         getStorageID().getFullTableName() + " (StorageReplicatedMergeTree::queueUpdatingTask)", [this]{ queueUpdatingTask(); });
 
-    mutations_updating_task = global_context.getSchedulePool().createTask(
+    mutations_updating_task = getContext()->getSchedulePool().createTask(
         getStorageID().getFullTableName() + " (StorageReplicatedMergeTree::mutationsUpdatingTask)", [this]{ mutationsUpdatingTask(); });
 
-    merge_selecting_task = global_context.getSchedulePool().createTask(
+    merge_selecting_task = getContext()->getSchedulePool().createTask(
         getStorageID().getFullTableName() + " (StorageReplicatedMergeTree::mergeSelectingTask)", [this] { mergeSelectingTask(); });
 
     /// Will be activated if we win leader election.
     merge_selecting_task->deactivate();
 
-    mutations_finalizing_task = global_context.getSchedulePool().createTask(
+    mutations_finalizing_task = getContext()->getSchedulePool().createTask(
         getStorageID().getFullTableName() + " (StorageReplicatedMergeTree::mutationsFinalizingTask)", [this] { mutationsFinalizingTask(); });
 
-    if (global_context.hasZooKeeper() || global_context.hasAuxiliaryZooKeeper(zookeeper_name))
+    if (getContext()->hasZooKeeper() || getContext()->hasAuxiliaryZooKeeper(zookeeper_name))
     {
         /// It's possible for getZooKeeper() to timeout if  zookeeper host(s) can't
         /// be reached. In such cases Poco::Exception is thrown after a connection
@@ -297,11 +299,11 @@ StorageReplicatedMergeTree::StorageReplicatedMergeTree(
         {
             if (zookeeper_name == default_zookeeper_name)
             {
-                current_zookeeper = global_context.getZooKeeper();
+                current_zookeeper = getContext()->getZooKeeper();
             }
             else
             {
-                current_zookeeper = global_context.getAuxiliaryZooKeeper(zookeeper_name);
+                current_zookeeper = getContext()->getAuxiliaryZooKeeper(zookeeper_name);
             }
         }
         catch (...)
@@ -455,12 +457,12 @@ void StorageReplicatedMergeTree::waitMutationToFinishOnReplicas(
     if (replicas.empty())
         return;
 
-    zkutil::EventPtr wait_event = std::make_shared<Poco::Event>();
 
     std::set<String> inactive_replicas;
     for (const String & replica : replicas)
     {
         LOG_DEBUG(log, "Waiting for {} to apply mutation {}", replica, mutation_id);
+        zkutil::EventPtr wait_event = std::make_shared<Poco::Event>();
 
         while (!partial_shutdown_called)
         {
@@ -484,9 +486,8 @@ void StorageReplicatedMergeTree::waitMutationToFinishOnReplicas(
 
             String mutation_pointer = zookeeper_path + "/replicas/" + replica + "/mutation_pointer";
             std::string mutation_pointer_value;
-            Coordination::Stat get_stat;
             /// Replica could be removed
-            if (!zookeeper->tryGet(mutation_pointer, mutation_pointer_value, &get_stat, wait_event))
+            if (!zookeeper->tryGet(mutation_pointer, mutation_pointer_value, nullptr, wait_event))
             {
                 LOG_WARNING(log, "Replica {} was removed", replica);
                 break;
@@ -496,8 +497,10 @@ void StorageReplicatedMergeTree::waitMutationToFinishOnReplicas(
 
             /// Replica can become inactive, so wait with timeout and recheck it
             if (wait_event->tryWait(1000))
-                break;
+                continue;
 
+            /// Here we check mutation for errors or kill on local replica. If they happen on this replica
+            /// they will happen on each replica, so we can check only in-memory info.
             auto mutation_status = queue.getIncompleteMutationsStatus(mutation_id);
             if (!mutation_status || !mutation_status->latest_fail_reason.empty())
                 break;
@@ -514,6 +517,8 @@ void StorageReplicatedMergeTree::waitMutationToFinishOnReplicas(
         std::set<String> mutation_ids;
         mutation_ids.insert(mutation_id);
 
+        /// Here we check mutation for errors or kill on local replica. If they happen on this replica
+        /// they will happen on each replica, so we can check only in-memory info.
         auto mutation_status = queue.getIncompleteMutationsStatus(mutation_id, &mutation_ids);
         checkMutationStatus(mutation_status, mutation_ids);
 
@@ -773,9 +778,9 @@ void StorageReplicatedMergeTree::drop()
         /// and calling StorageReplicatedMergeTree::getZooKeeper()/getAuxiliaryZooKeeper() won't suffice.
         zkutil::ZooKeeperPtr zookeeper;
         if (zookeeper_name == default_zookeeper_name)
-            zookeeper = global_context.getZooKeeper();
+            zookeeper = getContext()->getZooKeeper();
         else
-            zookeeper = global_context.getAuxiliaryZooKeeper(zookeeper_name);
+            zookeeper = getContext()->getAuxiliaryZooKeeper(zookeeper_name);
 
         /// If probably there is metadata in ZooKeeper, we don't allow to drop the table.
         if (!zookeeper)
@@ -893,7 +898,7 @@ void StorageReplicatedMergeTree::checkTableStructure(const String & zookeeper_pr
     Coordination::Stat metadata_stat;
     String metadata_str = zookeeper->get(zookeeper_prefix + "/metadata", &metadata_stat);
     auto metadata_from_zk = ReplicatedMergeTreeTableMetadata::parse(metadata_str);
-    old_metadata.checkEquals(metadata_from_zk, metadata_snapshot->getColumns(), global_context);
+    old_metadata.checkEquals(metadata_from_zk, metadata_snapshot->getColumns(), getContext());
 
     Coordination::Stat columns_stat;
     auto columns_from_zk = ColumnsDescription::parse(zookeeper->get(zookeeper_prefix + "/columns", &columns_stat));
@@ -938,7 +943,7 @@ void StorageReplicatedMergeTree::setTableStructure(
             auto & sorting_key = new_metadata.sorting_key;
             auto & primary_key = new_metadata.primary_key;
 
-            sorting_key.recalculateWithNewAST(order_by_ast, new_metadata.columns, global_context);
+            sorting_key.recalculateWithNewAST(order_by_ast, new_metadata.columns, getContext());
 
             if (primary_key.definition_ast == nullptr)
             {
@@ -946,18 +951,18 @@ void StorageReplicatedMergeTree::setTableStructure(
                 /// save the old ORDER BY expression as the new primary key.
                 auto old_sorting_key_ast = old_metadata.getSortingKey().definition_ast;
                 primary_key = KeyDescription::getKeyFromAST(
-                    old_sorting_key_ast, new_metadata.columns, global_context);
+                    old_sorting_key_ast, new_metadata.columns, getContext());
             }
         }
 
         if (metadata_diff.sampling_expression_changed)
         {
             auto sample_by_ast = parse_key_expr(metadata_diff.new_sampling_expression);
-            new_metadata.sampling_key.recalculateWithNewAST(sample_by_ast, new_metadata.columns, global_context);
+            new_metadata.sampling_key.recalculateWithNewAST(sample_by_ast, new_metadata.columns, getContext());
         }
 
         if (metadata_diff.skip_indices_changed)
-            new_metadata.secondary_indices = IndicesDescription::parse(metadata_diff.new_skip_indices, new_columns, global_context);
+            new_metadata.secondary_indices = IndicesDescription::parse(metadata_diff.new_skip_indices, new_columns, getContext());
 
         if (metadata_diff.constraints_changed)
             new_metadata.constraints = ConstraintsDescription::parse(metadata_diff.new_constraints);
@@ -969,7 +974,7 @@ void StorageReplicatedMergeTree::setTableStructure(
                 ParserTTLExpressionList parser;
                 auto ttl_for_table_ast = parseQuery(parser, metadata_diff.new_ttl_table, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH);
                 new_metadata.table_ttl = TTLTableDescription::getTTLForTableFromAST(
-                    ttl_for_table_ast, new_metadata.columns, global_context, new_metadata.primary_key);
+                    ttl_for_table_ast, new_metadata.columns, getContext(), new_metadata.primary_key);
             }
             else /// TTL was removed
             {
@@ -982,39 +987,39 @@ void StorageReplicatedMergeTree::setTableStructure(
     new_metadata.column_ttls_by_name.clear();
     for (const auto & [name, ast] : new_metadata.columns.getColumnTTLs())
     {
-        auto new_ttl_entry = TTLDescription::getTTLFromAST(ast, new_metadata.columns, global_context, new_metadata.primary_key);
+        auto new_ttl_entry = TTLDescription::getTTLFromAST(ast, new_metadata.columns, getContext(), new_metadata.primary_key);
         new_metadata.column_ttls_by_name[name] = new_ttl_entry;
     }
 
     if (new_metadata.partition_key.definition_ast != nullptr)
-        new_metadata.partition_key.recalculateWithNewColumns(new_metadata.columns, global_context);
+        new_metadata.partition_key.recalculateWithNewColumns(new_metadata.columns, getContext());
 
     if (!metadata_diff.sorting_key_changed) /// otherwise already updated
-        new_metadata.sorting_key.recalculateWithNewColumns(new_metadata.columns, global_context);
+        new_metadata.sorting_key.recalculateWithNewColumns(new_metadata.columns, getContext());
 
     /// Primary key is special, it exists even if not defined
     if (new_metadata.primary_key.definition_ast != nullptr)
     {
-        new_metadata.primary_key.recalculateWithNewColumns(new_metadata.columns, global_context);
+        new_metadata.primary_key.recalculateWithNewColumns(new_metadata.columns, getContext());
     }
     else
     {
-        new_metadata.primary_key = KeyDescription::getKeyFromAST(new_metadata.sorting_key.definition_ast, new_metadata.columns, global_context);
+        new_metadata.primary_key = KeyDescription::getKeyFromAST(new_metadata.sorting_key.definition_ast, new_metadata.columns, getContext());
         new_metadata.primary_key.definition_ast = nullptr;
     }
 
     if (!metadata_diff.sampling_expression_changed && new_metadata.sampling_key.definition_ast != nullptr)
-        new_metadata.sampling_key.recalculateWithNewColumns(new_metadata.columns, global_context);
+        new_metadata.sampling_key.recalculateWithNewColumns(new_metadata.columns, getContext());
 
     if (!metadata_diff.skip_indices_changed) /// otherwise already updated
     {
         for (auto & index : new_metadata.secondary_indices)
-            index.recalculateWithNewColumns(new_metadata.columns, global_context);
+            index.recalculateWithNewColumns(new_metadata.columns, getContext());
     }
 
     if (!metadata_diff.ttl_table_changed && new_metadata.table_ttl.definition_ast != nullptr)
         new_metadata.table_ttl = TTLTableDescription::getTTLForTableFromAST(
-            new_metadata.table_ttl.definition_ast, new_metadata.columns, global_context, new_metadata.primary_key);
+            new_metadata.table_ttl.definition_ast, new_metadata.columns, getContext(), new_metadata.primary_key);
 
     /// Even if the primary/sorting/partition keys didn't change we must reinitialize it
     /// because primary/partition key column types might have changed.
@@ -1022,7 +1027,7 @@ void StorageReplicatedMergeTree::setTableStructure(
     setProperties(new_metadata, old_metadata);
 
     auto table_id = getStorageID();
-    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(global_context, table_id, new_metadata);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(getContext(), table_id, new_metadata);
 }
 
 
@@ -1649,13 +1654,12 @@ bool StorageReplicatedMergeTree::tryExecuteMerge(const LogEntry & entry)
 
     /// Account TTL merge
     if (isTTLMergeType(future_merged_part.merge_type))
-        global_context.getMergeList().bookMergeWithTTL();
+        getContext()->getMergeList().bookMergeWithTTL();
 
     auto table_id = getStorageID();
 
     /// Add merge to list
-    MergeList::EntryPtr merge_entry = global_context.getMergeList().insert(
-        table_id.database_name, table_id.table_name, future_merged_part);
+    MergeList::EntryPtr merge_entry = getContext()->getMergeList().insert(table_id.database_name, table_id.table_name, future_merged_part);
 
     Transaction transaction(*this);
     MutableDataPartPtr part;
@@ -1673,7 +1677,7 @@ bool StorageReplicatedMergeTree::tryExecuteMerge(const LogEntry & entry)
     {
         part = merger_mutator.mergePartsToTemporaryPart(
             future_merged_part, metadata_snapshot, *merge_entry,
-            table_lock, entry.create_time, global_context, reserved_space, entry.deduplicate, entry.deduplicate_by_columns);
+            table_lock, entry.create_time, getContext(), reserved_space, entry.deduplicate, entry.deduplicate_by_columns);
 
         merger_mutator.renameMergedTemporaryPart(part, parts, &transaction);
 
@@ -1793,7 +1797,7 @@ bool StorageReplicatedMergeTree::tryExecutePartMutation(const StorageReplicatedM
     future_mutated_part.type = source_part->getType();
 
     auto table_id = getStorageID();
-    MergeList::EntryPtr merge_entry = global_context.getMergeList().insert(
+    MergeList::EntryPtr merge_entry = getContext()->getMergeList().insert(
         table_id.database_name, table_id.table_name, future_mutated_part);
 
     Stopwatch stopwatch;
@@ -1809,7 +1813,7 @@ bool StorageReplicatedMergeTree::tryExecutePartMutation(const StorageReplicatedM
     {
         new_part = merger_mutator.mutatePartToTemporaryPart(
             future_mutated_part, metadata_snapshot, commands, *merge_entry,
-            entry.create_time, global_context, reserved_space, table_lock);
+            entry.create_time, getContext(), reserved_space, table_lock);
         renameTempPartAndReplace(new_part, nullptr, &transaction);
 
         try
@@ -2159,12 +2163,20 @@ bool StorageReplicatedMergeTree::executeReplaceRange(const LogEntry & entry)
 
     struct PartDescription
     {
-        PartDescription(size_t index_, const String & src_part_name_, const String & new_part_name_, const String & checksum_hex_,
-                        MergeTreeDataFormatVersion format_version)
-            : index(index_),
-            src_part_name(src_part_name_), src_part_info(MergeTreePartInfo::fromPartName(src_part_name_, format_version)),
-            new_part_name(new_part_name_), new_part_info(MergeTreePartInfo::fromPartName(new_part_name_, format_version)),
-            checksum_hex(checksum_hex_) {}
+        PartDescription(
+            size_t index_,
+            const String & src_part_name_,
+            const String & new_part_name_,
+            const String & checksum_hex_,
+            MergeTreeDataFormatVersion format_version)
+            : index(index_)
+            , src_part_name(src_part_name_)
+            , src_part_info(MergeTreePartInfo::fromPartName(src_part_name_, format_version))
+            , new_part_name(new_part_name_)
+            , new_part_info(MergeTreePartInfo::fromPartName(new_part_name_, format_version))
+            , checksum_hex(checksum_hex_)
+        {
+        }
 
         size_t index; // in log entry arrays
         String src_part_name;
@@ -2239,7 +2251,7 @@ bool StorageReplicatedMergeTree::executeReplaceRange(const LogEntry & entry)
 
     auto clone_data_parts_from_source_table = [&] () -> size_t
     {
-        source_table = DatabaseCatalog::instance().tryGetTable(source_table_id, global_context);
+        source_table = DatabaseCatalog::instance().tryGetTable(source_table_id, getContext());
         if (!source_table)
         {
             LOG_DEBUG(log, "Can't use {} as source table for REPLACE PARTITION command. It does not exist.", source_table_id.getNameForLogs());
@@ -2395,17 +2407,17 @@ bool StorageReplicatedMergeTree::executeReplaceRange(const LogEntry & entry)
         {
             String source_replica_path = zookeeper_path + "/replicas/" + part_desc->replica;
             ReplicatedMergeTreeAddress address(getZooKeeper()->get(source_replica_path + "/host"));
-            auto timeouts = getFetchPartHTTPTimeouts(global_context);
+            auto timeouts = getFetchPartHTTPTimeouts(getContext());
 
-            auto [user, password] = global_context.getInterserverCredentials();
-            String interserver_scheme = global_context.getInterserverScheme();
+            auto credentials = getContext()->getInterserverCredentials();
+            String interserver_scheme = getContext()->getInterserverScheme();
 
             if (interserver_scheme != address.scheme)
                 throw Exception("Interserver schemas are different '" + interserver_scheme + "' != '" + address.scheme + "', can't fetch part from " + address.host, ErrorCodes::LOGICAL_ERROR);
 
             part_desc->res_part = fetcher.fetchPart(
                 metadata_snapshot, part_desc->found_new_part_name, source_replica_path,
-                address.host, address.replication_port, timeouts, user, password, interserver_scheme, false, TMP_PREFIX + "fetch_");
+                address.host, address.replication_port, timeouts, credentials->getUser(), credentials->getPassword(), interserver_scheme, false, TMP_PREFIX + "fetch_");
 
             /// TODO: check columns_version of fetched part
 
@@ -2454,11 +2466,11 @@ bool StorageReplicatedMergeTree::executeReplaceRange(const LogEntry & entry)
                 parts_to_remove = removePartsInRangeFromWorkingSet(drop_range, true, false, data_parts_lock);
         }
 
-        PartLog::addNewParts(global_context, res_parts, watch.elapsed());
+        PartLog::addNewParts(getContext(), res_parts, watch.elapsed());
     }
     catch (...)
     {
-        PartLog::addNewParts(global_context, res_parts, watch.elapsed(), ExecutionStatus::fromCurrentException());
+        PartLog::addNewParts(getContext(), res_parts, watch.elapsed(), ExecutionStatus::fromCurrentException());
         throw;
     }
 
@@ -3293,7 +3305,7 @@ void StorageReplicatedMergeTree::enterLeaderElection()
     try
     {
         leader_election = std::make_shared<zkutil::LeaderElection>(
-            global_context.getSchedulePool(),
+            getContext()->getSchedulePool(),
             zookeeper_path + "/leader_election",
             *current_zookeeper,    /// current_zookeeper lives for the lifetime of leader_election,
                                    ///  since before changing `current_zookeeper`, `leader_election` object is destroyed in `partialShutdown` method.
@@ -3329,9 +3341,9 @@ void StorageReplicatedMergeTree::exitLeaderElection()
     leader_election = nullptr;
 }
 
-ConnectionTimeouts StorageReplicatedMergeTree::getFetchPartHTTPTimeouts(const Context & context)
+ConnectionTimeouts StorageReplicatedMergeTree::getFetchPartHTTPTimeouts(ContextPtr local_context)
 {
-    auto timeouts = ConnectionTimeouts::getHTTPTimeouts(context);
+    auto timeouts = ConnectionTimeouts::getHTTPTimeouts(local_context);
     auto settings = getSettings();
 
     if (settings->replicated_fetches_http_connection_timeout.changed)
@@ -3690,7 +3702,7 @@ bool StorageReplicatedMergeTree::fetchPart(const String & part_name, const Stora
         }
     }
 
-    SCOPE_EXIT
+    SCOPE_EXIT_MEMORY
     ({
         std::lock_guard lock(currently_fetching_parts_mutex);
         currently_fetching_parts.erase(part_name);
@@ -3751,8 +3763,8 @@ bool StorageReplicatedMergeTree::fetchPart(const String & part_name, const Stora
 
     ReplicatedMergeTreeAddress address;
     ConnectionTimeouts timeouts;
-    std::pair<String, String> user_password;
     String interserver_scheme;
+    InterserverCredentialsPtr credentials;
     std::optional<CurrentlySubmergingEmergingTagger> tagger_ptr;
     std::function<MutableDataPartPtr()> get_part;
 
@@ -3766,12 +3778,12 @@ bool StorageReplicatedMergeTree::fetchPart(const String & part_name, const Stora
     else
     {
         address.fromString(zookeeper->get(source_replica_path + "/host"));
-        timeouts = getFetchPartHTTPTimeouts(global_context);
+        timeouts = getFetchPartHTTPTimeouts(getContext());
 
-        user_password = global_context.getInterserverCredentials();
-        interserver_scheme = global_context.getInterserverScheme();
+        credentials = getContext()->getInterserverCredentials();
+        interserver_scheme = getContext()->getInterserverScheme();
 
-        get_part = [&, address, timeouts, user_password, interserver_scheme]()
+        get_part = [&, address, timeouts, credentials, interserver_scheme]()
         {
             if (interserver_scheme != address.scheme)
                 throw Exception("Interserver schemes are different: '" + interserver_scheme
@@ -3785,8 +3797,8 @@ bool StorageReplicatedMergeTree::fetchPart(const String & part_name, const Stora
                 address.host,
                 address.replication_port,
                 timeouts,
-                user_password.first,
-                user_password.second,
+                credentials->getUser(),
+                credentials->getPassword(),
                 interserver_scheme,
                 to_detached,
                 "",
@@ -3898,7 +3910,7 @@ bool StorageReplicatedMergeTree::fetchExistsPart(const String & part_name, const
         }
     }
 
-    SCOPE_EXIT
+    SCOPE_EXIT_MEMORY
     ({
         std::lock_guard lock(currently_fetching_parts_mutex);
         currently_fetching_parts.erase(part_name);
@@ -3923,11 +3935,11 @@ bool StorageReplicatedMergeTree::fetchExistsPart(const String & part_name, const
     std::function<MutableDataPartPtr()> get_part;
 
     ReplicatedMergeTreeAddress address(zookeeper->get(source_replica_path + "/host"));
-    auto timeouts = ConnectionTimeouts::getHTTPTimeouts(global_context);
-    auto user_password = global_context.getInterserverCredentials();
-    String interserver_scheme = global_context.getInterserverScheme();
+    auto timeouts = ConnectionTimeouts::getHTTPTimeouts(getContext());
+    auto credentials = getContext()->getInterserverCredentials();
+    String interserver_scheme = getContext()->getInterserverScheme();
 
-    get_part = [&, address, timeouts, user_password, interserver_scheme]()
+    get_part = [&, address, timeouts, interserver_scheme, credentials]()
     {
         if (interserver_scheme != address.scheme)
             throw Exception("Interserver schemes are different: '" + interserver_scheme
@@ -3937,7 +3949,7 @@ bool StorageReplicatedMergeTree::fetchExistsPart(const String & part_name, const
         return fetcher.fetchPart(
             metadata_snapshot, part_name, source_replica_path,
             address.host, address.replication_port,
-            timeouts, user_password.first, user_password.second, interserver_scheme, false, "", nullptr, true,
+            timeouts, credentials->getUser(), credentials->getPassword(), interserver_scheme, false, "", nullptr, true,
             replaced_disk);
     };
 
@@ -3985,7 +3997,7 @@ void StorageReplicatedMergeTree::startup()
         InterserverIOEndpointPtr data_parts_exchange_ptr = std::make_shared<DataPartsExchange::Service>(*this);
         [[maybe_unused]] auto prev_ptr = std::atomic_exchange(&data_parts_exchange_endpoint, data_parts_exchange_ptr);
         assert(prev_ptr == nullptr);
-        global_context.getInterserverIOHandler().addEndpoint(data_parts_exchange_ptr->getId(replica_path), data_parts_exchange_ptr);
+        getContext()->getInterserverIOHandler().addEndpoint(data_parts_exchange_ptr->getId(replica_path), data_parts_exchange_ptr);
 
         /// In this thread replica will be activated.
         restarting_thread.start();
@@ -4040,7 +4052,7 @@ void StorageReplicatedMergeTree::shutdown()
     auto data_parts_exchange_ptr = std::atomic_exchange(&data_parts_exchange_endpoint, InterserverIOEndpointPtr{});
     if (data_parts_exchange_ptr)
     {
-        global_context.getInterserverIOHandler().removeEndpointIfExists(data_parts_exchange_ptr->getId(replica_path));
+        getContext()->getInterserverIOHandler().removeEndpointIfExists(data_parts_exchange_ptr->getId(replica_path));
         /// Ask all parts exchange handlers to finish asap. New ones will fail to start
         data_parts_exchange_ptr->blocker.cancelForever();
         /// Wait for all of them
@@ -4126,7 +4138,7 @@ void StorageReplicatedMergeTree::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t max_block_size,
     const unsigned num_streams)
@@ -4136,15 +4148,15 @@ void StorageReplicatedMergeTree::read(
     * 2. Do not read parts that have not yet been written to the quorum of the replicas.
     * For this you have to synchronously go to ZooKeeper.
     */
-    if (context.getSettingsRef().select_sequential_consistency)
+    if (local_context->getSettingsRef().select_sequential_consistency)
     {
         auto max_added_blocks = getMaxAddedBlocks();
-        if (auto plan = reader.read(column_names, metadata_snapshot, query_info, context, max_block_size, num_streams, &max_added_blocks))
+        if (auto plan = reader.read(column_names, metadata_snapshot, query_info, local_context, max_block_size, num_streams, &max_added_blocks))
             query_plan = std::move(*plan);
         return;
     }
 
-    if (auto plan = reader.read(column_names, metadata_snapshot, query_info, context, max_block_size, num_streams))
+    if (auto plan = reader.read(column_names, metadata_snapshot, query_info, local_context, max_block_size, num_streams))
         query_plan = std::move(*plan);
 }
 
@@ -4152,16 +4164,16 @@ Pipe StorageReplicatedMergeTree::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     const size_t max_block_size,
     const unsigned num_streams)
 {
     QueryPlan plan;
-    read(plan, column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams);
+    read(plan, column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams);
     return plan.convertToPipe(
-        QueryPlanOptimizationSettings::fromContext(context),
-        BuildQueryPipelineSettings::fromContext(context));
+        QueryPlanOptimizationSettings::fromContext(local_context),
+        BuildQueryPipelineSettings::fromContext(local_context));
 }
 
 
@@ -4200,11 +4212,11 @@ std::optional<UInt64> StorageReplicatedMergeTree::totalRows(const Settings & set
     return res;
 }
 
-std::optional<UInt64> StorageReplicatedMergeTree::totalRowsByPartitionPredicate(const SelectQueryInfo & query_info, const Context & context) const
+std::optional<UInt64> StorageReplicatedMergeTree::totalRowsByPartitionPredicate(const SelectQueryInfo & query_info, ContextPtr local_context) const
 {
     DataPartsVector parts;
-    foreachCommittedParts([&](auto & part) { parts.push_back(part); }, context.getSettingsRef().select_sequential_consistency);
-    return totalRowsByPartitionPredicateImpl(query_info, context, parts);
+    foreachCommittedParts([&](auto & part) { parts.push_back(part); }, local_context->getSettingsRef().select_sequential_consistency);
+    return totalRowsByPartitionPredicateImpl(query_info, local_context, parts);
 }
 
 std::optional<UInt64> StorageReplicatedMergeTree::totalBytes(const Settings & settings) const
@@ -4222,12 +4234,12 @@ void StorageReplicatedMergeTree::assertNotReadonly() const
 }
 
 
-BlockOutputStreamPtr StorageReplicatedMergeTree::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr StorageReplicatedMergeTree::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr local_context)
 {
     const auto storage_settings_ptr = getSettings();
     assertNotReadonly();
 
-    const Settings & query_settings = context.getSettingsRef();
+    const Settings & query_settings = local_context->getSettingsRef();
     bool deduplicate = storage_settings_ptr->replicated_deduplication_window != 0 && query_settings.insert_deduplicate;
 
     // TODO: should we also somehow pass list of columns to deduplicate on to the ReplicatedMergeTreeBlockOutputStream ?
@@ -4237,7 +4249,7 @@ BlockOutputStreamPtr StorageReplicatedMergeTree::write(const ASTPtr & /*query*/,
         query_settings.max_partitions_per_insert_block,
         query_settings.insert_quorum_parallel,
         deduplicate,
-        context.getSettingsRef().optimize_on_insert);
+        local_context->getSettingsRef().optimize_on_insert);
 }
 
 
@@ -4248,11 +4260,11 @@ bool StorageReplicatedMergeTree::optimize(
     bool final,
     bool deduplicate,
     const Names & deduplicate_by_columns,
-    const Context & query_context)
+    ContextPtr query_context)
 {
     /// NOTE: exclusive lock cannot be used here, since this may lead to deadlock (see comments below),
     /// but it should be safe to use non-exclusive to avoid dropping parts that may be required for processing queue.
-    auto table_lock = lockForShare(query_context.getCurrentQueryId(), query_context.getSettingsRef().lock_acquire_timeout);
+    auto table_lock = lockForShare(query_context->getCurrentQueryId(), query_context->getSettingsRef().lock_acquire_timeout);
 
     assertNotReadonly();
 
@@ -4267,7 +4279,7 @@ bool StorageReplicatedMergeTree::optimize(
 
         auto handle_noop = [&] (const String & message)
         {
-            if (query_context.getSettingsRef().optimize_throw_if_noop)
+            if (query_context->getSettingsRef().optimize_throw_if_noop)
                 throw Exception(message, ErrorCodes::CANNOT_ASSIGN_OPTIMIZE);
             return false;
         };
@@ -4301,7 +4313,7 @@ bool StorageReplicatedMergeTree::optimize(
                         future_merged_part.uuid = UUIDHelpers::generateV4();
 
                     SelectPartsDecision select_decision = merger_mutator.selectAllPartsToMergeWithinPartition(
-                        future_merged_part, disk_space, can_merge, partition_id, true, metadata_snapshot, nullptr, query_context.getSettingsRef().optimize_skip_merged_partitions);
+                        future_merged_part, disk_space, can_merge, partition_id, true, metadata_snapshot, nullptr, query_context->getSettingsRef().optimize_skip_merged_partitions);
 
                     if (select_decision != SelectPartsDecision::SELECTED)
                         break;
@@ -4352,7 +4364,7 @@ bool StorageReplicatedMergeTree::optimize(
                     UInt64 disk_space = getStoragePolicy()->getMaxUnreservedFreeSpace();
                     String partition_id = getPartitionIDFromQuery(partition, query_context);
                     select_decision = merger_mutator.selectAllPartsToMergeWithinPartition(
-                        future_merged_part, disk_space, can_merge, partition_id, final, metadata_snapshot, &disable_reason, query_context.getSettingsRef().optimize_skip_merged_partitions);
+                        future_merged_part, disk_space, can_merge, partition_id, final, metadata_snapshot, &disable_reason, query_context->getSettingsRef().optimize_skip_merged_partitions);
                 }
 
                 /// If there is nothing to merge then we treat this merge as successful (needed for optimize final optimization)
@@ -4390,7 +4402,7 @@ bool StorageReplicatedMergeTree::optimize(
         }
     }
 
-    if (query_context.getSettingsRef().replication_alter_partitions_sync != 0)
+    if (query_context->getSettingsRef().replication_alter_partitions_sync != 0)
     {
         /// NOTE Table lock must not be held while waiting. Some combination of R-W-R locks from different threads will yield to deadlock.
         for (auto & merge_entry : merge_entries)
@@ -4435,7 +4447,7 @@ bool StorageReplicatedMergeTree::executeMetadataAlter(const StorageReplicatedMer
 
 
 std::set<String> StorageReplicatedMergeTree::getPartitionIdsAffectedByCommands(
-    const MutationCommands & commands, const Context & query_context) const
+    const MutationCommands & commands, ContextPtr query_context) const
 {
     std::set<String> affected_partition_ids;
 
@@ -4457,7 +4469,7 @@ std::set<String> StorageReplicatedMergeTree::getPartitionIdsAffectedByCommands(
 
 
 PartitionBlockNumbersHolder StorageReplicatedMergeTree::allocateBlockNumbersInAffectedPartitions(
-    const MutationCommands & commands, const Context & query_context, const zkutil::ZooKeeperPtr & zookeeper) const
+    const MutationCommands & commands, ContextPtr query_context, const zkutil::ZooKeeperPtr & zookeeper) const
 {
     const std::set<String> mutation_affected_partition_ids = getPartitionIdsAffectedByCommands(commands, query_context);
 
@@ -4489,7 +4501,7 @@ PartitionBlockNumbersHolder StorageReplicatedMergeTree::allocateBlockNumbersInAf
 
 
 void StorageReplicatedMergeTree::alter(
-    const AlterCommands & commands, const Context & query_context, TableLockHolder & table_lock_holder)
+    const AlterCommands & commands, ContextPtr query_context, TableLockHolder & table_lock_holder)
 {
     assertNotReadonly();
 
@@ -4596,7 +4608,7 @@ void StorageReplicatedMergeTree::alter(
         alter_entry->create_time = time(nullptr);
 
         auto maybe_mutation_commands = commands.getMutationCommands(
-            *current_metadata, query_context.getSettingsRef().materialize_ttl_after_modify, query_context);
+            *current_metadata, query_context->getSettingsRef().materialize_ttl_after_modify, query_context);
         alter_entry->have_mutation = !maybe_mutation_commands.empty();
 
         alter_path_idx = ops.size();
@@ -4628,7 +4640,7 @@ void StorageReplicatedMergeTree::alter(
                 zkutil::makeCreateRequest(mutations_path + "/", mutation_entry.toString(), zkutil::CreateMode::PersistentSequential));
         }
 
-        if (auto txn = query_context.getZooKeeperMetadataTransaction())
+        if (auto txn = query_context->getZooKeeperMetadataTransaction())
         {
             txn->moveOpsTo(ops);
             /// NOTE: IDatabase::alterTable(...) is called when executing ALTER_METADATA queue entry without query context,
@@ -4684,12 +4696,12 @@ void StorageReplicatedMergeTree::alter(
     table_lock_holder.reset();
 
     std::vector<String> unwaited;
-    if (query_context.getSettingsRef().replication_alter_partitions_sync == 2)
+    if (query_context->getSettingsRef().replication_alter_partitions_sync == 2)
     {
         LOG_DEBUG(log, "Updated shared metadata nodes in ZooKeeper. Waiting for replicas to apply changes.");
         unwaited = waitForAllReplicasToProcessLogEntry(*alter_entry, false);
     }
-    else if (query_context.getSettingsRef().replication_alter_partitions_sync == 1)
+    else if (query_context->getSettingsRef().replication_alter_partitions_sync == 1)
     {
         LOG_DEBUG(log, "Updated shared metadata nodes in ZooKeeper. Waiting for replicas to apply changes.");
         waitForReplicaToProcessLogEntry(replica_name, *alter_entry);
@@ -4701,7 +4713,7 @@ void StorageReplicatedMergeTree::alter(
     if (mutation_znode)
     {
         LOG_DEBUG(log, "Metadata changes applied. Will wait for data changes.");
-        waitMutation(*mutation_znode, query_context.getSettingsRef().replication_alter_partitions_sync);
+        waitMutation(*mutation_znode, query_context->getSettingsRef().replication_alter_partitions_sync);
         LOG_DEBUG(log, "Data changes applied.");
     }
 }
@@ -4765,7 +4777,7 @@ bool StorageReplicatedMergeTree::getFakePartCoveringAllPartsInPartition(const St
 }
 
 
-void StorageReplicatedMergeTree::dropPartition(const ASTPtr & partition, bool detach, bool drop_part, const Context & query_context, bool throw_if_noop)
+void StorageReplicatedMergeTree::dropPartition(const ASTPtr & partition, bool detach, bool drop_part, ContextPtr query_context, bool throw_if_noop)
 {
     assertNotReadonly();
     if (!is_leader)
@@ -4790,9 +4802,9 @@ void StorageReplicatedMergeTree::dropPartition(const ASTPtr & partition, bool de
     if (did_drop)
     {
         /// If necessary, wait until the operation is performed on itself or on all replicas.
-        if (query_context.getSettingsRef().replication_alter_partitions_sync != 0)
+        if (query_context->getSettingsRef().replication_alter_partitions_sync != 0)
         {
-            if (query_context.getSettingsRef().replication_alter_partitions_sync == 1)
+            if (query_context->getSettingsRef().replication_alter_partitions_sync == 1)
                 waitForReplicaToProcessLogEntry(replica_name, entry);
             else
                 waitForAllReplicasToProcessLogEntry(entry);
@@ -4808,7 +4820,7 @@ void StorageReplicatedMergeTree::dropPartition(const ASTPtr & partition, bool de
 
 
 void StorageReplicatedMergeTree::truncate(
-    const ASTPtr &, const StorageMetadataPtr &, const Context & query_context, TableExclusiveLockHolder & table_lock)
+    const ASTPtr &, const StorageMetadataPtr &, ContextPtr query_context, TableExclusiveLockHolder & table_lock)
 {
     table_lock.release();   /// Truncate is done asynchronously.
 
@@ -4834,7 +4846,7 @@ PartitionCommandsResultInfo StorageReplicatedMergeTree::attachPartition(
     const ASTPtr & partition,
     const StorageMetadataPtr & metadata_snapshot,
     bool attach_part,
-    const Context & query_context)
+    ContextPtr query_context)
 {
     assertNotReadonly();
 
@@ -4869,7 +4881,7 @@ PartitionCommandsResultInfo StorageReplicatedMergeTree::attachPartition(
 void StorageReplicatedMergeTree::checkTableCanBeDropped() const
 {
     auto table_id = getStorageID();
-    global_context.checkTableCanBeDropped(table_id.database_name, table_id.table_name, getTotalActiveSizeInBytes());
+    getContext()->checkTableCanBeDropped(table_id.database_name, table_id.table_name, getTotalActiveSizeInBytes());
 }
 
 void StorageReplicatedMergeTree::checkTableCanBeRenamed() const
@@ -5349,13 +5361,13 @@ void StorageReplicatedMergeTree::fetchPartition(
     const ASTPtr & partition,
     const StorageMetadataPtr & metadata_snapshot,
     const String & from_,
-    const Context & query_context)
+    ContextPtr query_context)
 {
     Macros::MacroExpansionInfo info;
     info.expand_special_macros_only = false;
     info.table_id = getStorageID();
     info.table_id.uuid = UUIDHelpers::Nil;
-    auto expand_from = query_context.getMacros()->expand(from_, info);
+    auto expand_from = query_context->getMacros()->expand(from_, info);
     String auxiliary_zookeeper_name = extractZooKeeperName(expand_from);
     String from = extractZooKeeperPath(expand_from);
     if (from.empty())
@@ -5365,7 +5377,7 @@ void StorageReplicatedMergeTree::fetchPartition(
     zkutil::ZooKeeperPtr zookeeper;
     if (auxiliary_zookeeper_name != default_zookeeper_name)
     {
-        zookeeper = global_context.getAuxiliaryZooKeeper(auxiliary_zookeeper_name);
+        zookeeper = getContext()->getAuxiliaryZooKeeper(auxiliary_zookeeper_name);
 
         LOG_INFO(log, "Will fetch partition {} from shard {} (auxiliary zookeeper '{}')", partition_id, from_, auxiliary_zookeeper_name);
     }
@@ -5466,7 +5478,7 @@ void StorageReplicatedMergeTree::fetchPartition(
         if (try_no)
             LOG_INFO(log, "Some of parts ({}) are missing. Will try to fetch covering parts.", missing_parts.size());
 
-        if (try_no >= query_context.getSettings().max_fetch_partition_retries_count)
+        if (try_no >= query_context->getSettings().max_fetch_partition_retries_count)
             throw Exception("Too many retries to fetch parts from " + best_replica_path, ErrorCodes::TOO_MANY_RETRIES_TO_FETCH_PARTS);
 
         Strings parts = zookeeper->getChildren(best_replica_path + "/parts");
@@ -5531,7 +5543,7 @@ void StorageReplicatedMergeTree::fetchPartition(
 }
 
 
-void StorageReplicatedMergeTree::mutate(const MutationCommands & commands, const Context & query_context)
+void StorageReplicatedMergeTree::mutate(const MutationCommands & commands, ContextPtr query_context)
 {
     /// Overview of the mutation algorithm.
     ///
@@ -5615,7 +5627,7 @@ void StorageReplicatedMergeTree::mutate(const MutationCommands & commands, const
         requests.emplace_back(zkutil::makeCreateRequest(
             mutations_path + "/", mutation_entry.toString(), zkutil::CreateMode::PersistentSequential));
 
-        if (auto txn = query_context.getZooKeeperMetadataTransaction())
+        if (auto txn = query_context->getZooKeeperMetadataTransaction())
             txn->moveOpsTo(requests);
 
         Coordination::Responses responses;
@@ -5640,7 +5652,7 @@ void StorageReplicatedMergeTree::mutate(const MutationCommands & commands, const
             throw Coordination::Exception("Unable to create a mutation znode", rc);
     }
 
-    waitMutation(mutation_entry.znode_name, query_context.getSettingsRef().mutations_sync);
+    waitMutation(mutation_entry.znode_name, query_context->getSettingsRef().mutations_sync);
 }
 
 void StorageReplicatedMergeTree::waitMutation(const String & znode_name, size_t mutations_sync) const
@@ -5684,11 +5696,61 @@ CancellationCode StorageReplicatedMergeTree::killMutation(const String & mutatio
     {
         const String & partition_id = pair.first;
         Int64 block_number = pair.second;
-        global_context.getMergeList().cancelPartMutations(partition_id, block_number);
+        getContext()->getMergeList().cancelPartMutations(partition_id, block_number);
     }
     return CancellationCode::CancelSent;
 }
 
+void StorageReplicatedMergeTree::removePartsFromFilesystem(const DataPartsVector & parts)
+{
+    auto remove_part = [&](const auto & part)
+    {
+        LOG_DEBUG(log, "Removing part from filesystem {}", part.name);
+        try
+        {
+            bool keep_s3 = !this->unlockSharedData(part);
+            part.remove(keep_s3);
+        }
+        catch (...)
+        {
+            tryLogCurrentException(log, "There is a problem with deleting part " + part.name + " from filesystem");
+        }
+    };
+
+    const auto settings = getSettings();
+    if (settings->max_part_removal_threads > 1 && parts.size() > settings->concurrent_part_removal_threshold)
+    {
+        /// Parallel parts removal.
+
+        size_t num_threads = std::min<size_t>(settings->max_part_removal_threads, parts.size());
+        ThreadPool pool(num_threads);
+
+        /// NOTE: Under heavy system load you may get "Cannot schedule a task" from ThreadPool.
+        for (const DataPartPtr & part : parts)
+        {
+            pool.scheduleOrThrowOnError([&, thread_group = CurrentThread::getGroup()]
+            {
+                SCOPE_EXIT_SAFE(
+                    if (thread_group)
+                        CurrentThread::detachQueryIfNotDetached();
+                );
+                if (thread_group)
+                    CurrentThread::attachTo(thread_group);
+
+                remove_part(*part);
+            });
+        }
+
+        pool.wait();
+    }
+    else
+    {
+        for (const DataPartPtr & part : parts)
+        {
+            remove_part(*part);
+        }
+    }
+}
 
 void StorageReplicatedMergeTree::clearOldPartsAndRemoveFromZK()
 {
@@ -5714,26 +5776,10 @@ void StorageReplicatedMergeTree::clearOldPartsAndRemoveFromZK()
     }
     parts.clear();
 
-    auto remove_parts_from_filesystem = [log=log, this] (const DataPartsVector & parts_to_remove)
-    {
-        for (const auto & part : parts_to_remove)
-        {
-            try
-            {
-                bool keep_s3 = !this->unlockSharedData(*part);
-                part->remove(keep_s3);
-            }
-            catch (...)
-            {
-                tryLogCurrentException(log, "There is a problem with deleting part " + part->name + " from filesystem");
-            }
-        }
-    };
-
     /// Delete duplicate parts from filesystem
     if (!parts_to_delete_only_from_filesystem.empty())
     {
-        remove_parts_from_filesystem(parts_to_delete_only_from_filesystem);
+        removePartsFromFilesystem(parts_to_delete_only_from_filesystem);
         removePartsFinally(parts_to_delete_only_from_filesystem);
 
         LOG_DEBUG(log, "Removed {} old duplicate parts", parts_to_delete_only_from_filesystem.size());
@@ -5778,7 +5824,7 @@ void StorageReplicatedMergeTree::clearOldPartsAndRemoveFromZK()
     /// Remove parts from filesystem and finally from data_parts
     if (!parts_to_remove_from_filesystem.empty())
     {
-        remove_parts_from_filesystem(parts_to_remove_from_filesystem);
+        removePartsFromFilesystem(parts_to_remove_from_filesystem);
         removePartsFinally(parts_to_remove_from_filesystem);
 
         LOG_DEBUG(log, "Removed {} old parts", parts_to_remove_from_filesystem.size());
@@ -5983,18 +6029,18 @@ void StorageReplicatedMergeTree::clearBlocksInPartition(
 }
 
 void StorageReplicatedMergeTree::replacePartitionFrom(
-    const StoragePtr & source_table, const ASTPtr & partition, bool replace, const Context & context)
+    const StoragePtr & source_table, const ASTPtr & partition, bool replace, ContextPtr query_context)
 {
     /// First argument is true, because we possibly will add new data to current table.
-    auto lock1 = lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
-    auto lock2 = source_table->lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+    auto lock1 = lockForShare(query_context->getCurrentQueryId(), query_context->getSettingsRef().lock_acquire_timeout);
+    auto lock2 = source_table->lockForShare(query_context->getCurrentQueryId(), query_context->getSettingsRef().lock_acquire_timeout);
 
     auto source_metadata_snapshot = source_table->getInMemoryMetadataPtr();
     auto metadata_snapshot = getInMemoryMetadataPtr();
 
     Stopwatch watch;
     MergeTreeData & src_data = checkStructureAndGetMergeTreeData(source_table, source_metadata_snapshot, metadata_snapshot);
-    String partition_id = getPartitionIDFromQuery(partition, context);
+    String partition_id = getPartitionIDFromQuery(partition, query_context);
 
     DataPartsVector src_all_parts = src_data.getDataPartsVectorInPartition(MergeTreeDataPartState::Committed, partition_id);
     DataPartsVector src_parts;
@@ -6120,7 +6166,7 @@ void StorageReplicatedMergeTree::replacePartitionFrom(
             }
         }
 
-        if (auto txn = context.getZooKeeperMetadataTransaction())
+        if (auto txn = query_context->getZooKeeperMetadataTransaction())
             txn->moveOpsTo(ops);
 
         ops.emplace_back(zkutil::makeSetRequest(zookeeper_path + "/log", "", -1));  /// Just update version
@@ -6144,11 +6190,11 @@ void StorageReplicatedMergeTree::replacePartitionFrom(
                 parts_to_remove = removePartsInRangeFromWorkingSet(drop_range, true, false, data_parts_lock);
         }
 
-        PartLog::addNewParts(global_context, dst_parts, watch.elapsed());
+        PartLog::addNewParts(getContext(), dst_parts, watch.elapsed());
     }
     catch (...)
     {
-        PartLog::addNewParts(global_context, dst_parts, watch.elapsed(), ExecutionStatus::fromCurrentException());
+        PartLog::addNewParts(getContext(), dst_parts, watch.elapsed(), ExecutionStatus::fromCurrentException());
         throw;
     }
 
@@ -6166,7 +6212,7 @@ void StorageReplicatedMergeTree::replacePartitionFrom(
     cleanup_thread.wakeup();
 
     /// If necessary, wait until the operation is performed on all replicas.
-    if (context.getSettingsRef().replication_alter_partitions_sync > 1)
+    if (query_context->getSettingsRef().replication_alter_partitions_sync > 1)
     {
         lock2.reset();
         lock1.reset();
@@ -6174,10 +6220,10 @@ void StorageReplicatedMergeTree::replacePartitionFrom(
     }
 }
 
-void StorageReplicatedMergeTree::movePartitionToTable(const StoragePtr & dest_table, const ASTPtr & partition, const Context & query_context)
+void StorageReplicatedMergeTree::movePartitionToTable(const StoragePtr & dest_table, const ASTPtr & partition, ContextPtr query_context)
 {
-    auto lock1 = lockForShare(query_context.getCurrentQueryId(), query_context.getSettingsRef().lock_acquire_timeout);
-    auto lock2 = dest_table->lockForShare(query_context.getCurrentQueryId(), query_context.getSettingsRef().lock_acquire_timeout);
+    auto lock1 = lockForShare(query_context->getCurrentQueryId(), query_context->getSettingsRef().lock_acquire_timeout);
+    auto lock2 = dest_table->lockForShare(query_context->getCurrentQueryId(), query_context->getSettingsRef().lock_acquire_timeout);
 
     auto dest_table_storage = std::dynamic_pointer_cast<StorageReplicatedMergeTree>(dest_table);
     if (!dest_table_storage)
@@ -6330,11 +6376,11 @@ void StorageReplicatedMergeTree::movePartitionToTable(const StoragePtr & dest_ta
             transaction.commit(&lock);
         }
 
-        PartLog::addNewParts(global_context, dst_parts, watch.elapsed());
+        PartLog::addNewParts(getContext(), dst_parts, watch.elapsed());
     }
     catch (...)
     {
-        PartLog::addNewParts(global_context, dst_parts, watch.elapsed(), ExecutionStatus::fromCurrentException());
+        PartLog::addNewParts(getContext(), dst_parts, watch.elapsed(), ExecutionStatus::fromCurrentException());
         throw;
     }
 
@@ -6349,7 +6395,7 @@ void StorageReplicatedMergeTree::movePartitionToTable(const StoragePtr & dest_ta
     parts_to_remove.clear();
     cleanup_thread.wakeup();
 
-    if (query_context.getSettingsRef().replication_alter_partitions_sync > 1)
+    if (query_context->getSettingsRef().replication_alter_partitions_sync > 1)
     {
         lock2.reset();
         dest_table_storage->waitForAllReplicasToProcessLogEntry(entry);
@@ -6366,7 +6412,7 @@ void StorageReplicatedMergeTree::movePartitionToTable(const StoragePtr & dest_ta
     log_znode_path = dynamic_cast<const Coordination::CreateResponse &>(*op_results.front()).path_created;
     entry_delete.znode_name = log_znode_path.substr(log_znode_path.find_last_of('/') + 1);
 
-    if (query_context.getSettingsRef().replication_alter_partitions_sync > 1)
+    if (query_context->getSettingsRef().replication_alter_partitions_sync > 1)
     {
         lock1.reset();
         waitForAllReplicasToProcessLogEntry(entry_delete);
@@ -6421,16 +6467,16 @@ void StorageReplicatedMergeTree::getCommitPartOps(
 
 ReplicatedMergeTreeAddress StorageReplicatedMergeTree::getReplicatedMergeTreeAddress() const
 {
-    auto host_port = global_context.getInterserverIOAddress();
+    auto host_port = getContext()->getInterserverIOAddress();
     auto table_id = getStorageID();
 
     ReplicatedMergeTreeAddress res;
     res.host = host_port.first;
     res.replication_port = host_port.second;
-    res.queries_port = global_context.getTCPPort();
+    res.queries_port = getContext()->getTCPPort();
     res.database = table_id.database_name;
     res.table = table_id.table_name;
-    res.scheme = global_context.getInterserverScheme();
+    res.scheme = getContext()->getInterserverScheme();
     return res;
 }
 
@@ -6591,7 +6637,7 @@ bool StorageReplicatedMergeTree::dropPart(
 }
 
 bool StorageReplicatedMergeTree::dropAllPartsInPartition(
-    zkutil::ZooKeeper & zookeeper, String & partition_id, LogEntry & entry, const Context & query_context, bool detach)
+    zkutil::ZooKeeper & zookeeper, String & partition_id, LogEntry & entry, ContextPtr query_context, bool detach)
 {
     MergeTreePartInfo drop_range_info;
     if (!getFakePartCoveringAllPartsInPartition(partition_id, drop_range_info))
@@ -6623,7 +6669,7 @@ bool StorageReplicatedMergeTree::dropAllPartsInPartition(
     Coordination::Requests ops;
     ops.emplace_back(zkutil::makeCreateRequest(zookeeper_path + "/log/log-", entry.toString(), zkutil::CreateMode::PersistentSequential));
     ops.emplace_back(zkutil::makeSetRequest(zookeeper_path + "/log", "", -1));  /// Just update version.
-    if (auto txn = query_context.getZooKeeperMetadataTransaction())
+    if (auto txn = query_context->getZooKeeperMetadataTransaction())
         txn->moveOpsTo(ops);
     Coordination::Responses responses = zookeeper.multi(ops);
 
@@ -6634,13 +6680,13 @@ bool StorageReplicatedMergeTree::dropAllPartsInPartition(
 }
 
 
-CheckResults StorageReplicatedMergeTree::checkData(const ASTPtr & query, const Context & context)
+CheckResults StorageReplicatedMergeTree::checkData(const ASTPtr & query, ContextPtr local_context)
 {
     CheckResults results;
     DataPartsVector data_parts;
     if (const auto & check_query = query->as<ASTCheckQuery &>(); check_query.partition)
     {
-        String partition_id = getPartitionIDFromQuery(check_query.partition, context);
+        String partition_id = getPartitionIDFromQuery(check_query.partition, local_context);
         data_parts = getDataPartsVectorInPartition(MergeTreeDataPartState::Committed, partition_id);
     }
     else
diff --git a/src/Storages/StorageReplicatedMergeTree.h b/src/Storages/StorageReplicatedMergeTree.h
index 0c8aca18c6a..0180fa8bc1a 100644
--- a/src/Storages/StorageReplicatedMergeTree.h
+++ b/src/Storages/StorageReplicatedMergeTree.h
@@ -96,7 +96,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -106,16 +106,16 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
     std::optional<UInt64> totalRows(const Settings & settings) const override;
-    std::optional<UInt64> totalRowsByPartitionPredicate(const SelectQueryInfo & query_info, const Context & context) const override;
+    std::optional<UInt64> totalRowsByPartitionPredicate(const SelectQueryInfo & query_info, ContextPtr context) const override;
     std::optional<UInt64> totalBytes(const Settings & settings) const override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     bool optimize(
         const ASTPtr & query,
@@ -124,11 +124,11 @@ public:
         bool final,
         bool deduplicate,
         const Names & deduplicate_by_columns,
-        const Context & query_context) override;
+        ContextPtr query_context) override;
 
-    void alter(const AlterCommands & commands, const Context & query_context, TableLockHolder & table_lock_holder) override;
+    void alter(const AlterCommands & commands, ContextPtr query_context, TableLockHolder & table_lock_holder) override;
 
-    void mutate(const MutationCommands & commands, const Context & context) override;
+    void mutate(const MutationCommands & commands, ContextPtr context) override;
     void waitMutation(const String & znode_name, size_t mutations_sync) const;
     std::vector<MergeTreeMutationStatus> getMutationsStatus() const override;
     CancellationCode killMutation(const String & mutation_id) override;
@@ -137,7 +137,7 @@ public:
       */
     void drop() override;
 
-    void truncate(const ASTPtr &, const StorageMetadataPtr &, const Context & query_context, TableExclusiveLockHolder &) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr query_context, TableExclusiveLockHolder &) override;
 
     void checkTableCanBeRenamed() const override;
 
@@ -197,7 +197,7 @@ public:
         part_check_thread.enqueuePart(part_name, delay_to_check_seconds);
     }
 
-    CheckResults checkData(const ASTPtr & query, const Context & context) override;
+    CheckResults checkData(const ASTPtr & query, ContextPtr context) override;
 
     /// Checks ability to use granularity
     bool canUseAdaptiveGranularity() const override;
@@ -408,6 +408,8 @@ private:
     /// Just removes part from ZooKeeper using previous method
     void removePartFromZooKeeper(const String & part_name);
 
+    void removePartsFromFilesystem(const DataPartsVector & parts);
+
     /// Quickly removes big set of parts from ZooKeeper (using async multi queries)
     void removePartsFromZooKeeper(zkutil::ZooKeeperPtr & zookeeper, const Strings & part_names,
                                   NameSet * parts_should_be_retried = nullptr);
@@ -515,7 +517,7 @@ private:
 
     /// Exchange parts.
 
-    ConnectionTimeouts getFetchPartHTTPTimeouts(const Context & context);
+    ConnectionTimeouts getFetchPartHTTPTimeouts(ContextPtr context);
 
     /** Returns an empty string if no one has a part.
       */
@@ -617,14 +619,14 @@ private:
 
     bool dropPart(zkutil::ZooKeeperPtr & zookeeper, String part_name, LogEntry & entry, bool detach, bool throw_if_noop);
     bool dropAllPartsInPartition(
-        zkutil::ZooKeeper & zookeeper, String & partition_id, LogEntry & entry, const Context & query_context, bool detach);
+        zkutil::ZooKeeper & zookeeper, String & partition_id, LogEntry & entry, ContextPtr query_context, bool detach);
 
     // Partition helpers
-    void dropPartition(const ASTPtr & partition, bool detach, bool drop_part, const Context & query_context, bool throw_if_noop) override;
-    PartitionCommandsResultInfo attachPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, bool part, const Context & query_context) override;
-    void replacePartitionFrom(const StoragePtr & source_table, const ASTPtr & partition, bool replace, const Context & query_context) override;
-    void movePartitionToTable(const StoragePtr & dest_table, const ASTPtr & partition, const Context & query_context) override;
-    void fetchPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, const String & from, const Context & query_context) override;
+    void dropPartition(const ASTPtr & partition, bool detach, bool drop_part, ContextPtr query_context, bool throw_if_noop) override;
+    PartitionCommandsResultInfo attachPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, bool part, ContextPtr query_context) override;
+    void replacePartitionFrom(const StoragePtr & source_table, const ASTPtr & partition, bool replace, ContextPtr query_context) override;
+    void movePartitionToTable(const StoragePtr & dest_table, const ASTPtr & partition, ContextPtr query_context) override;
+    void fetchPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, const String & from, ContextPtr query_context) override;
 
     /// Check granularity of already existing replicated table in zookeeper if it exists
     /// return true if it's fixed
@@ -638,9 +640,9 @@ private:
 
     void startBackgroundMovesIfNeeded() override;
 
-    std::set<String> getPartitionIdsAffectedByCommands(const MutationCommands & commands, const Context & query_context) const;
+    std::set<String> getPartitionIdsAffectedByCommands(const MutationCommands & commands, ContextPtr query_context) const;
     PartitionBlockNumbersHolder allocateBlockNumbersInAffectedPartitions(
-        const MutationCommands & commands, const Context & query_context, const zkutil::ZooKeeperPtr & zookeeper) const;
+        const MutationCommands & commands, ContextPtr query_context, const zkutil::ZooKeeperPtr & zookeeper) const;
 
 protected:
     /** If not 'attach', either creates a new table in ZK, or adds a replica to an existing table.
@@ -652,7 +654,7 @@ protected:
         const StorageID & table_id_,
         const String & relative_data_path_,
         const StorageInMemoryMetadata & metadata_,
-        Context & context_,
+        ContextPtr context_,
         const String & date_column_name,
         const MergingParams & merging_params_,
         std::unique_ptr<MergeTreeSettings> settings_,
diff --git a/src/Storages/StorageS3.cpp b/src/Storages/StorageS3.cpp
index 6a6a9b8b7b9..af4b1777223 100644
--- a/src/Storages/StorageS3.cpp
+++ b/src/Storages/StorageS3.cpp
@@ -69,7 +69,7 @@ namespace
             const String & format,
             String name_,
             const Block & sample_block,
-            const Context & context,
+            ContextPtr context,
             const ColumnsDescription & columns,
             UInt64 max_block_size,
             const CompressionMethod compression_method,
@@ -144,7 +144,7 @@ namespace
         StorageS3BlockOutputStream(
             const String & format,
             const Block & sample_block_,
-            const Context & context,
+            ContextPtr context,
             const CompressionMethod compression_method,
             const std::shared_ptr<Aws::S3::S3Client> & client,
             const String & bucket,
@@ -204,21 +204,21 @@ StorageS3::StorageS3(
     UInt64 max_connections_,
     const ColumnsDescription & columns_,
     const ConstraintsDescription & constraints_,
-    const Context & context_,
+    ContextPtr context_,
     const String & compression_method_)
     : IStorage(table_id_)
+    , WithContext(context_->getGlobalContext())
     , uri(uri_)
     , access_key_id(access_key_id_)
     , secret_access_key(secret_access_key_)
     , max_connections(max_connections_)
-    , global_context(context_.getGlobalContext())
     , format_name(format_name_)
     , min_upload_part_size(min_upload_part_size_)
     , max_single_part_upload_size(max_single_part_upload_size_)
     , compression_method(compression_method_)
     , name(uri_.storage_name)
 {
-    global_context.getRemoteHostFilter().checkURL(uri_.uri);
+    getContext()->getRemoteHostFilter().checkURL(uri_.uri);
     StorageInMemoryMetadata storage_metadata;
     storage_metadata.setColumns(columns_);
     storage_metadata.setConstraints(constraints_);
@@ -290,12 +290,12 @@ Pipe StorageS3::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size,
     unsigned num_streams)
 {
-    updateAuthSettings(context);
+    updateAuthSettings(local_context);
 
     Pipes pipes;
     bool need_path_column = false;
@@ -315,7 +315,7 @@ Pipe StorageS3::read(
             format_name,
             getName(),
             metadata_snapshot->getSampleBlock(),
-            context,
+            local_context,
             metadata_snapshot->getColumns(),
             max_block_size,
             chooseCompressionMethod(uri.key, compression_method),
@@ -330,13 +330,13 @@ Pipe StorageS3::read(
     return pipe;
 }
 
-BlockOutputStreamPtr StorageS3::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr StorageS3::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr local_context)
 {
-    updateAuthSettings(context);
+    updateAuthSettings(local_context);
     return std::make_shared<StorageS3BlockOutputStream>(
         format_name,
         metadata_snapshot->getSampleBlock(),
-        global_context,
+        getContext(),
         chooseCompressionMethod(uri.key, compression_method),
         client,
         uri.bucket,
@@ -345,9 +345,9 @@ BlockOutputStreamPtr StorageS3::write(const ASTPtr & /*query*/, const StorageMet
         max_single_part_upload_size);
 }
 
-void StorageS3::updateAuthSettings(const Context & context)
+void StorageS3::updateAuthSettings(ContextPtr local_context)
 {
-    auto settings = context.getStorageS3Settings().getSettings(uri.uri.toString());
+    auto settings = local_context->getStorageS3Settings().getSettings(uri.uri.toString());
     if (client && (!access_key_id.empty() || settings == auth_settings))
         return;
 
@@ -360,7 +360,7 @@ void StorageS3::updateAuthSettings(const Context & context)
     }
 
     S3::PocoHTTPClientConfiguration client_configuration = S3::ClientFactory::instance().createClientConfiguration(
-        context.getRemoteHostFilter(), context.getGlobalContext().getSettingsRef().s3_max_redirects);
+        local_context->getRemoteHostFilter(), local_context->getGlobalContext()->getSettingsRef().s3_max_redirects);
 
     client_configuration.endpointOverride = uri.endpoint;
     client_configuration.maxConnections = max_connections;
@@ -372,7 +372,7 @@ void StorageS3::updateAuthSettings(const Context & context)
         credentials.GetAWSSecretKey(),
         settings.server_side_encryption_customer_key_base64,
         std::move(headers),
-        settings.use_environment_credentials.value_or(global_context.getConfigRef().getBool("s3.use_environment_credentials", false)));
+        settings.use_environment_credentials.value_or(getContext()->getConfigRef().getBool("s3.use_environment_credentials", false)));
 
     auth_settings = std::move(settings);
 }
@@ -388,7 +388,7 @@ void registerStorageS3Impl(const String & name, StorageFactory & factory)
                 "Storage S3 requires 2 to 5 arguments: url, [access_key_id, secret_access_key], name of used format and [compression_method].", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
         for (auto & engine_arg : engine_args)
-            engine_arg = evaluateConstantExpressionOrIdentifierAsLiteral(engine_arg, args.local_context);
+            engine_arg = evaluateConstantExpressionOrIdentifierAsLiteral(engine_arg, args.getLocalContext());
 
         String url = engine_args[0]->as<ASTLiteral &>().value.safeGet<String>();
         Poco::URI uri (url);
@@ -402,9 +402,9 @@ void registerStorageS3Impl(const String & name, StorageFactory & factory)
             secret_access_key = engine_args[2]->as<ASTLiteral &>().value.safeGet<String>();
         }
 
-        UInt64 min_upload_part_size = args.local_context.getSettingsRef().s3_min_upload_part_size;
-        UInt64 max_single_part_upload_size = args.local_context.getSettingsRef().s3_max_single_part_upload_size;
-        UInt64 max_connections = args.local_context.getSettingsRef().s3_max_connections;
+        UInt64 min_upload_part_size = args.getLocalContext()->getSettingsRef().s3_min_upload_part_size;
+        UInt64 max_single_part_upload_size = args.getLocalContext()->getSettingsRef().s3_max_single_part_upload_size;
+        UInt64 max_connections = args.getLocalContext()->getSettingsRef().s3_max_connections;
 
         String compression_method;
         String format_name;
@@ -430,7 +430,7 @@ void registerStorageS3Impl(const String & name, StorageFactory & factory)
             max_connections,
             args.columns,
             args.constraints,
-            args.context,
+            args.getContext(),
             compression_method
         );
     },
diff --git a/src/Storages/StorageS3.h b/src/Storages/StorageS3.h
index 46d8c9276a2..14946f881f2 100644
--- a/src/Storages/StorageS3.h
+++ b/src/Storages/StorageS3.h
@@ -23,7 +23,7 @@ namespace DB
  * It sends HTTP GET to server when select is called and
  * HTTP PUT when insert is called.
  */
-class StorageS3 : public ext::shared_ptr_helper<StorageS3>, public IStorage
+class StorageS3 : public ext::shared_ptr_helper<StorageS3>, public IStorage, WithContext
 {
 public:
     StorageS3(const S3::URI & uri,
@@ -36,7 +36,7 @@ public:
         UInt64 max_connections_,
         const ColumnsDescription & columns_,
         const ConstraintsDescription & constraints_,
-        const Context & context_,
+        ContextPtr context_,
         const String & compression_method_ = "");
 
     String getName() const override
@@ -48,12 +48,12 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     NamesAndTypesList getVirtuals() const override;
 
@@ -62,7 +62,6 @@ private:
     const String access_key_id;
     const String secret_access_key;
     const UInt64 max_connections;
-    const Context & global_context;
 
     String format_name;
     size_t min_upload_part_size;
@@ -72,7 +71,7 @@ private:
     String name;
     S3AuthSettings auth_settings;
 
-    void updateAuthSettings(const Context & context);
+    void updateAuthSettings(ContextPtr context);
 };
 
 }
diff --git a/src/Storages/StorageSet.cpp b/src/Storages/StorageSet.cpp
index d64042f0c1e..34bbfed874f 100644
--- a/src/Storages/StorageSet.cpp
+++ b/src/Storages/StorageSet.cpp
@@ -99,7 +99,7 @@ void SetOrJoinBlockOutputStream::writeSuffix()
 }
 
 
-BlockOutputStreamPtr StorageSetOrJoinBase::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & /*context*/)
+BlockOutputStreamPtr StorageSetOrJoinBase::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr /*context*/)
 {
     UInt64 id = ++increment;
     return std::make_shared<SetOrJoinBlockOutputStream>(*this, metadata_snapshot, path, path + "tmp/", toString(id) + ".bin", persistent);
@@ -156,7 +156,7 @@ size_t StorageSet::getSize() const { return set->getTotalRowCount(); }
 std::optional<UInt64> StorageSet::totalRows(const Settings &) const { return set->getTotalRowCount(); }
 std::optional<UInt64> StorageSet::totalBytes(const Settings &) const { return set->getTotalByteCount(); }
 
-void StorageSet::truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context &, TableExclusiveLockHolder &)
+void StorageSet::truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr, TableExclusiveLockHolder &)
 {
     disk->removeRecursive(path);
     disk->createDirectories(path);
@@ -246,7 +246,7 @@ void registerStorageSet(StorageFactory & factory)
         if (has_settings)
             set_settings.loadFromQuery(*args.storage_def);
 
-        DiskPtr disk = args.context.getDisk(set_settings.disk);
+        DiskPtr disk = args.getContext()->getDisk(set_settings.disk);
         return StorageSet::create(disk, args.relative_data_path, args.table_id, args.columns, args.constraints, set_settings.persistent);
     }, StorageFactory::StorageFeatures{ .supports_settings = true, });
 }
diff --git a/src/Storages/StorageSet.h b/src/Storages/StorageSet.h
index 9b9078f7dd5..b87dcf21a23 100644
--- a/src/Storages/StorageSet.h
+++ b/src/Storages/StorageSet.h
@@ -23,7 +23,7 @@ class StorageSetOrJoinBase : public IStorage
 public:
     void rename(const String & new_path_to_table_data, const StorageID & new_table_id) override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     bool storesDataOnDisk() const override { return true; }
     Strings getDataPaths() const override { return {path}; }
@@ -72,7 +72,7 @@ public:
     /// Access the insides.
     SetPtr & getSet() { return set; }
 
-    void truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context &, TableExclusiveLockHolder &) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr, TableExclusiveLockHolder &) override;
 
     std::optional<UInt64> totalRows(const Settings & settings) const override;
     std::optional<UInt64> totalBytes(const Settings & settings) const override;
diff --git a/src/Storages/StorageStripeLog.cpp b/src/Storages/StorageStripeLog.cpp
index f31e66281c8..d845dfb71f2 100644
--- a/src/Storages/StorageStripeLog.cpp
+++ b/src/Storages/StorageStripeLog.cpp
@@ -307,9 +307,9 @@ void StorageStripeLog::rename(const String & new_path_to_table_data, const Stora
 }
 
 
-static std::chrono::seconds getLockTimeout(const Context & context)
+static std::chrono::seconds getLockTimeout(ContextPtr context)
 {
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
     Int64 lock_timeout = settings.lock_acquire_timeout.totalSeconds();
     if (settings.max_execution_time.totalSeconds() != 0 && settings.max_execution_time.totalSeconds() < lock_timeout)
         lock_timeout = settings.max_execution_time.totalSeconds();
@@ -321,7 +321,7 @@ Pipe StorageStripeLog::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t /*max_block_size*/,
     unsigned num_streams)
@@ -358,7 +358,7 @@ Pipe StorageStripeLog::read(
         std::advance(end, (stream + 1) * size / num_streams);
 
         pipes.emplace_back(std::make_shared<StripeLogSource>(
-            *this, metadata_snapshot, column_names, context.getSettingsRef().max_read_buffer_size, index, begin, end));
+            *this, metadata_snapshot, column_names, context->getSettingsRef().max_read_buffer_size, index, begin, end));
     }
 
     /// We do not keep read lock directly at the time of reading, because we read ranges of data that do not change.
@@ -367,7 +367,7 @@ Pipe StorageStripeLog::read(
 }
 
 
-BlockOutputStreamPtr StorageStripeLog::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr StorageStripeLog::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr context)
 {
     std::unique_lock lock(rwlock, getLockTimeout(context));
     if (!lock)
@@ -377,7 +377,7 @@ BlockOutputStreamPtr StorageStripeLog::write(const ASTPtr & /*query*/, const Sto
 }
 
 
-CheckResults StorageStripeLog::checkData(const ASTPtr & /* query */, const Context & context)
+CheckResults StorageStripeLog::checkData(const ASTPtr & /* query */, ContextPtr context)
 {
     std::shared_lock lock(rwlock, getLockTimeout(context));
     if (!lock)
@@ -386,7 +386,7 @@ CheckResults StorageStripeLog::checkData(const ASTPtr & /* query */, const Conte
     return file_checker.check();
 }
 
-void StorageStripeLog::truncate(const ASTPtr &, const StorageMetadataPtr &, const Context &, TableExclusiveLockHolder &)
+void StorageStripeLog::truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr, TableExclusiveLockHolder &)
 {
     disk->clearDirectory(table_path);
     file_checker = FileChecker{disk, table_path + "sizes.json"};
@@ -407,11 +407,11 @@ void registerStorageStripeLog(StorageFactory & factory)
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
         String disk_name = getDiskName(*args.storage_def);
-        DiskPtr disk = args.context.getDisk(disk_name);
+        DiskPtr disk = args.getContext()->getDisk(disk_name);
 
         return StorageStripeLog::create(
             disk, args.relative_data_path, args.table_id, args.columns, args.constraints,
-            args.attach, args.context.getSettings().max_compress_block_size);
+            args.attach, args.getContext()->getSettings().max_compress_block_size);
     }, features);
 }
 
diff --git a/src/Storages/StorageStripeLog.h b/src/Storages/StorageStripeLog.h
index 77fd12cd1aa..7fad94870dc 100644
--- a/src/Storages/StorageStripeLog.h
+++ b/src/Storages/StorageStripeLog.h
@@ -29,21 +29,21 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     void rename(const String & new_path_to_table_data, const StorageID & new_table_id) override;
 
-    CheckResults checkData(const ASTPtr & /* query */, const Context & /* context */) override;
+    CheckResults checkData(const ASTPtr & /* query */, ContextPtr /* context */) override;
 
     bool storesDataOnDisk() const override { return true; }
     Strings getDataPaths() const override { return {DB::fullPath(disk, table_path)}; }
 
-    void truncate(const ASTPtr &, const StorageMetadataPtr &, const Context &, TableExclusiveLockHolder&) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr, TableExclusiveLockHolder&) override;
 
 protected:
     StorageStripeLog(
diff --git a/src/Storages/StorageTableFunction.h b/src/Storages/StorageTableFunction.h
index adb54d65bb4..7d909165d5f 100644
--- a/src/Storages/StorageTableFunction.h
+++ b/src/Storages/StorageTableFunction.h
@@ -73,7 +73,7 @@ public:
             const Names & column_names,
             const StorageMetadataPtr & metadata_snapshot,
             SelectQueryInfo & query_info,
-            const Context & context,
+            ContextPtr context,
             QueryProcessingStage::Enum processed_stage,
             size_t max_block_size,
             unsigned num_streams) override
@@ -96,7 +96,7 @@ public:
                     ActionsDAG::MatchColumnsMode::Name);
             auto convert_actions = std::make_shared<ExpressionActions>(
                 convert_actions_dag,
-                ExpressionActionsSettings::fromSettings(context.getSettingsRef()));
+                ExpressionActionsSettings::fromSettings(context->getSettingsRef()));
 
             pipe.addSimpleTransform([&](const Block & header)
             {
@@ -109,7 +109,7 @@ public:
     BlockOutputStreamPtr write(
             const ASTPtr & query,
             const StorageMetadataPtr & metadata_snapshot,
-            const Context & context) override
+            ContextPtr context) override
     {
         auto storage = getNested();
         auto cached_structure = metadata_snapshot->getSampleBlock();
diff --git a/src/Storages/StorageTinyLog.cpp b/src/Storages/StorageTinyLog.cpp
index b63a0c7d255..41c2961e929 100644
--- a/src/Storages/StorageTinyLog.cpp
+++ b/src/Storages/StorageTinyLog.cpp
@@ -465,9 +465,9 @@ void StorageTinyLog::rename(const String & new_path_to_table_data, const Storage
 }
 
 
-static std::chrono::seconds getLockTimeout(const Context & context)
+static std::chrono::seconds getLockTimeout(ContextPtr context)
 {
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
     Int64 lock_timeout = settings.lock_acquire_timeout.totalSeconds();
     if (settings.max_execution_time.totalSeconds() != 0 && settings.max_execution_time.totalSeconds() < lock_timeout)
         lock_timeout = settings.max_execution_time.totalSeconds();
@@ -479,7 +479,7 @@ Pipe StorageTinyLog::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t max_block_size,
     const unsigned /*num_streams*/)
@@ -490,7 +490,7 @@ Pipe StorageTinyLog::read(
 
     // When reading, we lock the entire storage, because we only have one file
     // per column and can't modify it concurrently.
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
 
     std::shared_lock lock{rwlock, getLockTimeout(context)};
     if (!lock)
@@ -506,13 +506,13 @@ Pipe StorageTinyLog::read(
 }
 
 
-BlockOutputStreamPtr StorageTinyLog::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr StorageTinyLog::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr context)
 {
     return std::make_shared<TinyLogBlockOutputStream>(*this, metadata_snapshot, std::unique_lock{rwlock, getLockTimeout(context)});
 }
 
 
-CheckResults StorageTinyLog::checkData(const ASTPtr & /* query */, const Context & context)
+CheckResults StorageTinyLog::checkData(const ASTPtr & /* query */, ContextPtr context)
 {
     std::shared_lock lock(rwlock, getLockTimeout(context));
     if (!lock)
@@ -522,7 +522,7 @@ CheckResults StorageTinyLog::checkData(const ASTPtr & /* query */, const Context
 }
 
 void StorageTinyLog::truncate(
-    const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context &, TableExclusiveLockHolder &)
+    const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr, TableExclusiveLockHolder &)
 {
     disk->clearDirectory(table_path);
 
@@ -548,11 +548,11 @@ void registerStorageTinyLog(StorageFactory & factory)
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
         String disk_name = getDiskName(*args.storage_def);
-        DiskPtr disk = args.context.getDisk(disk_name);
+        DiskPtr disk = args.getContext()->getDisk(disk_name);
 
         return StorageTinyLog::create(
             disk, args.relative_data_path, args.table_id, args.columns, args.constraints,
-            args.attach, args.context.getSettings().max_compress_block_size);
+            args.attach, args.getContext()->getSettings().max_compress_block_size);
     }, features);
 }
 
diff --git a/src/Storages/StorageTinyLog.h b/src/Storages/StorageTinyLog.h
index 1187f7f905d..01652169b62 100644
--- a/src/Storages/StorageTinyLog.h
+++ b/src/Storages/StorageTinyLog.h
@@ -28,22 +28,22 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     void rename(const String & new_path_to_table_data, const StorageID & new_table_id) override;
 
-    CheckResults checkData(const ASTPtr & /* query */, const Context & /* context */) override;
+    CheckResults checkData(const ASTPtr & /* query */, ContextPtr /* context */) override;
 
     bool storesDataOnDisk() const override { return true; }
     Strings getDataPaths() const override { return {DB::fullPath(disk, table_path)}; }
     bool supportsSubcolumns() const override { return true; }
 
-    void truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, const Context &, TableExclusiveLockHolder &) override;
+    void truncate(const ASTPtr &, const StorageMetadataPtr & metadata_snapshot, ContextPtr, TableExclusiveLockHolder &) override;
 
 protected:
     StorageTinyLog(
diff --git a/src/Storages/StorageURL.cpp b/src/Storages/StorageURL.cpp
index 2d3879340dc..8b6d7839de0 100644
--- a/src/Storages/StorageURL.cpp
+++ b/src/Storages/StorageURL.cpp
@@ -33,7 +33,7 @@ namespace ErrorCodes
 
 IStorageURLBase::IStorageURLBase(
     const Poco::URI & uri_,
-    const Context & /*context_*/,
+    ContextPtr /*context_*/,
     const StorageID & table_id_,
     const String & format_name_,
     const std::optional<FormatSettings> & format_settings_,
@@ -64,7 +64,7 @@ namespace
             const std::optional<FormatSettings> & format_settings,
             String name_,
             const Block & sample_block,
-            const Context & context,
+            ContextPtr context,
             const ColumnsDescription & columns,
             UInt64 max_block_size,
             const ConnectionTimeouts & timeouts,
@@ -96,11 +96,11 @@ namespace
                     method,
                     std::move(callback),
                     timeouts,
-                    context.getSettingsRef().max_http_get_redirects,
+                    context->getSettingsRef().max_http_get_redirects,
                     Poco::Net::HTTPBasicCredentials{},
                     DBMS_DEFAULT_BUFFER_SIZE,
                     header,
-                    context.getRemoteHostFilter()),
+                    context->getRemoteHostFilter()),
                 compression_method);
 
             auto input_format = FormatFactory::instance().getInput(format, *read_buf, sample_block, context, max_block_size, format_settings);
@@ -144,7 +144,7 @@ StorageURLBlockOutputStream::StorageURLBlockOutputStream(const Poco::URI & uri,
         const String & format,
         const std::optional<FormatSettings> & format_settings,
         const Block & sample_block_,
-        const Context & context,
+        ContextPtr context,
         const ConnectionTimeouts & timeouts,
         const CompressionMethod compression_method)
         : sample_block(sample_block_)
@@ -184,7 +184,7 @@ std::vector<std::pair<std::string, std::string>> IStorageURLBase::getReadURIPara
     const Names & /*column_names*/,
     const StorageMetadataPtr & /*metadata_snapshot*/,
     const SelectQueryInfo & /*query_info*/,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum & /*processed_stage*/,
     size_t /*max_block_size*/) const
 {
@@ -195,7 +195,7 @@ std::function<void(std::ostream &)> IStorageURLBase::getReadPOSTDataCallback(
     const Names & /*column_names*/,
     const StorageMetadataPtr & /*metadata_snapshot*/,
     const SelectQueryInfo & /*query_info*/,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum & /*processed_stage*/,
     size_t /*max_block_size*/) const
 {
@@ -207,13 +207,13 @@ Pipe IStorageURLBase::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     size_t max_block_size,
     unsigned /*num_streams*/)
 {
     auto request_uri = uri;
-    auto params = getReadURIParams(column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size);
+    auto params = getReadURIParams(column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size);
     for (const auto & [param, value] : params)
         request_uri.addQueryParameter(param, value);
 
@@ -222,19 +222,19 @@ Pipe IStorageURLBase::read(
         getReadMethod(),
         getReadPOSTDataCallback(
             column_names, metadata_snapshot, query_info,
-            context, processed_stage, max_block_size),
+            local_context, processed_stage, max_block_size),
         format_name,
         format_settings,
         getName(),
         getHeaderBlock(column_names, metadata_snapshot),
-        context,
+        local_context,
         metadata_snapshot->getColumns(),
         max_block_size,
-        ConnectionTimeouts::getHTTPTimeouts(context),
+        ConnectionTimeouts::getHTTPTimeouts(local_context),
         chooseCompressionMethod(request_uri.getPath(), compression_method)));
 }
 
-BlockOutputStreamPtr IStorageURLBase::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr IStorageURLBase::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr context)
 {
     return std::make_shared<StorageURLBlockOutputStream>(uri, format_name,
         format_settings, metadata_snapshot->getSampleBlock(), context,
@@ -248,12 +248,12 @@ StorageURL::StorageURL(const Poco::URI & uri_,
            const std::optional<FormatSettings> & format_settings_,
            const ColumnsDescription & columns_,
            const ConstraintsDescription & constraints_,
-           Context & context_,
+           ContextPtr context_,
            const String & compression_method_)
     : IStorageURLBase(uri_, context_, table_id_, format_name_,
                       format_settings_, columns_, constraints_, compression_method_)
 {
-    context_.getRemoteHostFilter().checkURL(uri);
+    context_->getRemoteHostFilter().checkURL(uri);
 }
 
 void registerStorageURL(StorageFactory & factory)
@@ -266,19 +266,19 @@ void registerStorageURL(StorageFactory & factory)
             throw Exception(
                 "Storage URL requires 2 or 3 arguments: url, name of used format and optional compression method.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        engine_args[0] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[0], args.local_context);
+        engine_args[0] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[0], args.getLocalContext());
 
         String url = engine_args[0]->as<ASTLiteral &>().value.safeGet<String>();
         Poco::URI uri(url);
 
-        engine_args[1] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[1], args.local_context);
+        engine_args[1] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[1], args.getLocalContext());
 
         String format_name = engine_args[1]->as<ASTLiteral &>().value.safeGet<String>();
 
         String compression_method;
         if (engine_args.size() == 3)
         {
-            engine_args[2] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[2], args.local_context);
+            engine_args[2] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[2], args.getLocalContext());
             compression_method = engine_args[2]->as<ASTLiteral &>().value.safeGet<String>();
         }
         else
@@ -296,7 +296,7 @@ void registerStorageURL(StorageFactory & factory)
 
             // Apply changed settings from global context, but ignore the
             // unknown ones, because we only have the format settings here.
-            const auto & changes = args.context.getSettingsRef().changes();
+            const auto & changes = args.getContext()->getSettingsRef().changes();
             for (const auto & change : changes)
             {
                 if (user_format_settings.has(change.name))
@@ -308,12 +308,12 @@ void registerStorageURL(StorageFactory & factory)
             // Apply changes from SETTINGS clause, with validation.
             user_format_settings.applyChanges(args.storage_def->settings->changes);
 
-            format_settings = getFormatSettings(args.context,
+            format_settings = getFormatSettings(args.getContext(),
                 user_format_settings);
         }
         else
         {
-            format_settings = getFormatSettings(args.context);
+            format_settings = getFormatSettings(args.getContext());
         }
 
         return StorageURL::create(
@@ -321,7 +321,7 @@ void registerStorageURL(StorageFactory & factory)
             args.table_id,
             format_name,
             format_settings,
-            args.columns, args.constraints, args.context,
+            args.columns, args.constraints, args.getContext(),
             compression_method);
     },
     {
diff --git a/src/Storages/StorageURL.h b/src/Storages/StorageURL.h
index 2b2384b1043..6fc1a6006ec 100644
--- a/src/Storages/StorageURL.h
+++ b/src/Storages/StorageURL.h
@@ -26,17 +26,17 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
 protected:
     IStorageURLBase(
         const Poco::URI & uri_,
-        const Context & context_,
+        ContextPtr context_,
         const StorageID & id_,
         const String & format_name_,
         const std::optional<FormatSettings> & format_settings_,
@@ -60,7 +60,7 @@ private:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum & processed_stage,
         size_t max_block_size) const;
 
@@ -68,7 +68,7 @@ private:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum & processed_stage,
         size_t max_block_size) const;
 
@@ -83,9 +83,9 @@ public:
         const String & format,
         const std::optional<FormatSettings> & format_settings,
         const Block & sample_block_,
-        const Context & context,
+        ContextPtr context,
         const ConnectionTimeouts & timeouts,
-        const CompressionMethod compression_method);
+        CompressionMethod compression_method);
 
     Block getHeader() const override
     {
@@ -112,7 +112,7 @@ public:
             const std::optional<FormatSettings> & format_settings_,
             const ColumnsDescription & columns_,
             const ConstraintsDescription & constraints_,
-            Context & context_,
+            ContextPtr context_,
             const String & compression_method_);
 
     String getName() const override
diff --git a/src/Storages/StorageValues.cpp b/src/Storages/StorageValues.cpp
index 500deac5f25..ace5ca3667c 100644
--- a/src/Storages/StorageValues.cpp
+++ b/src/Storages/StorageValues.cpp
@@ -24,7 +24,7 @@ Pipe StorageValues::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t /*max_block_size*/,
     unsigned /*num_streams*/)
diff --git a/src/Storages/StorageValues.h b/src/Storages/StorageValues.h
index 5729f245149..6ae33ed70f1 100644
--- a/src/Storages/StorageValues.h
+++ b/src/Storages/StorageValues.h
@@ -19,7 +19,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/StorageView.cpp b/src/Storages/StorageView.cpp
index bcaf63152c1..75bd4b2967f 100644
--- a/src/Storages/StorageView.cpp
+++ b/src/Storages/StorageView.cpp
@@ -54,7 +54,7 @@ Pipe StorageView::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum processed_stage,
     const size_t max_block_size,
     const unsigned num_streams)
@@ -71,7 +71,7 @@ void StorageView::read(
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum /*processed_stage*/,
         const size_t /*max_block_size*/,
         const unsigned /*num_streams*/)
diff --git a/src/Storages/StorageView.h b/src/Storages/StorageView.h
index 6f894ce2775..fa11472218d 100644
--- a/src/Storages/StorageView.h
+++ b/src/Storages/StorageView.h
@@ -25,7 +25,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -35,7 +35,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/StorageXDBC.cpp b/src/Storages/StorageXDBC.cpp
index f2f8cdb23f5..c535f6977a6 100644
--- a/src/Storages/StorageXDBC.cpp
+++ b/src/Storages/StorageXDBC.cpp
@@ -28,7 +28,7 @@ StorageXDBC::StorageXDBC(
     const std::string & remote_database_name_,
     const std::string & remote_table_name_,
     const ColumnsDescription & columns_,
-    const Context & context_,
+    ContextPtr context_,
     const BridgeHelperPtr bridge_helper_)
     /// Please add support for constraints as soon as StorageODBC or JDBC will support insertion.
     : IStorageURLBase(Poco::URI(),
@@ -56,7 +56,7 @@ std::vector<std::pair<std::string, std::string>> StorageXDBC::getReadURIParams(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     const SelectQueryInfo & /*query_info*/,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum & /*processed_stage*/,
     size_t max_block_size) const
 {
@@ -73,7 +73,7 @@ std::function<void(std::ostream &)> StorageXDBC::getReadPOSTDataCallback(
     const Names & /*column_names*/,
     const StorageMetadataPtr & metadata_snapshot,
     const SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum & /*processed_stage*/,
     size_t /*max_block_size*/) const
 {
@@ -82,7 +82,7 @@ std::function<void(std::ostream &)> StorageXDBC::getReadPOSTDataCallback(
         bridge_helper->getIdentifierQuotingStyle(),
         remote_database_name,
         remote_table_name,
-        context);
+        local_context);
 
     return [query](std::ostream & os) { os << "query=" << query; };
 }
@@ -91,7 +91,7 @@ Pipe StorageXDBC::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr local_context,
     QueryProcessingStage::Enum processed_stage,
     size_t max_block_size,
     unsigned num_streams)
@@ -99,10 +99,10 @@ Pipe StorageXDBC::read(
     metadata_snapshot->check(column_names, getVirtuals(), getStorageID());
 
     bridge_helper->startBridgeSync();
-    return IStorageURLBase::read(column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams);
+    return IStorageURLBase::read(column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams);
 }
 
-BlockOutputStreamPtr StorageXDBC::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, const Context & context)
+BlockOutputStreamPtr StorageXDBC::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr local_context)
 {
     bridge_helper->startBridgeSync();
 
@@ -124,10 +124,10 @@ BlockOutputStreamPtr StorageXDBC::write(const ASTPtr & /*query*/, const StorageM
     return std::make_shared<StorageURLBlockOutputStream>(
         request_uri,
         format_name,
-        getFormatSettings(context),
+        getFormatSettings(local_context),
         metadata_snapshot->getSampleBlock(),
-        context,
-        ConnectionTimeouts::getHTTPTimeouts(context),
+        local_context,
+        ConnectionTimeouts::getHTTPTimeouts(local_context),
         chooseCompressionMethod(uri.toString(), compression_method));
 }
 
@@ -155,16 +155,16 @@ namespace
                     ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
             for (size_t i = 0; i < 3; ++i)
-                engine_args[i] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[i], args.local_context);
+                engine_args[i] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[i], args.getLocalContext());
 
-            BridgeHelperPtr bridge_helper = std::make_shared<XDBCBridgeHelper<BridgeHelperMixin>>(args.context,
-                args.context.getSettingsRef().http_receive_timeout.value,
+            BridgeHelperPtr bridge_helper = std::make_shared<XDBCBridgeHelper<BridgeHelperMixin>>(args.getContext(),
+                args.getContext()->getSettingsRef().http_receive_timeout.value,
                 engine_args[0]->as<ASTLiteral &>().value.safeGet<String>());
             return std::make_shared<StorageXDBC>(args.table_id,
                 engine_args[1]->as<ASTLiteral &>().value.safeGet<String>(),
                 engine_args[2]->as<ASTLiteral &>().value.safeGet<String>(),
                 args.columns,
-                args.context,
+                args.getContext(),
                 bridge_helper);
 
         },
diff --git a/src/Storages/StorageXDBC.h b/src/Storages/StorageXDBC.h
index 8524a03503a..064912fda92 100644
--- a/src/Storages/StorageXDBC.h
+++ b/src/Storages/StorageXDBC.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Storages/StorageURL.h>
-#include <Common/XDBCBridgeHelper.h>
+#include <Bridge/XDBCBridgeHelper.h>
 
 
 namespace DB
@@ -19,7 +19,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
@@ -29,10 +29,10 @@ public:
         const std::string & remote_database_name,
         const std::string & remote_table_name,
         const ColumnsDescription & columns_,
-        const Context & context_,
+        ContextPtr context_,
         BridgeHelperPtr bridge_helper_);
 
-    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, const Context & context) override;
+    BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr context) override;
 
     std::string getName() const override;
 private:
@@ -49,7 +49,7 @@ private:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum & processed_stage,
         size_t max_block_size) const override;
 
@@ -57,7 +57,7 @@ private:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         const SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum & processed_stage,
         size_t max_block_size) const override;
 
diff --git a/src/Storages/System/IStorageSystemOneBlock.h b/src/Storages/System/IStorageSystemOneBlock.h
index d83a71c2592..36e92d5a1f4 100644
--- a/src/Storages/System/IStorageSystemOneBlock.h
+++ b/src/Storages/System/IStorageSystemOneBlock.h
@@ -18,7 +18,7 @@ template <typename Self>
 class IStorageSystemOneBlock : public IStorage
 {
 protected:
-    virtual void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const = 0;
+    virtual void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const = 0;
 
 public:
 #if defined(ARCADIA_BUILD)
@@ -36,7 +36,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum /*processed_stage*/,
         size_t /*max_block_size*/,
         unsigned /*num_streams*/) override
diff --git a/src/Storages/System/StorageSystemAggregateFunctionCombinators.cpp b/src/Storages/System/StorageSystemAggregateFunctionCombinators.cpp
index c0dd5cc85d3..c2d82c6cd7c 100644
--- a/src/Storages/System/StorageSystemAggregateFunctionCombinators.cpp
+++ b/src/Storages/System/StorageSystemAggregateFunctionCombinators.cpp
@@ -12,13 +12,13 @@ NamesAndTypesList StorageSystemAggregateFunctionCombinators::getNamesAndTypes()
     };
 }
 
-void StorageSystemAggregateFunctionCombinators::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemAggregateFunctionCombinators::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     const auto & combinators = AggregateFunctionCombinatorFactory::instance().getAllAggregateFunctionCombinators();
     for (const auto & pair : combinators)
     {
-        res_columns[0]->insert(pair.first);
-        res_columns[1]->insert(pair.second->isForInternalUsageOnly());
+        res_columns[0]->insert(pair.name);
+        res_columns[1]->insert(pair.combinator_ptr->isForInternalUsageOnly());
     }
 }
 
diff --git a/src/Storages/System/StorageSystemAggregateFunctionCombinators.h b/src/Storages/System/StorageSystemAggregateFunctionCombinators.h
index 8d204020160..a978bfbface 100644
--- a/src/Storages/System/StorageSystemAggregateFunctionCombinators.h
+++ b/src/Storages/System/StorageSystemAggregateFunctionCombinators.h
@@ -12,7 +12,7 @@ class StorageSystemAggregateFunctionCombinators final : public ext::shared_ptr_h
 {
     friend struct ext::shared_ptr_helper<StorageSystemAggregateFunctionCombinators>;
 protected:
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 public:
diff --git a/src/Storages/System/StorageSystemAsynchronousMetrics.cpp b/src/Storages/System/StorageSystemAsynchronousMetrics.cpp
index 8dabac4fb49..70e12440678 100644
--- a/src/Storages/System/StorageSystemAsynchronousMetrics.cpp
+++ b/src/Storages/System/StorageSystemAsynchronousMetrics.cpp
@@ -21,7 +21,7 @@ StorageSystemAsynchronousMetrics::StorageSystemAsynchronousMetrics(const Storage
 {
 }
 
-void StorageSystemAsynchronousMetrics::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemAsynchronousMetrics::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     auto async_metrics_values = async_metrics.getValues();
     for (const auto & name_value : async_metrics_values)
diff --git a/src/Storages/System/StorageSystemAsynchronousMetrics.h b/src/Storages/System/StorageSystemAsynchronousMetrics.h
index a2a92d248d8..eee029bbe51 100644
--- a/src/Storages/System/StorageSystemAsynchronousMetrics.h
+++ b/src/Storages/System/StorageSystemAsynchronousMetrics.h
@@ -33,7 +33,7 @@ protected:
 #endif
     StorageSystemAsynchronousMetrics(const StorageID & table_id_, const AsynchronousMetrics & async_metrics_);
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemBuildOptions.cpp b/src/Storages/System/StorageSystemBuildOptions.cpp
index a63afcf4ce5..01a60a0235c 100644
--- a/src/Storages/System/StorageSystemBuildOptions.cpp
+++ b/src/Storages/System/StorageSystemBuildOptions.cpp
@@ -16,7 +16,7 @@ NamesAndTypesList StorageSystemBuildOptions::getNamesAndTypes()
     };
 }
 
-void StorageSystemBuildOptions::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemBuildOptions::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
 #if !defined(ARCADIA_BUILD)
     for (auto * it = auto_config_build; *it; it += 2)
diff --git a/src/Storages/System/StorageSystemBuildOptions.h b/src/Storages/System/StorageSystemBuildOptions.h
index afd27f00bcc..8a22a3dcb45 100644
--- a/src/Storages/System/StorageSystemBuildOptions.h
+++ b/src/Storages/System/StorageSystemBuildOptions.h
@@ -16,7 +16,7 @@ class StorageSystemBuildOptions final : public ext::shared_ptr_helper<StorageSys
 {
     friend struct ext::shared_ptr_helper<StorageSystemBuildOptions>;
 protected:
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
diff --git a/src/Storages/System/StorageSystemClusters.cpp b/src/Storages/System/StorageSystemClusters.cpp
index e20ce233190..8a3227aafdb 100644
--- a/src/Storages/System/StorageSystemClusters.cpp
+++ b/src/Storages/System/StorageSystemClusters.cpp
@@ -29,9 +29,9 @@ NamesAndTypesList StorageSystemClusters::getNamesAndTypes()
 }
 
 
-void StorageSystemClusters::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemClusters::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    for (const auto & name_and_cluster : context.getClusters().getContainer())
+    for (const auto & name_and_cluster : context->getClusters().getContainer())
         writeCluster(res_columns, name_and_cluster);
 
     const auto databases = DatabaseCatalog::instance().getDatabases();
diff --git a/src/Storages/System/StorageSystemClusters.h b/src/Storages/System/StorageSystemClusters.h
index 4f2a843999f..81aefaff1c4 100644
--- a/src/Storages/System/StorageSystemClusters.h
+++ b/src/Storages/System/StorageSystemClusters.h
@@ -28,7 +28,7 @@ protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     using NameAndCluster = std::pair<String, std::shared_ptr<Cluster>>;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
     static void writeCluster(MutableColumns & res_columns, const NameAndCluster & name_and_cluster);
 };
 
diff --git a/src/Storages/System/StorageSystemCollations.cpp b/src/Storages/System/StorageSystemCollations.cpp
index a870a7c7c78..c9343ccd146 100644
--- a/src/Storages/System/StorageSystemCollations.cpp
+++ b/src/Storages/System/StorageSystemCollations.cpp
@@ -13,7 +13,7 @@ NamesAndTypesList StorageSystemCollations::getNamesAndTypes()
     };
 }
 
-void StorageSystemCollations::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemCollations::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     for (const auto & [locale, lang]: AvailableCollationLocales::instance().getAvailableCollations())
     {
diff --git a/src/Storages/System/StorageSystemCollations.h b/src/Storages/System/StorageSystemCollations.h
index 133acd937a1..454fd968511 100644
--- a/src/Storages/System/StorageSystemCollations.h
+++ b/src/Storages/System/StorageSystemCollations.h
@@ -10,7 +10,7 @@ class StorageSystemCollations final : public ext::shared_ptr_helper<StorageSyste
 {
     friend struct ext::shared_ptr_helper<StorageSystemCollations>;
 protected:
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 public:
diff --git a/src/Storages/System/StorageSystemColumns.cpp b/src/Storages/System/StorageSystemColumns.cpp
index 6726d502071..8f65147bb11 100644
--- a/src/Storages/System/StorageSystemColumns.cpp
+++ b/src/Storages/System/StorageSystemColumns.cpp
@@ -65,12 +65,12 @@ public:
         ColumnPtr databases_,
         ColumnPtr tables_,
         Storages storages_,
-        const Context & context)
+        ContextPtr context)
         : SourceWithProgress(header_)
         , columns_mask(std::move(columns_mask_)), max_block_size(max_block_size_)
         , databases(std::move(databases_)), tables(std::move(tables_)), storages(std::move(storages_))
-        , total_tables(tables->size()), access(context.getAccess())
-        , query_id(context.getCurrentQueryId()), lock_acquire_timeout(context.getSettingsRef().lock_acquire_timeout)
+        , total_tables(tables->size()), access(context->getAccess())
+        , query_id(context->getCurrentQueryId()), lock_acquire_timeout(context->getSettingsRef().lock_acquire_timeout)
     {
     }
 
@@ -243,7 +243,7 @@ Pipe StorageSystemColumns::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t max_block_size,
     const unsigned /*num_streams*/)
@@ -289,9 +289,9 @@ Pipe StorageSystemColumns::read(
         }
 
         Tables external_tables;
-        if (context.hasSessionContext())
+        if (context->hasSessionContext())
         {
-            external_tables = context.getSessionContext().getExternalTables();
+            external_tables = context->getSessionContext()->getExternalTables();
             if (!external_tables.empty())
                 database_column_mut->insertDefault(); /// Empty database for external tables.
         }
diff --git a/src/Storages/System/StorageSystemColumns.h b/src/Storages/System/StorageSystemColumns.h
index c4f35485612..5cd8c5b38fd 100644
--- a/src/Storages/System/StorageSystemColumns.h
+++ b/src/Storages/System/StorageSystemColumns.h
@@ -21,7 +21,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/System/StorageSystemContributors.cpp b/src/Storages/System/StorageSystemContributors.cpp
index cd0f31975cc..ed28be2a4ab 100644
--- a/src/Storages/System/StorageSystemContributors.cpp
+++ b/src/Storages/System/StorageSystemContributors.cpp
@@ -16,7 +16,7 @@ NamesAndTypesList StorageSystemContributors::getNamesAndTypes()
     };
 }
 
-void StorageSystemContributors::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemContributors::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     std::vector<const char *> contributors;
     for (auto * it = auto_contributors; *it; ++it)
diff --git a/src/Storages/System/StorageSystemContributors.h b/src/Storages/System/StorageSystemContributors.h
index 0fd77f78655..c4a50263c5b 100644
--- a/src/Storages/System/StorageSystemContributors.h
+++ b/src/Storages/System/StorageSystemContributors.h
@@ -16,7 +16,7 @@ class StorageSystemContributors final : public ext::shared_ptr_helper<StorageSys
 {
     friend struct ext::shared_ptr_helper<StorageSystemContributors>;
 protected:
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
diff --git a/src/Storages/System/StorageSystemCurrentRoles.cpp b/src/Storages/System/StorageSystemCurrentRoles.cpp
index b0667f2f3ca..a5b3566f5f7 100644
--- a/src/Storages/System/StorageSystemCurrentRoles.cpp
+++ b/src/Storages/System/StorageSystemCurrentRoles.cpp
@@ -22,10 +22,10 @@ NamesAndTypesList StorageSystemCurrentRoles::getNamesAndTypes()
 }
 
 
-void StorageSystemCurrentRoles::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemCurrentRoles::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    auto roles_info = context.getRolesInfo();
-    auto user = context.getUser();
+    auto roles_info = context->getRolesInfo();
+    auto user = context->getUser();
     if (!roles_info || !user)
         return;
 
diff --git a/src/Storages/System/StorageSystemCurrentRoles.h b/src/Storages/System/StorageSystemCurrentRoles.h
index 807db661371..77ab95547fa 100644
--- a/src/Storages/System/StorageSystemCurrentRoles.h
+++ b/src/Storages/System/StorageSystemCurrentRoles.h
@@ -18,7 +18,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemCurrentRoles>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemDDLWorkerQueue.cpp b/src/Storages/System/StorageSystemDDLWorkerQueue.cpp
index 04321544f5d..98b15bfa6e2 100644
--- a/src/Storages/System/StorageSystemDDLWorkerQueue.cpp
+++ b/src/Storages/System/StorageSystemDDLWorkerQueue.cpp
@@ -95,7 +95,7 @@ NamesAndTypesList StorageSystemDDLWorkerQueue::getNamesAndTypes()
     };
 }
 
-static String clusterNameFromDDLQuery(const Context & context, const DDLLogEntry & entry)
+static String clusterNameFromDDLQuery(ContextPtr context, const DDLLogEntry & entry)
 {
     const char * begin = entry.query.data();
     const char * end = begin + entry.query.size();
@@ -104,15 +104,15 @@ static String clusterNameFromDDLQuery(const Context & context, const DDLLogEntry
     String cluster_name;
     ParserQuery parser_query(end);
     String description;
-    query = parseQuery(parser_query, begin, end, description, 0, context.getSettingsRef().max_parser_depth);
+    query = parseQuery(parser_query, begin, end, description, 0, context->getSettingsRef().max_parser_depth);
     if (query && (query_on_cluster = dynamic_cast<ASTQueryWithOnCluster *>(query.get())))
         cluster_name = query_on_cluster->cluster;
     return cluster_name;
 }
 
-void StorageSystemDDLWorkerQueue::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemDDLWorkerQueue::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    zkutil::ZooKeeperPtr zookeeper = context.getZooKeeper();
+    zkutil::ZooKeeperPtr zookeeper = context->getZooKeeper();
     Coordination::Error zk_exception_code = Coordination::Error::ZOK;
     String ddl_zookeeper_path = config.getString("distributed_ddl.path", "/clickhouse/task_queue/ddl/");
     String ddl_query_path;
@@ -130,7 +130,7 @@ void StorageSystemDDLWorkerQueue::fillData(MutableColumns & res_columns, const C
     if (code != Coordination::Error::ZOK && code != Coordination::Error::ZNONODE)
         zk_exception_code = code;
 
-    const auto & clusters = context.getClusters();
+    const auto & clusters = context->getClusters();
     for (const auto & name_and_cluster : clusters.getContainer())
     {
         const ClusterPtr & cluster = name_and_cluster.second;
diff --git a/src/Storages/System/StorageSystemDDLWorkerQueue.h b/src/Storages/System/StorageSystemDDLWorkerQueue.h
index 9326d4dcb26..d1afa2d546a 100644
--- a/src/Storages/System/StorageSystemDDLWorkerQueue.h
+++ b/src/Storages/System/StorageSystemDDLWorkerQueue.h
@@ -22,7 +22,7 @@ class StorageSystemDDLWorkerQueue final : public ext::shared_ptr_helper<StorageS
     Poco::Util::LayeredConfiguration & config = Poco::Util::Application::instance().config();
 
 protected:
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
diff --git a/src/Storages/System/StorageSystemDataTypeFamilies.cpp b/src/Storages/System/StorageSystemDataTypeFamilies.cpp
index 0957e8f8349..c34589d85b1 100644
--- a/src/Storages/System/StorageSystemDataTypeFamilies.cpp
+++ b/src/Storages/System/StorageSystemDataTypeFamilies.cpp
@@ -16,7 +16,7 @@ NamesAndTypesList StorageSystemDataTypeFamilies::getNamesAndTypes()
     };
 }
 
-void StorageSystemDataTypeFamilies::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemDataTypeFamilies::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     const auto & factory = DataTypeFactory::instance();
     auto names = factory.getAllRegisteredNames();
diff --git a/src/Storages/System/StorageSystemDataTypeFamilies.h b/src/Storages/System/StorageSystemDataTypeFamilies.h
index 2a89ae77647..4de2ed99252 100644
--- a/src/Storages/System/StorageSystemDataTypeFamilies.h
+++ b/src/Storages/System/StorageSystemDataTypeFamilies.h
@@ -11,7 +11,7 @@ class StorageSystemDataTypeFamilies final : public ext::shared_ptr_helper<Storag
 {
     friend struct ext::shared_ptr_helper<StorageSystemDataTypeFamilies>;
 protected:
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
diff --git a/src/Storages/System/StorageSystemDatabases.cpp b/src/Storages/System/StorageSystemDatabases.cpp
index 88ac987014d..e09e47d8baf 100644
--- a/src/Storages/System/StorageSystemDatabases.cpp
+++ b/src/Storages/System/StorageSystemDatabases.cpp
@@ -20,9 +20,9 @@ NamesAndTypesList StorageSystemDatabases::getNamesAndTypes()
     };
 }
 
-void StorageSystemDatabases::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemDatabases::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    const auto access = context.getAccess();
+    const auto access = context->getAccess();
     const bool check_access_for_databases = !access->isGranted(AccessType::SHOW_DATABASES);
 
     const auto databases = DatabaseCatalog::instance().getDatabases();
@@ -36,7 +36,7 @@ void StorageSystemDatabases::fillData(MutableColumns & res_columns, const Contex
 
         res_columns[0]->insert(database_name);
         res_columns[1]->insert(database->getEngineName());
-        res_columns[2]->insert(context.getPath() + database->getDataPath());
+        res_columns[2]->insert(context->getPath() + database->getDataPath());
         res_columns[3]->insert(database->getMetadataPath());
         res_columns[4]->insert(database->getUUID());
    }
diff --git a/src/Storages/System/StorageSystemDatabases.h b/src/Storages/System/StorageSystemDatabases.h
index fe517c0f651..33f91fee837 100644
--- a/src/Storages/System/StorageSystemDatabases.h
+++ b/src/Storages/System/StorageSystemDatabases.h
@@ -26,7 +26,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemDetachedParts.cpp b/src/Storages/System/StorageSystemDetachedParts.cpp
index f96566026b1..56644620f97 100644
--- a/src/Storages/System/StorageSystemDetachedParts.cpp
+++ b/src/Storages/System/StorageSystemDetachedParts.cpp
@@ -33,7 +33,7 @@ Pipe StorageSystemDetachedParts::read(
     const Names & /* column_names */,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t /*max_block_size*/,
     const unsigned /*num_streams*/)
diff --git a/src/Storages/System/StorageSystemDetachedParts.h b/src/Storages/System/StorageSystemDetachedParts.h
index 4c6970dadd6..18a6f5576d6 100644
--- a/src/Storages/System/StorageSystemDetachedParts.h
+++ b/src/Storages/System/StorageSystemDetachedParts.h
@@ -26,7 +26,7 @@ protected:
             const Names & /* column_names */,
             const StorageMetadataPtr & metadata_snapshot,
             SelectQueryInfo & query_info,
-            const Context & context,
+            ContextPtr context,
             QueryProcessingStage::Enum /*processed_stage*/,
             const size_t /*max_block_size*/,
             const unsigned /*num_streams*/) override;
diff --git a/src/Storages/System/StorageSystemDictionaries.cpp b/src/Storages/System/StorageSystemDictionaries.cpp
index 378905b7dc0..a362e6a44e3 100644
--- a/src/Storages/System/StorageSystemDictionaries.cpp
+++ b/src/Storages/System/StorageSystemDictionaries.cpp
@@ -50,12 +50,12 @@ NamesAndTypesList StorageSystemDictionaries::getNamesAndTypes()
     };
 }
 
-void StorageSystemDictionaries::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & /*query_info*/) const
+void StorageSystemDictionaries::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & /*query_info*/) const
 {
-    const auto access = context.getAccess();
+    const auto access = context->getAccess();
     const bool check_access_for_dictionaries = !access->isGranted(AccessType::SHOW_DICTIONARIES);
 
-    const auto & external_dictionaries = context.getExternalDictionariesLoader();
+    const auto & external_dictionaries = context->getExternalDictionariesLoader();
     for (const auto & load_result : external_dictionaries.getLoadResults())
     {
         const auto dict_ptr = std::dynamic_pointer_cast<const IDictionary>(load_result.object);
diff --git a/src/Storages/System/StorageSystemDictionaries.h b/src/Storages/System/StorageSystemDictionaries.h
index 5139ce3c5f6..63b33adaaff 100644
--- a/src/Storages/System/StorageSystemDictionaries.h
+++ b/src/Storages/System/StorageSystemDictionaries.h
@@ -21,7 +21,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemDisks.cpp b/src/Storages/System/StorageSystemDisks.cpp
index b04d24cc705..5d7628acb2a 100644
--- a/src/Storages/System/StorageSystemDisks.cpp
+++ b/src/Storages/System/StorageSystemDisks.cpp
@@ -30,7 +30,7 @@ Pipe StorageSystemDisks::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t /*max_block_size*/,
     const unsigned /*num_streams*/)
@@ -44,7 +44,7 @@ Pipe StorageSystemDisks::read(
     MutableColumnPtr col_keep = ColumnUInt64::create();
     MutableColumnPtr col_type = ColumnString::create();
 
-    for (const auto & [disk_name, disk_ptr] : context.getDisksMap())
+    for (const auto & [disk_name, disk_ptr] : context->getDisksMap())
     {
         col_name->insert(disk_name);
         col_path->insert(disk_ptr->getPath());
diff --git a/src/Storages/System/StorageSystemDisks.h b/src/Storages/System/StorageSystemDisks.h
index cff05242019..fa0f6fe4b8a 100644
--- a/src/Storages/System/StorageSystemDisks.h
+++ b/src/Storages/System/StorageSystemDisks.h
@@ -24,7 +24,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/System/StorageSystemDistributionQueue.cpp b/src/Storages/System/StorageSystemDistributionQueue.cpp
index db649e7e1ba..9c0f8818011 100644
--- a/src/Storages/System/StorageSystemDistributionQueue.cpp
+++ b/src/Storages/System/StorageSystemDistributionQueue.cpp
@@ -103,9 +103,9 @@ NamesAndTypesList StorageSystemDistributionQueue::getNamesAndTypes()
 }
 
 
-void StorageSystemDistributionQueue::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const
+void StorageSystemDistributionQueue::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const
 {
-    const auto access = context.getAccess();
+    const auto access = context->getAccess();
     const bool check_access_for_databases = !access->isGranted(AccessType::SHOW_TABLES);
 
     std::map<String, std::map<String, StoragePtr>> tables;
diff --git a/src/Storages/System/StorageSystemDistributionQueue.h b/src/Storages/System/StorageSystemDistributionQueue.h
index 88e7fa45cf5..9314418d242 100644
--- a/src/Storages/System/StorageSystemDistributionQueue.h
+++ b/src/Storages/System/StorageSystemDistributionQueue.h
@@ -23,7 +23,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemEnabledRoles.cpp b/src/Storages/System/StorageSystemEnabledRoles.cpp
index 27a42ca6f8b..99370dd647d 100644
--- a/src/Storages/System/StorageSystemEnabledRoles.cpp
+++ b/src/Storages/System/StorageSystemEnabledRoles.cpp
@@ -23,10 +23,10 @@ NamesAndTypesList StorageSystemEnabledRoles::getNamesAndTypes()
 }
 
 
-void StorageSystemEnabledRoles::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemEnabledRoles::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    auto roles_info = context.getRolesInfo();
-    auto user = context.getUser();
+    auto roles_info = context->getRolesInfo();
+    auto user = context->getUser();
     if (!roles_info || !user)
         return;
 
diff --git a/src/Storages/System/StorageSystemEnabledRoles.h b/src/Storages/System/StorageSystemEnabledRoles.h
index 18df31c646a..13b0533b790 100644
--- a/src/Storages/System/StorageSystemEnabledRoles.h
+++ b/src/Storages/System/StorageSystemEnabledRoles.h
@@ -18,7 +18,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemEnabledRoles>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemErrors.cpp b/src/Storages/System/StorageSystemErrors.cpp
index 09d0aaddb3d..d08ffd730ac 100644
--- a/src/Storages/System/StorageSystemErrors.cpp
+++ b/src/Storages/System/StorageSystemErrors.cpp
@@ -23,11 +23,11 @@ NamesAndTypesList StorageSystemErrors::getNamesAndTypes()
 }
 
 
-void StorageSystemErrors::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemErrors::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
     auto add_row = [&](std::string_view name, size_t code, const auto & error, bool remote)
     {
-        if (error.count || context.getSettingsRef().system_events_show_zero_values)
+        if (error.count || context->getSettingsRef().system_events_show_zero_values)
         {
             size_t col_num = 0;
             res_columns[col_num++]->insert(name);
diff --git a/src/Storages/System/StorageSystemErrors.h b/src/Storages/System/StorageSystemErrors.h
index 569a7a998b7..ff3af11d251 100644
--- a/src/Storages/System/StorageSystemErrors.h
+++ b/src/Storages/System/StorageSystemErrors.h
@@ -25,7 +25,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemEvents.cpp b/src/Storages/System/StorageSystemEvents.cpp
index ddb00659473..be2d3f8d49e 100644
--- a/src/Storages/System/StorageSystemEvents.cpp
+++ b/src/Storages/System/StorageSystemEvents.cpp
@@ -16,13 +16,13 @@ NamesAndTypesList StorageSystemEvents::getNamesAndTypes()
     };
 }
 
-void StorageSystemEvents::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemEvents::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
     for (size_t i = 0, end = ProfileEvents::end(); i < end; ++i)
     {
         UInt64 value = ProfileEvents::global_counters[i];
 
-        if (0 != value || context.getSettingsRef().system_events_show_zero_values)
+        if (0 != value || context->getSettingsRef().system_events_show_zero_values)
         {
             res_columns[0]->insert(ProfileEvents::getName(ProfileEvents::Event(i)));
             res_columns[1]->insert(value);
diff --git a/src/Storages/System/StorageSystemEvents.h b/src/Storages/System/StorageSystemEvents.h
index f1687e42233..6071cb7b2b3 100644
--- a/src/Storages/System/StorageSystemEvents.h
+++ b/src/Storages/System/StorageSystemEvents.h
@@ -22,7 +22,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemFormats.cpp b/src/Storages/System/StorageSystemFormats.cpp
index 7048ab98a0d..86e0212a523 100644
--- a/src/Storages/System/StorageSystemFormats.cpp
+++ b/src/Storages/System/StorageSystemFormats.cpp
@@ -15,7 +15,7 @@ NamesAndTypesList StorageSystemFormats::getNamesAndTypes()
     };
 }
 
-void StorageSystemFormats::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemFormats::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     const auto & formats = FormatFactory::instance().getAllFormats();
     for (const auto & pair : formats)
diff --git a/src/Storages/System/StorageSystemFormats.h b/src/Storages/System/StorageSystemFormats.h
index f90839e44e9..ed65cd2af88 100644
--- a/src/Storages/System/StorageSystemFormats.h
+++ b/src/Storages/System/StorageSystemFormats.h
@@ -9,7 +9,7 @@ class StorageSystemFormats final : public ext::shared_ptr_helper<StorageSystemFo
 {
     friend struct ext::shared_ptr_helper<StorageSystemFormats>;
 protected:
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 public:
diff --git a/src/Storages/System/StorageSystemFunctions.cpp b/src/Storages/System/StorageSystemFunctions.cpp
index e46b7007dc2..973bf493cd1 100644
--- a/src/Storages/System/StorageSystemFunctions.cpp
+++ b/src/Storages/System/StorageSystemFunctions.cpp
@@ -34,7 +34,7 @@ NamesAndTypesList StorageSystemFunctions::getNamesAndTypes()
     };
 }
 
-void StorageSystemFunctions::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemFunctions::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     const auto & functions_factory = FunctionFactory::instance();
     const auto & function_names = functions_factory.getAllRegisteredNames();
diff --git a/src/Storages/System/StorageSystemFunctions.h b/src/Storages/System/StorageSystemFunctions.h
index f62d731f288..62942721995 100644
--- a/src/Storages/System/StorageSystemFunctions.h
+++ b/src/Storages/System/StorageSystemFunctions.h
@@ -24,7 +24,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemGrants.cpp b/src/Storages/System/StorageSystemGrants.cpp
index 0c06ad99b22..1ba5e6d96a4 100644
--- a/src/Storages/System/StorageSystemGrants.cpp
+++ b/src/Storages/System/StorageSystemGrants.cpp
@@ -35,10 +35,10 @@ NamesAndTypesList StorageSystemGrants::getNamesAndTypes()
 }
 
 
-void StorageSystemGrants::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemGrants::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_USERS | AccessType::SHOW_ROLES);
-    const auto & access_control = context.getAccessControlManager();
+    context->checkAccess(AccessType::SHOW_USERS | AccessType::SHOW_ROLES);
+    const auto & access_control = context->getAccessControlManager();
     std::vector<UUID> ids = access_control.findAll<User>();
     boost::range::push_back(ids, access_control.findAll<Role>());
 
diff --git a/src/Storages/System/StorageSystemGrants.h b/src/Storages/System/StorageSystemGrants.h
index 39c38deed85..8c8a0f9f7bf 100644
--- a/src/Storages/System/StorageSystemGrants.h
+++ b/src/Storages/System/StorageSystemGrants.h
@@ -18,7 +18,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemGrants>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemGraphite.cpp b/src/Storages/System/StorageSystemGraphite.cpp
index 93bc16785b2..dd592600d18 100644
--- a/src/Storages/System/StorageSystemGraphite.cpp
+++ b/src/Storages/System/StorageSystemGraphite.cpp
@@ -25,7 +25,7 @@ NamesAndTypesList StorageSystemGraphite::getNamesAndTypes()
 /*
  * Looking for (Replicated)*GraphiteMergeTree and get all configuration parameters for them
  */
-static StorageSystemGraphite::Configs getConfigs(const Context & context)
+static StorageSystemGraphite::Configs getConfigs(ContextPtr context)
 {
     const Databases databases = DatabaseCatalog::instance().getDatabases();
     StorageSystemGraphite::Configs graphite_configs;
@@ -73,7 +73,7 @@ static StorageSystemGraphite::Configs getConfigs(const Context & context)
     return graphite_configs;
 }
 
-void StorageSystemGraphite::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemGraphite::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
     Configs graphite_configs = getConfigs(context);
 
diff --git a/src/Storages/System/StorageSystemGraphite.h b/src/Storages/System/StorageSystemGraphite.h
index 703db41dc39..256ad50e472 100644
--- a/src/Storages/System/StorageSystemGraphite.h
+++ b/src/Storages/System/StorageSystemGraphite.h
@@ -32,7 +32,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemLicenses.cpp b/src/Storages/System/StorageSystemLicenses.cpp
index 894c861de29..6f880f03e10 100644
--- a/src/Storages/System/StorageSystemLicenses.cpp
+++ b/src/Storages/System/StorageSystemLicenses.cpp
@@ -18,7 +18,7 @@ NamesAndTypesList StorageSystemLicenses::getNamesAndTypes()
     };
 }
 
-void StorageSystemLicenses::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemLicenses::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     for (const auto * it = library_licenses; *it; it += 4)
     {
diff --git a/src/Storages/System/StorageSystemLicenses.h b/src/Storages/System/StorageSystemLicenses.h
index cee48abacab..43bb1c20c22 100644
--- a/src/Storages/System/StorageSystemLicenses.h
+++ b/src/Storages/System/StorageSystemLicenses.h
@@ -17,7 +17,7 @@ class StorageSystemLicenses final :
 {
     friend struct ext::shared_ptr_helper<StorageSystemLicenses>;
 protected:
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
diff --git a/src/Storages/System/StorageSystemMacros.cpp b/src/Storages/System/StorageSystemMacros.cpp
index 8e6420add8b..576fbc69039 100644
--- a/src/Storages/System/StorageSystemMacros.cpp
+++ b/src/Storages/System/StorageSystemMacros.cpp
@@ -14,9 +14,9 @@ NamesAndTypesList StorageSystemMacros::getNamesAndTypes()
     };
 }
 
-void StorageSystemMacros::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemMacros::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    auto macros = context.getMacros();
+    auto macros = context->getMacros();
 
     for (const auto & macro : macros->getMacroMap())
     {
diff --git a/src/Storages/System/StorageSystemMacros.h b/src/Storages/System/StorageSystemMacros.h
index 52336bd6f69..298aa488265 100644
--- a/src/Storages/System/StorageSystemMacros.h
+++ b/src/Storages/System/StorageSystemMacros.h
@@ -24,7 +24,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemMergeTreeSettings.cpp b/src/Storages/System/StorageSystemMergeTreeSettings.cpp
index 19cbf76f252..626319af63f 100644
--- a/src/Storages/System/StorageSystemMergeTreeSettings.cpp
+++ b/src/Storages/System/StorageSystemMergeTreeSettings.cpp
@@ -20,9 +20,9 @@ NamesAndTypesList SystemMergeTreeSettings<replicated>::getNamesAndTypes()
 }
 
 template <bool replicated>
-void SystemMergeTreeSettings<replicated>::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void SystemMergeTreeSettings<replicated>::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    const auto & settings = replicated ? context.getReplicatedMergeTreeSettings().all() : context.getMergeTreeSettings().all();
+    const auto & settings = replicated ? context->getReplicatedMergeTreeSettings().all() : context->getMergeTreeSettings().all();
     for (const auto & setting : settings)
     {
         res_columns[0]->insert(setting.getName());
diff --git a/src/Storages/System/StorageSystemMergeTreeSettings.h b/src/Storages/System/StorageSystemMergeTreeSettings.h
index 9f61fa6f780..b02b191fb69 100644
--- a/src/Storages/System/StorageSystemMergeTreeSettings.h
+++ b/src/Storages/System/StorageSystemMergeTreeSettings.h
@@ -28,7 +28,7 @@ public:
 protected:
     using IStorageSystemOneBlock<SystemMergeTreeSettings<replicated>>::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemMerges.cpp b/src/Storages/System/StorageSystemMerges.cpp
index b61324818e4..b29836206d0 100644
--- a/src/Storages/System/StorageSystemMerges.cpp
+++ b/src/Storages/System/StorageSystemMerges.cpp
@@ -36,12 +36,12 @@ NamesAndTypesList StorageSystemMerges::getNamesAndTypes()
 }
 
 
-void StorageSystemMerges::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemMerges::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    const auto access = context.getAccess();
+    const auto access = context->getAccess();
     const bool check_access_for_tables = !access->isGranted(AccessType::SHOW_TABLES);
 
-    for (const auto & merge : context.getMergeList().get())
+    for (const auto & merge : context->getMergeList().get())
     {
         if (check_access_for_tables && !access->isGranted(AccessType::SHOW_TABLES, merge.database, merge.table))
             continue;
diff --git a/src/Storages/System/StorageSystemMerges.h b/src/Storages/System/StorageSystemMerges.h
index 81c03c4e397..5898bf62825 100644
--- a/src/Storages/System/StorageSystemMerges.h
+++ b/src/Storages/System/StorageSystemMerges.h
@@ -24,7 +24,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemMetrics.cpp b/src/Storages/System/StorageSystemMetrics.cpp
index b2332c52817..6007c8a7c71 100644
--- a/src/Storages/System/StorageSystemMetrics.cpp
+++ b/src/Storages/System/StorageSystemMetrics.cpp
@@ -17,7 +17,7 @@ NamesAndTypesList StorageSystemMetrics::getNamesAndTypes()
     };
 }
 
-void StorageSystemMetrics::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemMetrics::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     for (size_t i = 0, end = CurrentMetrics::end(); i < end; ++i)
     {
diff --git a/src/Storages/System/StorageSystemMetrics.h b/src/Storages/System/StorageSystemMetrics.h
index c47bcea656f..af5d32ec46b 100644
--- a/src/Storages/System/StorageSystemMetrics.h
+++ b/src/Storages/System/StorageSystemMetrics.h
@@ -23,7 +23,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemModels.cpp b/src/Storages/System/StorageSystemModels.cpp
index 9fae9803b96..3df48e830bb 100644
--- a/src/Storages/System/StorageSystemModels.cpp
+++ b/src/Storages/System/StorageSystemModels.cpp
@@ -25,9 +25,9 @@ NamesAndTypesList StorageSystemModels::getNamesAndTypes()
     };
 }
 
-void StorageSystemModels::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemModels::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    const auto & external_models_loader = context.getExternalModelsLoader();
+    const auto & external_models_loader = context->getExternalModelsLoader();
     auto load_results = external_models_loader.getLoadResults();
 
     for (const auto & load_result : load_results)
diff --git a/src/Storages/System/StorageSystemModels.h b/src/Storages/System/StorageSystemModels.h
index cee5200e7de..832a9d550db 100644
--- a/src/Storages/System/StorageSystemModels.h
+++ b/src/Storages/System/StorageSystemModels.h
@@ -21,7 +21,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemMutations.cpp b/src/Storages/System/StorageSystemMutations.cpp
index f66f57ef5d1..fa521c632b8 100644
--- a/src/Storages/System/StorageSystemMutations.cpp
+++ b/src/Storages/System/StorageSystemMutations.cpp
@@ -35,9 +35,9 @@ NamesAndTypesList StorageSystemMutations::getNamesAndTypes()
 }
 
 
-void StorageSystemMutations::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const
+void StorageSystemMutations::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const
 {
-    const auto access = context.getAccess();
+    const auto access = context->getAccess();
     const bool check_access_for_databases = !access->isGranted(AccessType::SHOW_TABLES);
 
     /// Collect a set of *MergeTree tables.
diff --git a/src/Storages/System/StorageSystemMutations.h b/src/Storages/System/StorageSystemMutations.h
index f7bc5f6f33c..1f41ff6051b 100644
--- a/src/Storages/System/StorageSystemMutations.h
+++ b/src/Storages/System/StorageSystemMutations.h
@@ -23,7 +23,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemNumbers.cpp b/src/Storages/System/StorageSystemNumbers.cpp
index 677e0c02400..f8a0e94bf98 100644
--- a/src/Storages/System/StorageSystemNumbers.cpp
+++ b/src/Storages/System/StorageSystemNumbers.cpp
@@ -126,7 +126,7 @@ Pipe StorageSystemNumbers::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo &,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size,
     unsigned num_streams)
diff --git a/src/Storages/System/StorageSystemNumbers.h b/src/Storages/System/StorageSystemNumbers.h
index d12c28c1ce2..708ace7a4cd 100644
--- a/src/Storages/System/StorageSystemNumbers.h
+++ b/src/Storages/System/StorageSystemNumbers.h
@@ -33,7 +33,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/System/StorageSystemOne.cpp b/src/Storages/System/StorageSystemOne.cpp
index c456b22e97b..7c28f897121 100644
--- a/src/Storages/System/StorageSystemOne.cpp
+++ b/src/Storages/System/StorageSystemOne.cpp
@@ -24,7 +24,7 @@ Pipe StorageSystemOne::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo &,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t /*max_block_size*/,
     const unsigned /*num_streams*/)
diff --git a/src/Storages/System/StorageSystemOne.h b/src/Storages/System/StorageSystemOne.h
index 8228ce465e0..a34f9562025 100644
--- a/src/Storages/System/StorageSystemOne.h
+++ b/src/Storages/System/StorageSystemOne.h
@@ -25,7 +25,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/System/StorageSystemPartsBase.cpp b/src/Storages/System/StorageSystemPartsBase.cpp
index 02627a3ba03..f1c82aa4c63 100644
--- a/src/Storages/System/StorageSystemPartsBase.cpp
+++ b/src/Storages/System/StorageSystemPartsBase.cpp
@@ -62,8 +62,8 @@ StoragesInfo::getParts(MergeTreeData::DataPartStateVector & state, bool has_stat
     return data->getDataPartsVector({State::Committed}, &state);
 }
 
-StoragesInfoStream::StoragesInfoStream(const SelectQueryInfo & query_info, const Context & context)
-    : query_id(context.getCurrentQueryId()), settings(context.getSettings())
+StoragesInfoStream::StoragesInfoStream(const SelectQueryInfo & query_info, ContextPtr context)
+    : query_id(context->getCurrentQueryId()), settings(context->getSettings())
 {
     /// Will apply WHERE to subset of columns and then add more columns.
     /// This is kind of complicated, but we use WHERE to do less work.
@@ -74,7 +74,7 @@ StoragesInfoStream::StoragesInfoStream(const SelectQueryInfo & query_info, const
     MutableColumnPtr engine_column_mut = ColumnString::create();
     MutableColumnPtr active_column_mut = ColumnUInt8::create();
 
-    const auto access = context.getAccess();
+    const auto access = context->getAccess();
     const bool check_access_for_tables = !access->isGranted(AccessType::SHOW_TABLES);
 
     {
@@ -234,7 +234,7 @@ Pipe StorageSystemPartsBase::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t /*max_block_size*/,
     const unsigned /*num_streams*/)
diff --git a/src/Storages/System/StorageSystemPartsBase.h b/src/Storages/System/StorageSystemPartsBase.h
index 3f63d75e2b6..33f82d04252 100644
--- a/src/Storages/System/StorageSystemPartsBase.h
+++ b/src/Storages/System/StorageSystemPartsBase.h
@@ -31,7 +31,7 @@ struct StoragesInfo
 class StoragesInfoStream
 {
 public:
-    StoragesInfoStream(const SelectQueryInfo & query_info, const Context & context);
+    StoragesInfoStream(const SelectQueryInfo & query_info, ContextPtr context);
     StoragesInfo next();
 
 private:
@@ -59,7 +59,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & metadata_snapshot,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/System/StorageSystemPrivileges.cpp b/src/Storages/System/StorageSystemPrivileges.cpp
index 5dda0caf201..ca369efe43a 100644
--- a/src/Storages/System/StorageSystemPrivileges.cpp
+++ b/src/Storages/System/StorageSystemPrivileges.cpp
@@ -74,7 +74,7 @@ NamesAndTypesList StorageSystemPrivileges::getNamesAndTypes()
 }
 
 
-void StorageSystemPrivileges::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemPrivileges::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     size_t column_index = 0;
     auto & column_access_type = assert_cast<ColumnInt8 &>(*res_columns[column_index++]).getData();
diff --git a/src/Storages/System/StorageSystemPrivileges.h b/src/Storages/System/StorageSystemPrivileges.h
index 8540e3d7ec3..618e1c91597 100644
--- a/src/Storages/System/StorageSystemPrivileges.h
+++ b/src/Storages/System/StorageSystemPrivileges.h
@@ -19,7 +19,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemPrivileges>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemProcesses.cpp b/src/Storages/System/StorageSystemProcesses.cpp
index e6266503095..785b4c0df11 100644
--- a/src/Storages/System/StorageSystemProcesses.cpp
+++ b/src/Storages/System/StorageSystemProcesses.cpp
@@ -70,9 +70,9 @@ NamesAndTypesList StorageSystemProcesses::getNamesAndTypes()
 }
 
 
-void StorageSystemProcesses::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemProcesses::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    ProcessList::Info info = context.getProcessList().getInfo(true, true, true);
+    ProcessList::Info info = context->getProcessList().getInfo(true, true, true);
 
     for (const auto & process : info)
     {
diff --git a/src/Storages/System/StorageSystemProcesses.h b/src/Storages/System/StorageSystemProcesses.h
index 62c568970e7..4f876348a4b 100644
--- a/src/Storages/System/StorageSystemProcesses.h
+++ b/src/Storages/System/StorageSystemProcesses.h
@@ -23,7 +23,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemQuotaLimits.cpp b/src/Storages/System/StorageSystemQuotaLimits.cpp
index c6e99cc9203..63a419e213c 100644
--- a/src/Storages/System/StorageSystemQuotaLimits.cpp
+++ b/src/Storages/System/StorageSystemQuotaLimits.cpp
@@ -69,10 +69,10 @@ NamesAndTypesList StorageSystemQuotaLimits::getNamesAndTypes()
 }
 
 
-void StorageSystemQuotaLimits::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemQuotaLimits::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_QUOTAS);
-    const auto & access_control = context.getAccessControlManager();
+    context->checkAccess(AccessType::SHOW_QUOTAS);
+    const auto & access_control = context->getAccessControlManager();
     std::vector<UUID> ids = access_control.findAll<Quota>();
 
     size_t column_index = 0;
diff --git a/src/Storages/System/StorageSystemQuotaLimits.h b/src/Storages/System/StorageSystemQuotaLimits.h
index e9ae7fc09d0..8f496734e0f 100644
--- a/src/Storages/System/StorageSystemQuotaLimits.h
+++ b/src/Storages/System/StorageSystemQuotaLimits.h
@@ -18,7 +18,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemQuotaLimits>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemQuotaUsage.cpp b/src/Storages/System/StorageSystemQuotaUsage.cpp
index 6d6e22e7be6..a25a130bf6c 100644
--- a/src/Storages/System/StorageSystemQuotaUsage.cpp
+++ b/src/Storages/System/StorageSystemQuotaUsage.cpp
@@ -81,10 +81,10 @@ NamesAndTypesList StorageSystemQuotaUsage::getNamesAndTypesImpl(bool add_column_
 }
 
 
-void StorageSystemQuotaUsage::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemQuotaUsage::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_QUOTAS);
-    auto usage = context.getQuotaUsage();
+    context->checkAccess(AccessType::SHOW_QUOTAS);
+    auto usage = context->getQuotaUsage();
     if (!usage)
         return;
 
@@ -94,7 +94,7 @@ void StorageSystemQuotaUsage::fillData(MutableColumns & res_columns, const Conte
 
 void StorageSystemQuotaUsage::fillDataImpl(
     MutableColumns & res_columns,
-    const Context & context,
+    ContextPtr context,
     bool add_column_is_current,
     const std::vector<QuotaUsage> & quotas_usage)
 {
@@ -128,7 +128,7 @@ void StorageSystemQuotaUsage::fillDataImpl(
     std::optional<UUID> current_quota_id;
     if (add_column_is_current)
     {
-        if (auto current_usage = context.getQuotaUsage())
+        if (auto current_usage = context->getQuotaUsage())
             current_quota_id = current_usage->quota_id;
     }
 
diff --git a/src/Storages/System/StorageSystemQuotaUsage.h b/src/Storages/System/StorageSystemQuotaUsage.h
index abb9505eb5a..806c3eb3f4a 100644
--- a/src/Storages/System/StorageSystemQuotaUsage.h
+++ b/src/Storages/System/StorageSystemQuotaUsage.h
@@ -20,12 +20,12 @@ public:
     static NamesAndTypesList getNamesAndTypes();
 
     static NamesAndTypesList getNamesAndTypesImpl(bool add_column_is_current);
-    static void fillDataImpl(MutableColumns & res_columns, const Context & context, bool add_column_is_current, const std::vector<QuotaUsage> & quotas_usage);
+    static void fillDataImpl(MutableColumns & res_columns, ContextPtr context, bool add_column_is_current, const std::vector<QuotaUsage> & quotas_usage);
 
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemQuotaUsage>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemQuotas.cpp b/src/Storages/System/StorageSystemQuotas.cpp
index fab6384e6a8..4bba082f66e 100644
--- a/src/Storages/System/StorageSystemQuotas.cpp
+++ b/src/Storages/System/StorageSystemQuotas.cpp
@@ -52,10 +52,10 @@ NamesAndTypesList StorageSystemQuotas::getNamesAndTypes()
 }
 
 
-void StorageSystemQuotas::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemQuotas::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_QUOTAS);
-    const auto & access_control = context.getAccessControlManager();
+    context->checkAccess(AccessType::SHOW_QUOTAS);
+    const auto & access_control = context->getAccessControlManager();
     std::vector<UUID> ids = access_control.findAll<Quota>();
 
     size_t column_index = 0;
diff --git a/src/Storages/System/StorageSystemQuotas.h b/src/Storages/System/StorageSystemQuotas.h
index 8d1da53d641..fb74ea9b05f 100644
--- a/src/Storages/System/StorageSystemQuotas.h
+++ b/src/Storages/System/StorageSystemQuotas.h
@@ -19,7 +19,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemQuotas>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemQuotasUsage.cpp b/src/Storages/System/StorageSystemQuotasUsage.cpp
index 5c6879cd143..363562bce19 100644
--- a/src/Storages/System/StorageSystemQuotasUsage.cpp
+++ b/src/Storages/System/StorageSystemQuotasUsage.cpp
@@ -13,10 +13,10 @@ NamesAndTypesList StorageSystemQuotasUsage::getNamesAndTypes()
     return StorageSystemQuotaUsage::getNamesAndTypesImpl(/* add_column_is_current = */ true);
 }
 
-void StorageSystemQuotasUsage::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemQuotasUsage::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_QUOTAS);
-    auto all_quotas_usage = context.getAccessControlManager().getAllQuotasUsage();
+    context->checkAccess(AccessType::SHOW_QUOTAS);
+    auto all_quotas_usage = context->getAccessControlManager().getAllQuotasUsage();
     StorageSystemQuotaUsage::fillDataImpl(res_columns, context, /* add_column_is_current = */ true, all_quotas_usage);
 }
 }
diff --git a/src/Storages/System/StorageSystemQuotasUsage.h b/src/Storages/System/StorageSystemQuotasUsage.h
index d4fd93b577d..1f29ea9b886 100644
--- a/src/Storages/System/StorageSystemQuotasUsage.h
+++ b/src/Storages/System/StorageSystemQuotasUsage.h
@@ -20,7 +20,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemQuotasUsage>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemReplicas.cpp b/src/Storages/System/StorageSystemReplicas.cpp
index 0af67ab6986..fc33c6b421b 100644
--- a/src/Storages/System/StorageSystemReplicas.cpp
+++ b/src/Storages/System/StorageSystemReplicas.cpp
@@ -60,14 +60,14 @@ Pipe StorageSystemReplicas::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t /*max_block_size*/,
     const unsigned /*num_streams*/)
 {
     metadata_snapshot->check(column_names, getVirtuals(), getStorageID());
 
-    const auto access = context.getAccess();
+    const auto access = context->getAccess();
     const bool check_access_for_databases = !access->isGranted(AccessType::SHOW_TABLES);
 
     /// We collect a set of replicated tables.
diff --git a/src/Storages/System/StorageSystemReplicas.h b/src/Storages/System/StorageSystemReplicas.h
index d9e364a28c0..2352d7ccdf2 100644
--- a/src/Storages/System/StorageSystemReplicas.h
+++ b/src/Storages/System/StorageSystemReplicas.h
@@ -22,7 +22,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/System/StorageSystemReplicatedFetches.cpp b/src/Storages/System/StorageSystemReplicatedFetches.cpp
index 53bec5aa42f..453568e3b86 100644
--- a/src/Storages/System/StorageSystemReplicatedFetches.cpp
+++ b/src/Storages/System/StorageSystemReplicatedFetches.cpp
@@ -30,12 +30,12 @@ NamesAndTypesList StorageSystemReplicatedFetches::getNamesAndTypes()
     };
 }
 
-void StorageSystemReplicatedFetches::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemReplicatedFetches::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    const auto access = context.getAccess();
+    const auto access = context->getAccess();
     const bool check_access_for_tables = !access->isGranted(AccessType::SHOW_TABLES);
 
-    for (const auto & fetch : context.getReplicatedFetchList().get())
+    for (const auto & fetch : context->getReplicatedFetchList().get())
     {
         if (check_access_for_tables && !access->isGranted(AccessType::SHOW_TABLES, fetch.database, fetch.table))
             continue;
diff --git a/src/Storages/System/StorageSystemReplicatedFetches.h b/src/Storages/System/StorageSystemReplicatedFetches.h
index 34081923e4f..ed25e75eb70 100644
--- a/src/Storages/System/StorageSystemReplicatedFetches.h
+++ b/src/Storages/System/StorageSystemReplicatedFetches.h
@@ -22,7 +22,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemReplicationQueue.cpp b/src/Storages/System/StorageSystemReplicationQueue.cpp
index 9cd5e8b8ff3..8acd192eac4 100644
--- a/src/Storages/System/StorageSystemReplicationQueue.cpp
+++ b/src/Storages/System/StorageSystemReplicationQueue.cpp
@@ -47,9 +47,9 @@ NamesAndTypesList StorageSystemReplicationQueue::getNamesAndTypes()
 }
 
 
-void StorageSystemReplicationQueue::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const
+void StorageSystemReplicationQueue::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const
 {
-    const auto access = context.getAccess();
+    const auto access = context->getAccess();
     const bool check_access_for_databases = !access->isGranted(AccessType::SHOW_TABLES);
 
     std::map<String, std::map<String, StoragePtr>> replicated_tables;
diff --git a/src/Storages/System/StorageSystemReplicationQueue.h b/src/Storages/System/StorageSystemReplicationQueue.h
index 36841fb9be9..f85f23a2b20 100644
--- a/src/Storages/System/StorageSystemReplicationQueue.h
+++ b/src/Storages/System/StorageSystemReplicationQueue.h
@@ -23,7 +23,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemRoleGrants.cpp b/src/Storages/System/StorageSystemRoleGrants.cpp
index cf0fad8f8ce..32984afcfc5 100644
--- a/src/Storages/System/StorageSystemRoleGrants.cpp
+++ b/src/Storages/System/StorageSystemRoleGrants.cpp
@@ -31,10 +31,10 @@ NamesAndTypesList StorageSystemRoleGrants::getNamesAndTypes()
 }
 
 
-void StorageSystemRoleGrants::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemRoleGrants::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_USERS | AccessType::SHOW_ROLES);
-    const auto & access_control = context.getAccessControlManager();
+    context->checkAccess(AccessType::SHOW_USERS | AccessType::SHOW_ROLES);
+    const auto & access_control = context->getAccessControlManager();
     std::vector<UUID> ids = access_control.findAll<User>();
     boost::range::push_back(ids, access_control.findAll<Role>());
 
diff --git a/src/Storages/System/StorageSystemRoleGrants.h b/src/Storages/System/StorageSystemRoleGrants.h
index 0a02303abc3..a290dcf320d 100644
--- a/src/Storages/System/StorageSystemRoleGrants.h
+++ b/src/Storages/System/StorageSystemRoleGrants.h
@@ -18,7 +18,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemRoleGrants>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemRoles.cpp b/src/Storages/System/StorageSystemRoles.cpp
index c560bc2bc6e..65ae74887a7 100644
--- a/src/Storages/System/StorageSystemRoles.cpp
+++ b/src/Storages/System/StorageSystemRoles.cpp
@@ -23,10 +23,10 @@ NamesAndTypesList StorageSystemRoles::getNamesAndTypes()
 }
 
 
-void StorageSystemRoles::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemRoles::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_ROLES);
-    const auto & access_control = context.getAccessControlManager();
+    context->checkAccess(AccessType::SHOW_ROLES);
+    const auto & access_control = context->getAccessControlManager();
     std::vector<UUID> ids = access_control.findAll<Role>();
 
     size_t column_index = 0;
diff --git a/src/Storages/System/StorageSystemRoles.h b/src/Storages/System/StorageSystemRoles.h
index fb44194baff..38c7ed05f1e 100644
--- a/src/Storages/System/StorageSystemRoles.h
+++ b/src/Storages/System/StorageSystemRoles.h
@@ -18,7 +18,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemRoles>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemRowPolicies.cpp b/src/Storages/System/StorageSystemRowPolicies.cpp
index 9b11a781d6f..f9d6b14957e 100644
--- a/src/Storages/System/StorageSystemRowPolicies.cpp
+++ b/src/Storages/System/StorageSystemRowPolicies.cpp
@@ -52,10 +52,10 @@ NamesAndTypesList StorageSystemRowPolicies::getNamesAndTypes()
 }
 
 
-void StorageSystemRowPolicies::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemRowPolicies::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_ROW_POLICIES);
-    const auto & access_control = context.getAccessControlManager();
+    context->checkAccess(AccessType::SHOW_ROW_POLICIES);
+    const auto & access_control = context->getAccessControlManager();
     std::vector<UUID> ids = access_control.findAll<RowPolicy>();
 
     size_t column_index = 0;
diff --git a/src/Storages/System/StorageSystemRowPolicies.h b/src/Storages/System/StorageSystemRowPolicies.h
index b81020b421c..3b9ebfcc25a 100644
--- a/src/Storages/System/StorageSystemRowPolicies.h
+++ b/src/Storages/System/StorageSystemRowPolicies.h
@@ -20,7 +20,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemRowPolicies>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemSettings.cpp b/src/Storages/System/StorageSystemSettings.cpp
index 07a2d450b12..1aca7e45190 100644
--- a/src/Storages/System/StorageSystemSettings.cpp
+++ b/src/Storages/System/StorageSystemSettings.cpp
@@ -26,10 +26,10 @@ NamesAndTypesList StorageSystemSettings::getNamesAndTypes()
 #pragma GCC optimize("-fno-var-tracking-assignments")
 #endif
 
-void StorageSystemSettings::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemSettings::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    const Settings & settings = context.getSettingsRef();
-    auto settings_constraints = context.getSettingsConstraints();
+    const Settings & settings = context->getSettingsRef();
+    auto settings_constraints = context->getSettingsConstraints();
     for (const auto & setting : settings.all())
     {
         const auto & setting_name = setting.getName();
diff --git a/src/Storages/System/StorageSystemSettings.h b/src/Storages/System/StorageSystemSettings.h
index 6cb5e18e1d7..d93c09d3f80 100644
--- a/src/Storages/System/StorageSystemSettings.h
+++ b/src/Storages/System/StorageSystemSettings.h
@@ -23,7 +23,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemSettingsProfileElements.cpp b/src/Storages/System/StorageSystemSettingsProfileElements.cpp
index cf47416e188..fa824091238 100644
--- a/src/Storages/System/StorageSystemSettingsProfileElements.cpp
+++ b/src/Storages/System/StorageSystemSettingsProfileElements.cpp
@@ -37,10 +37,10 @@ NamesAndTypesList StorageSystemSettingsProfileElements::getNamesAndTypes()
 }
 
 
-void StorageSystemSettingsProfileElements::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemSettingsProfileElements::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_SETTINGS_PROFILES);
-    const auto & access_control = context.getAccessControlManager();
+    context->checkAccess(AccessType::SHOW_SETTINGS_PROFILES);
+    const auto & access_control = context->getAccessControlManager();
     std::vector<UUID> ids = access_control.findAll<User>();
     boost::range::push_back(ids, access_control.findAll<Role>());
     boost::range::push_back(ids, access_control.findAll<SettingsProfile>());
diff --git a/src/Storages/System/StorageSystemSettingsProfileElements.h b/src/Storages/System/StorageSystemSettingsProfileElements.h
index 2dc79fed0e7..2262ea96dde 100644
--- a/src/Storages/System/StorageSystemSettingsProfileElements.h
+++ b/src/Storages/System/StorageSystemSettingsProfileElements.h
@@ -18,7 +18,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemSettingsProfileElements>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemSettingsProfiles.cpp b/src/Storages/System/StorageSystemSettingsProfiles.cpp
index a678290d447..c726f54a324 100644
--- a/src/Storages/System/StorageSystemSettingsProfiles.cpp
+++ b/src/Storages/System/StorageSystemSettingsProfiles.cpp
@@ -30,10 +30,10 @@ NamesAndTypesList StorageSystemSettingsProfiles::getNamesAndTypes()
 }
 
 
-void StorageSystemSettingsProfiles::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemSettingsProfiles::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_SETTINGS_PROFILES);
-    const auto & access_control = context.getAccessControlManager();
+    context->checkAccess(AccessType::SHOW_SETTINGS_PROFILES);
+    const auto & access_control = context->getAccessControlManager();
     std::vector<UUID> ids = access_control.findAll<SettingsProfile>();
 
     size_t column_index = 0;
diff --git a/src/Storages/System/StorageSystemSettingsProfiles.h b/src/Storages/System/StorageSystemSettingsProfiles.h
index c6b887c99df..580430dc28b 100644
--- a/src/Storages/System/StorageSystemSettingsProfiles.h
+++ b/src/Storages/System/StorageSystemSettingsProfiles.h
@@ -18,7 +18,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemSettingsProfiles>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemStackTrace.cpp b/src/Storages/System/StorageSystemStackTrace.cpp
index e74d56108ad..a6651aff8be 100644
--- a/src/Storages/System/StorageSystemStackTrace.cpp
+++ b/src/Storages/System/StorageSystemStackTrace.cpp
@@ -183,7 +183,7 @@ NamesAndTypesList StorageSystemStackTrace::getNamesAndTypes()
 }
 
 
-void StorageSystemStackTrace::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemStackTrace::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     /// It shouldn't be possible to do concurrent reads from this table.
     std::lock_guard lock(mutex);
diff --git a/src/Storages/System/StorageSystemStackTrace.h b/src/Storages/System/StorageSystemStackTrace.h
index 582618d2ecd..7f10e309775 100644
--- a/src/Storages/System/StorageSystemStackTrace.h
+++ b/src/Storages/System/StorageSystemStackTrace.h
@@ -31,7 +31,7 @@ public:
 
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     mutable std::mutex mutex;
 
diff --git a/src/Storages/System/StorageSystemStoragePolicies.cpp b/src/Storages/System/StorageSystemStoragePolicies.cpp
index 7a10b986c11..48dfadd2b3c 100644
--- a/src/Storages/System/StorageSystemStoragePolicies.cpp
+++ b/src/Storages/System/StorageSystemStoragePolicies.cpp
@@ -39,7 +39,7 @@ Pipe StorageSystemStoragePolicies::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & /*query_info*/,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t /*max_block_size*/,
     const unsigned /*num_streams*/)
@@ -55,7 +55,7 @@ Pipe StorageSystemStoragePolicies::read(
     MutableColumnPtr col_move_factor = ColumnFloat32::create();
     MutableColumnPtr col_prefer_not_to_merge = ColumnUInt8::create();
 
-    for (const auto & [policy_name, policy_ptr] : context.getPoliciesMap())
+    for (const auto & [policy_name, policy_ptr] : context->getPoliciesMap())
     {
         const auto & volumes = policy_ptr->getVolumes();
         for (size_t i = 0; i != volumes.size(); ++i)
diff --git a/src/Storages/System/StorageSystemStoragePolicies.h b/src/Storages/System/StorageSystemStoragePolicies.h
index afd5e672d66..70053ebc1bc 100644
--- a/src/Storages/System/StorageSystemStoragePolicies.h
+++ b/src/Storages/System/StorageSystemStoragePolicies.h
@@ -24,7 +24,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/System/StorageSystemTableEngines.cpp b/src/Storages/System/StorageSystemTableEngines.cpp
index 3f06faf6736..bc33cd9189c 100644
--- a/src/Storages/System/StorageSystemTableEngines.cpp
+++ b/src/Storages/System/StorageSystemTableEngines.cpp
@@ -20,7 +20,7 @@ NamesAndTypesList StorageSystemTableEngines::getNamesAndTypes()
     };
 }
 
-void StorageSystemTableEngines::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemTableEngines::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     for (const auto & pair : StorageFactory::instance().getAllStorages())
     {
diff --git a/src/Storages/System/StorageSystemTableEngines.h b/src/Storages/System/StorageSystemTableEngines.h
index 1c080c3040b..37f7f354073 100644
--- a/src/Storages/System/StorageSystemTableEngines.h
+++ b/src/Storages/System/StorageSystemTableEngines.h
@@ -12,7 +12,7 @@ class StorageSystemTableEngines final : public ext::shared_ptr_helper<StorageSys
 {
     friend struct ext::shared_ptr_helper<StorageSystemTableEngines>;
 protected:
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
diff --git a/src/Storages/System/StorageSystemTableFunctions.cpp b/src/Storages/System/StorageSystemTableFunctions.cpp
index 65b1dc41879..2824e1726e9 100644
--- a/src/Storages/System/StorageSystemTableFunctions.cpp
+++ b/src/Storages/System/StorageSystemTableFunctions.cpp
@@ -9,7 +9,7 @@ NamesAndTypesList StorageSystemTableFunctions::getNamesAndTypes()
     return {{"name", std::make_shared<DataTypeString>()}};
 }
 
-void StorageSystemTableFunctions::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemTableFunctions::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     const auto & functions_names = TableFunctionFactory::instance().getAllRegisteredNames();
     for (const auto & function_name : functions_names)
diff --git a/src/Storages/System/StorageSystemTableFunctions.h b/src/Storages/System/StorageSystemTableFunctions.h
index 95e025b9881..a5db5450d20 100644
--- a/src/Storages/System/StorageSystemTableFunctions.h
+++ b/src/Storages/System/StorageSystemTableFunctions.h
@@ -14,7 +14,7 @@ protected:
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
 public:
 
diff --git a/src/Storages/System/StorageSystemTables.cpp b/src/Storages/System/StorageSystemTables.cpp
index 4599dad2e3d..9602339f381 100644
--- a/src/Storages/System/StorageSystemTables.cpp
+++ b/src/Storages/System/StorageSystemTables.cpp
@@ -62,7 +62,7 @@ StorageSystemTables::StorageSystemTables(const StorageID & table_id_)
 }
 
 
-static ColumnPtr getFilteredDatabases(const SelectQueryInfo & query_info, const Context & context)
+static ColumnPtr getFilteredDatabases(const SelectQueryInfo & query_info, ContextPtr context)
 {
     MutableColumnPtr column = ColumnString::create();
 
@@ -104,12 +104,12 @@ public:
         Block header,
         UInt64 max_block_size_,
         ColumnPtr databases_,
-        const Context & context_)
+        ContextPtr context_)
         : SourceWithProgress(std::move(header))
         , columns_mask(std::move(columns_mask_))
         , max_block_size(max_block_size_)
         , databases(std::move(databases_))
-        , context(context_) {}
+        , context(Context::createCopy(context_)) {}
 
     String getName() const override { return "Tables"; }
 
@@ -121,7 +121,7 @@ protected:
 
         MutableColumns res_columns = getPort().getHeader().cloneEmptyColumns();
 
-        const auto access = context.getAccess();
+        const auto access = context->getAccess();
         const bool check_access_for_databases = !access->isGranted(AccessType::SHOW_TABLES);
 
         size_t rows_count = 0;
@@ -148,9 +148,9 @@ protected:
             /// This is for temporary tables. They are output in single block regardless to max_block_size.
             if (database_idx >= databases->size())
             {
-                if (context.hasSessionContext())
+                if (context->hasSessionContext())
                 {
-                    Tables external_tables = context.getSessionContext().getExternalTables();
+                    Tables external_tables = context->getSessionContext()->getExternalTables();
 
                     for (auto & table : external_tables)
                     {
@@ -278,7 +278,7 @@ protected:
                     }
                     try
                     {
-                        lock = table->lockForShare(context.getCurrentQueryId(), context.getSettingsRef().lock_acquire_timeout);
+                        lock = table->lockForShare(context->getCurrentQueryId(), context->getSettingsRef().lock_acquire_timeout);
                     }
                     catch (const Exception & e)
                     {
@@ -355,7 +355,7 @@ protected:
                 {
                     ASTPtr ast = database->tryGetCreateTableQuery(table_name, context);
 
-                    if (ast && !context.getSettingsRef().show_table_uuid_in_table_create_query_if_not_nil)
+                    if (ast && !context->getSettingsRef().show_table_uuid_in_table_create_query_if_not_nil)
                     {
                         auto & create = ast->as<ASTCreateQuery &>();
                         create.uuid = UUIDHelpers::Nil;
@@ -442,7 +442,7 @@ protected:
                 if (columns_mask[src_index++])
                 {
                     assert(table != nullptr);
-                    auto total_rows = table->totalRows(context.getSettingsRef());
+                    auto total_rows = table->totalRows(context->getSettingsRef());
                     if (total_rows)
                         res_columns[res_index++]->insert(*total_rows);
                     else
@@ -452,7 +452,7 @@ protected:
                 if (columns_mask[src_index++])
                 {
                     assert(table != nullptr);
-                    auto total_bytes = table->totalBytes(context.getSettingsRef());
+                    auto total_bytes = table->totalBytes(context->getSettingsRef());
                     if (total_bytes)
                         res_columns[res_index++]->insert(*total_bytes);
                     else
@@ -490,7 +490,7 @@ private:
     ColumnPtr databases;
     size_t database_idx = 0;
     DatabaseTablesIteratorPtr tables_it;
-    const Context context;
+    ContextPtr context;
     bool done = false;
     DatabasePtr database;
     std::string database_name;
@@ -501,7 +501,7 @@ Pipe StorageSystemTables::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo & query_info,
-    const Context & context,
+    ContextPtr context,
     QueryProcessingStage::Enum /*processed_stage*/,
     const size_t max_block_size,
     const unsigned /*num_streams*/)
diff --git a/src/Storages/System/StorageSystemTables.h b/src/Storages/System/StorageSystemTables.h
index 2e0b3386f8c..da5e236b33f 100644
--- a/src/Storages/System/StorageSystemTables.h
+++ b/src/Storages/System/StorageSystemTables.h
@@ -22,7 +22,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/System/StorageSystemTimeZones.cpp b/src/Storages/System/StorageSystemTimeZones.cpp
index e5523f54caf..dc3711812a6 100644
--- a/src/Storages/System/StorageSystemTimeZones.cpp
+++ b/src/Storages/System/StorageSystemTimeZones.cpp
@@ -15,7 +15,7 @@ NamesAndTypesList StorageSystemTimeZones::getNamesAndTypes()
     };
 }
 
-void StorageSystemTimeZones::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
+void StorageSystemTimeZones::fillData(MutableColumns & res_columns, ContextPtr, const SelectQueryInfo &) const
 {
     for (auto * it = auto_time_zones; *it; ++it)
         res_columns[0]->insert(String(*it));
diff --git a/src/Storages/System/StorageSystemTimeZones.h b/src/Storages/System/StorageSystemTimeZones.h
index b7544ecb16d..0f68b2de293 100644
--- a/src/Storages/System/StorageSystemTimeZones.h
+++ b/src/Storages/System/StorageSystemTimeZones.h
@@ -17,7 +17,7 @@ class StorageSystemTimeZones final : public ext::shared_ptr_helper<StorageSystem
     friend struct ext::shared_ptr_helper<StorageSystemTimeZones>;
 
 protected:
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
diff --git a/src/Storages/System/StorageSystemUserDirectories.cpp b/src/Storages/System/StorageSystemUserDirectories.cpp
index 519f0c0dcb0..7858af25365 100644
--- a/src/Storages/System/StorageSystemUserDirectories.cpp
+++ b/src/Storages/System/StorageSystemUserDirectories.cpp
@@ -22,9 +22,9 @@ NamesAndTypesList StorageSystemUserDirectories::getNamesAndTypes()
 }
 
 
-void StorageSystemUserDirectories::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemUserDirectories::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    const auto & access_control = context.getAccessControlManager();
+    const auto & access_control = context->getAccessControlManager();
     auto storages = access_control.getStorages();
 
     size_t column_index = 0;
diff --git a/src/Storages/System/StorageSystemUserDirectories.h b/src/Storages/System/StorageSystemUserDirectories.h
index 902c890fe29..0ddb0ad49d8 100644
--- a/src/Storages/System/StorageSystemUserDirectories.h
+++ b/src/Storages/System/StorageSystemUserDirectories.h
@@ -18,7 +18,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemUserDirectories>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemUsers.cpp b/src/Storages/System/StorageSystemUsers.cpp
index eaebf759a85..e60f1372df9 100644
--- a/src/Storages/System/StorageSystemUsers.cpp
+++ b/src/Storages/System/StorageSystemUsers.cpp
@@ -55,10 +55,10 @@ NamesAndTypesList StorageSystemUsers::getNamesAndTypes()
 }
 
 
-void StorageSystemUsers::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+void StorageSystemUsers::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const
 {
-    context.checkAccess(AccessType::SHOW_USERS);
-    const auto & access_control = context.getAccessControlManager();
+    context->checkAccess(AccessType::SHOW_USERS);
+    const auto & access_control = context->getAccessControlManager();
     std::vector<UUID> ids = access_control.findAll<User>();
 
     size_t column_index = 0;
diff --git a/src/Storages/System/StorageSystemUsers.h b/src/Storages/System/StorageSystemUsers.h
index 707ea94591d..3c463a23db9 100644
--- a/src/Storages/System/StorageSystemUsers.h
+++ b/src/Storages/System/StorageSystemUsers.h
@@ -18,7 +18,7 @@ public:
 protected:
     friend struct ext::shared_ptr_helper<StorageSystemUsers>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
 
 }
diff --git a/src/Storages/System/StorageSystemZeros.cpp b/src/Storages/System/StorageSystemZeros.cpp
index ed5ab93369a..d1456d72685 100644
--- a/src/Storages/System/StorageSystemZeros.cpp
+++ b/src/Storages/System/StorageSystemZeros.cpp
@@ -94,7 +94,7 @@ Pipe StorageSystemZeros::read(
     const Names & column_names,
     const StorageMetadataPtr & metadata_snapshot,
     SelectQueryInfo &,
-    const Context & /*context*/,
+    ContextPtr /*context*/,
     QueryProcessingStage::Enum /*processed_stage*/,
     size_t max_block_size,
     unsigned num_streams)
diff --git a/src/Storages/System/StorageSystemZeros.h b/src/Storages/System/StorageSystemZeros.h
index 04733f550c1..2ccdcf9c944 100644
--- a/src/Storages/System/StorageSystemZeros.h
+++ b/src/Storages/System/StorageSystemZeros.h
@@ -24,7 +24,7 @@ public:
         const Names & column_names,
         const StorageMetadataPtr & /*metadata_snapshot*/,
         SelectQueryInfo & query_info,
-        const Context & context,
+        ContextPtr context,
         QueryProcessingStage::Enum processed_stage,
         size_t max_block_size,
         unsigned num_streams) override;
diff --git a/src/Storages/System/StorageSystemZooKeeper.cpp b/src/Storages/System/StorageSystemZooKeeper.cpp
index 8fa5ccbd630..1a8aac3b277 100644
--- a/src/Storages/System/StorageSystemZooKeeper.cpp
+++ b/src/Storages/System/StorageSystemZooKeeper.cpp
@@ -63,7 +63,7 @@ static String pathCorrected(const String & path)
 }
 
 
-static bool extractPathImpl(const IAST & elem, Paths & res, const Context & context)
+static bool extractPathImpl(const IAST & elem, Paths & res, ContextPtr context)
 {
     const auto * function = elem.as<ASTFunction>();
     if (!function)
@@ -94,8 +94,8 @@ static bool extractPathImpl(const IAST & elem, Paths & res, const Context & cont
         {
             auto interpreter_subquery = interpretSubquery(value, context, {}, {});
             auto stream = interpreter_subquery->execute().getInputStream();
-            SizeLimits limites(context.getSettingsRef().max_rows_in_set, context.getSettingsRef().max_bytes_in_set, OverflowMode::THROW);
-            Set set(limites, true, context.getSettingsRef().transform_null_in);
+            SizeLimits limites(context->getSettingsRef().max_rows_in_set, context->getSettingsRef().max_bytes_in_set, OverflowMode::THROW);
+            Set set(limites, true, context->getSettingsRef().transform_null_in);
             set.setHeader(stream->getHeader());
 
             stream->readPrefix();
@@ -165,7 +165,7 @@ static bool extractPathImpl(const IAST & elem, Paths & res, const Context & cont
 
 /** Retrieve from the query a condition of the form `path = 'path'`, from conjunctions in the WHERE clause.
   */
-static Paths extractPath(const ASTPtr & query, const Context & context)
+static Paths extractPath(const ASTPtr & query, ContextPtr context)
 {
     const auto & select = query->as<ASTSelectQuery &>();
     if (!select.where())
@@ -176,13 +176,13 @@ static Paths extractPath(const ASTPtr & query, const Context & context)
 }
 
 
-void StorageSystemZooKeeper::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const
+void StorageSystemZooKeeper::fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const
 {
     const Paths & paths = extractPath(query_info.query, context);
     if (paths.empty())
         throw Exception("SELECT from system.zookeeper table must contain condition like path = 'path' or path IN ('path1','path2'...) or path IN (subquery) in WHERE clause.", ErrorCodes::BAD_ARGUMENTS);
 
-    zkutil::ZooKeeperPtr zookeeper = context.getZooKeeper();
+    zkutil::ZooKeeperPtr zookeeper = context->getZooKeeper();
 
     std::unordered_set<String> paths_corrected;
     for (const auto & path : paths)
diff --git a/src/Storages/System/StorageSystemZooKeeper.h b/src/Storages/System/StorageSystemZooKeeper.h
index 06611f61dae..226ca79facf 100644
--- a/src/Storages/System/StorageSystemZooKeeper.h
+++ b/src/Storages/System/StorageSystemZooKeeper.h
@@ -23,7 +23,7 @@ public:
 protected:
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
+    void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 };
 
 }
diff --git a/src/Storages/TTLDescription.cpp b/src/Storages/TTLDescription.cpp
index 41c20b2714b..95ea4f07f18 100644
--- a/src/Storages/TTLDescription.cpp
+++ b/src/Storages/TTLDescription.cpp
@@ -162,7 +162,7 @@ TTLDescription & TTLDescription::operator=(const TTLDescription & other)
 TTLDescription TTLDescription::getTTLFromAST(
     const ASTPtr & definition_ast,
     const ColumnsDescription & columns,
-    const Context & context,
+    ContextPtr context,
     const KeyDescription & primary_key)
 {
     TTLDescription result;
@@ -289,7 +289,7 @@ TTLDescription TTLDescription::getTTLFromAST(
         {
             result.recompression_codec =
                 CompressionCodecFactory::instance().validateCodecAndGetPreprocessedAST(
-                    ttl_element->recompression_codec, {}, !context.getSettingsRef().allow_suspicious_codecs);
+                    ttl_element->recompression_codec, {}, !context->getSettingsRef().allow_suspicious_codecs);
         }
     }
 
@@ -330,7 +330,7 @@ TTLTableDescription & TTLTableDescription::operator=(const TTLTableDescription &
 TTLTableDescription TTLTableDescription::getTTLForTableFromAST(
     const ASTPtr & definition_ast,
     const ColumnsDescription & columns,
-    const Context & context,
+    ContextPtr context,
     const KeyDescription & primary_key)
 {
     TTLTableDescription result;
diff --git a/src/Storages/TTLDescription.h b/src/Storages/TTLDescription.h
index a2340ad6bcd..6288098b3c5 100644
--- a/src/Storages/TTLDescription.h
+++ b/src/Storages/TTLDescription.h
@@ -80,7 +80,7 @@ struct TTLDescription
 
     /// Parse TTL structure from definition. Able to parse both column and table
     /// TTLs.
-    static TTLDescription getTTLFromAST(const ASTPtr & definition_ast, const ColumnsDescription & columns, const Context & context, const KeyDescription & primary_key);
+    static TTLDescription getTTLFromAST(const ASTPtr & definition_ast, const ColumnsDescription & columns, ContextPtr context, const KeyDescription & primary_key);
 
     TTLDescription() = default;
     TTLDescription(const TTLDescription & other);
@@ -117,7 +117,7 @@ struct TTLTableDescription
     TTLTableDescription & operator=(const TTLTableDescription & other);
 
     static TTLTableDescription getTTLForTableFromAST(
-        const ASTPtr & definition_ast, const ColumnsDescription & columns, const Context & context, const KeyDescription & primary_key);
+        const ASTPtr & definition_ast, const ColumnsDescription & columns, ContextPtr context, const KeyDescription & primary_key);
 };
 
 }
diff --git a/src/Storages/VirtualColumnUtils.cpp b/src/Storages/VirtualColumnUtils.cpp
index 0002d7c9c28..a6a68f598c7 100644
--- a/src/Storages/VirtualColumnUtils.cpp
+++ b/src/Storages/VirtualColumnUtils.cpp
@@ -122,7 +122,7 @@ void rewriteEntityInAst(ASTPtr ast, const String & column_name, const Field & va
     }
 }
 
-bool prepareFilterBlockWithQuery(const ASTPtr & query, const Context & context, Block block, ASTPtr & expression_ast)
+bool prepareFilterBlockWithQuery(const ASTPtr & query, ContextPtr context, Block block, ASTPtr & expression_ast)
 {
     bool unmodified = true;
     const auto & select = query->as<ASTSelectQuery &>();
@@ -167,7 +167,7 @@ bool prepareFilterBlockWithQuery(const ASTPtr & query, const Context & context,
     return unmodified;
 }
 
-void filterBlockWithQuery(const ASTPtr & query, Block & block, const Context & context, ASTPtr expression_ast)
+void filterBlockWithQuery(const ASTPtr & query, Block & block, ContextPtr context, ASTPtr expression_ast)
 {
     if (!expression_ast)
         prepareFilterBlockWithQuery(query, context, block, expression_ast);
@@ -191,10 +191,15 @@ void filterBlockWithQuery(const ASTPtr & query, Block & block, const Context & c
     ConstantFilterDescription constant_filter(*filter_column);
 
     if (constant_filter.always_true)
+    {
         return;
+    }
 
     if (constant_filter.always_false)
+    {
         block = block.cloneEmpty();
+        return;
+    }
 
     FilterDescription filter(*filter_column);
 
diff --git a/src/Storages/VirtualColumnUtils.h b/src/Storages/VirtualColumnUtils.h
index 78e3d62472e..15783f6e79f 100644
--- a/src/Storages/VirtualColumnUtils.h
+++ b/src/Storages/VirtualColumnUtils.h
@@ -1,16 +1,16 @@
 #pragma once
 
-#include <unordered_set>
-
 #include <Core/Block.h>
+#include <Interpreters/Context_fwd.h>
 #include <Parsers/IAST_fwd.h>
 #include <Storages/SelectQueryInfo.h>
 
+#include <unordered_set>
+
 
 namespace DB
 {
 
-class Context;
 class NamesAndTypesList;
 
 
@@ -27,12 +27,12 @@ void rewriteEntityInAst(ASTPtr ast, const String & column_name, const Field & va
 
 /// Prepare `expression_ast` to filter block. Returns true if `expression_ast` is not trimmed, that is,
 /// `block` provides all needed columns for `expression_ast`, else return false.
-bool prepareFilterBlockWithQuery(const ASTPtr & query, const Context & context, Block block, ASTPtr & expression_ast);
+bool prepareFilterBlockWithQuery(const ASTPtr & query, ContextPtr context, Block block, ASTPtr & expression_ast);
 
 /// Leave in the block only the rows that fit under the WHERE clause and the PREWHERE clause of the query.
 /// Only elements of the outer conjunction are considered, depending only on the columns present in the block.
 /// If `expression_ast` is passed, use it to filter block.
-void filterBlockWithQuery(const ASTPtr & query, Block & block, const Context & context, ASTPtr expression_ast = {});
+void filterBlockWithQuery(const ASTPtr & query, Block & block, ContextPtr context, ASTPtr expression_ast = {});
 
 /// Extract from the input stream a set of `name` column values
 template <typename T>
diff --git a/src/Storages/getStructureOfRemoteTable.cpp b/src/Storages/getStructureOfRemoteTable.cpp
index de5f3924ca9..fb828b8f744 100644
--- a/src/Storages/getStructureOfRemoteTable.cpp
+++ b/src/Storages/getStructureOfRemoteTable.cpp
@@ -29,7 +29,7 @@ ColumnsDescription getStructureOfRemoteTableInShard(
     const Cluster & cluster,
     const Cluster::ShardInfo & shard_info,
     const StorageID & table_id,
-    const Context & context,
+    ContextPtr context,
     const ASTPtr & table_func_ptr)
 {
     String query;
@@ -59,7 +59,7 @@ ColumnsDescription getStructureOfRemoteTableInShard(
 
     ColumnsDescription res;
 
-    auto new_context = ClusterProxy::updateSettingsForCluster(cluster, context, context.getSettingsRef());
+    auto new_context = ClusterProxy::updateSettingsForCluster(cluster, context, context->getSettingsRef());
 
     /// Expect only needed columns from the result of DESC TABLE. NOTE 'comment' column is ignored for compatibility reasons.
     Block sample_block
@@ -71,7 +71,7 @@ ColumnsDescription getStructureOfRemoteTableInShard(
     };
 
     /// Execute remote query without restrictions (because it's not real user query, but part of implementation)
-    auto input = std::make_shared<RemoteBlockInputStream>(shard_info.pool, query, sample_block, *new_context);
+    auto input = std::make_shared<RemoteBlockInputStream>(shard_info.pool, query, sample_block, new_context);
     input->setPoolMode(PoolMode::GET_ONE);
     if (!table_func_ptr)
         input->setMainTable(table_id);
@@ -104,7 +104,7 @@ ColumnsDescription getStructureOfRemoteTableInShard(
                 column.default_desc.kind = columnDefaultKindFromString(kind_name);
                 String expr_str = (*default_expr)[i].get<const String &>();
                 column.default_desc.expression = parseQuery(
-                    expr_parser, expr_str.data(), expr_str.data() + expr_str.size(), "default expression", 0, context.getSettingsRef().max_parser_depth);
+                    expr_parser, expr_str.data(), expr_str.data() + expr_str.size(), "default expression", 0, context->getSettingsRef().max_parser_depth);
             }
 
             res.add(column);
@@ -117,7 +117,7 @@ ColumnsDescription getStructureOfRemoteTableInShard(
 ColumnsDescription getStructureOfRemoteTable(
     const Cluster & cluster,
     const StorageID & table_id,
-    const Context & context,
+    ContextPtr context,
     const ASTPtr & table_func_ptr)
 {
     const auto & shards_info = cluster.getShardsInfo();
diff --git a/src/Storages/getStructureOfRemoteTable.h b/src/Storages/getStructureOfRemoteTable.h
index af418144cb0..3f77236c756 100644
--- a/src/Storages/getStructureOfRemoteTable.h
+++ b/src/Storages/getStructureOfRemoteTable.h
@@ -16,7 +16,7 @@ struct StorageID;
 ColumnsDescription getStructureOfRemoteTable(
     const Cluster & cluster,
     const StorageID & table_id,
-    const Context & context,
+    ContextPtr context,
     const ASTPtr & table_func_ptr = nullptr);
 
 }
diff --git a/src/Storages/registerStorages.cpp b/src/Storages/registerStorages.cpp
index 0022ee6bd4f..7100afa6909 100644
--- a/src/Storages/registerStorages.cpp
+++ b/src/Storages/registerStorages.cpp
@@ -62,6 +62,10 @@ void registerStorageEmbeddedRocksDB(StorageFactory & factory);
 void registerStoragePostgreSQL(StorageFactory & factory);
 #endif
 
+#if USE_MYSQL || USE_LIBPQXX
+void registerStorageExternalDistributed(StorageFactory & factory);
+#endif
+
 void registerStorages()
 {
     auto & factory = StorageFactory::instance();
@@ -118,6 +122,10 @@ void registerStorages()
     #if USE_LIBPQXX
     registerStoragePostgreSQL(factory);
     #endif
+
+    #if USE_MYSQL || USE_LIBPQXX
+    registerStorageExternalDistributed(factory);
+    #endif
 }
 
 }
diff --git a/src/Storages/tests/gtest_background_executor.cpp b/src/Storages/tests/gtest_background_executor.cpp
index 0ddf2d9ea2a..283cdf3fbf8 100644
--- a/src/Storages/tests/gtest_background_executor.cpp
+++ b/src/Storages/tests/gtest_background_executor.cpp
@@ -17,9 +17,9 @@ static std::atomic<Int64> counter{0};
 class TestJobExecutor : public IBackgroundJobExecutor
 {
 public:
-    explicit TestJobExecutor(Context & context)
+    explicit TestJobExecutor(ContextPtr local_context)
         :IBackgroundJobExecutor(
-            context,
+            local_context,
             BackgroundTaskSchedulingSettings{},
             {PoolConfig{PoolType::MERGE_MUTATE, 4, CurrentMetrics::BackgroundPoolTask}})
         {}
@@ -43,7 +43,7 @@ TEST(BackgroundExecutor, TestMetric)
     const auto & context_holder = getContext();
     std::vector<TestExecutorPtr> executors;
     for (size_t i = 0; i < 100; ++i)
-        executors.emplace_back(std::make_unique<TestJobExecutor>(const_cast<Context &>(context_holder.context)));
+        executors.emplace_back(std::make_unique<TestJobExecutor>(context_holder.context));
 
     for (size_t i = 0; i < 100; ++i)
         executors[i]->start();
diff --git a/src/Storages/tests/gtest_storage_log.cpp b/src/Storages/tests/gtest_storage_log.cpp
index cbb894c7420..de2139a4a5a 100644
--- a/src/Storages/tests/gtest_storage_log.cpp
+++ b/src/Storages/tests/gtest_storage_log.cpp
@@ -70,7 +70,7 @@ using DiskImplementations = testing::Types<DB::DiskMemory, DB::DiskLocal>;
 TYPED_TEST_SUITE(StorageLogTest, DiskImplementations);
 
 // Returns data written to table in Values format.
-std::string writeData(int rows, DB::StoragePtr & table, const DB::Context & context)
+std::string writeData(int rows, DB::StoragePtr & table, const DB::ContextPtr context)
 {
     using namespace DB;
     auto metadata_snapshot = table->getInMemoryMetadataPtr();
@@ -108,7 +108,7 @@ std::string writeData(int rows, DB::StoragePtr & table, const DB::Context & cont
 }
 
 // Returns all table data in Values format.
-std::string readData(DB::StoragePtr & table, const DB::Context & context)
+std::string readData(DB::StoragePtr & table, const DB::ContextPtr context)
 {
     using namespace DB;
     auto metadata_snapshot = table->getInMemoryMetadataPtr();
diff --git a/src/Storages/tests/gtest_transform_query_for_external_database.cpp b/src/Storages/tests/gtest_transform_query_for_external_database.cpp
index d40c62fef60..d774fd144cf 100644
--- a/src/Storages/tests/gtest_transform_query_for_external_database.cpp
+++ b/src/Storages/tests/gtest_transform_query_for_external_database.cpp
@@ -22,7 +22,7 @@ struct State
 {
     State(const State&) = delete;
 
-    Context context;
+    ContextPtr context;
 
     static const State & instance()
     {
@@ -74,7 +74,7 @@ private:
     };
 
     explicit State()
-        : context(getContext().context)
+        : context(Context::createCopy(getContext().context))
     {
         tryRegisterFunctions();
         DatabasePtr database = std::make_shared<DatabaseMemory>("test", context);
@@ -88,7 +88,7 @@ private:
                 StorageMemory::create(StorageID(db_name, table_name), ColumnsDescription{getColumns()}, ConstraintsDescription{}));
         }
         DatabaseCatalog::instance().attachDatabase(database->getDatabaseName(), database);
-        context.setCurrentDatabase("test");
+        context->setCurrentDatabase("test");
     }
 };
 
diff --git a/src/Storages/transformQueryForExternalDatabase.cpp b/src/Storages/transformQueryForExternalDatabase.cpp
index 59d357f72e6..b3fe788d874 100644
--- a/src/Storages/transformQueryForExternalDatabase.cpp
+++ b/src/Storages/transformQueryForExternalDatabase.cpp
@@ -88,7 +88,7 @@ public:
     }
 };
 
-void replaceConstantExpressions(ASTPtr & node, const Context & context, const NamesAndTypesList & all_columns)
+void replaceConstantExpressions(ASTPtr & node, ContextPtr context, const NamesAndTypesList & all_columns)
 {
     auto syntax_result = TreeRewriter(context).analyze(node, all_columns);
     Block block_with_constants = KeyCondition::getBlockWithConstants(node, syntax_result, context);
@@ -239,7 +239,7 @@ String transformQueryForExternalDatabase(
     IdentifierQuotingStyle identifier_quoting_style,
     const String & database,
     const String & table,
-    const Context & context)
+    ContextPtr context)
 {
     auto clone_query = query_info.query->clone();
     const Names used_columns = query_info.syntax_analyzer_result->requiredSourceColumns();
diff --git a/src/Storages/transformQueryForExternalDatabase.h b/src/Storages/transformQueryForExternalDatabase.h
index c760c628970..215afab8b30 100644
--- a/src/Storages/transformQueryForExternalDatabase.h
+++ b/src/Storages/transformQueryForExternalDatabase.h
@@ -4,13 +4,13 @@
 #include <Core/NamesAndTypes.h>
 #include <Parsers/IdentifierQuotingStyle.h>
 #include <Storages/SelectQueryInfo.h>
+#include <Interpreters/Context_fwd.h>
 
 
 namespace DB
 {
 
 class IAST;
-class Context;
 
 /** For given ClickHouse query,
   * creates another query in a form of
@@ -29,6 +29,6 @@ String transformQueryForExternalDatabase(
     IdentifierQuotingStyle identifier_quoting_style,
     const String & database,
     const String & table,
-    const Context & context);
+    ContextPtr context);
 
 }
diff --git a/src/Storages/ya.make b/src/Storages/ya.make
index e3e1807c566..ba294b05857 100644
--- a/src/Storages/ya.make
+++ b/src/Storages/ya.make
@@ -57,6 +57,7 @@ SRCS(
     MergeTree/MergeTreeDataPartWriterWide.cpp
     MergeTree/MergeTreeDataSelectExecutor.cpp
     MergeTree/MergeTreeDataWriter.cpp
+    MergeTree/MergeTreeDeduplicationLog.cpp
     MergeTree/MergeTreeIndexAggregatorBloomFilter.cpp
     MergeTree/MergeTreeIndexBloomFilter.cpp
     MergeTree/MergeTreeIndexConditionBloomFilter.cpp
@@ -117,6 +118,7 @@ SRCS(
     StorageBuffer.cpp
     StorageDictionary.cpp
     StorageDistributed.cpp
+    StorageExternalDistributed.cpp
     StorageFactory.cpp
     StorageFile.cpp
     StorageGenerateRandom.cpp
diff --git a/src/TableFunctions/ITableFunction.cpp b/src/TableFunctions/ITableFunction.cpp
index b637838c6da..218d86fe4a2 100644
--- a/src/TableFunctions/ITableFunction.cpp
+++ b/src/TableFunctions/ITableFunction.cpp
@@ -14,11 +14,11 @@ namespace ProfileEvents
 namespace DB
 {
 
-StoragePtr ITableFunction::execute(const ASTPtr & ast_function, const Context & context, const std::string & table_name,
+StoragePtr ITableFunction::execute(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name,
                                    ColumnsDescription cached_columns) const
 {
     ProfileEvents::increment(ProfileEvents::TableFunctionExecute);
-    context.checkAccess(AccessType::CREATE_TEMPORARY_TABLE | StorageFactory::instance().getSourceAccessType(getStorageTypeName()));
+    context->checkAccess(AccessType::CREATE_TEMPORARY_TABLE | StorageFactory::instance().getSourceAccessType(getStorageTypeName()));
 
     if (cached_columns.empty())
         return executeImpl(ast_function, context, table_name, std::move(cached_columns));
@@ -26,12 +26,12 @@ StoragePtr ITableFunction::execute(const ASTPtr & ast_function, const Context &
     /// We have table structure, so it's CREATE AS table_function().
     /// We should use global context here because there will be no query context on server startup
     /// and because storage lifetime is bigger than query context lifetime.
-    const Context & global_context = context.getGlobalContext();
+    auto global_context = context->getGlobalContext();
     if (hasStaticStructure() && cached_columns == getActualTableStructure(context))
         return executeImpl(ast_function, global_context, table_name, std::move(cached_columns));
 
     auto this_table_function = shared_from_this();
-    auto get_storage = [=, &global_context]() -> StoragePtr
+    auto get_storage = [=]() -> StoragePtr
     {
         return this_table_function->executeImpl(ast_function, global_context, table_name, cached_columns);
     };
diff --git a/src/TableFunctions/ITableFunction.h b/src/TableFunctions/ITableFunction.h
index eb5e1618b3c..56147ffd598 100644
--- a/src/TableFunctions/ITableFunction.h
+++ b/src/TableFunctions/ITableFunction.h
@@ -47,18 +47,20 @@ public:
     /// Returns false if storage returned by table function supports type conversion (e.g. StorageDistributed)
     virtual bool needStructureConversion() const { return true; }
 
-    virtual void parseArguments(const ASTPtr & /*ast_function*/, const Context & /*context*/) {}
+    virtual void parseArguments(const ASTPtr & /*ast_function*/, ContextPtr /*context*/) {}
 
     /// Returns actual table structure probably requested from remote server, may fail
-    virtual ColumnsDescription getActualTableStructure(const Context & /*context*/) const = 0;
+    virtual ColumnsDescription getActualTableStructure(ContextPtr /*context*/) const = 0;
 
     /// Create storage according to the query.
-    StoragePtr execute(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns_ = {}) const;
+    StoragePtr
+    execute(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns_ = {}) const;
 
     virtual ~ITableFunction() = default;
 
 private:
-    virtual StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const = 0;
+    virtual StoragePtr executeImpl(
+        const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const = 0;
     virtual const char * getStorageTypeName() const = 0;
 };
 
diff --git a/src/TableFunctions/ITableFunctionFileLike.cpp b/src/TableFunctions/ITableFunctionFileLike.cpp
index 1349c166474..44a917a0f00 100644
--- a/src/TableFunctions/ITableFunctionFileLike.cpp
+++ b/src/TableFunctions/ITableFunctionFileLike.cpp
@@ -26,7 +26,7 @@ namespace ErrorCodes
     extern const int BAD_ARGUMENTS;
 }
 
-void ITableFunctionFileLike::parseArguments(const ASTPtr & ast_function, const Context & context)
+void ITableFunctionFileLike::parseArguments(const ASTPtr & ast_function, ContextPtr context)
 {
     /// Parse args
     ASTs & args_func = ast_function->children;
@@ -64,20 +64,20 @@ void ITableFunctionFileLike::parseArguments(const ASTPtr & ast_function, const C
         compression_method = args[3]->as<ASTLiteral &>().value.safeGet<String>();
 }
 
-StoragePtr ITableFunctionFileLike::executeImpl(const ASTPtr & /*ast_function*/, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr ITableFunctionFileLike::executeImpl(const ASTPtr & /*ast_function*/, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     auto columns = getActualTableStructure(context);
-    StoragePtr storage = getStorage(filename, format, columns, const_cast<Context &>(context), table_name, compression_method);
+    StoragePtr storage = getStorage(filename, format, columns, context, table_name, compression_method);
     storage->startup();
     return storage;
 }
 
-ColumnsDescription ITableFunctionFileLike::getActualTableStructure(const Context & context) const
+ColumnsDescription ITableFunctionFileLike::getActualTableStructure(ContextPtr context) const
 {
     if (structure.empty())
     {
         assert(getName() == "file" && format == "Distributed");
-        Strings paths = StorageFile::getPathsList(filename, context.getUserFilesPath(), context);
+        Strings paths = StorageFile::getPathsList(filename, context->getUserFilesPath(), context);
         if (paths.empty())
             throw Exception("Cannot get table structure from file, because no files match specified name", ErrorCodes::INCORRECT_FILE_NAME);
         auto read_stream = StorageDistributedDirectoryMonitor::createStreamFromFile(paths[0]);
diff --git a/src/TableFunctions/ITableFunctionFileLike.h b/src/TableFunctions/ITableFunctionFileLike.h
index f1c648ac0aa..7c96ce610b3 100644
--- a/src/TableFunctions/ITableFunctionFileLike.h
+++ b/src/TableFunctions/ITableFunctionFileLike.h
@@ -13,15 +13,15 @@ class Context;
 class ITableFunctionFileLike : public ITableFunction
 {
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const override;
 
     virtual StoragePtr getStorage(
-        const String & source, const String & format, const ColumnsDescription & columns, Context & global_context,
+        const String & source, const String & format, const ColumnsDescription & columns, ContextPtr global_context,
         const std::string & table_name, const String & compression_method) const = 0;
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
 
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
     bool hasStaticStructure() const override { return true; }
 
diff --git a/src/TableFunctions/ITableFunctionXDBC.cpp b/src/TableFunctions/ITableFunctionXDBC.cpp
index 21c78d199db..51431a1e3a6 100644
--- a/src/TableFunctions/ITableFunctionXDBC.cpp
+++ b/src/TableFunctions/ITableFunctionXDBC.cpp
@@ -28,7 +28,7 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
-void ITableFunctionXDBC::parseArguments(const ASTPtr & ast_function, const Context & context)
+void ITableFunctionXDBC::parseArguments(const ASTPtr & ast_function, ContextPtr context)
 {
     const auto & args_func = ast_function->as<ASTFunction &>();
 
@@ -57,17 +57,17 @@ void ITableFunctionXDBC::parseArguments(const ASTPtr & ast_function, const Conte
     }
 }
 
-void ITableFunctionXDBC::startBridgeIfNot(const Context & context) const
+void ITableFunctionXDBC::startBridgeIfNot(ContextPtr context) const
 {
     if (!helper)
     {
         /// Have to const_cast, because bridges store their commands inside context
-        helper = createBridgeHelper(const_cast<Context &>(context), context.getSettingsRef().http_receive_timeout.value, connection_string);
+        helper = createBridgeHelper(context, context->getSettingsRef().http_receive_timeout.value, connection_string);
         helper->startBridgeSync();
     }
 }
 
-ColumnsDescription ITableFunctionXDBC::getActualTableStructure(const Context & context) const
+ColumnsDescription ITableFunctionXDBC::getActualTableStructure(ContextPtr context) const
 {
     startBridgeIfNot(context);
 
@@ -78,7 +78,7 @@ ColumnsDescription ITableFunctionXDBC::getActualTableStructure(const Context & c
         columns_info_uri.addQueryParameter("schema", schema_name);
     columns_info_uri.addQueryParameter("table", remote_table_name);
 
-    const auto use_nulls = context.getSettingsRef().external_table_functions_use_nulls;
+    const auto use_nulls = context->getSettingsRef().external_table_functions_use_nulls;
     columns_info_uri.addQueryParameter("external_table_functions_use_nulls",
                                        Poco::NumberFormatter::format(use_nulls));
 
@@ -91,7 +91,7 @@ ColumnsDescription ITableFunctionXDBC::getActualTableStructure(const Context & c
     return ColumnsDescription{columns};
 }
 
-StoragePtr ITableFunctionXDBC::executeImpl(const ASTPtr & /*ast_function*/, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr ITableFunctionXDBC::executeImpl(const ASTPtr & /*ast_function*/, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     startBridgeIfNot(context);
     auto columns = getActualTableStructure(context);
diff --git a/src/TableFunctions/ITableFunctionXDBC.h b/src/TableFunctions/ITableFunctionXDBC.h
index f3ff64c2f2d..a58d574513f 100644
--- a/src/TableFunctions/ITableFunctionXDBC.h
+++ b/src/TableFunctions/ITableFunctionXDBC.h
@@ -3,7 +3,7 @@
 #include <Storages/StorageXDBC.h>
 #include <TableFunctions/ITableFunction.h>
 #include <Poco/Util/AbstractConfiguration.h>
-#include <Common/XDBCBridgeHelper.h>
+#include <Bridge/XDBCBridgeHelper.h>
 
 #if !defined(ARCADIA_BUILD)
 #    include <Common/config.h>
@@ -18,18 +18,18 @@ namespace DB
 class ITableFunctionXDBC : public ITableFunction
 {
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const override;
 
     /* A factory method to create bridge helper, that will assist in remote interaction */
-    virtual BridgeHelperPtr createBridgeHelper(Context & context,
+    virtual BridgeHelperPtr createBridgeHelper(ContextPtr context,
         const Poco::Timespan & http_timeout_,
         const std::string & connection_string_) const = 0;
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
 
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
-    void startBridgeIfNot(const Context & context) const;
+    void startBridgeIfNot(ContextPtr context) const;
 
     String connection_string;
     String schema_name;
@@ -47,7 +47,7 @@ public:
     }
 
 private:
-    BridgeHelperPtr createBridgeHelper(Context & context,
+    BridgeHelperPtr createBridgeHelper(ContextPtr context,
         const Poco::Timespan & http_timeout_,
         const std::string & connection_string_) const override
     {
@@ -67,7 +67,7 @@ public:
     }
 
 private:
-    BridgeHelperPtr createBridgeHelper(Context & context,
+    BridgeHelperPtr createBridgeHelper(ContextPtr context,
         const Poco::Timespan & http_timeout_,
         const std::string & connection_string_) const override
     {
diff --git a/src/TableFunctions/TableFunctionDictionary.cpp b/src/TableFunctions/TableFunctionDictionary.cpp
index 722ffccc07d..46d3183bba9 100644
--- a/src/TableFunctions/TableFunctionDictionary.cpp
+++ b/src/TableFunctions/TableFunctionDictionary.cpp
@@ -19,7 +19,7 @@ namespace ErrorCodes
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
 }
 
-void TableFunctionDictionary::parseArguments(const ASTPtr & ast_function, const Context & context)
+void TableFunctionDictionary::parseArguments(const ASTPtr & ast_function, ContextPtr context)
 {
     // Parse args
     ASTs & args_func = ast_function->children;
@@ -38,9 +38,9 @@ void TableFunctionDictionary::parseArguments(const ASTPtr & ast_function, const
     dictionary_name = args[0]->as<ASTLiteral &>().value.safeGet<String>();
 }
 
-ColumnsDescription TableFunctionDictionary::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionDictionary::getActualTableStructure(ContextPtr context) const
 {
-    const ExternalDictionariesLoader & external_loader = context.getExternalDictionariesLoader();
+    const ExternalDictionariesLoader & external_loader = context->getExternalDictionariesLoader();
     auto dictionary_structure = external_loader.getDictionaryStructure(dictionary_name, context);
     auto result = ColumnsDescription(StorageDictionary::getNamesAndTypes(dictionary_structure));
 
@@ -48,7 +48,7 @@ ColumnsDescription TableFunctionDictionary::getActualTableStructure(const Contex
 }
 
 StoragePtr TableFunctionDictionary::executeImpl(
-    const ASTPtr &, const Context & context, const std::string & table_name, ColumnsDescription) const
+    const ASTPtr &, ContextPtr context, const std::string & table_name, ColumnsDescription) const
 {
     StorageID dict_id(getDatabaseName(), table_name);
     auto dictionary_table_structure = getActualTableStructure(context);
diff --git a/src/TableFunctions/TableFunctionDictionary.h b/src/TableFunctions/TableFunctionDictionary.h
index 8c518eb7929..aed435bebfd 100644
--- a/src/TableFunctions/TableFunctionDictionary.h
+++ b/src/TableFunctions/TableFunctionDictionary.h
@@ -20,11 +20,11 @@ public:
         return name;
     }
 
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
 
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription) const override;
 
     const char * getStorageTypeName() const override { return "Dictionary"; }
 
diff --git a/src/TableFunctions/TableFunctionFactory.cpp b/src/TableFunctions/TableFunctionFactory.cpp
index e8f844e8074..15e61354f6d 100644
--- a/src/TableFunctions/TableFunctionFactory.cpp
+++ b/src/TableFunctions/TableFunctionFactory.cpp
@@ -31,7 +31,7 @@ void TableFunctionFactory::registerFunction(const std::string & name, Value crea
 
 TableFunctionPtr TableFunctionFactory::get(
     const ASTPtr & ast_function,
-    const Context & context) const
+    ContextPtr context) const
 {
     const auto * table_function = ast_function->as<ASTFunction>();
     auto res = tryGet(table_function->name, context);
@@ -50,7 +50,7 @@ TableFunctionPtr TableFunctionFactory::get(
 
 TableFunctionPtr TableFunctionFactory::tryGet(
         const std::string & name_param,
-        const Context &) const
+        ContextPtr) const
 {
     String name = getAliasToOrName(name_param);
     TableFunctionPtr res;
@@ -70,7 +70,7 @@ TableFunctionPtr TableFunctionFactory::tryGet(
 
     if (CurrentThread::isInitialized())
     {
-        const auto * query_context = CurrentThread::get().getQueryContext();
+        auto query_context = CurrentThread::get().getQueryContext();
         if (query_context && query_context->getSettingsRef().log_queries)
             query_context->addQueryFactoriesInfo(Context::QueryLogFactories::TableFunction, name);
     }
diff --git a/src/TableFunctions/TableFunctionFactory.h b/src/TableFunctions/TableFunctionFactory.h
index 820b5eb1c7b..59b4ffb9fd5 100644
--- a/src/TableFunctions/TableFunctionFactory.h
+++ b/src/TableFunctions/TableFunctionFactory.h
@@ -41,10 +41,10 @@ public:
     }
 
     /// Throws an exception if not found.
-    TableFunctionPtr get(const ASTPtr & ast_function, const Context & context) const;
+    TableFunctionPtr get(const ASTPtr & ast_function, ContextPtr context) const;
 
     /// Returns nullptr if not found.
-    TableFunctionPtr tryGet(const std::string & name, const Context & context) const;
+    TableFunctionPtr tryGet(const std::string & name, ContextPtr context) const;
 
     bool isTableFunctionName(const std::string & name) const;
 
diff --git a/src/TableFunctions/TableFunctionFile.cpp b/src/TableFunctions/TableFunctionFile.cpp
index 13ac6dc2145..6ecb5606d56 100644
--- a/src/TableFunctions/TableFunctionFile.cpp
+++ b/src/TableFunctions/TableFunctionFile.cpp
@@ -12,20 +12,23 @@ namespace DB
 {
 StoragePtr TableFunctionFile::getStorage(const String & source,
     const String & format_, const ColumnsDescription & columns,
-    Context & global_context, const std::string & table_name,
+    ContextPtr global_context, const std::string & table_name,
     const std::string & compression_method_) const
 {
     // For `file` table function, we are going to use format settings from the
     // query context.
-    StorageFile::CommonArguments args{StorageID(getDatabaseName(), table_name),
+    StorageFile::CommonArguments args
+    {
+        WithContext(global_context),
+        StorageID(getDatabaseName(), table_name),
         format_,
         std::nullopt /*format settings*/,
         compression_method_,
         columns,
         ConstraintsDescription{},
-        global_context};
+    };
 
-    return StorageFile::create(source, global_context.getUserFilesPath(), args);
+    return StorageFile::create(source, global_context->getUserFilesPath(), args);
 }
 
 void registerTableFunctionFile(TableFunctionFactory & factory)
diff --git a/src/TableFunctions/TableFunctionFile.h b/src/TableFunctions/TableFunctionFile.h
index 02704e4bf7f..460656a7218 100644
--- a/src/TableFunctions/TableFunctionFile.h
+++ b/src/TableFunctions/TableFunctionFile.h
@@ -5,7 +5,6 @@
 
 namespace DB
 {
-class Context;
 
 /* file(path, format, structure) - creates a temporary storage from file
  *
@@ -23,7 +22,7 @@ public:
 
 private:
     StoragePtr getStorage(
-        const String & source, const String & format_, const ColumnsDescription & columns, Context & global_context,
+        const String & source, const String & format_, const ColumnsDescription & columns, ContextPtr global_context,
         const std::string & table_name, const std::string & compression_method_) const override;
     const char * getStorageTypeName() const override { return "File"; }
 };}
diff --git a/src/TableFunctions/TableFunctionGenerateRandom.cpp b/src/TableFunctions/TableFunctionGenerateRandom.cpp
index 15c2c2bfa1f..b19be7bd7a3 100644
--- a/src/TableFunctions/TableFunctionGenerateRandom.cpp
+++ b/src/TableFunctions/TableFunctionGenerateRandom.cpp
@@ -26,7 +26,7 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
-void TableFunctionGenerateRandom::parseArguments(const ASTPtr & ast_function, const Context & /*context*/)
+void TableFunctionGenerateRandom::parseArguments(const ASTPtr & ast_function, ContextPtr /*context*/)
 {
     ASTs & args_func = ast_function->children;
 
@@ -74,12 +74,12 @@ void TableFunctionGenerateRandom::parseArguments(const ASTPtr & ast_function, co
         max_array_length = args[3]->as<const ASTLiteral &>().value.safeGet<UInt64>();
 }
 
-ColumnsDescription TableFunctionGenerateRandom::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionGenerateRandom::getActualTableStructure(ContextPtr context) const
 {
     return parseColumnsListFromString(structure, context);
 }
 
-StoragePtr TableFunctionGenerateRandom::executeImpl(const ASTPtr & /*ast_function*/, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr TableFunctionGenerateRandom::executeImpl(const ASTPtr & /*ast_function*/, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     auto columns = getActualTableStructure(context);
     auto res = StorageGenerateRandom::create(StorageID(getDatabaseName(), table_name), columns, max_array_length, max_string_length, random_seed);
diff --git a/src/TableFunctions/TableFunctionGenerateRandom.h b/src/TableFunctions/TableFunctionGenerateRandom.h
index 1d8839ba6d4..bcad11156be 100644
--- a/src/TableFunctions/TableFunctionGenerateRandom.h
+++ b/src/TableFunctions/TableFunctionGenerateRandom.h
@@ -15,11 +15,11 @@ public:
     std::string getName() const override { return name; }
     bool hasStaticStructure() const override { return true; }
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const override;
     const char * getStorageTypeName() const override { return "GenerateRandom"; }
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
     String structure;
     UInt64 max_string_length = 10;
diff --git a/src/TableFunctions/TableFunctionHDFS.cpp b/src/TableFunctions/TableFunctionHDFS.cpp
index 700cb93ca06..714c6ea1f59 100644
--- a/src/TableFunctions/TableFunctionHDFS.cpp
+++ b/src/TableFunctions/TableFunctionHDFS.cpp
@@ -10,7 +10,7 @@
 namespace DB
 {
 StoragePtr TableFunctionHDFS::getStorage(
-    const String & source, const String & format_, const ColumnsDescription & columns, Context & global_context,
+    const String & source, const String & format_, const ColumnsDescription & columns, ContextPtr global_context,
     const std::string & table_name, const String & compression_method_) const
 {
     return StorageHDFS::create(
diff --git a/src/TableFunctions/TableFunctionHDFS.h b/src/TableFunctions/TableFunctionHDFS.h
index 47e040f7593..d9ee9b47868 100644
--- a/src/TableFunctions/TableFunctionHDFS.h
+++ b/src/TableFunctions/TableFunctionHDFS.h
@@ -26,7 +26,7 @@ public:
 
 private:
     StoragePtr getStorage(
-        const String & source, const String & format_, const ColumnsDescription & columns, Context & global_context,
+        const String & source, const String & format_, const ColumnsDescription & columns, ContextPtr global_context,
         const std::string & table_name, const String & compression_method_) const override;
     const char * getStorageTypeName() const override { return "HDFS"; }
 };
diff --git a/src/TableFunctions/TableFunctionInput.cpp b/src/TableFunctions/TableFunctionInput.cpp
index 41c41835434..677a6ff3ce4 100644
--- a/src/TableFunctions/TableFunctionInput.cpp
+++ b/src/TableFunctions/TableFunctionInput.cpp
@@ -22,7 +22,7 @@ namespace ErrorCodes
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
 }
 
-void TableFunctionInput::parseArguments(const ASTPtr & ast_function, const Context & context)
+void TableFunctionInput::parseArguments(const ASTPtr & ast_function, ContextPtr context)
 {
     const auto * function = ast_function->as<ASTFunction>();
 
@@ -38,12 +38,12 @@ void TableFunctionInput::parseArguments(const ASTPtr & ast_function, const Conte
     structure = evaluateConstantExpressionOrIdentifierAsLiteral(args[0], context)->as<ASTLiteral &>().value.safeGet<String>();
 }
 
-ColumnsDescription TableFunctionInput::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionInput::getActualTableStructure(ContextPtr context) const
 {
     return parseColumnsListFromString(structure, context);
 }
 
-StoragePtr TableFunctionInput::executeImpl(const ASTPtr & /*ast_function*/, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr TableFunctionInput::executeImpl(const ASTPtr & /*ast_function*/, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     auto storage = StorageInput::create(StorageID(getDatabaseName(), table_name), getActualTableStructure(context));
     storage->startup();
diff --git a/src/TableFunctions/TableFunctionInput.h b/src/TableFunctions/TableFunctionInput.h
index 5809d48a77c..5953693e711 100644
--- a/src/TableFunctions/TableFunctionInput.h
+++ b/src/TableFunctions/TableFunctionInput.h
@@ -18,11 +18,11 @@ public:
     bool hasStaticStructure() const override { return true; }
 
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const override;
     const char * getStorageTypeName() const override { return "Input"; }
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
     String structure;
 };
diff --git a/src/TableFunctions/TableFunctionMerge.cpp b/src/TableFunctions/TableFunctionMerge.cpp
index c5fb9a7686d..6d10b0d04b6 100644
--- a/src/TableFunctions/TableFunctionMerge.cpp
+++ b/src/TableFunctions/TableFunctionMerge.cpp
@@ -33,7 +33,7 @@ namespace
 }
 
 
-void TableFunctionMerge::parseArguments(const ASTPtr & ast_function, const Context & context)
+void TableFunctionMerge::parseArguments(const ASTPtr & ast_function, ContextPtr context)
 {
     ASTs & args_func = ast_function->children;
 
@@ -57,7 +57,7 @@ void TableFunctionMerge::parseArguments(const ASTPtr & ast_function, const Conte
 }
 
 
-const Strings & TableFunctionMerge::getSourceTables(const Context & context) const
+const Strings & TableFunctionMerge::getSourceTables(ContextPtr context) const
 {
     if (source_tables)
         return *source_tables;
@@ -67,7 +67,7 @@ const Strings & TableFunctionMerge::getSourceTables(const Context & context) con
     OptimizedRegularExpression re(source_table_regexp);
     auto table_name_match = [&](const String & table_name_) { return re.match(table_name_); };
 
-    auto access = context.getAccess();
+    auto access = context->getAccess();
     bool granted_show_on_all_tables = access->isGranted(AccessType::SHOW_TABLES, source_database);
     bool granted_select_on_all_tables = access->isGranted(AccessType::SELECT, source_database);
 
@@ -91,7 +91,7 @@ const Strings & TableFunctionMerge::getSourceTables(const Context & context) con
 }
 
 
-ColumnsDescription TableFunctionMerge::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionMerge::getActualTableStructure(ContextPtr context) const
 {
     for (const auto & table_name : getSourceTables(context))
     {
@@ -104,7 +104,7 @@ ColumnsDescription TableFunctionMerge::getActualTableStructure(const Context & c
 }
 
 
-StoragePtr TableFunctionMerge::executeImpl(const ASTPtr & /*ast_function*/, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr TableFunctionMerge::executeImpl(const ASTPtr & /*ast_function*/, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     auto res = StorageMerge::create(
         StorageID(getDatabaseName(), table_name),
diff --git a/src/TableFunctions/TableFunctionMerge.h b/src/TableFunctions/TableFunctionMerge.h
index 8f9f4522d17..04027b9d76a 100644
--- a/src/TableFunctions/TableFunctionMerge.h
+++ b/src/TableFunctions/TableFunctionMerge.h
@@ -16,12 +16,12 @@ public:
     static constexpr auto name = "merge";
     std::string getName() const override { return name; }
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const override;
     const char * getStorageTypeName() const override { return "Merge"; }
 
-    const Strings & getSourceTables(const Context & context) const;
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    const Strings & getSourceTables(ContextPtr context) const;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
     String source_database;
     String source_table_regexp;
diff --git a/src/TableFunctions/TableFunctionMySQL.cpp b/src/TableFunctions/TableFunctionMySQL.cpp
index d6a62dc68b4..c7dda873a00 100644
--- a/src/TableFunctions/TableFunctionMySQL.cpp
+++ b/src/TableFunctions/TableFunctionMySQL.cpp
@@ -1,29 +1,30 @@
 #if !defined(ARCADIA_BUILD)
-#    include "config_core.h"
+#include "config_core.h"
 #endif
 
 #if USE_MYSQL
-#    include <Core/Defines.h>
-#    include <Databases/MySQL/FetchTablesColumnsList.h>
-#    include <DataTypes/DataTypeString.h>
-#    include <DataTypes/DataTypesNumber.h>
-#    include <DataTypes/convertMySQLDataType.h>
-#    include <Formats/MySQLBlockInputStream.h>
-#    include <IO/Operators.h>
-#    include <Interpreters/Context.h>
-#    include <Interpreters/evaluateConstantExpression.h>
-#    include <Parsers/ASTFunction.h>
-#    include <Parsers/ASTLiteral.h>
-#    include <Storages/StorageMySQL.h>
-#    include <TableFunctions/ITableFunction.h>
-#    include <TableFunctions/TableFunctionFactory.h>
-#    include <TableFunctions/TableFunctionMySQL.h>
-#    include <Common/Exception.h>
-#    include <Common/parseAddress.h>
-#    include <Common/quoteString.h>
-#    include "registerTableFunctions.h"
+#include <Core/Defines.h>
+#include <Databases/MySQL/FetchTablesColumnsList.h>
+#include <DataTypes/DataTypeString.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/convertMySQLDataType.h>
+#include <Formats/MySQLBlockInputStream.h>
+#include <IO/Operators.h>
+#include <Interpreters/Context.h>
+#include <Interpreters/evaluateConstantExpression.h>
+#include <Parsers/ASTFunction.h>
+#include <Parsers/ASTLiteral.h>
+#include <Storages/StorageMySQL.h>
+#include <TableFunctions/ITableFunction.h>
+#include <TableFunctions/TableFunctionFactory.h>
+#include <TableFunctions/TableFunctionMySQL.h>
+#include <Common/Exception.h>
+#include <Common/parseAddress.h>
+#include <Common/quoteString.h>
+#include "registerTableFunctions.h"
 
-#    include <Databases/MySQL/DatabaseConnectionMySQL.h> // for fetchTablesColumnsList
+#include <Databases/MySQL/DatabaseConnectionMySQL.h> // for fetchTablesColumnsList
+#include <Common/parseRemoteDescription.h>
 
 
 namespace DB
@@ -37,7 +38,7 @@ namespace ErrorCodes
     extern const int UNKNOWN_TABLE;
 }
 
-void TableFunctionMySQL::parseArguments(const ASTPtr & ast_function, const Context & context)
+void TableFunctionMySQL::parseArguments(const ASTPtr & ast_function, ContextPtr context)
 {
     const auto & args_func = ast_function->as<ASTFunction &>();
 
@@ -59,6 +60,11 @@ void TableFunctionMySQL::parseArguments(const ASTPtr & ast_function, const Conte
     user_name = args[3]->as<ASTLiteral &>().value.safeGet<String>();
     password = args[4]->as<ASTLiteral &>().value.safeGet<String>();
 
+    /// Split into replicas if needed. 3306 is the default MySQL port number
+    size_t max_addresses = context->getSettingsRef().glob_expansion_max_elements;
+    auto addresses = parseRemoteDescriptionForExternalDatabase(host_port, max_addresses, 3306);
+    pool.emplace(remote_database_name, addresses, user_name, password);
+
     if (args.size() >= 6)
         replace_query = args[5]->as<ASTLiteral &>().value.safeGet<UInt64>() > 0;
     if (args.size() == 7)
@@ -68,18 +74,11 @@ void TableFunctionMySQL::parseArguments(const ASTPtr & ast_function, const Conte
         throw Exception(
             "Only one of 'replace_query' and 'on_duplicate_clause' can be specified, or none of them",
             ErrorCodes::BAD_ARGUMENTS);
-
-    /// 3306 is the default MySQL port number
-    parsed_host_port = parseAddress(host_port, 3306);
 }
 
-ColumnsDescription TableFunctionMySQL::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionMySQL::getActualTableStructure(ContextPtr context) const
 {
-    assert(!parsed_host_port.first.empty());
-    if (!pool)
-        pool.emplace(remote_database_name, parsed_host_port.first, user_name, password, parsed_host_port.second);
-
-    const auto & settings = context.getSettingsRef();
+    const auto & settings = context->getSettingsRef();
     const auto tables_and_columns = fetchTablesColumnsList(*pool, remote_database_name, {remote_table_name}, settings.external_table_functions_use_nulls, settings.mysql_datatypes_support_level);
 
     const auto columns = tables_and_columns.find(remote_table_name);
@@ -89,12 +88,8 @@ ColumnsDescription TableFunctionMySQL::getActualTableStructure(const Context & c
     return ColumnsDescription{columns->second};
 }
 
-StoragePtr TableFunctionMySQL::executeImpl(const ASTPtr & /*ast_function*/, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr TableFunctionMySQL::executeImpl(const ASTPtr & /*ast_function*/, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
-    assert(!parsed_host_port.first.empty());
-    if (!pool)
-        pool.emplace(remote_database_name, parsed_host_port.first, user_name, password, parsed_host_port.second);
-
     auto columns = getActualTableStructure(context);
 
     auto res = StorageMySQL::create(
diff --git a/src/TableFunctions/TableFunctionMySQL.h b/src/TableFunctions/TableFunctionMySQL.h
index 1fe5a4aa4ac..64c7d56cf2a 100644
--- a/src/TableFunctions/TableFunctionMySQL.h
+++ b/src/TableFunctions/TableFunctionMySQL.h
@@ -24,13 +24,12 @@ public:
         return name;
     }
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const override;
     const char * getStorageTypeName() const override { return "MySQL"; }
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
-    std::pair<std::string, UInt16> parsed_host_port;
     String remote_database_name;
     String remote_table_name;
     String user_name;
@@ -38,7 +37,7 @@ private:
     bool replace_query = false;
     String on_duplicate_clause;
 
-    mutable std::optional<mysqlxx::Pool> pool;
+    mutable std::optional<mysqlxx::PoolWithFailover> pool;
 };
 
 }
diff --git a/src/TableFunctions/TableFunctionNull.cpp b/src/TableFunctions/TableFunctionNull.cpp
index 6abe0319394..334d7c3dcbd 100644
--- a/src/TableFunctions/TableFunctionNull.cpp
+++ b/src/TableFunctions/TableFunctionNull.cpp
@@ -17,7 +17,7 @@ namespace ErrorCodes
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
 }
 
-void TableFunctionNull::parseArguments(const ASTPtr & ast_function, const Context & context)
+void TableFunctionNull::parseArguments(const ASTPtr & ast_function, ContextPtr context)
 {
     const auto * function = ast_function->as<ASTFunction>();
     if (!function || !function->arguments)
@@ -30,12 +30,12 @@ void TableFunctionNull::parseArguments(const ASTPtr & ast_function, const Contex
     structure = evaluateConstantExpressionOrIdentifierAsLiteral(arguments[0], context)->as<ASTLiteral>()->value.safeGet<String>();
 }
 
-ColumnsDescription TableFunctionNull::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionNull::getActualTableStructure(ContextPtr context) const
 {
     return parseColumnsListFromString(structure, context);
 }
 
-StoragePtr TableFunctionNull::executeImpl(const ASTPtr & /*ast_function*/, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr TableFunctionNull::executeImpl(const ASTPtr & /*ast_function*/, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     auto columns = getActualTableStructure(context);
     auto res = StorageNull::create(StorageID(getDatabaseName(), table_name), columns, ConstraintsDescription());
diff --git a/src/TableFunctions/TableFunctionNull.h b/src/TableFunctions/TableFunctionNull.h
index 4d4cecb0292..6734fb8efb6 100644
--- a/src/TableFunctions/TableFunctionNull.h
+++ b/src/TableFunctions/TableFunctionNull.h
@@ -17,11 +17,11 @@ public:
     static constexpr auto name = "null";
     std::string getName() const override { return name; }
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const String & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const String & table_name, ColumnsDescription cached_columns) const override;
     const char * getStorageTypeName() const override { return "Null"; }
 
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
 
     String structure;
 };
diff --git a/src/TableFunctions/TableFunctionNumbers.cpp b/src/TableFunctions/TableFunctionNumbers.cpp
index 594075b1c82..01ffd2b2e3d 100644
--- a/src/TableFunctions/TableFunctionNumbers.cpp
+++ b/src/TableFunctions/TableFunctionNumbers.cpp
@@ -23,14 +23,14 @@ namespace ErrorCodes
 
 
 template <bool multithreaded>
-ColumnsDescription TableFunctionNumbers<multithreaded>::getActualTableStructure(const Context & /*context*/) const
+ColumnsDescription TableFunctionNumbers<multithreaded>::getActualTableStructure(ContextPtr /*context*/) const
 {
     /// NOTE: https://bugs.llvm.org/show_bug.cgi?id=47418
     return ColumnsDescription{{{"number", std::make_shared<DataTypeUInt64>()}}};
 }
 
 template <bool multithreaded>
-StoragePtr TableFunctionNumbers<multithreaded>::executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr TableFunctionNumbers<multithreaded>::executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     if (const auto * function = ast_function->as<ASTFunction>())
     {
@@ -56,7 +56,7 @@ void registerTableFunctionNumbers(TableFunctionFactory & factory)
 }
 
 template <bool multithreaded>
-UInt64 TableFunctionNumbers<multithreaded>::evaluateArgument(const Context & context, ASTPtr & argument) const
+UInt64 TableFunctionNumbers<multithreaded>::evaluateArgument(ContextPtr context, ASTPtr & argument) const
 {
     const auto & [field, type] = evaluateConstantExpression(argument, context);
 
diff --git a/src/TableFunctions/TableFunctionNumbers.h b/src/TableFunctions/TableFunctionNumbers.h
index c27bb7319ba..6cee752390e 100644
--- a/src/TableFunctions/TableFunctionNumbers.h
+++ b/src/TableFunctions/TableFunctionNumbers.h
@@ -19,12 +19,12 @@ public:
     std::string getName() const override { return name; }
     bool hasStaticStructure() const override { return true; }
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const override;
     const char * getStorageTypeName() const override { return "SystemNumbers"; }
 
-    UInt64 evaluateArgument(const Context & context, ASTPtr & argument) const;
+    UInt64 evaluateArgument(ContextPtr context, ASTPtr & argument) const;
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
 };
 
 
diff --git a/src/TableFunctions/TableFunctionPostgreSQL.cpp b/src/TableFunctions/TableFunctionPostgreSQL.cpp
index f20aae11648..6e7ba1825fc 100644
--- a/src/TableFunctions/TableFunctionPostgreSQL.cpp
+++ b/src/TableFunctions/TableFunctionPostgreSQL.cpp
@@ -12,6 +12,7 @@
 #include <Databases/PostgreSQL/fetchPostgreSQLTableStructure.h>
 #include <Storages/PostgreSQL/PostgreSQLConnection.h>
 #include <Common/quoteString.h>
+#include <Common/parseRemoteDescription.h>
 
 
 namespace DB
@@ -25,21 +26,21 @@ namespace ErrorCodes
 
 
 StoragePtr TableFunctionPostgreSQL::executeImpl(const ASTPtr & /*ast_function*/,
-        const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+        ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     auto columns = getActualTableStructure(context);
     auto result = std::make_shared<StoragePostgreSQL>(
-            StorageID(getDatabaseName(), table_name), remote_table_name,
-            connection_pool, columns, ConstraintsDescription{}, context, remote_table_schema);
+            StorageID(getDatabaseName(), table_name), *connection_pool, remote_table_name,
+            columns, ConstraintsDescription{}, context, remote_table_schema);
 
     result->startup();
     return result;
 }
 
 
-ColumnsDescription TableFunctionPostgreSQL::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionPostgreSQL::getActualTableStructure(ContextPtr context) const
 {
-    const bool use_nulls = context.getSettingsRef().external_table_functions_use_nulls;
+    const bool use_nulls = context->getSettingsRef().external_table_functions_use_nulls;
     auto columns = fetchPostgreSQLTableStructure(
             connection_pool->get(),
             remote_table_schema.empty() ? doubleQuoteString(remote_table_name)
@@ -50,7 +51,7 @@ ColumnsDescription TableFunctionPostgreSQL::getActualTableStructure(const Contex
 }
 
 
-void TableFunctionPostgreSQL::parseArguments(const ASTPtr & ast_function, const Context & context)
+void TableFunctionPostgreSQL::parseArguments(const ASTPtr & ast_function, ContextPtr context)
 {
     const auto & func_args = ast_function->as<ASTFunction &>();
 
@@ -67,16 +68,19 @@ void TableFunctionPostgreSQL::parseArguments(const ASTPtr & ast_function, const
     for (auto & arg : args)
         arg = evaluateConstantExpressionOrIdentifierAsLiteral(arg, context);
 
-    auto parsed_host_port = parseAddress(args[0]->as<ASTLiteral &>().value.safeGet<String>(), 5432);
+    /// Split into replicas if needed. 5432 is a default postgresql port.
+    const auto & host_port = args[0]->as<ASTLiteral &>().value.safeGet<String>();
+    size_t max_addresses = context->getSettingsRef().glob_expansion_max_elements;
+    auto addresses = parseRemoteDescriptionForExternalDatabase(host_port, max_addresses, 5432);
+
     remote_table_name = args[2]->as<ASTLiteral &>().value.safeGet<String>();
 
     if (args.size() == 6)
         remote_table_schema = args[5]->as<ASTLiteral &>().value.safeGet<String>();
 
-    connection_pool = std::make_shared<PostgreSQLConnectionPool>(
+    connection_pool = std::make_shared<postgres::PoolWithFailover>(
         args[1]->as<ASTLiteral &>().value.safeGet<String>(),
-        parsed_host_port.first,
-        parsed_host_port.second,
+        addresses,
         args[3]->as<ASTLiteral &>().value.safeGet<String>(),
         args[4]->as<ASTLiteral &>().value.safeGet<String>());
 }
diff --git a/src/TableFunctions/TableFunctionPostgreSQL.h b/src/TableFunctions/TableFunctionPostgreSQL.h
index 601b2a090b2..44f804fbb30 100644
--- a/src/TableFunctions/TableFunctionPostgreSQL.h
+++ b/src/TableFunctions/TableFunctionPostgreSQL.h
@@ -5,14 +5,12 @@
 
 #if USE_LIBPQXX
 #include <TableFunctions/ITableFunction.h>
+#include <Storages/PostgreSQL/PostgreSQLPoolWithFailover.h>
 
 
 namespace DB
 {
 
-class PostgreSQLConnectionPool;
-using PostgreSQLConnectionPoolPtr = std::shared_ptr<PostgreSQLConnectionPool>;
-
 class TableFunctionPostgreSQL : public ITableFunction
 {
 public:
@@ -21,17 +19,17 @@ public:
 
 private:
     StoragePtr executeImpl(
-            const ASTPtr & ast_function, const Context & context,
+            const ASTPtr & ast_function, ContextPtr context,
             const std::string & table_name, ColumnsDescription cached_columns) const override;
 
     const char * getStorageTypeName() const override { return "PostgreSQL"; }
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
     String connection_str;
     String remote_table_name, remote_table_schema;
-    PostgreSQLConnectionPoolPtr connection_pool;
+    postgres::PoolWithFailoverPtr connection_pool;
 };
 
 }
diff --git a/src/TableFunctions/TableFunctionRemote.cpp b/src/TableFunctions/TableFunctionRemote.cpp
index 0e7623c0ac3..ab2458b64f4 100644
--- a/src/TableFunctions/TableFunctionRemote.cpp
+++ b/src/TableFunctions/TableFunctionRemote.cpp
@@ -28,7 +28,7 @@ namespace ErrorCodes
 }
 
 
-void TableFunctionRemote::parseArguments(const ASTPtr & ast_function, const Context & context)
+void TableFunctionRemote::parseArguments(const ASTPtr & ast_function, ContextPtr context)
 {
     ASTs & args_func = ast_function->children;
 
@@ -162,14 +162,14 @@ void TableFunctionRemote::parseArguments(const ASTPtr & ast_function, const Cont
     {
         /// Use an existing cluster from the main config
         if (name != "clusterAllReplicas")
-            cluster = context.getCluster(cluster_name);
+            cluster = context->getCluster(cluster_name);
         else
-            cluster = context.getCluster(cluster_name)->getClusterWithReplicasAsShards(context.getSettings());
+            cluster = context->getCluster(cluster_name)->getClusterWithReplicasAsShards(context->getSettings());
     }
     else
     {
         /// Create new cluster from the scratch
-        size_t max_addresses = context.getSettingsRef().table_function_remote_max_addresses;
+        size_t max_addresses = context->getSettingsRef().table_function_remote_max_addresses;
         std::vector<String> shards = parseRemoteDescription(cluster_description, 0, cluster_description.size(), ',', max_addresses);
 
         std::vector<std::vector<String>> names;
@@ -180,7 +180,7 @@ void TableFunctionRemote::parseArguments(const ASTPtr & ast_function, const Cont
         if (names.empty())
             throw Exception("Shard list is empty after parsing first argument", ErrorCodes::BAD_ARGUMENTS);
 
-        auto maybe_secure_port = context.getTCPPortSecure();
+        auto maybe_secure_port = context->getTCPPortSecure();
 
         /// Check host and port on affiliation allowed hosts.
         for (const auto & hosts : names)
@@ -189,20 +189,20 @@ void TableFunctionRemote::parseArguments(const ASTPtr & ast_function, const Cont
             {
                 size_t colon = host.find(':');
                 if (colon == String::npos)
-                    context.getRemoteHostFilter().checkHostAndPort(
+                    context->getRemoteHostFilter().checkHostAndPort(
                         host,
-                        toString((secure ? (maybe_secure_port ? *maybe_secure_port : DBMS_DEFAULT_SECURE_PORT) : context.getTCPPort())));
+                        toString((secure ? (maybe_secure_port ? *maybe_secure_port : DBMS_DEFAULT_SECURE_PORT) : context->getTCPPort())));
                 else
-                    context.getRemoteHostFilter().checkHostAndPort(host.substr(0, colon), host.substr(colon + 1));
+                    context->getRemoteHostFilter().checkHostAndPort(host.substr(0, colon), host.substr(colon + 1));
             }
         }
 
         cluster = std::make_shared<Cluster>(
-            context.getSettings(),
+            context->getSettings(),
             names,
             username,
             password,
-            (secure ? (maybe_secure_port ? *maybe_secure_port : DBMS_DEFAULT_SECURE_PORT) : context.getTCPPort()),
+            (secure ? (maybe_secure_port ? *maybe_secure_port : DBMS_DEFAULT_SECURE_PORT) : context->getTCPPort()),
             false,
             secure);
     }
@@ -214,7 +214,7 @@ void TableFunctionRemote::parseArguments(const ASTPtr & ast_function, const Cont
     remote_table_id.table_name = remote_table;
 }
 
-StoragePtr TableFunctionRemote::executeImpl(const ASTPtr & /*ast_function*/, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const
+StoragePtr TableFunctionRemote::executeImpl(const ASTPtr & /*ast_function*/, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const
 {
     /// StorageDistributed supports mismatching structure of remote table, so we can use outdated structure for CREATE ... AS remote(...)
     /// without additional conversion in StorageTableFunctionProxy
@@ -255,7 +255,7 @@ StoragePtr TableFunctionRemote::executeImpl(const ASTPtr & /*ast_function*/, con
     return res;
 }
 
-ColumnsDescription TableFunctionRemote::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionRemote::getActualTableStructure(ContextPtr context) const
 {
     assert(cluster);
     return getStructureOfRemoteTable(*cluster, remote_table_id, context, remote_table_function_ptr);
diff --git a/src/TableFunctions/TableFunctionRemote.h b/src/TableFunctions/TableFunctionRemote.h
index d485440d604..8fc918dfc20 100644
--- a/src/TableFunctions/TableFunctionRemote.h
+++ b/src/TableFunctions/TableFunctionRemote.h
@@ -22,15 +22,15 @@ public:
 
     std::string getName() const override { return name; }
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
 
     bool needStructureConversion() const override { return false; }
 
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const override;
     const char * getStorageTypeName() const override { return "Distributed"; }
 
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
     std::string name;
     bool is_cluster_function;
diff --git a/src/TableFunctions/TableFunctionS3.cpp b/src/TableFunctions/TableFunctionS3.cpp
index 6dc9230ca46..1a67bae48b0 100644
--- a/src/TableFunctions/TableFunctionS3.cpp
+++ b/src/TableFunctions/TableFunctionS3.cpp
@@ -21,7 +21,7 @@ namespace ErrorCodes
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
 }
 
-void TableFunctionS3::parseArguments(const ASTPtr & ast_function, const Context & context)
+void TableFunctionS3::parseArguments(const ASTPtr & ast_function, ContextPtr context)
 {
     /// Parse args
     ASTs & args_func = ast_function->children;
@@ -57,18 +57,18 @@ void TableFunctionS3::parseArguments(const ASTPtr & ast_function, const Context
         compression_method = args.back()->as<ASTLiteral &>().value.safeGet<String>();
 }
 
-ColumnsDescription TableFunctionS3::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionS3::getActualTableStructure(ContextPtr context) const
 {
     return parseColumnsListFromString(structure, context);
 }
 
-StoragePtr TableFunctionS3::executeImpl(const ASTPtr & /*ast_function*/, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr TableFunctionS3::executeImpl(const ASTPtr & /*ast_function*/, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     Poco::URI uri (filename);
     S3::URI s3_uri (uri);
-    UInt64 min_upload_part_size = context.getSettingsRef().s3_min_upload_part_size;
-    UInt64 max_single_part_upload_size = context.getSettingsRef().s3_max_single_part_upload_size;
-    UInt64 max_connections = context.getSettingsRef().s3_max_connections;
+    UInt64 min_upload_part_size = context->getSettingsRef().s3_min_upload_part_size;
+    UInt64 max_single_part_upload_size = context->getSettingsRef().s3_max_single_part_upload_size;
+    UInt64 max_connections = context->getSettingsRef().s3_max_connections;
 
     StoragePtr storage = StorageS3::create(
             s3_uri,
@@ -81,7 +81,7 @@ StoragePtr TableFunctionS3::executeImpl(const ASTPtr & /*ast_function*/, const C
             max_connections,
             getActualTableStructure(context),
             ConstraintsDescription{},
-            const_cast<Context &>(context),
+            context,
             compression_method);
 
     storage->startup();
diff --git a/src/TableFunctions/TableFunctionS3.h b/src/TableFunctions/TableFunctionS3.h
index 722fb9eb23c..1835fa3daa9 100644
--- a/src/TableFunctions/TableFunctionS3.h
+++ b/src/TableFunctions/TableFunctionS3.h
@@ -27,14 +27,14 @@ public:
 protected:
     StoragePtr executeImpl(
         const ASTPtr & ast_function,
-        const Context & context,
+        ContextPtr context,
         const std::string & table_name,
         ColumnsDescription cached_columns) const override;
 
     const char * getStorageTypeName() const override { return "S3"; }
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
     String filename;
     String format;
diff --git a/src/TableFunctions/TableFunctionURL.cpp b/src/TableFunctions/TableFunctionURL.cpp
index 1c0109e892b..a77b9140508 100644
--- a/src/TableFunctions/TableFunctionURL.cpp
+++ b/src/TableFunctions/TableFunctionURL.cpp
@@ -12,7 +12,7 @@
 namespace DB
 {
 StoragePtr TableFunctionURL::getStorage(
-    const String & source, const String & format_, const ColumnsDescription & columns, Context & global_context,
+    const String & source, const String & format_, const ColumnsDescription & columns, ContextPtr global_context,
     const std::string & table_name, const String & compression_method_) const
 {
     Poco::URI uri(source);
diff --git a/src/TableFunctions/TableFunctionURL.h b/src/TableFunctions/TableFunctionURL.h
index 5eb027e2b8a..fde361e8bbb 100644
--- a/src/TableFunctions/TableFunctionURL.h
+++ b/src/TableFunctions/TableFunctionURL.h
@@ -21,7 +21,7 @@ public:
 
 private:
     StoragePtr getStorage(
-        const String & source, const String & format_, const ColumnsDescription & columns, Context & global_context,
+        const String & source, const String & format_, const ColumnsDescription & columns, ContextPtr global_context,
         const std::string & table_name, const String & compression_method_) const override;
     const char * getStorageTypeName() const override { return "URL"; }
 };
diff --git a/src/TableFunctions/TableFunctionValues.cpp b/src/TableFunctions/TableFunctionValues.cpp
index 4127a30892f..c66ebe7322e 100644
--- a/src/TableFunctions/TableFunctionValues.cpp
+++ b/src/TableFunctions/TableFunctionValues.cpp
@@ -30,7 +30,7 @@ namespace ErrorCodes
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
 }
 
-static void parseAndInsertValues(MutableColumns & res_columns, const ASTs & args, const Block & sample_block, const Context & context)
+static void parseAndInsertValues(MutableColumns & res_columns, const ASTs & args, const Block & sample_block, ContextPtr context)
 {
     if (res_columns.size() == 1) /// Parsing arguments as Fields
     {
@@ -68,7 +68,7 @@ static void parseAndInsertValues(MutableColumns & res_columns, const ASTs & args
     }
 }
 
-void TableFunctionValues::parseArguments(const ASTPtr & ast_function, const Context & /*context*/)
+void TableFunctionValues::parseArguments(const ASTPtr & ast_function, ContextPtr /*context*/)
 {
     ASTs & args_func = ast_function->children;
 
@@ -93,12 +93,12 @@ void TableFunctionValues::parseArguments(const ASTPtr & ast_function, const Cont
     structure = args[0]->as<ASTLiteral &>().value.safeGet<String>();
 }
 
-ColumnsDescription TableFunctionValues::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionValues::getActualTableStructure(ContextPtr context) const
 {
     return parseColumnsListFromString(structure, context);
 }
 
-StoragePtr TableFunctionValues::executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr TableFunctionValues::executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     auto columns = getActualTableStructure(context);
 
diff --git a/src/TableFunctions/TableFunctionValues.h b/src/TableFunctions/TableFunctionValues.h
index 549fa2de507..058f5f1d2ed 100644
--- a/src/TableFunctions/TableFunctionValues.h
+++ b/src/TableFunctions/TableFunctionValues.h
@@ -14,11 +14,11 @@ public:
     std::string getName() const override { return name; }
     bool hasStaticStructure() const override { return true; }
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const override;
     const char * getStorageTypeName() const override { return "Values"; }
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
     String structure;
 };
diff --git a/src/TableFunctions/TableFunctionView.cpp b/src/TableFunctions/TableFunctionView.cpp
index 62a833dabc4..3f51e0bbc95 100644
--- a/src/TableFunctions/TableFunctionView.cpp
+++ b/src/TableFunctions/TableFunctionView.cpp
@@ -15,7 +15,7 @@ namespace ErrorCodes
     extern const int BAD_ARGUMENTS;
 }
 
-void TableFunctionView::parseArguments(const ASTPtr & ast_function, const Context & /*context*/)
+void TableFunctionView::parseArguments(const ASTPtr & ast_function, ContextPtr /*context*/)
 {
     const auto * function = ast_function->as<ASTFunction>();
     if (function)
@@ -29,7 +29,7 @@ void TableFunctionView::parseArguments(const ASTPtr & ast_function, const Contex
     throw Exception("Table function '" + getName() + "' requires a query argument.", ErrorCodes::BAD_ARGUMENTS);
 }
 
-ColumnsDescription TableFunctionView::getActualTableStructure(const Context & context) const
+ColumnsDescription TableFunctionView::getActualTableStructure(ContextPtr context) const
 {
     assert(create.select);
     assert(create.children.size() == 1);
@@ -39,7 +39,7 @@ ColumnsDescription TableFunctionView::getActualTableStructure(const Context & co
 }
 
 StoragePtr TableFunctionView::executeImpl(
-    const ASTPtr & /*ast_function*/, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+    const ASTPtr & /*ast_function*/, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     auto columns = getActualTableStructure(context);
     auto res = StorageView::create(StorageID(getDatabaseName(), table_name), create, columns);
diff --git a/src/TableFunctions/TableFunctionView.h b/src/TableFunctions/TableFunctionView.h
index 0ed66ff712c..9ef634746eb 100644
--- a/src/TableFunctions/TableFunctionView.h
+++ b/src/TableFunctions/TableFunctionView.h
@@ -17,11 +17,11 @@ public:
     static constexpr auto name = "view";
     std::string getName() const override { return name; }
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const String & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const String & table_name, ColumnsDescription cached_columns) const override;
     const char * getStorageTypeName() const override { return "View"; }
 
-    void parseArguments(const ASTPtr & ast_function, const Context & context) override;
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
+    void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
 
     ASTCreateQuery create;
 };
diff --git a/src/TableFunctions/TableFunctionZeros.cpp b/src/TableFunctions/TableFunctionZeros.cpp
index 9b0c6c6e78b..9fd14eec4af 100644
--- a/src/TableFunctions/TableFunctionZeros.cpp
+++ b/src/TableFunctions/TableFunctionZeros.cpp
@@ -20,14 +20,14 @@ extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
 
 
 template <bool multithreaded>
-ColumnsDescription TableFunctionZeros<multithreaded>::getActualTableStructure(const Context & /*context*/) const
+ColumnsDescription TableFunctionZeros<multithreaded>::getActualTableStructure(ContextPtr /*context*/) const
 {
     /// NOTE: https://bugs.llvm.org/show_bug.cgi?id=47418
     return ColumnsDescription{{{"zero", std::make_shared<DataTypeUInt8>()}}};
 }
 
 template <bool multithreaded>
-StoragePtr TableFunctionZeros<multithreaded>::executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
+StoragePtr TableFunctionZeros<multithreaded>::executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription /*cached_columns*/) const
 {
     if (const auto * function = ast_function->as<ASTFunction>())
     {
@@ -53,7 +53,7 @@ void registerTableFunctionZeros(TableFunctionFactory & factory)
 }
 
 template <bool multithreaded>
-UInt64 TableFunctionZeros<multithreaded>::evaluateArgument(const Context & context, ASTPtr & argument) const
+UInt64 TableFunctionZeros<multithreaded>::evaluateArgument(ContextPtr context, ASTPtr & argument) const
 {
     return evaluateConstantExpressionOrIdentifierAsLiteral(argument, context)->as<ASTLiteral &>().value.safeGet<UInt64>();
 }
diff --git a/src/TableFunctions/TableFunctionZeros.h b/src/TableFunctions/TableFunctionZeros.h
index 48a2d8019f6..0407eff2f78 100644
--- a/src/TableFunctions/TableFunctionZeros.h
+++ b/src/TableFunctions/TableFunctionZeros.h
@@ -19,12 +19,12 @@ public:
     std::string getName() const override { return name; }
     bool hasStaticStructure() const override { return true; }
 private:
-    StoragePtr executeImpl(const ASTPtr & ast_function, const Context & context, const std::string & table_name, ColumnsDescription cached_columns) const override;
+    StoragePtr executeImpl(const ASTPtr & ast_function, ContextPtr context, const std::string & table_name, ColumnsDescription cached_columns) const override;
     const char * getStorageTypeName() const override { return "SystemZeros"; }
 
-    UInt64 evaluateArgument(const Context & context, ASTPtr & argument) const;
+    UInt64 evaluateArgument(ContextPtr context, ASTPtr & argument) const;
 
-    ColumnsDescription getActualTableStructure(const Context & context) const override;
+    ColumnsDescription getActualTableStructure(ContextPtr context) const override;
 };
 
 
diff --git a/src/TableFunctions/parseColumnsListForTableFunction.cpp b/src/TableFunctions/parseColumnsListForTableFunction.cpp
index 5221d96e086..659aa779ede 100644
--- a/src/TableFunctions/parseColumnsListForTableFunction.cpp
+++ b/src/TableFunctions/parseColumnsListForTableFunction.cpp
@@ -14,10 +14,10 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
-ColumnsDescription parseColumnsListFromString(const std::string & structure, const Context & context)
+ColumnsDescription parseColumnsListFromString(const std::string & structure, ContextPtr context)
 {
     ParserColumnDeclarationList parser;
-    const Settings & settings = context.getSettingsRef();
+    const Settings & settings = context->getSettingsRef();
 
     ASTPtr columns_list_raw = parseQuery(parser, structure, "columns declaration list", settings.max_query_size, settings.max_parser_depth);
 
diff --git a/src/TableFunctions/parseColumnsListForTableFunction.h b/src/TableFunctions/parseColumnsListForTableFunction.h
index d077d308e37..e0130a2618d 100644
--- a/src/TableFunctions/parseColumnsListForTableFunction.h
+++ b/src/TableFunctions/parseColumnsListForTableFunction.h
@@ -10,6 +10,6 @@ namespace DB
 class Context;
 
 /// Parses a common argument for table functions such as table structure given in string
-ColumnsDescription parseColumnsListFromString(const std::string & structure, const Context & context);
+ColumnsDescription parseColumnsListFromString(const std::string & structure, ContextPtr context);
 
 }
diff --git a/src/ya.make b/src/ya.make
index 5361c8a5695..6537f67d66f 100644
--- a/src/ya.make
+++ b/src/ya.make
@@ -5,6 +5,7 @@ LIBRARY()
 PEERDIR(
     clickhouse/src/Access
     clickhouse/src/AggregateFunctions
+    clickhouse/src/Bridge
     clickhouse/src/Client
     clickhouse/src/Columns
     clickhouse/src/Common
diff --git a/tests/clickhouse-test b/tests/clickhouse-test
index a44f7972397..112f30852ee 100755
--- a/tests/clickhouse-test
+++ b/tests/clickhouse-test
@@ -116,6 +116,8 @@ def get_db_engine(args, database_name):
 def run_single_test(args, ext, server_logs_level, client_options, case_file, stdout_file, stderr_file, suite_tmp_dir):
     # print(client_options)
 
+    client = f"{args.client} --log_comment='{case_file}'"
+
     start_time = datetime.now()
     if args.database:
         database = args.database
@@ -130,7 +132,7 @@ def run_single_test(args, ext, server_logs_level, client_options, case_file, std
             return ''.join(random.choice(alphabet) for _ in range(length))
         database = 'test_{suffix}'.format(suffix=random_str())
 
-        clickhouse_proc_create = Popen(shlex.split(args.client), stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines=True)
+        clickhouse_proc_create = Popen(shlex.split(client), stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines=True)
         try:
             clickhouse_proc_create.communicate(("CREATE DATABASE " + database + get_db_engine(args, database)), timeout=args.timeout)
         except TimeoutExpired:
@@ -149,7 +151,7 @@ def run_single_test(args, ext, server_logs_level, client_options, case_file, std
     os.environ["CLICKHOUSE_LOG_COMMENT"] = case_file
 
     params = {
-        'client': args.client + ' --database=' + database,
+        'client': client + ' --database=' + database,
         'logs_level': server_logs_level,
         'options': client_options,
         'test': case_file,
@@ -160,7 +162,7 @@ def run_single_test(args, ext, server_logs_level, client_options, case_file, std
     pattern = '{test} > {stdout} 2> {stderr}'
 
     if ext == '.sql':
-        pattern = "{client} --send_logs_level={logs_level} --testmode --multiquery {options} --log_comment='{test}' < " + pattern
+        pattern = "{client} --send_logs_level={logs_level} --testmode --multiquery {options} < " + pattern
 
     command = pattern.format(**params)
 
@@ -177,7 +179,7 @@ def run_single_test(args, ext, server_logs_level, client_options, case_file, std
         need_drop_database = not maybe_passed
 
     if need_drop_database:
-        clickhouse_proc_create = Popen(shlex.split(args.client), stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines=True)
+        clickhouse_proc_create = Popen(shlex.split(client), stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines=True)
         seconds_left = max(args.timeout - (datetime.now() - start_time).total_seconds(), 20)
         try:
             drop_database_query = "DROP DATABASE " + database
@@ -406,7 +408,7 @@ def run_tests_array(all_tests_with_params):
                             status += stderr
                     else:
                         counter = 1
-                        while proc.returncode != 0 and need_retry(stderr):
+                        while need_retry(stderr):
                             proc, stdout, stderr, total_time = run_single_test(args, ext, server_logs_level, client_options, case_file, stdout_file, stderr_file, suite_tmp_dir)
                             sleep(2**counter)
                             counter += 1
diff --git a/tests/config/config.d/database_replicated.xml b/tests/config/config.d/database_replicated.xml
index c2e62f9645a..1e6871a525d 100644
--- a/tests/config/config.d/database_replicated.xml
+++ b/tests/config/config.d/database_replicated.xml
@@ -19,8 +19,8 @@
         <server_id>1</server_id>
 
         <coordination_settings>
-            <operation_timeout_ms>5000</operation_timeout_ms>
-            <session_timeout_ms>10000</session_timeout_ms>
+            <operation_timeout_ms>10000</operation_timeout_ms>
+            <session_timeout_ms>30000</session_timeout_ms>
             <heart_beat_interval_ms>1000</heart_beat_interval_ms>
             <election_timeout_lower_bound_ms>2000</election_timeout_lower_bound_ms>
             <election_timeout_upper_bound_ms>4000</election_timeout_upper_bound_ms>
diff --git a/tests/config/install.sh b/tests/config/install.sh
index 9c4f8caca07..7e01860e241 100755
--- a/tests/config/install.sh
+++ b/tests/config/install.sh
@@ -71,8 +71,8 @@ if [[ -n "$USE_DATABASE_REPLICATED" ]] && [[ "$USE_DATABASE_REPLICATED" -eq 1 ]]
 
     # There is a bug in config reloading, so we cannot override macros using --macros.replica r2
     # And we have to copy configs...
-    mkdir /etc/clickhouse-server1
-    mkdir /etc/clickhouse-server2
+    mkdir -p /etc/clickhouse-server1
+    mkdir -p /etc/clickhouse-server2
     chown clickhouse /etc/clickhouse-server1
     chown clickhouse /etc/clickhouse-server2
     chgrp clickhouse /etc/clickhouse-server1
@@ -84,8 +84,8 @@ if [[ -n "$USE_DATABASE_REPLICATED" ]] && [[ "$USE_DATABASE_REPLICATED" -eq 1 ]]
     sudo -u clickhouse cat /etc/clickhouse-server/config.d/macros.xml | sed "s|<replica>r1</replica>|<replica>r2</replica>|" > /etc/clickhouse-server1/config.d/macros.xml
     sudo -u clickhouse cat /etc/clickhouse-server/config.d/macros.xml | sed "s|<shard>s1</shard>|<shard>s2</shard>|" > /etc/clickhouse-server2/config.d/macros.xml
 
-    sudo mkdir /var/lib/clickhouse1
-    sudo mkdir /var/lib/clickhouse2
+    sudo mkdir -p /var/lib/clickhouse1
+    sudo mkdir -p /var/lib/clickhouse2
     sudo chown clickhouse /var/lib/clickhouse1
     sudo chown clickhouse /var/lib/clickhouse2
     sudo chgrp clickhouse /var/lib/clickhouse1
diff --git a/tests/integration/ci-runner.py b/tests/integration/ci-runner.py
index 9215cc56a50..3bd30982098 100755
--- a/tests/integration/ci-runner.py
+++ b/tests/integration/ci-runner.py
@@ -15,6 +15,7 @@ MAX_RETRY = 2
 SLEEP_BETWEEN_RETRIES = 5
 CLICKHOUSE_BINARY_PATH = "/usr/bin/clickhouse"
 CLICKHOUSE_ODBC_BRIDGE_BINARY_PATH = "/usr/bin/clickhouse-odbc-bridge"
+CLICKHOUSE_LIBRARY_BRIDGE_BINARY_PATH = "/usr/bin/clickhouse-library-bridge"
 
 TRIES_COUNT = 10
 MAX_TIME_SECONDS = 3600
@@ -238,10 +239,13 @@ class ClickhouseIntegrationTestsRunner:
         logging.info("All packages installed")
         os.chmod(CLICKHOUSE_BINARY_PATH, 0o777)
         os.chmod(CLICKHOUSE_ODBC_BRIDGE_BINARY_PATH, 0o777)
+        os.chmod(CLICKHOUSE_LIBRARY_BRIDGE_BINARY_PATH, 0o777)
         result_path_bin = os.path.join(str(self.base_path()), "clickhouse")
-        result_path_bridge = os.path.join(str(self.base_path()), "clickhouse-odbc-bridge")
+        result_path_odbc_bridge = os.path.join(str(self.base_path()), "clickhouse-odbc-bridge")
+        result_path_library_bridge = os.path.join(str(self.base_path()), "clickhouse-library-bridge")
         shutil.copy(CLICKHOUSE_BINARY_PATH, result_path_bin)
-        shutil.copy(CLICKHOUSE_ODBC_BRIDGE_BINARY_PATH, result_path_bridge)
+        shutil.copy(CLICKHOUSE_ODBC_BRIDGE_BINARY_PATH, result_path_odbc_bridge)
+        shutil.copy(CLICKHOUSE_LIBRARY_BRIDGE_BINARY_PATH, result_path_library_bridge)
         return None, None
 
     def _compress_logs(self, path, result_path):
@@ -330,12 +334,11 @@ class ClickhouseIntegrationTestsRunner:
                 logging.info("Task timeout exceeded, skipping %s", test)
                 counters["SKIPPED"].append(test)
                 tests_times[test] = 0
-            log_name = None
-            log_path = None
-            return counters, tests_times, log_name, log_path
+            return counters, tests_times, []
 
         image_cmd = self._get_runner_image_cmd(repo_path)
         test_group_str = test_group.replace('/', '_').replace('.', '_')
+        log_paths = []
 
         for i in range(num_tries):
             logging.info("Running test group %s for the %s retry", test_group, i)
@@ -344,6 +347,7 @@ class ClickhouseIntegrationTestsRunner:
             output_path = os.path.join(str(self.path()), "test_output_" + test_group_str + "_" + str(i) + ".log")
             log_name = "integration_run_" + test_group_str + "_" + str(i) + ".txt"
             log_path = os.path.join(str(self.path()), log_name)
+            log_paths.append(log_path)
             logging.info("Will wait output inside %s", output_path)
 
             test_names = set([])
@@ -386,7 +390,7 @@ class ClickhouseIntegrationTestsRunner:
                 if test not in counters["PASSED"] and test not in counters["ERROR"] and test not in counters["FAILED"]:
                     counters["ERROR"].append(test)
 
-        return counters, tests_times, log_name, log_path
+        return counters, tests_times, log_paths
 
     def run_flaky_check(self, repo_path, build_path):
         pr_info = self.params['pr_info']
@@ -404,12 +408,12 @@ class ClickhouseIntegrationTestsRunner:
         start = time.time()
         logging.info("Starting check with retries")
         final_retry = 0
-        log_paths = []
+        logs = []
         for i in range(TRIES_COUNT):
             final_retry += 1
             logging.info("Running tests for the %s time", i)
-            counters, tests_times, _, log_path = self.run_test_group(repo_path, "flaky", tests_to_run, 1)
-            log_paths.append(log_path)
+            counters, tests_times, log_paths = self.run_test_group(repo_path, "flaky", tests_to_run, 1)
+            logs += log_paths
             if counters["FAILED"]:
                 logging.info("Found failed tests: %s", ' '.join(counters["FAILED"]))
                 description_prefix = "Flaky tests found: "
@@ -446,7 +450,7 @@ class ClickhouseIntegrationTestsRunner:
             test_result += [(c + ' (✕' + str(final_retry) + ')', text_state, "{:.2f}".format(tests_times[c])) for c in counters[state]]
         status_text = description_prefix + ', '.join([str(n).lower().replace('failed', 'fail') + ': ' + str(len(c)) for n, c in counters.items()])
 
-        return result_state, status_text, test_result, [test_logs] + log_paths
+        return result_state, status_text, test_result, [test_logs] + logs
 
     def run_impl(self, repo_path, build_path):
         if self.flaky_check:
@@ -467,8 +471,8 @@ class ClickhouseIntegrationTestsRunner:
             "FLAKY": [],
         }
         tests_times = defaultdict(float)
+        tests_log_paths = defaultdict(list)
 
-        logs = []
         items_to_run = list(grouped_tests.items())
 
         logging.info("Total test groups %s", len(items_to_run))
@@ -478,7 +482,7 @@ class ClickhouseIntegrationTestsRunner:
 
         for group, tests in items_to_run:
             logging.info("Running test group %s countaining %s tests", group, len(tests))
-            group_counters, group_test_times, _, log_path = self.run_test_group(repo_path, group, tests, MAX_RETRY)
+            group_counters, group_test_times, log_paths = self.run_test_group(repo_path, group, tests, MAX_RETRY)
             total_tests = 0
             for counter, value in group_counters.items():
                 logging.info("Tests from group %s stats, %s count %s", group, counter, len(value))
@@ -489,7 +493,8 @@ class ClickhouseIntegrationTestsRunner:
 
             for test_name, test_time in group_test_times.items():
                 tests_times[test_name] = test_time
-            logs.append(log_path)
+                tests_log_paths[test_name] = log_paths
+
             if len(counters["FAILED"]) + len(counters["ERROR"]) >= 20:
                 logging.info("Collected more than 20 failed/error tests, stopping")
                 break
@@ -514,7 +519,7 @@ class ClickhouseIntegrationTestsRunner:
                 text_state = "FAIL"
             else:
                 text_state = state
-            test_result += [(c, text_state, "{:.2f}".format(tests_times[c])) for c in counters[state]]
+            test_result += [(c, text_state, "{:.2f}".format(tests_times[c]), tests_log_paths[c]) for c in counters[state]]
 
         failed_sum = len(counters['FAILED']) + len(counters['ERROR'])
         status_text = "fail: {}, passed: {}, flaky: {}".format(failed_sum, len(counters['PASSED']), len(counters['FLAKY']))
@@ -531,7 +536,7 @@ class ClickhouseIntegrationTestsRunner:
         if '(memory)' in self.params['context_name']:
             result_state = "success"
 
-        return result_state, status_text, test_result, [test_logs] + logs
+        return result_state, status_text, test_result, [test_logs]
 
 def write_results(results_file, status_file, results, status):
     with open(results_file, 'w') as f:
diff --git a/tests/integration/helpers/cluster.py b/tests/integration/helpers/cluster.py
index 00ada45398f..3d85f494676 100644
--- a/tests/integration/helpers/cluster.py
+++ b/tests/integration/helpers/cluster.py
@@ -54,6 +54,26 @@ def run_and_check(args, env=None, shell=False, stdout=subprocess.PIPE, stderr=su
         raise Exception('Command {} return non-zero code {}: {}'.format(args, res.returncode, res.stderr.decode('utf-8')))
 
 
+def retry_exception(num, delay, func, exception=Exception, *args, **kwargs):
+    """
+    Retry if `func()` throws, `num` times.
+
+    :param func: func to run
+    :param num: number of retries
+
+    :throws StopIteration
+    """
+    i = 0
+    while i <= num:
+        try:
+            func(*args, **kwargs)
+            time.sleep(delay)
+        except exception: # pylint: disable=broad-except
+            i += 1
+            continue
+        return
+    raise StopIteration('Function did not finished successfully')
+
 def subprocess_check_call(args):
     # Uncomment for debugging
     # print('run:', ' ' . join(args))
@@ -75,6 +95,15 @@ def get_odbc_bridge_path():
             return '/usr/bin/clickhouse-odbc-bridge'
     return path
 
+def get_library_bridge_path():
+    path = os.environ.get('CLICKHOUSE_TESTS_LIBRARY_BRIDGE_BIN_PATH')
+    if path is None:
+        server_path = os.environ.get('CLICKHOUSE_TESTS_SERVER_BIN_PATH')
+        if server_path is not None:
+            return os.path.join(os.path.dirname(server_path), 'clickhouse-library-bridge')
+        else:
+            return '/usr/bin/clickhouse-library-bridge'
+    return path
 
 def get_docker_compose_path():
     compose_path = os.environ.get('DOCKER_COMPOSE_DIR')
@@ -98,7 +127,7 @@ class ClickHouseCluster:
     """
 
     def __init__(self, base_path, name=None, base_config_dir=None, server_bin_path=None, client_bin_path=None,
-                 odbc_bridge_bin_path=None, zookeeper_config_path=None, custom_dockerd_host=None):
+                 odbc_bridge_bin_path=None, library_bridge_bin_path=None, zookeeper_config_path=None, custom_dockerd_host=None):
         for param in list(os.environ.keys()):
             print("ENV %40s %s" % (param, os.environ[param]))
         self.base_dir = p.dirname(base_path)
@@ -109,6 +138,7 @@ class ClickHouseCluster:
         self.server_bin_path = p.realpath(
             server_bin_path or os.environ.get('CLICKHOUSE_TESTS_SERVER_BIN_PATH', '/usr/bin/clickhouse'))
         self.odbc_bridge_bin_path = p.realpath(odbc_bridge_bin_path or get_odbc_bridge_path())
+        self.library_bridge_bin_path = p.realpath(library_bridge_bin_path or get_library_bridge_path())
         self.client_bin_path = p.realpath(
             client_bin_path or os.environ.get('CLICKHOUSE_TESTS_CLIENT_BIN_PATH', '/usr/bin/clickhouse-client'))
         self.zookeeper_config_path = p.join(self.base_dir, zookeeper_config_path) if zookeeper_config_path else p.join(
@@ -139,7 +169,9 @@ class ClickHouseCluster:
         self.instances = {}
         self.with_zookeeper = False
         self.with_mysql = False
+        self.with_mysql_cluster = False
         self.with_postgres = False
+        self.with_postgres_cluster = False
         self.with_kafka = False
         self.with_kerberized_kafka = False
         self.with_rabbitmq = False
@@ -180,9 +212,9 @@ class ClickHouseCluster:
 
     def add_instance(self, name, base_config_dir=None, main_configs=None, user_configs=None, dictionaries=None,
                      macros=None,
-                     with_zookeeper=False, with_mysql=False, with_kafka=False, with_kerberized_kafka=False, with_rabbitmq=False,
+                     with_zookeeper=False, with_mysql=False, with_mysql_cluster=False, with_kafka=False, with_kerberized_kafka=False, with_rabbitmq=False,
                      clickhouse_path_dir=None,
-                     with_odbc_drivers=False, with_postgres=False, with_hdfs=False, with_kerberized_hdfs=False, with_mongo=False,
+                     with_odbc_drivers=False, with_postgres=False, with_postgres_cluster=False, with_hdfs=False, with_kerberized_hdfs=False, with_mongo=False,
                      with_redis=False, with_minio=False, with_cassandra=False,
                      hostname=None, env_variables=None, image="yandex/clickhouse-integration-test", tag=None,
                      stay_alive=False, ipv4_address=None, ipv6_address=None, with_installed_binary=False, tmpfs=None,
@@ -223,6 +255,7 @@ class ClickHouseCluster:
             with_zookeeper=with_zookeeper,
             zookeeper_config_path=self.zookeeper_config_path,
             with_mysql=with_mysql,
+            with_mysql_cluster=with_mysql_cluster,
             with_kafka=with_kafka,
             with_kerberized_kafka=with_kerberized_kafka,
             with_rabbitmq=with_rabbitmq,
@@ -233,6 +266,7 @@ class ClickHouseCluster:
             with_cassandra=with_cassandra,
             server_bin_path=self.server_bin_path,
             odbc_bridge_bin_path=self.odbc_bridge_bin_path,
+            library_bridge_bin_path=self.library_bridge_bin_path,
             clickhouse_path_dir=clickhouse_path_dir,
             with_odbc_drivers=with_odbc_drivers,
             hostname=hostname,
@@ -274,6 +308,14 @@ class ClickHouseCluster:
 
             cmds.append(self.base_mysql_cmd)
 
+        if with_mysql_cluster and not self.with_mysql_cluster:
+            self.with_mysql_cluster = True
+            self.base_cmd.extend(['--file', p.join(docker_compose_yml_dir, 'docker_compose_mysql_cluster.yml')])
+            self.base_mysql_cluster_cmd = ['docker-compose', '--project-name', self.project_name,
+                                   '--file', p.join(docker_compose_yml_dir, 'docker_compose_mysql_cluster.yml')]
+
+            cmds.append(self.base_mysql_cluster_cmd)
+
         if with_postgres and not self.with_postgres:
             self.with_postgres = True
             self.base_cmd.extend(['--file', p.join(docker_compose_yml_dir, 'docker_compose_postgres.yml')])
@@ -281,6 +323,13 @@ class ClickHouseCluster:
                                       '--file', p.join(docker_compose_yml_dir, 'docker_compose_postgres.yml')]
             cmds.append(self.base_postgres_cmd)
 
+        if with_postgres_cluster and not self.with_postgres_cluster:
+            self.with_postgres_cluster = True
+            self.base_cmd.extend(['--file', p.join(docker_compose_yml_dir, 'docker_compose_postgres.yml')])
+            self.base_postgres_cluster_cmd = ['docker-compose', '--project-name', self.project_name,
+                                      '--file', p.join(docker_compose_yml_dir, 'docker_compose_postgres_cluster.yml')]
+            cmds.append(self.base_postgres_cluster_cmd)
+
         if with_odbc_drivers and not self.with_odbc_drivers:
             self.with_odbc_drivers = True
             if not self.with_mysql:
@@ -449,11 +498,11 @@ class ClickHouseCluster:
                                    ["bash", "-c", "echo {} | base64 --decode > {}".format(encodedStr, dest_path)],
                                    user='root')
 
-    def wait_mysql_to_start(self, timeout=60):
+    def wait_mysql_to_start(self, timeout=60, port=3308):
         start = time.time()
         while time.time() - start < timeout:
             try:
-                conn = pymysql.connect(user='root', password='clickhouse', host='127.0.0.1', port=3308)
+                conn = pymysql.connect(user='root', password='clickhouse', host='127.0.0.1', port=port)
                 conn.close()
                 print("Mysql Started")
                 return
@@ -464,11 +513,11 @@ class ClickHouseCluster:
         subprocess_call(['docker-compose', 'ps', '--services', '--all'])
         raise Exception("Cannot wait MySQL container")
 
-    def wait_postgres_to_start(self, timeout=60):
+    def wait_postgres_to_start(self, timeout=60, port=5432):
         start = time.time()
         while time.time() - start < timeout:
             try:
-                conn_string = "host='localhost' user='postgres' password='mysecretpassword'"
+                conn_string = "host='localhost' port={} user='postgres' password='mysecretpassword'".format(port)
                 conn = psycopg2.connect(conn_string)
                 conn.close()
                 print("Postgres Started")
@@ -603,16 +652,6 @@ class ClickHouseCluster:
         if self.is_up:
             return
 
-        # Just in case kill unstopped containers from previous launch
-        try:
-            print("Trying to kill unstopped containers...")
-
-            if not subprocess_call(['docker-compose', 'kill']):
-                subprocess_call(['docker-compose', 'down', '--volumes'])
-            print("Unstopped containers killed")
-        except:
-            pass
-
         try:
             if destroy_dirs and p.exists(self.instances_dir):
                 print(("Removing instances dir %s", self.instances_dir))
@@ -622,9 +661,24 @@ class ClickHouseCluster:
                 print(('Setup directory for instance: {} destroy_dirs: {}'.format(instance.name, destroy_dirs)))
                 instance.create_dir(destroy_dir=destroy_dirs)
 
+            # In case of multiple cluster we should not stop compose services.
+            if destroy_dirs:
+                # Just in case kill unstopped containers from previous launch
+                try:
+                    print("Trying to kill unstopped containers...")
+                    subprocess_call(['docker-compose', 'kill'])
+                    subprocess_call(self.base_cmd + ['down', '--volumes', '--remove-orphans'])
+                    print("Unstopped containers killed")
+                except:
+                    pass
+
+            clickhouse_pull_cmd = self.base_cmd + ['pull']
+            print(f"Pulling images for {self.base_cmd}")
+            retry_exception(10, 5, subprocess_check_call, Exception, clickhouse_pull_cmd)
+
             self.docker_client = docker.from_env(version=self.docker_api_version)
 
-            common_opts = ['up', '-d', '--force-recreate']
+            common_opts = ['up', '-d']
 
             if self.with_zookeeper and self.base_zookeeper_cmd:
                 print('Setup ZooKeeper')
@@ -650,11 +704,25 @@ class ClickHouseCluster:
                 subprocess_check_call(self.base_mysql_cmd + common_opts)
                 self.wait_mysql_to_start(120)
 
+            if self.with_mysql_cluster and self.base_mysql_cluster_cmd:
+                print('Setup MySQL')
+                subprocess_check_call(self.base_mysql_cluster_cmd + common_opts)
+                self.wait_mysql_to_start(120, port=3348)
+                self.wait_mysql_to_start(120, port=3368)
+                self.wait_mysql_to_start(120, port=3388)
+
             if self.with_postgres and self.base_postgres_cmd:
                 print('Setup Postgres')
                 subprocess_check_call(self.base_postgres_cmd + common_opts)
                 self.wait_postgres_to_start(120)
 
+            if self.with_postgres_cluster and self.base_postgres_cluster_cmd:
+                print('Setup Postgres')
+                subprocess_check_call(self.base_postgres_cluster_cmd + common_opts)
+                self.wait_postgres_to_start(120, port=5421)
+                self.wait_postgres_to_start(120, port=5441)
+                self.wait_postgres_to_start(120, port=5461)
+
             if self.with_kafka and self.base_kafka_cmd:
                 print('Setup Kafka')
                 subprocess_check_call(self.base_kafka_cmd + common_opts + ['--renew-anon-volumes'])
@@ -692,7 +760,7 @@ class ClickHouseCluster:
 
             if self.with_redis and self.base_redis_cmd:
                 print('Setup Redis')
-                subprocess_check_call(self.base_redis_cmd + ['up', '-d', '--force-recreate'])
+                subprocess_check_call(self.base_redis_cmd + ['up', '-d'])
                 time.sleep(10)
 
             if self.with_minio and self.base_minio_cmd:
@@ -726,7 +794,7 @@ class ClickHouseCluster:
                             os.environ.pop('SSL_CERT_FILE')
 
             if self.with_cassandra and self.base_cassandra_cmd:
-                subprocess_check_call(self.base_cassandra_cmd + ['up', '-d', '--force-recreate'])
+                subprocess_check_call(self.base_cassandra_cmd + ['up', '-d'])
                 self.wait_cassandra_to_start()
 
             clickhouse_start_cmd = self.base_cmd + ['up', '-d', '--no-recreate']
@@ -861,6 +929,7 @@ services:
             - /etc/passwd:/etc/passwd:ro
             {binary_volume}
             {odbc_bridge_volume}
+            {library_bridge_volume}
             {odbc_ini_path}
             {keytab_path}
             {krb5_conf}
@@ -896,9 +965,9 @@ class ClickHouseInstance:
     def __init__(
             self, cluster, base_path, name, base_config_dir, custom_main_configs, custom_user_configs,
             custom_dictionaries,
-            macros, with_zookeeper, zookeeper_config_path, with_mysql, with_kafka, with_kerberized_kafka, with_rabbitmq, with_kerberized_hdfs,
+            macros, with_zookeeper, zookeeper_config_path, with_mysql, with_mysql_cluster, with_kafka, with_kerberized_kafka, with_rabbitmq, with_kerberized_hdfs,
             with_mongo, with_redis, with_minio,
-            with_cassandra, server_bin_path, odbc_bridge_bin_path, clickhouse_path_dir, with_odbc_drivers,
+            with_cassandra, server_bin_path, odbc_bridge_bin_path, library_bridge_bin_path, clickhouse_path_dir, with_odbc_drivers,
             hostname=None, env_variables=None,
             image="yandex/clickhouse-integration-test", tag="latest",
             stay_alive=False, ipv4_address=None, ipv6_address=None, with_installed_binary=False, tmpfs=None):
@@ -922,8 +991,10 @@ class ClickHouseInstance:
 
         self.server_bin_path = server_bin_path
         self.odbc_bridge_bin_path = odbc_bridge_bin_path
+        self.library_bridge_bin_path = library_bridge_bin_path
 
         self.with_mysql = with_mysql
+        self.with_mysql_cluster = with_mysql_cluster
         self.with_kafka = with_kafka
         self.with_kerberized_kafka = with_kerberized_kafka
         self.with_rabbitmq = with_rabbitmq
@@ -1389,9 +1460,11 @@ class ClickHouseInstance:
         if not self.with_installed_binary:
             binary_volume = "- " + self.server_bin_path + ":/usr/bin/clickhouse"
             odbc_bridge_volume = "- " + self.odbc_bridge_bin_path + ":/usr/bin/clickhouse-odbc-bridge"
+            library_bridge_volume = "- " + self.library_bridge_bin_path + ":/usr/bin/clickhouse-library-bridge"
         else:
             binary_volume = "- " + self.server_bin_path + ":/usr/share/clickhouse_fresh"
             odbc_bridge_volume = "- " + self.odbc_bridge_bin_path + ":/usr/share/clickhouse-odbc-bridge_fresh"
+            library_bridge_volume = "- " + self.library_bridge_bin_path + ":/usr/share/clickhouse-library-bridge_fresh"
 
         with open(self.docker_compose_path, 'w') as docker_compose:
             docker_compose.write(DOCKER_COMPOSE_TEMPLATE.format(
@@ -1401,6 +1474,7 @@ class ClickHouseInstance:
                 hostname=self.hostname,
                 binary_volume=binary_volume,
                 odbc_bridge_volume=odbc_bridge_volume,
+                library_bridge_volume=library_bridge_volume,
                 instance_config_dir=instance_config_dir,
                 config_d_dir=self.config_d_dir,
                 db_dir=db_dir,
diff --git a/tests/integration/runner b/tests/integration/runner
index 6dca7663310..e89e10fbc21 100755
--- a/tests/integration/runner
+++ b/tests/integration/runner
@@ -33,10 +33,15 @@ def check_args_and_update_paths(args):
     if not os.path.isabs(args.binary):
         args.binary = os.path.abspath(os.path.join(CURRENT_WORK_DIR, args.binary))
 
-    if not args.bridge_binary:
-        args.bridge_binary = os.path.join(os.path.dirname(args.binary), 'clickhouse-odbc-bridge')
-    elif not os.path.isabs(args.bridge_binary):
-        args.bridge_binary = os.path.abspath(os.path.join(CURRENT_WORK_DIR, args.bridge_binary))
+    if not args.odbc_bridge_binary:
+        args.odbc_bridge_binary = os.path.join(os.path.dirname(args.binary), 'clickhouse-odbc-bridge')
+    elif not os.path.isabs(args.odbc_bridge_binary):
+        args.odbc_bridge_binary = os.path.abspath(os.path.join(CURRENT_WORK_DIR, args.odbc_bridge_binary))
+
+    if not args.library_bridge_binary:
+        args.library_bridge_binary = os.path.join(os.path.dirname(args.binary), 'clickhouse-library-bridge')
+    elif not os.path.isabs(args.library_bridge_binary):
+        args.library_bridge_binary = os.path.abspath(os.path.join(CURRENT_WORK_DIR, args.library_bridge_binary))
 
     if args.base_configs_dir:
         if not os.path.isabs(args.base_configs_dir):
@@ -61,7 +66,7 @@ def check_args_and_update_paths(args):
 
     logging.info("base_configs_dir: {},  binary: {}, cases_dir: {} ".format(args.base_configs_dir, args.binary, args.cases_dir))
 
-    for path in [args.binary, args.bridge_binary, args.base_configs_dir, args.cases_dir, CLICKHOUSE_ROOT]:
+    for path in [args.binary, args.odbc_bridge_binary, args.library_bridge_binary, args.base_configs_dir, args.cases_dir, CLICKHOUSE_ROOT]:
         if not os.path.exists(path):
             raise Exception("Path {} doesn't exist".format(path))
 
@@ -82,7 +87,8 @@ signal.signal(signal.SIGINT, docker_kill_handler_handler)
 # To run integration tests following artfacts should be sufficient:
 #   - clickhouse binaries (env CLICKHOUSE_TESTS_SERVER_BIN_PATH or --binary arg)
 #   - clickhouse default configs(config.xml, users.xml) from same version as binary (env CLICKHOUSE_TESTS_BASE_CONFIG_DIR or --base-configs-dir arg)
-#   - odbc bridge binary (env CLICKHOUSE_TESTS_ODBC_BRIDGE_BIN_PATH or --bridge-binary arg)
+#   - odbc bridge binary (env CLICKHOUSE_TESTS_ODBC_BRIDGE_BIN_PATH or --odbc-bridge-binary arg)
+#   - library bridge binary (env CLICKHOUSE_TESTS_LIBRARY_BRIDGE_BIN_PATH or --library-bridge-binary)
 #   - tests/integration directory with all test cases and configs (env CLICKHOUSE_TESTS_INTEGRATION_PATH or --cases-dir)
 #
 # 1) --clickhouse-root is only used to determine other paths on default places
@@ -98,10 +104,15 @@ if __name__ == "__main__":
         help="Path to clickhouse binary. For example /usr/bin/clickhouse")
 
     parser.add_argument(
-        "--bridge-binary",
+        "--odbc-bridge-binary",
         default=os.environ.get("CLICKHOUSE_TESTS_ODBC_BRIDGE_BIN_PATH", ""),
         help="Path to clickhouse-odbc-bridge binary. Defaults to clickhouse-odbc-bridge in the same dir as clickhouse.")
 
+    parser.add_argument(
+        "--library-bridge-binary",
+        default=os.environ.get("CLICKHOUSE_TESTS_LIBRARY_BRIDGE_BIN_PATH", ""),
+        help="Path to clickhouse-library-bridge binary. Defaults to clickhouse-library-bridge in the same dir as clickhouse.")
+
     parser.add_argument(
         "--base-configs-dir",
         default=os.environ.get("CLICKHOUSE_TESTS_BASE_CONFIG_DIR"),
@@ -185,14 +196,17 @@ if __name__ == "__main__":
     if sys.stdout.isatty() and sys.stdin.isatty():
         tty = "-it"
 
-    cmd = "docker run {net} {tty} --rm --name {name} --privileged --volume={bridge_bin}:/clickhouse-odbc-bridge --volume={bin}:/clickhouse \
+    cmd = "docker run {net} {tty} --rm --name {name} --privileged \
+        --volume={odbc_bridge_bin}:/clickhouse-odbc-bridge --volume={bin}:/clickhouse \
+        --volume={library_bridge_bin}:/clickhouse-library-bridge --volume={bin}:/clickhouse \
         --volume={base_cfg}:/clickhouse-config --volume={cases_dir}:/ClickHouse/tests/integration \
         --volume={src_dir}/Server/grpc_protos:/ClickHouse/src/Server/grpc_protos \
         --volume={name}_volume:/var/lib/docker {env_tags} -e PYTEST_OPTS='{opts}' {img} {command}".format(
         net=net,
         tty=tty,
         bin=args.binary,
-        bridge_bin=args.bridge_binary,
+        odbc_bridge_bin=args.odbc_bridge_binary,
+        library_bridge_bin=args.library_bridge_binary,
         base_cfg=args.base_configs_dir,
         cases_dir=args.cases_dir,
         src_dir=args.src_dir,
diff --git a/tests/queries/0_stateless/01709_inactive_parts_to_delay_throw.reference b/tests/integration/test_catboost_model_config_reload/__init__.py
similarity index 100%
rename from tests/queries/0_stateless/01709_inactive_parts_to_delay_throw.reference
rename to tests/integration/test_catboost_model_config_reload/__init__.py
diff --git a/tests/integration/test_catboost_model_config_reload/config/catboost_lib.xml b/tests/integration/test_catboost_model_config_reload/config/catboost_lib.xml
new file mode 100644
index 00000000000..745be7cebe6
--- /dev/null
+++ b/tests/integration/test_catboost_model_config_reload/config/catboost_lib.xml
@@ -0,0 +1,3 @@
+<yandex>
+    <catboost_dynamic_library_path>/etc/clickhouse-server/model/libcatboostmodel.so</catboost_dynamic_library_path>
+</yandex>
diff --git a/tests/integration/test_catboost_model_config_reload/config/models_config.xml b/tests/integration/test_catboost_model_config_reload/config/models_config.xml
new file mode 100644
index 00000000000..7e62283a83c
--- /dev/null
+++ b/tests/integration/test_catboost_model_config_reload/config/models_config.xml
@@ -0,0 +1,2 @@
+<yandex>
+</yandex>
diff --git a/tests/integration/test_catboost_model_config_reload/model/libcatboostmodel.so b/tests/integration/test_catboost_model_config_reload/model/libcatboostmodel.so
new file mode 100755
index 00000000000..388d9f887b4
Binary files /dev/null and b/tests/integration/test_catboost_model_config_reload/model/libcatboostmodel.so differ
diff --git a/tests/integration/test_catboost_model_config_reload/model/model.bin b/tests/integration/test_catboost_model_config_reload/model/model.bin
new file mode 100644
index 00000000000..118e099d176
Binary files /dev/null and b/tests/integration/test_catboost_model_config_reload/model/model.bin differ
diff --git a/tests/integration/test_catboost_model_config_reload/model/model_config.xml b/tests/integration/test_catboost_model_config_reload/model/model_config.xml
new file mode 100644
index 00000000000..af9778097fa
--- /dev/null
+++ b/tests/integration/test_catboost_model_config_reload/model/model_config.xml
@@ -0,0 +1,8 @@
+<models>
+    <model>
+        <type>catboost</type>
+        <name>model1</name>
+        <path>/etc/clickhouse-server/model/model.bin</path>
+        <lifetime>0</lifetime>
+    </model>
+</models>
diff --git a/tests/integration/test_catboost_model_config_reload/model/model_config2.xml b/tests/integration/test_catboost_model_config_reload/model/model_config2.xml
new file mode 100644
index 00000000000..b81120ec900
--- /dev/null
+++ b/tests/integration/test_catboost_model_config_reload/model/model_config2.xml
@@ -0,0 +1,8 @@
+<models>
+    <model>
+        <type>catboost</type>
+        <name>model2</name>
+        <path>/etc/clickhouse-server/model/model.bin</path>
+        <lifetime>0</lifetime>
+    </model>
+</models>
diff --git a/tests/integration/test_catboost_model_config_reload/test.py b/tests/integration/test_catboost_model_config_reload/test.py
new file mode 100644
index 00000000000..34da1cda2d5
--- /dev/null
+++ b/tests/integration/test_catboost_model_config_reload/test.py
@@ -0,0 +1,58 @@
+import os
+import sys
+import time
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
+
+from helpers.cluster import ClickHouseCluster
+
+cluster = ClickHouseCluster(__file__)
+node = cluster.add_instance('node', stay_alive=True, main_configs=['config/models_config.xml', 'config/catboost_lib.xml'])
+
+
+def copy_file_to_container(local_path, dist_path, container_id):
+    os.system("docker cp {local} {cont_id}:{dist}".format(local=local_path, cont_id=container_id, dist=dist_path))
+
+
+config = '''<yandex>
+    <models_config>/etc/clickhouse-server/model/{model_config}</models_config>
+</yandex>'''
+
+
+@pytest.fixture(scope="module")
+def started_cluster():
+    try:
+        cluster.start()
+
+        copy_file_to_container(os.path.join(SCRIPT_DIR, 'model/.'), '/etc/clickhouse-server/model', node.docker_id)
+        node.restart_clickhouse()
+
+        yield cluster
+
+    finally:
+        cluster.shutdown()
+
+
+def change_config(model_config):
+    node.replace_config("/etc/clickhouse-server/config.d/models_config.xml", config.format(model_config=model_config))
+    node.query("SYSTEM RELOAD CONFIG;")
+
+
+def test(started_cluster):
+    # Set config with the path to the first model.
+    change_config("model_config.xml")
+
+    node.query("SELECT modelEvaluate('model1', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);")
+
+    # Change path to the second model in config.
+    change_config("model_config2.xml")
+
+    # Check that the new model is loaded.
+    node.query("SELECT modelEvaluate('model2', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);")
+
+    # Check that the old model was unloaded.
+    node.query_and_get_error("SELECT modelEvaluate('model1', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);")
+
diff --git a/tests/integration/test_cluster_copier/configs/users.xml b/tests/integration/test_cluster_copier/configs/users.xml
index e742d4f05a6..d27ca56eec7 100644
--- a/tests/integration/test_cluster_copier/configs/users.xml
+++ b/tests/integration/test_cluster_copier/configs/users.xml
@@ -17,6 +17,14 @@
             <profile>default</profile>
             <quota>default</quota>
         </default>
+        <dbuser>
+            <password>12345678</password>
+            <networks incl="networks" replace="replace">
+                <ip>::/0</ip>
+            </networks>
+            <profile>default</profile>
+            <quota>default</quota>
+        </dbuser>
     </users>
 
     <quotas>
diff --git a/tests/integration/test_cluster_copier/task_self_copy.xml b/tests/integration/test_cluster_copier/task_self_copy.xml
new file mode 100644
index 00000000000..e0e35ccfe99
--- /dev/null
+++ b/tests/integration/test_cluster_copier/task_self_copy.xml
@@ -0,0 +1,64 @@
+<?xml version="1.0"?>
+<yandex>
+    <tcp_port_secure>9440</tcp_port_secure>
+    <remote_servers>
+        <source_cluster>
+            <shard>
+                <internal_replication>false</internal_replication>
+                <replica>
+                    <host>s0_0_0</host>
+                    <port>9000</port>
+                    <user>dbuser</user>
+                    <password>12345678</password>
+                    <secure>0</secure>
+                </replica>
+            </shard>
+        </source_cluster>
+
+        <destination_cluster>
+            <shard>
+                <internal_replication>false</internal_replication>
+                <replica>
+                    <host>s0_0_0</host>
+                    <port>9000</port>
+                    <user>dbuser</user>
+                    <password>12345678</password>
+                    <secure>0</secure>
+                </replica>
+            </shard>
+        </destination_cluster>
+    </remote_servers>
+
+    <max_workers>2</max_workers>
+
+    <settings_pull>
+        <readonly>1</readonly>
+    </settings_pull>
+
+    <settings_push>
+        <readonly>0</readonly>
+    </settings_push>
+
+    <settings>
+        <connect_timeout>3</connect_timeout>
+        <insert_distributed_sync>1</insert_distributed_sync>
+    </settings>
+
+    <tables>
+        <table1>
+            <cluster_pull>source_cluster</cluster_pull>
+    	    <database_pull>db1</database_pull>
+            <table_pull>source_table</table_pull>
+
+            <cluster_push>destination_cluster</cluster_push>
+            <database_push>db2</database_push>
+            <table_push>destination_table</table_push>
+
+            <engine>
+	            ENGINE = MergeTree PARTITION BY a ORDER BY a SETTINGS index_granularity = 8192
+	        </engine>
+
+    	    <sharding_key>rand()</sharding_key>
+        </table1>
+    </tables>
+</yandex>
\ No newline at end of file
diff --git a/tests/integration/test_cluster_copier/test.py b/tests/integration/test_cluster_copier/test.py
index d87969630cd..57f9d150c8d 100644
--- a/tests/integration/test_cluster_copier/test.py
+++ b/tests/integration/test_cluster_copier/test.py
@@ -251,6 +251,31 @@ class Task_non_partitioned_table:
         instance = cluster.instances['s1_1_0']
         instance.query("DROP TABLE copier_test1_1")
 
+class Task_self_copy:
+
+    def __init__(self, cluster):
+        self.cluster = cluster
+        self.zk_task_path = "/clickhouse-copier/task_self_copy"
+        self.copier_task_config = open(os.path.join(CURRENT_TEST_DIR, 'task_self_copy.xml'), 'r').read()
+
+    def start(self):
+        instance = cluster.instances['s0_0_0']
+        instance.query("CREATE DATABASE db1;")
+        instance.query(
+            "CREATE TABLE db1.source_table (`a` Int8, `b` String, `c` Int8) ENGINE = MergeTree PARTITION BY a ORDER BY a SETTINGS index_granularity = 8192")
+        instance.query("CREATE DATABASE db2;")
+        instance.query(
+            "CREATE TABLE db2.destination_table (`a` Int8, `b` String, `c` Int8) ENGINE = MergeTree PARTITION BY a ORDER BY a SETTINGS index_granularity = 8192")
+        instance.query("INSERT INTO db1.source_table VALUES (1, 'ClickHouse', 1);")
+        instance.query("INSERT INTO db1.source_table VALUES (2, 'Copier', 2);")
+
+    def check(self):
+        instance = cluster.instances['s0_0_0']
+        assert TSV(instance.query("SELECT * FROM db2.destination_table ORDER BY a")) == TSV(instance.query("SELECT * FROM db1.source_table ORDER BY a"))
+        instance = cluster.instances['s0_0_0']
+        instance.query("DROP DATABASE db1 SYNC")
+        instance.query("DROP DATABASE db2 SYNC")
+
 
 def execute_task(task, cmd_options):
     task.start()
@@ -380,9 +405,14 @@ def test_no_index(started_cluster):
 def test_no_arg(started_cluster):
     execute_task(Task_no_arg(started_cluster), [])
 
+
 def test_non_partitioned_table(started_cluster):
     execute_task(Task_non_partitioned_table(started_cluster), [])
 
+
+def test_self_copy(started_cluster):
+    execute_task(Task_self_copy(started_cluster), [])
+
 if __name__ == '__main__':
     with contextmanager(started_cluster)() as cluster:
         for name, instance in list(cluster.instances.items()):
diff --git a/tests/integration/test_dictionaries_postgresql/test.py b/tests/integration/test_dictionaries_postgresql/test.py
index 10d9f4213e1..5b3b5a5aa45 100644
--- a/tests/integration/test_dictionaries_postgresql/test.py
+++ b/tests/integration/test_dictionaries_postgresql/test.py
@@ -9,7 +9,7 @@ cluster = ClickHouseCluster(__file__)
 node1 = cluster.add_instance('node1', main_configs=[
     'configs/config.xml',
     'configs/dictionaries/postgres_dict.xml',
-    'configs/log_conf.xml'], with_postgres=True)
+    'configs/log_conf.xml'], with_postgres=True, with_postgres_cluster=True)
 
 postgres_dict_table_template = """
     CREATE TABLE IF NOT EXISTS {} (
@@ -62,7 +62,7 @@ def started_cluster():
         print("postgres1 connected")
         create_postgres_db(postgres_conn, 'clickhouse')
 
-        postgres_conn = get_postgres_conn(port=5441)
+        postgres_conn = get_postgres_conn(port=5421)
         print("postgres2 connected")
         create_postgres_db(postgres_conn, 'clickhouse')
 
@@ -131,7 +131,7 @@ def test_invalidate_query(started_cluster):
 def test_dictionary_with_replicas(started_cluster):
     conn1 = get_postgres_conn(port=5432, database=True)
     cursor1 = conn1.cursor()
-    conn2 = get_postgres_conn(port=5441, database=True)
+    conn2 = get_postgres_conn(port=5421, database=True)
     cursor2 = conn2.cursor()
 
     create_postgres_table(cursor1, 'test1')
diff --git a/tests/integration/test_hedged_requests/test.py b/tests/integration/test_hedged_requests/test.py
index a1693206ecc..e40b3109c44 100644
--- a/tests/integration/test_hedged_requests/test.py
+++ b/tests/integration/test_hedged_requests/test.py
@@ -87,7 +87,10 @@ def check_settings(node_name, sleep_in_send_tables_status_ms, sleep_in_send_data
 
 def check_changing_replica_events(expected_count):
     result = NODES['node'].query("SELECT value FROM system.events WHERE event='HedgedRequestsChangeReplica'")
-    assert int(result) == expected_count
+
+    # If server load is high we can see more than expected
+    # replica change events, but never less than expected
+    assert int(result) >= expected_count
 
 
 def update_configs(node_1_sleep_in_send_tables_status=0, node_1_sleep_in_send_data=0,
diff --git a/tests/integration/test_hedged_requests_parallel/test.py b/tests/integration/test_hedged_requests_parallel/test.py
index 33f70da00ca..7abc2eb1d2a 100644
--- a/tests/integration/test_hedged_requests_parallel/test.py
+++ b/tests/integration/test_hedged_requests_parallel/test.py
@@ -88,7 +88,10 @@ def check_settings(node_name, sleep_in_send_tables_status_ms, sleep_in_send_data
 
 def check_changing_replica_events(expected_count):
     result = NODES['node'].query("SELECT value FROM system.events WHERE event='HedgedRequestsChangeReplica'")
-    assert int(result) == expected_count
+
+    # If server load is high we can see more than expected
+    # replica change events, but never less than expected
+    assert int(result) >= expected_count
 
 
 def update_configs(node_1_sleep_in_send_tables_status=0, node_1_sleep_in_send_data=0,
diff --git a/tests/integration/test_keeper_internal_secure/__init__.py b/tests/integration/test_keeper_internal_secure/__init__.py
new file mode 100644
index 00000000000..e5a0d9b4834
--- /dev/null
+++ b/tests/integration/test_keeper_internal_secure/__init__.py
@@ -0,0 +1 @@
+#!/usr/bin/env python3
diff --git a/tests/integration/test_keeper_internal_secure/configs/enable_secure_keeper1.xml b/tests/integration/test_keeper_internal_secure/configs/enable_secure_keeper1.xml
new file mode 100644
index 00000000000..ecbd50c72a6
--- /dev/null
+++ b/tests/integration/test_keeper_internal_secure/configs/enable_secure_keeper1.xml
@@ -0,0 +1,42 @@
+<yandex>
+    <keeper_server>
+        <tcp_port>9181</tcp_port>
+        <server_id>1</server_id>
+        <log_storage_path>/var/lib/clickhouse/coordination/log</log_storage_path>
+        <snapshot_storage_path>/var/lib/clickhouse/coordination/snapshots</snapshot_storage_path>
+
+        <coordination_settings>
+            <operation_timeout_ms>5000</operation_timeout_ms>
+            <session_timeout_ms>10000</session_timeout_ms>
+            <snapshot_distance>75</snapshot_distance>
+            <raft_logs_level>trace</raft_logs_level>
+        </coordination_settings>
+
+        <raft_configuration>
+            <secure>true</secure>
+            <server>
+                <id>1</id>
+                <hostname>node1</hostname>
+                <port>44444</port>
+                <can_become_leader>true</can_become_leader>
+                <priority>3</priority>
+            </server>
+            <server>
+                <id>2</id>
+                <hostname>node2</hostname>
+                <port>44444</port>
+                <can_become_leader>true</can_become_leader>
+                <start_as_follower>true</start_as_follower>
+                <priority>2</priority>
+            </server>
+            <server>
+                <id>3</id>
+                <hostname>node3</hostname>
+                <port>44444</port>
+                <can_become_leader>true</can_become_leader>
+                <start_as_follower>true</start_as_follower>
+                <priority>1</priority>
+            </server>
+        </raft_configuration>
+    </keeper_server>
+</yandex>
diff --git a/tests/integration/test_keeper_internal_secure/configs/enable_secure_keeper2.xml b/tests/integration/test_keeper_internal_secure/configs/enable_secure_keeper2.xml
new file mode 100644
index 00000000000..53129ae0a75
--- /dev/null
+++ b/tests/integration/test_keeper_internal_secure/configs/enable_secure_keeper2.xml
@@ -0,0 +1,42 @@
+<yandex>
+    <keeper_server>
+        <tcp_port>9181</tcp_port>
+        <server_id>2</server_id>
+        <log_storage_path>/var/lib/clickhouse/coordination/log</log_storage_path>
+        <snapshot_storage_path>/var/lib/clickhouse/coordination/snapshots</snapshot_storage_path>
+
+        <coordination_settings>
+            <operation_timeout_ms>5000</operation_timeout_ms>
+            <session_timeout_ms>10000</session_timeout_ms>
+            <snapshot_distance>75</snapshot_distance>
+            <raft_logs_level>trace</raft_logs_level>
+        </coordination_settings>
+
+        <raft_configuration>
+            <secure>true</secure>
+            <server>
+                <id>1</id>
+                <hostname>node1</hostname>
+                <port>44444</port>
+                <can_become_leader>true</can_become_leader>
+                <priority>3</priority>
+            </server>
+            <server>
+                <id>2</id>
+                <hostname>node2</hostname>
+                <port>44444</port>
+                <can_become_leader>true</can_become_leader>
+                <start_as_follower>true</start_as_follower>
+                <priority>2</priority>
+            </server>
+            <server>
+                <id>3</id>
+                <hostname>node3</hostname>
+                <port>44444</port>
+                <can_become_leader>true</can_become_leader>
+                <start_as_follower>true</start_as_follower>
+                <priority>1</priority>
+            </server>
+        </raft_configuration>
+    </keeper_server>
+</yandex>
diff --git a/tests/integration/test_keeper_internal_secure/configs/enable_secure_keeper3.xml b/tests/integration/test_keeper_internal_secure/configs/enable_secure_keeper3.xml
new file mode 100644
index 00000000000..4c685764ec0
--- /dev/null
+++ b/tests/integration/test_keeper_internal_secure/configs/enable_secure_keeper3.xml
@@ -0,0 +1,42 @@
+<yandex>
+    <keeper_server>
+        <tcp_port>9181</tcp_port>
+        <server_id>3</server_id>
+        <log_storage_path>/var/lib/clickhouse/coordination/log</log_storage_path>
+        <snapshot_storage_path>/var/lib/clickhouse/coordination/snapshots</snapshot_storage_path>
+
+        <coordination_settings>
+            <operation_timeout_ms>5000</operation_timeout_ms>
+            <session_timeout_ms>10000</session_timeout_ms>
+            <snapshot_distance>75</snapshot_distance>
+            <raft_logs_level>trace</raft_logs_level>
+        </coordination_settings>
+
+        <raft_configuration>
+            <secure>true</secure>
+            <server>
+                <id>1</id>
+                <hostname>node1</hostname>
+                <port>44444</port>
+                <can_become_leader>true</can_become_leader>
+                <priority>3</priority>
+            </server>
+            <server>
+                <id>2</id>
+                <hostname>node2</hostname>
+                <port>44444</port>
+                <can_become_leader>true</can_become_leader>
+                <start_as_follower>true</start_as_follower>
+                <priority>2</priority>
+            </server>
+            <server>
+                <id>3</id>
+                <hostname>node3</hostname>
+                <port>44444</port>
+                <can_become_leader>true</can_become_leader>
+                <start_as_follower>true</start_as_follower>
+                <priority>1</priority>
+            </server>
+        </raft_configuration>
+    </keeper_server>
+</yandex>
diff --git a/tests/integration/test_keeper_internal_secure/configs/rootCA.pem b/tests/integration/test_keeper_internal_secure/configs/rootCA.pem
new file mode 100644
index 00000000000..ec16533d98a
--- /dev/null
+++ b/tests/integration/test_keeper_internal_secure/configs/rootCA.pem
@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDazCCAlOgAwIBAgIUUiyhAav08YhTLfUIXLN/0Ln09n4wDQYJKoZIhvcNAQEL
+BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMTA0MTIxMTQ1MjBaFw0yMTA1
+MTIxMTQ1MjBaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
+HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB
+AQUAA4IBDwAwggEKAoIBAQDK0Ww4voPlkePBPS2MsEi7e1ePS+CDxTdDuOwWWEA7
+JiOyqIGqdyL6AE2EqjL3sSdVFVxytpGQWDuM6JHXdb01AnMngBuql9Jkiln7i267
+v54HtMWdm8o3rik/b/mB+kkn/sP715tI49Ybh/RobtvtK16ZgHr1ombkq6rXiom2
+8GmSmpYFwZtZsXtm2JwbZVayupQpWwdu3KrTXKBtVyKVvvWdgkf47DWYtWDS3vqE
+cShM1H97G4DvI+4RX1WtQevQ0yCx1aFTg4xMHFkpUxlP8iW6mQaQPqy9rnI57e3L
+RHc2I/B56xa43R3GmQ2S7bE4hvm1SrZDtVgrZLf4nvwNAgMBAAGjUzBRMB0GA1Ud
+DgQWBBQ4+o0x1FzK7nRbcnm2pNLwaywCdzAfBgNVHSMEGDAWgBQ4+o0x1FzK7nRb
+cnm2pNLwaywCdzAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQDE
+YmM8MH6RKcaqMqCBefWLj0LTcZ/Wm4G/eCFC51PkAIsf7thnzViemBHRXUSF8wzc
+1MBPD6II6OB1F0i7ntGjtlhnL2WcPYbo2Np59p7fo9SMbYwF49OZ40twsuKeeoAp
+pfow+y/EBZqa99MY2q6FU6FDA3Rpv0Sdk+/5PHdsSP6cgeMszFBUS0tCQEvEl83n
+FJUb0vjEX4x3J64XO/0DKXyCxFyF77OwHG2ZV5BeCpIhGXu+d/e221LJkGI2orKR
+kgsaUwrkS8HQt3Hd0gYpLI1Opx/JlRpB0VLYLzRGj7kDpbAcTj3SMEUp/FAZmlXR
+Iiebt73eE3rOWVFgyY9f
+-----END CERTIFICATE-----
diff --git a/tests/integration/test_keeper_internal_secure/configs/server.crt b/tests/integration/test_keeper_internal_secure/configs/server.crt
new file mode 100644
index 00000000000..dfa32da5444
--- /dev/null
+++ b/tests/integration/test_keeper_internal_secure/configs/server.crt
@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDETCCAfkCFHL+gKBQnU0P73/nrFrGaVPauTPmMA0GCSqGSIb3DQEBCwUAMEUx
+CzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRl
+cm5ldCBXaWRnaXRzIFB0eSBMdGQwHhcNMjEwNDEyMTE0NzI5WhcNMjEwNTEyMTE0
+NzI5WjBFMQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UE
+CgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOC
+AQ8AMIIBCgKCAQEA1iPeYn1Vy4QnQi6uNVqQnFLr0u3qdrMjGEBNAOuGmtIdhIn8
+rMCzaehNr3y2YTMRbZAqmv28P/wOXpzR1uQaFlQzTOjmsn/HOZ9JX2hv5sBUv7SU
+UiPJS7UtptKDPbLv3N/v1dOXbY+vVyzo8U1Q9OS1J5yhYW6KtxP++hfSrOsFu669
+d1pqWFWaNBsmf0zF+ETvi6lywhyTFA1/PazcStP5GntcDL7eDvGq+DDsRC40oRpy
+S4xRQRSteCTtGGmWpx+Jmt+90wFnLgruUbWT0veCoLxLvz0tJUk3ueUVnMkrxBQG
+Fz+IWm+SQppNU5LlAcBcu9wJfo3h34BXp0NFNQIDAQABMA0GCSqGSIb3DQEBCwUA
+A4IBAQCUnvQsv+GsPwGnIWqH9iiFVhgDx5QbSTW94Fyqk8dcIJBzWAiCshmLBWPJ
+pfy4y2nxJbzovFsd9DA49pxqqILeLjue99yma2DVKeo+XDLDN3OX5faIMTBd7AnL
+0MKqW7gUSLRUZrNOvFciAY8xRezgBQQBo4mcmmMbAbk5wKndGY6ZZOcY+JwXlqGB
+5hyi6ishO8ciiZi3GMFNWWk9ViSfo27IqjKdSkQq1pr3FULvepd6SkdX+NvfZTAH
+rG+CSoFGiJcOBbhDkvpY32cAJEnJOA1vHpFxfnGP8/1haeVZHqSwH1cySD78HVtF
+fBs000wGHzBYWNI2KkwjNtYf06P4
+-----END CERTIFICATE-----
diff --git a/tests/integration/test_keeper_internal_secure/configs/server.key b/tests/integration/test_keeper_internal_secure/configs/server.key
new file mode 100644
index 00000000000..7e57c8b6b34
--- /dev/null
+++ b/tests/integration/test_keeper_internal_secure/configs/server.key
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEA1iPeYn1Vy4QnQi6uNVqQnFLr0u3qdrMjGEBNAOuGmtIdhIn8
+rMCzaehNr3y2YTMRbZAqmv28P/wOXpzR1uQaFlQzTOjmsn/HOZ9JX2hv5sBUv7SU
+UiPJS7UtptKDPbLv3N/v1dOXbY+vVyzo8U1Q9OS1J5yhYW6KtxP++hfSrOsFu669
+d1pqWFWaNBsmf0zF+ETvi6lywhyTFA1/PazcStP5GntcDL7eDvGq+DDsRC40oRpy
+S4xRQRSteCTtGGmWpx+Jmt+90wFnLgruUbWT0veCoLxLvz0tJUk3ueUVnMkrxBQG
+Fz+IWm+SQppNU5LlAcBcu9wJfo3h34BXp0NFNQIDAQABAoIBAHYDso2o8V2F6XTp
+8QxqawQcFudaQztDonW9CjMVmks8vRPMUDqMwNP/OMEcBA8xa8tsBm8Ao3zH1suB
+tYuujkn8AYHDYVDCZvN0u6UfE3yiRpKYXJ2gJ1HX+d7UaYvZT6P0rmKzh+LTqxhq
+Ib7Kk3FDkirQgYgGueAH3x/JfUvaAGvFrq+HvvlhHOs7M7iFU4nJA8jNfBolpTnG
+v5MMI+f8/GHGreVICJUoclE+4V/4LDHUlrc3l1kQk0keeD6ECw/pl48TNL6ncXKu
+baez1rfKbMPjhLUy2q5UZa93oW+olchEOXs1nUNKUhIOOr0f0YweYhUHNTineVM9
+yTecMIkCgYEA7CFQMyeLVeBA6C9AHBe8Zf/k64cMPyr0lUz6548ulil580PNPbvW
+kd2vIKfUMgCO5lMA47ArL4bXZ7cjTvJmPYE1Yv8z+F0Tk03fnTrudHOSBEiGXAu3
+MPTxCDU7Se5Dwj0Fq81aFRtCHl8Rrss+WiBD8eRoxb/vwXKFc6VUAWMCgYEA6CjZ
+XrZz11lySBhjkyVXcdLj89hDZ+bPxA7b3VB7TfCxsn5xVck7U3TFkg5Z9XwEQ7Ob
+XFAPuwT9GKm7QPp6L8T2RltoJ3ys40UH1RtcNLz2aIo/xSP7lopPdAfWHef5r4y9
+kRw+Gh4NP/l5wefXsRz/D0jY3+t+QnwnhuCKbocCgYEAiR6bPOlkvzyXVH1DxEyA
+Sdb8b00f7nqaRyzJsrfxvJ9fQsWHpKa0ZkYOUW9ECLlMQjHHHXEK0vGBmqe9qDWY
+63RhtRgvbLVYDb018k7rc9I846Hd7AudmJ9UbIjE4hyrWlsnNOntur32ej6IvTEn
+Bx0fd5NEyDi6GGLRXiOOkbMCgYAressLE/yqDlR68CZl/o5cAPU0TAKDyRSMUYQX
+9OTC+hstpMSxHlkADlSaQBnVAf8CdvbX2R65FfwYzGEHkGGl5KuDDcd57b2rathG
+rzMbpXA4r/u1fkG2Nf0fbABL5ZA7so4mSTXQSmSM4LpO+I7K2vVh9XC4rzAcX4g/
+mHoUrQKBgBf3rxp5h9P3HWoZYjzBDo2FqXUjKLLjE9ed5e/VqecqfHIkmueuNHlN
+xifHr7lpsYu6IXkTnlK14pvLoPuwP59dCIOUYwAFz8RlH4MSUGNhYeGA8cqRrhmJ
+tYk3OKExuN/+O12kUPVTy6BMH1hBdRJP+7y7lapWsRhZt18y+8Za
+-----END RSA PRIVATE KEY-----
diff --git a/tests/integration/test_keeper_internal_secure/configs/ssl_conf.xml b/tests/integration/test_keeper_internal_secure/configs/ssl_conf.xml
new file mode 100644
index 00000000000..babc7cf0f18
--- /dev/null
+++ b/tests/integration/test_keeper_internal_secure/configs/ssl_conf.xml
@@ -0,0 +1,15 @@
+
+<yandex>
+    <openSSL>
+        <server>
+            <certificateFile>/etc/clickhouse-server/config.d/server.crt</certificateFile>
+            <privateKeyFile>/etc/clickhouse-server/config.d/server.key</privateKeyFile>
+            <caConfig>/etc/clickhouse-server/config.d/rootCA.pem</caConfig>
+            <loadDefaultCAFile>true</loadDefaultCAFile>
+            <verificationMode>none</verificationMode>
+            <cacheSessions>true</cacheSessions>
+            <disableProtocols>sslv2,sslv3</disableProtocols>
+            <preferServerCiphers>true</preferServerCiphers>
+        </server>
+    </openSSL>
+</yandex>
diff --git a/tests/integration/test_keeper_internal_secure/test.py b/tests/integration/test_keeper_internal_secure/test.py
new file mode 100644
index 00000000000..d9fbca624e1
--- /dev/null
+++ b/tests/integration/test_keeper_internal_secure/test.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+
+import pytest
+from helpers.cluster import ClickHouseCluster
+import random
+import string
+import os
+import time
+
+cluster = ClickHouseCluster(__file__)
+node1 = cluster.add_instance('node1', main_configs=['configs/enable_secure_keeper1.xml', 'configs/ssl_conf.xml', 'configs/server.crt', 'configs/server.key', 'configs/rootCA.pem'])
+node2 = cluster.add_instance('node2', main_configs=['configs/enable_secure_keeper2.xml', 'configs/ssl_conf.xml', 'configs/server.crt', 'configs/server.key', 'configs/rootCA.pem'])
+node3 = cluster.add_instance('node3', main_configs=['configs/enable_secure_keeper3.xml', 'configs/ssl_conf.xml', 'configs/server.crt', 'configs/server.key', 'configs/rootCA.pem'])
+
+from kazoo.client import KazooClient, KazooState
+
+@pytest.fixture(scope="module")
+def started_cluster():
+    try:
+        cluster.start()
+
+        yield cluster
+
+    finally:
+        cluster.shutdown()
+
+def get_fake_zk(nodename, timeout=30.0):
+    _fake_zk_instance = KazooClient(hosts=cluster.get_instance_ip(nodename) + ":9181", timeout=timeout)
+    def reset_listener(state):
+        nonlocal _fake_zk_instance
+        print("Fake zk callback called for state", state)
+        if state != KazooState.CONNECTED:
+            _fake_zk_instance._reset()
+
+    _fake_zk_instance.add_listener(reset_listener)
+    _fake_zk_instance.start()
+    return _fake_zk_instance
+
+def test_secure_raft_works(started_cluster):
+    try:
+        node1_zk = get_fake_zk("node1")
+        node2_zk = get_fake_zk("node2")
+        node3_zk = get_fake_zk("node3")
+
+        node1_zk.create("/test_node", b"somedata1")
+        node2_zk.sync("/test_node")
+        node3_zk.sync("/test_node")
+
+        assert node1_zk.exists("/test_node") is not None
+        assert node2_zk.exists("/test_node") is not None
+        assert node3_zk.exists("/test_node") is not None
+    finally:
+        try:
+            for zk_conn in [node1_zk, node2_zk, node3_zk]:
+                zk_conn.stop()
+                zk_conn.close()
+        except:
+            pass
diff --git a/tests/integration/test_keeper_secure_client/__init__.py b/tests/integration/test_keeper_secure_client/__init__.py
new file mode 100644
index 00000000000..e5a0d9b4834
--- /dev/null
+++ b/tests/integration/test_keeper_secure_client/__init__.py
@@ -0,0 +1 @@
+#!/usr/bin/env python3
diff --git a/tests/integration/test_keeper_secure_client/configs/dhparam.pem b/tests/integration/test_keeper_secure_client/configs/dhparam.pem
new file mode 100644
index 00000000000..2e6cee0798d
--- /dev/null
+++ b/tests/integration/test_keeper_secure_client/configs/dhparam.pem
@@ -0,0 +1,8 @@
+-----BEGIN DH PARAMETERS-----
+MIIBCAKCAQEAua92DDli13gJ+//ZXyGaggjIuidqB0crXfhUlsrBk9BV1hH3i7fR
+XGP9rUdk2ubnB3k2ejBStL5oBrkHm9SzUFSQHqfDjLZjKoUpOEmuDc4cHvX1XTR5
+Pr1vf5cd0yEncJWG5W4zyUB8k++SUdL2qaeslSs+f491HBLDYn/h8zCgRbBvxhxb
+9qeho1xcbnWeqkN6Kc9bgGozA16P9NLuuLttNnOblkH+lMBf42BSne/TWt3AlGZf
+slKmmZcySUhF8aKfJnLKbkBCFqOtFRh8zBA9a7g+BT/lSANATCDPaAk1YVih2EKb
+dpc3briTDbRsiqg2JKMI7+VdULY9bh3EawIBAg==
+-----END DH PARAMETERS-----
diff --git a/tests/integration/test_keeper_secure_client/configs/enable_secure_keeper.xml b/tests/integration/test_keeper_secure_client/configs/enable_secure_keeper.xml
new file mode 100644
index 00000000000..af815f4a3bc
--- /dev/null
+++ b/tests/integration/test_keeper_secure_client/configs/enable_secure_keeper.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<yandex>
+    <keeper_server>
+        <tcp_port_secure>10181</tcp_port_secure>
+        <server_id>1</server_id>
+        <log_storage_path>/var/lib/clickhouse/coordination/log</log_storage_path>
+        <snapshot_storage_path>/var/lib/clickhouse/coordination/snapshots</snapshot_storage_path>
+
+        <coordination_settings>
+            <operation_timeout_ms>10000</operation_timeout_ms>
+            <session_timeout_ms>30000</session_timeout_ms>
+            <raft_logs_level>trace</raft_logs_level>
+            <force_sync>false</force_sync>
+        </coordination_settings>
+
+        <raft_configuration>
+            <server>
+                <id>1</id>
+                <hostname>localhost</hostname>
+                <port>44444</port>
+            </server>
+        </raft_configuration>
+    </keeper_server>
+</yandex>
diff --git a/tests/integration/test_keeper_secure_client/configs/server.crt b/tests/integration/test_keeper_secure_client/configs/server.crt
new file mode 100644
index 00000000000..7ade2d96273
--- /dev/null
+++ b/tests/integration/test_keeper_secure_client/configs/server.crt
@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIC/TCCAeWgAwIBAgIJANjx1QSR77HBMA0GCSqGSIb3DQEBCwUAMBQxEjAQBgNV
+BAMMCWxvY2FsaG9zdDAgFw0xODA3MzAxODE2MDhaGA8yMjkyMDUxNDE4MTYwOFow
+FDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEAs9uSo6lJG8o8pw0fbVGVu0tPOljSWcVSXH9uiJBwlZLQnhN4SFSFohfI
+4K8U1tBDTnxPLUo/V1K9yzoLiRDGMkwVj6+4+hE2udS2ePTQv5oaMeJ9wrs+5c9T
+4pOtlq3pLAdm04ZMB1nbrEysceVudHRkQbGHzHp6VG29Fw7Ga6YpqyHQihRmEkTU
+7UCYNA+Vk7aDPdMS/khweyTpXYZimaK9f0ECU3/VOeG3fH6Sp2X6FN4tUj/aFXEj
+sRmU5G2TlYiSIUMF2JPdhSihfk1hJVALrHPTU38SOL+GyyBRWdNcrIwVwbpvsvPg
+pryMSNxnpr0AK0dFhjwnupIv5hJIOQIDAQABo1AwTjAdBgNVHQ4EFgQUjPLb3uYC
+kcamyZHK4/EV8jAP0wQwHwYDVR0jBBgwFoAUjPLb3uYCkcamyZHK4/EV8jAP0wQw
+DAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAM/ocuDvfPus/KpMVD51j
+4IdlU8R0vmnYLQ+ygzOAo7+hUWP5j0yvq4ILWNmQX6HNvUggCgFv9bjwDFhb/5Vr
+85ieWfTd9+LTjrOzTw4avdGwpX9G+6jJJSSq15tw5ElOIFb/qNA9O4dBiu8vn03C
+L/zRSXrARhSqTW5w/tZkUcSTT+M5h28+Lgn9ysx4Ff5vi44LJ1NnrbJbEAIYsAAD
++UA+4MBFKx1r6hHINULev8+lCfkpwIaeS8RL+op4fr6kQPxnULw8wT8gkuc8I4+L
+P9gg/xDHB44T3ADGZ5Ib6O0DJaNiToO6rnoaaxs0KkotbvDWvRoxEytSbXKoYjYp
+0g==
+-----END CERTIFICATE-----
diff --git a/tests/integration/test_keeper_secure_client/configs/server.key b/tests/integration/test_keeper_secure_client/configs/server.key
new file mode 100644
index 00000000000..f0fb61ac443
--- /dev/null
+++ b/tests/integration/test_keeper_secure_client/configs/server.key
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCz25KjqUkbyjyn
+DR9tUZW7S086WNJZxVJcf26IkHCVktCeE3hIVIWiF8jgrxTW0ENOfE8tSj9XUr3L
+OguJEMYyTBWPr7j6ETa51LZ49NC/mhox4n3Cuz7lz1Pik62WreksB2bThkwHWdus
+TKxx5W50dGRBsYfMenpUbb0XDsZrpimrIdCKFGYSRNTtQJg0D5WTtoM90xL+SHB7
+JOldhmKZor1/QQJTf9U54bd8fpKnZfoU3i1SP9oVcSOxGZTkbZOViJIhQwXYk92F
+KKF+TWElUAusc9NTfxI4v4bLIFFZ01ysjBXBum+y8+CmvIxI3GemvQArR0WGPCe6
+ki/mEkg5AgMBAAECggEATrbIBIxwDJOD2/BoUqWkDCY3dGevF8697vFuZKIiQ7PP
+TX9j4vPq0DfsmDjHvAPFkTHiTQXzlroFik3LAp+uvhCCVzImmHq0IrwvZ9xtB43f
+7Pkc5P6h1l3Ybo8HJ6zRIY3TuLtLxuPSuiOMTQSGRL0zq3SQ5DKuGwkz+kVjHXUN
+MR2TECFwMHKQ5VLrC+7PMpsJYyOMlDAWhRfUalxC55xOXTpaN8TxNnwQ8K2ISVY5
+212Jz/a4hn4LdwxSz3Tiu95PN072K87HLWx3EdT6vW4Ge5P/A3y+smIuNAlanMnu
+plHBRtpATLiTxZt/n6npyrfQVbYjSH7KWhB8hBHtaQKBgQDh9Cq1c/KtqDtE0Ccr
+/r9tZNTUwBE6VP+3OJeKdEdtsfuxjOCkS1oAjgBJiSDOiWPh1DdoDeVZjPKq6pIu
+Mq12OE3Doa8znfCXGbkSzEKOb2unKZMJxzrz99kXt40W5DtrqKPNb24CNqTiY8Aa
+CjtcX+3weat82VRXvph6U8ltMwKBgQDLxjiQQzNoY7qvg7CwJCjf9qq8jmLK766g
+1FHXopqS+dTxDLM8eJSRrpmxGWJvNeNc1uPhsKsKgotqAMdBUQTf7rSTbt4MyoH5
+bUcRLtr+0QTK9hDWMOOvleqNXha68vATkohWYfCueNsC60qD44o8RZAS6UNy3ENq
+cM1cxqe84wKBgQDKkHutWnooJtajlTxY27O/nZKT/HA1bDgniMuKaz4R4Gr1PIez
+on3YW3V0d0P7BP6PWRIm7bY79vkiMtLEKdiKUGWeyZdo3eHvhDb/3DCawtau8L2K
+GZsHVp2//mS1Lfz7Qh8/L/NedqCQ+L4iWiPnZ3THjjwn3CoZ05ucpvrAMwKBgB54
+nay039MUVq44Owub3KDg+dcIU62U+cAC/9oG7qZbxYPmKkc4oL7IJSNecGHA5SbU
+2268RFdl/gLz6tfRjbEOuOHzCjFPdvAdbysanpTMHLNc6FefJ+zxtgk9sJh0C4Jh
+vxFrw9nTKKzfEl12gQ1SOaEaUIO0fEBGbe8ZpauRAoGAMAlGV+2/K4ebvAJKOVTa
+dKAzQ+TD2SJmeR1HZmKDYddNqwtZlzg3v4ZhCk4eaUmGeC1Bdh8MDuB3QQvXz4Dr
+vOIP4UVaOr+uM+7TgAgVnP4/K6IeJGzUDhX93pmpWhODfdu/oojEKVcpCojmEmS1
+KCBtmIrQLqzMpnBpLNuSY+Q=
+-----END PRIVATE KEY-----
diff --git a/tests/integration/test_keeper_secure_client/configs/ssl_conf.xml b/tests/integration/test_keeper_secure_client/configs/ssl_conf.xml
new file mode 100644
index 00000000000..7ca51acde22
--- /dev/null
+++ b/tests/integration/test_keeper_secure_client/configs/ssl_conf.xml
@@ -0,0 +1,26 @@
+<yandex>
+    <openSSL>
+        <server>
+            <certificateFile>/etc/clickhouse-server/config.d/server.crt</certificateFile>
+            <privateKeyFile>/etc/clickhouse-server/config.d/server.key</privateKeyFile>
+            <dhParamsFile>/etc/clickhouse-server/config.d/dhparam.pem</dhParamsFile>
+            <verificationMode>none</verificationMode>
+            <loadDefaultCAFile>true</loadDefaultCAFile>
+            <cacheSessions>true</cacheSessions>
+            <disableProtocols>sslv2,sslv3</disableProtocols>
+            <preferServerCiphers>true</preferServerCiphers>
+        </server>
+        <client>
+            <certificateFile>/etc/clickhouse-server/config.d/server.crt</certificateFile>
+            <privateKeyFile>/etc/clickhouse-server/config.d/server.key</privateKeyFile>
+            <loadDefaultCAFile>true</loadDefaultCAFile>
+            <cacheSessions>true</cacheSessions>
+            <disableProtocols>sslv2,sslv3</disableProtocols>
+            <preferServerCiphers>true</preferServerCiphers>
+            <verificationMode>none</verificationMode>
+            <invalidCertificateHandler>
+                <name>RejectCertificateHandler</name>
+            </invalidCertificateHandler>
+        </client>
+    </openSSL>
+</yandex>
diff --git a/tests/integration/test_keeper_secure_client/configs/use_secure_keeper.xml b/tests/integration/test_keeper_secure_client/configs/use_secure_keeper.xml
new file mode 100644
index 00000000000..a0d19300022
--- /dev/null
+++ b/tests/integration/test_keeper_secure_client/configs/use_secure_keeper.xml
@@ -0,0 +1,9 @@
+<yandex>
+    <zookeeper>
+        <node index="1">
+            <host>node1</host>
+            <port>10181</port>
+            <secure>1</secure>
+        </node>
+    </zookeeper>
+</yandex>
diff --git a/tests/integration/test_keeper_secure_client/test.py b/tests/integration/test_keeper_secure_client/test.py
new file mode 100644
index 00000000000..fe03ed8dcf8
--- /dev/null
+++ b/tests/integration/test_keeper_secure_client/test.py
@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+import pytest
+from helpers.cluster import ClickHouseCluster
+import string
+import os
+import time
+
+cluster = ClickHouseCluster(__file__)
+node1 = cluster.add_instance('node1', main_configs=['configs/enable_secure_keeper.xml', 'configs/ssl_conf.xml', "configs/dhparam.pem", "configs/server.crt", "configs/server.key"])
+node2 = cluster.add_instance('node2', main_configs=['configs/use_secure_keeper.xml', 'configs/ssl_conf.xml', "configs/server.crt", "configs/server.key"])
+
+
+@pytest.fixture(scope="module")
+def started_cluster():
+    try:
+        cluster.start()
+
+        yield cluster
+
+    finally:
+        cluster.shutdown()
+
+
+def test_connection(started_cluster):
+    # just nothrow
+    node2.query("SELECT * FROM system.zookeeper WHERE path = '/'")
diff --git a/tests/integration/test_library_bridge/__init__.py b/tests/integration/test_library_bridge/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/integration/test_library_bridge/configs/config.d/config.xml b/tests/integration/test_library_bridge/configs/config.d/config.xml
new file mode 100644
index 00000000000..9bea75fbb6f
--- /dev/null
+++ b/tests/integration/test_library_bridge/configs/config.d/config.xml
@@ -0,0 +1,12 @@
+<yandex>
+    <dictionaries_lib_path>/etc/clickhouse-server/config.d/dictionaries_lib</dictionaries_lib_path>
+    <logger>
+        <level>trace</level>
+        <log>/var/log/clickhouse-server/log.log</log>
+        <errorlog>/var/log/clickhouse-server/log.err.log</errorlog>
+        <size>1000M</size>
+        <count>10</count>
+        <stderr>/var/log/clickhouse-server/stderr.log</stderr>
+        <stdout>/var/log/clickhouse-server/stdout.log</stdout>
+    </logger>
+</yandex>
diff --git a/tests/integration/test_library_bridge/configs/dict_lib.cpp b/tests/integration/test_library_bridge/configs/dict_lib.cpp
new file mode 100644
index 00000000000..be25804ed64
--- /dev/null
+++ b/tests/integration/test_library_bridge/configs/dict_lib.cpp
@@ -0,0 +1,298 @@
+/// c++ sample dictionary library
+
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <vector>
+
+namespace ClickHouseLibrary
+{
+using CString = const char *;
+using ColumnName = CString;
+using ColumnNames = ColumnName[];
+
+struct CStrings
+{
+    CString * data = nullptr;
+    uint64_t size = 0;
+};
+
+struct VectorUInt64
+{
+    const uint64_t * data = nullptr;
+    uint64_t size = 0;
+};
+
+struct ColumnsUInt64
+{
+    VectorUInt64 * data = nullptr;
+    uint64_t size = 0;
+};
+
+struct Field
+{
+    const void * data = nullptr;
+    uint64_t size = 0;
+};
+
+struct Row
+{
+    const Field * data = nullptr;
+    uint64_t size = 0;
+};
+
+struct Table
+{
+    const Row * data = nullptr;
+    uint64_t size = 0;
+    uint64_t error_code = 0; // 0 = ok; !0 = error, with message in error_string
+    const char * error_string = nullptr;
+};
+
+enum LogLevel
+{
+    FATAL = 1,
+    CRITICAL,
+    ERROR,
+    WARNING,
+    NOTICE,
+    INFORMATION,
+    DEBUG,
+    TRACE,
+};
+
+void log(LogLevel level, CString msg);
+}
+
+
+#define LOG(logger, message)                                             \
+    do                                                                   \
+    {                                                                    \
+        std::stringstream builder;                                       \
+        builder << message;                                              \
+        (logger)(ClickHouseLibrary::INFORMATION, builder.str().c_str()); \
+    } while (false)
+
+
+struct LibHolder
+{
+    std::function<void(ClickHouseLibrary::LogLevel, ClickHouseLibrary::CString)> log;
+};
+
+
+struct DataHolder
+{
+    std::vector<std::vector<uint64_t>> dataHolder; // Actual data storage
+    std::vector<std::vector<ClickHouseLibrary::Field>> fieldHolder; // Pointers and sizes of data
+    std::unique_ptr<ClickHouseLibrary::Row[]> rowHolder;
+    ClickHouseLibrary::Table ctable; // Result data prepared for transfer via c-style interface
+    LibHolder * lib = nullptr;
+
+    size_t num_rows;
+    size_t num_cols;
+};
+
+
+template <typename T>
+void MakeColumnsFromVector(T * ptr)
+{
+    if (ptr->dataHolder.empty())
+    {
+        LOG(ptr->lib->log, "generating null values, cols: " << ptr->num_cols);
+        std::vector<ClickHouseLibrary::Field> fields;
+        for (size_t i = 0; i < ptr->num_cols; ++i)
+            fields.push_back({nullptr, 0});
+        ptr->fieldHolder.push_back(fields);
+    }
+    else
+    {
+        for (const auto & row : ptr->dataHolder)
+        {
+            std::vector<ClickHouseLibrary::Field> fields;
+            for (const auto & field : row)
+                fields.push_back({&field, sizeof(field)});
+            ptr->fieldHolder.push_back(fields);
+        }
+    }
+
+    const auto rows_num = ptr->fieldHolder.size();
+    ptr->rowHolder = std::make_unique<ClickHouseLibrary::Row[]>(rows_num);
+    size_t i = 0;
+    for (auto & row : ptr->fieldHolder)
+    {
+        ptr->rowHolder[i].size = row.size();
+        ptr->rowHolder[i].data = row.data();
+        ++i;
+    }
+    ptr->ctable.size = rows_num;
+    ptr->ctable.data = ptr->rowHolder.get();
+}
+
+
+extern "C"
+{
+
+void * ClickHouseDictionary_v3_loadIds(void * data_ptr,
+    ClickHouseLibrary::CStrings * settings,
+    ClickHouseLibrary::CStrings * columns,
+    const struct ClickHouseLibrary::VectorUInt64 * ids)
+{
+    auto ptr = static_cast<DataHolder *>(data_ptr);
+
+    if (ids)
+        LOG(ptr->lib->log, "loadIds lib call ptr=" << data_ptr << " => " << ptr << " size=" << ids->size);
+
+    if (!ptr)
+        return nullptr;
+
+    if (settings)
+    {
+        LOG(ptr->lib->log, "settings passed: " << settings->size);
+        for (size_t i = 0; i < settings->size; ++i)
+        {
+            LOG(ptr->lib->log, "setting " << i << " :" << settings->data[i]);
+        }
+    }
+
+    if (columns)
+    {
+        LOG(ptr->lib->log, "columns passed:" << columns->size);
+        for (size_t i = 0; i < columns->size; ++i)
+        {
+            LOG(ptr->lib->log, "column " << i << " :" << columns->data[i]);
+        }
+    }
+
+    if (ids)
+    {
+        LOG(ptr->lib->log, "ids passed: " << ids->size);
+        for (size_t i = 0; i < ids->size; ++i)
+        {
+            LOG(ptr->lib->log, "id " << i << " :" << ids->data[i] << " generating.");
+            ptr->dataHolder.emplace_back(std::vector<uint64_t>{ids->data[i], ids->data[i] + 100, ids->data[i] + 200, ids->data[i] + 300});
+        }
+    }
+
+    MakeColumnsFromVector(ptr);
+    return static_cast<void *>(&ptr->ctable);
+}
+
+
+void * ClickHouseDictionary_v3_loadAll(void * data_ptr, ClickHouseLibrary::CStrings * settings, ClickHouseLibrary::CStrings * /*columns*/)
+{
+    auto ptr = static_cast<DataHolder *>(data_ptr);
+
+    LOG(ptr->lib->log, "loadAll lib call ptr=" << data_ptr << " => " << ptr);
+
+    if (!ptr)
+        return nullptr;
+
+    size_t num_rows = 0, num_cols = 4;
+    std::string test_type;
+    std::vector<std::string> settings_values;
+    if (settings)
+    {
+        LOG(ptr->lib->log, "settings size: " << settings->size);
+
+        for (size_t i = 0; i < settings->size; ++i)
+        {
+            std::string setting_name = settings->data[i];
+            std::string setting_value = settings->data[++i];
+            LOG(ptr->lib->log, "setting " + std::to_string(i) + " name " + setting_name + " value " + setting_value);
+
+            if (setting_name == "num_rows")
+                num_rows = std::atoi(setting_value.data());
+            else if (setting_name == "num_cols")
+                num_cols = std::atoi(setting_value.data());
+            else if (setting_name == "test_type")
+                test_type = setting_value;
+            else
+            {
+                LOG(ptr->lib->log, "Adding setting " + setting_name);
+                settings_values.push_back(setting_value);
+            }
+        }
+    }
+
+    if (test_type == "test_simple")
+    {
+        for (size_t i = 0; i < 10; ++i)
+        {
+            LOG(ptr->lib->log, "id " << i << " :" << " generating.");
+            ptr->dataHolder.emplace_back(std::vector<uint64_t>{i, i + 10, i + 20, i + 30});
+        }
+    }
+    else if (test_type == "test_many_rows" && num_rows)
+    {
+        for (size_t i = 0; i < num_rows; ++i)
+        {
+            ptr->dataHolder.emplace_back(std::vector<uint64_t>{i, i, i, i});
+        }
+    }
+
+    ptr->num_cols = num_cols;
+    ptr->num_rows = num_rows;
+
+    MakeColumnsFromVector(ptr);
+    return static_cast<void *>(&ptr->ctable);
+}
+
+
+void * ClickHouseDictionary_v3_loadKeys(void * data_ptr, ClickHouseLibrary::CStrings * settings, ClickHouseLibrary::Table * requested_keys)
+{
+    auto ptr = static_cast<DataHolder *>(data_ptr);
+    LOG(ptr->lib->log, "loadKeys lib call ptr=" << data_ptr << " => " << ptr);
+    if (settings)
+    {
+        LOG(ptr->lib->log, "settings passed: " << settings->size);
+        for (size_t i = 0; i < settings->size; ++i)
+        {
+            LOG(ptr->lib->log, "setting " << i << " :" << settings->data[i]);
+        }
+    }
+    if (requested_keys)
+    {
+        LOG(ptr->lib->log, "requested_keys columns passed: " << requested_keys->size);
+        for (size_t i = 0; i < requested_keys->size; ++i)
+        {
+            LOG(ptr->lib->log, "requested_keys at column " << i << " passed: " << requested_keys->data[i].size);
+            ptr->dataHolder.emplace_back(std::vector<uint64_t>{i, i + 100, i + 200, i + 300});
+        }
+    }
+
+    MakeColumnsFromVector(ptr);
+    return static_cast<void *>(&ptr->ctable);
+}
+
+void * ClickHouseDictionary_v3_libNew(
+    ClickHouseLibrary::CStrings * /*settings*/, void (*logFunc)(ClickHouseLibrary::LogLevel, ClickHouseLibrary::CString))
+{
+    auto lib_ptr = new LibHolder;
+    lib_ptr->log = logFunc;
+    return lib_ptr;
+}
+
+void ClickHouseDictionary_v3_libDelete(void * lib_ptr)
+{
+    auto ptr = static_cast<LibHolder *>(lib_ptr);
+    delete ptr;
+    return;
+}
+
+void * ClickHouseDictionary_v3_dataNew(void * lib_ptr)
+{
+    auto data_ptr = new DataHolder;
+    data_ptr->lib = static_cast<decltype(data_ptr->lib)>(lib_ptr);
+    return data_ptr;
+}
+
+void ClickHouseDictionary_v3_dataDelete(void * /*lib_ptr*/, void * data_ptr)
+{
+    auto ptr = static_cast<DataHolder *>(data_ptr);
+    delete ptr;
+    return;
+}
+
+}
diff --git a/tests/integration/test_library_bridge/configs/dictionaries/dict1.xml b/tests/integration/test_library_bridge/configs/dictionaries/dict1.xml
new file mode 100644
index 00000000000..9be21aea1e3
--- /dev/null
+++ b/tests/integration/test_library_bridge/configs/dictionaries/dict1.xml
@@ -0,0 +1,86 @@
+<?xml version="1.0"?>
+<yandex>
+    <dictionary>
+        <name>dict1</name>
+        <source>
+            <library>
+                <path>/etc/clickhouse-server/config.d/dictionaries_lib/dict_lib.so</path>
+                <settings>
+                    <test_type>test_simple</test_type>
+                    <key>nice key</key>
+                    <value>interesting, nice value</value>
+                    <table>//home/interesting-path/to-/interesting_data</table>
+                    <pass>11</pass>
+                    <user>user-u -user</user>
+                </settings>
+            </library>
+        </source>
+        <layout>
+            <hashed/>
+        </layout>
+        <lifetime>
+            <max>1</max>
+            <min>1</min>
+        </lifetime>
+        <structure>
+            <id>
+                <name>key</name>
+                <type>UInt64</type>
+            </id>
+            <attribute>
+                <name>value1</name>
+                <null_value></null_value>
+                <type>UInt64</type>
+            </attribute>
+            <attribute>
+                <name>value2</name>
+                <null_value></null_value>
+                <type>UInt64</type>
+            </attribute>
+            <attribute>
+                <name>value3</name>
+                <null_value></null_value>
+                <type>UInt64</type>
+            </attribute>
+        </structure>
+    </dictionary>
+    <dictionary>
+        <name>dict2</name>
+        <source>
+            <library>
+                <path>/etc/clickhouse-server/config.d/dictionaries_lib/dict_lib.so</path>
+                <settings>
+                    <test_type>test_nulls</test_type>
+                </settings>
+            </library>
+        </source>
+        <layout>
+            <hashed/>
+        </layout>
+        <lifetime>
+            <max>1</max>
+            <min>1</min>
+        </lifetime>
+        <structure>
+            <id>
+                <name>key</name>
+                <type>UInt64</type>
+            </id>
+            <attribute>
+                <name>value1</name>
+                <null_value>12</null_value>
+                <type>UInt64</type>
+            </attribute>
+            <attribute>
+                <name>value2</name>
+                <null_value>12</null_value>
+                <type>UInt64</type>
+            </attribute>
+            <attribute>
+                <name>value3</name>
+                <null_value>12</null_value>
+                <type>UInt64</type>
+            </attribute>
+        </structure>
+    </dictionary>
+</yandex>
diff --git a/tests/integration/test_library_bridge/configs/enable_dict.xml b/tests/integration/test_library_bridge/configs/enable_dict.xml
new file mode 100644
index 00000000000..264f1f667b1
--- /dev/null
+++ b/tests/integration/test_library_bridge/configs/enable_dict.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0"?>
+<yandex>
+    <dictionaries_config>/etc/clickhouse-server/config.d/dict*.xml</dictionaries_config>
+</yandex>
diff --git a/tests/integration/test_library_bridge/configs/log_conf.xml b/tests/integration/test_library_bridge/configs/log_conf.xml
new file mode 100644
index 00000000000..eed7a435b68
--- /dev/null
+++ b/tests/integration/test_library_bridge/configs/log_conf.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0"?>
+<yandex>
+    <logger>
+        <level>trace</level>
+        <log>/var/log/clickhouse-server/log.log</log>
+        <errorlog>/var/log/clickhouse-server/log.err.log</errorlog>
+        <size>1000M</size>
+        <count>10</count>
+        <stderr>/var/log/clickhouse-server/stderr.log</stderr>
+        <stdout>/var/log/clickhouse-server/stdout.log</stdout>
+        <library_bridge_log>/var/log/clickhouse-server/clickhouse-library-bridge.log</library_bridge_log>
+        <library_bridge_errlog>/var/log/clickhouse-server/clickhouse-library-bridge.err.log</library_bridge_errlog>
+        <library_bridge_stdout>/var/log/clickhouse-server/clickhouse-library-bridge.stdout</library_bridge_stdout>
+        <library_bridge_stderr>/var/log/clickhouse-server/clickhouse-library-bridge.stderr</library_bridge_stderr>
+        <library_bridge_level>trace</library_bridge_level>
+    </logger>
+</yandex>
diff --git a/tests/integration/test_library_bridge/test.py b/tests/integration/test_library_bridge/test.py
new file mode 100644
index 00000000000..f0aeb85a52b
--- /dev/null
+++ b/tests/integration/test_library_bridge/test.py
@@ -0,0 +1,154 @@
+import os
+import os.path as p
+import pytest
+import time
+
+from helpers.cluster import ClickHouseCluster, run_and_check
+
+cluster = ClickHouseCluster(__file__)
+
+instance = cluster.add_instance('instance',
+        main_configs=[
+            'configs/enable_dict.xml',
+            'configs/config.d/config.xml',
+            'configs/dictionaries/dict1.xml',
+            'configs/log_conf.xml'])
+
+@pytest.fixture(scope="module")
+def ch_cluster():
+    try:
+        cluster.start()
+        instance.query('CREATE DATABASE test')
+        container_lib_path = '/etc/clickhouse-server/config.d/dictionarites_lib/dict_lib.cpp'
+
+        instance.copy_file_to_container(os.path.join(os.path.dirname(os.path.realpath(__file__)), "configs/dict_lib.cpp"),
+                                                        "/etc/clickhouse-server/config.d/dictionaries_lib/dict_lib.cpp")
+
+        instance.query("SYSTEM RELOAD CONFIG")
+
+        instance.exec_in_container(
+                ['bash', '-c',
+                '/usr/bin/g++ -shared -o /etc/clickhouse-server/config.d/dictionaries_lib/dict_lib.so -fPIC /etc/clickhouse-server/config.d/dictionaries_lib/dict_lib.cpp'],
+                user='root')
+
+        yield cluster
+
+    finally:
+        cluster.shutdown()
+
+
+@pytest.fixture(autouse=True)
+def setup_teardown():
+    yield  # run test
+
+
+def test_load_all(ch_cluster):
+    instance.query('''
+        CREATE DICTIONARY lib_dict (key UInt64, value1 UInt64, value2 UInt64, value3 UInt64)
+        PRIMARY KEY key
+        SOURCE(library(
+            PATH '/etc/clickhouse-server/config.d/dictionaries_lib/dict_lib.so'
+            SETTINGS (test_type test_simple)))
+        LAYOUT(HASHED())
+        LIFETIME (MIN 0 MAX 10)
+    ''')
+
+    result = instance.query('SELECT * FROM lib_dict ORDER BY key')
+    expected = (
+"0\t10\t20\t30\n" +
+"1\t11\t21\t31\n" +
+"2\t12\t22\t32\n" +
+"3\t13\t23\t33\n" +
+"4\t14\t24\t34\n" +
+"5\t15\t25\t35\n" +
+"6\t16\t26\t36\n" +
+"7\t17\t27\t37\n" +
+"8\t18\t28\t38\n" +
+"9\t19\t29\t39\n"
+)
+    instance.query('SYSTEM RELOAD DICTIONARY dict1')
+    instance.query('DROP DICTIONARY lib_dict')
+    assert(result == expected)
+
+    instance.query("""
+        CREATE TABLE IF NOT EXISTS `dict1_table` (
+             key UInt64, value1 UInt64, value2 UInt64, value3 UInt64
+        ) ENGINE = Dictionary(dict1)
+        """)
+
+    result = instance.query('SELECT * FROM dict1_table ORDER BY key')
+    assert(result == expected)
+
+
+def test_load_ids(ch_cluster):
+    instance.query('''
+        CREATE DICTIONARY lib_dict_c (key UInt64, value1 UInt64, value2 UInt64, value3 UInt64)
+        PRIMARY KEY key SOURCE(library(PATH '/etc/clickhouse-server/config.d/dictionaries_lib/dict_lib.so'))
+        LAYOUT(CACHE(
+        SIZE_IN_CELLS 10000000
+        BLOCK_SIZE 4096
+        FILE_SIZE 16777216
+        READ_BUFFER_SIZE 1048576
+        MAX_STORED_KEYS 1048576))
+        LIFETIME(2) ;
+    ''')
+
+    result = instance.query('''select dictGet(lib_dict_c, 'value1', toUInt64(0));''')
+    assert(result.strip() == '100')
+    result = instance.query('''select dictGet(lib_dict_c, 'value1', toUInt64(1));''')
+    assert(result.strip() == '101')
+    instance.query('DROP DICTIONARY lib_dict_c')
+
+
+def test_load_keys(ch_cluster):
+    instance.query('''
+        CREATE DICTIONARY lib_dict_ckc (key UInt64, value1 UInt64, value2 UInt64, value3 UInt64)
+        PRIMARY KEY key
+        SOURCE(library(PATH '/etc/clickhouse-server/config.d/dictionaries_lib/dict_lib.so'))
+        LAYOUT(COMPLEX_KEY_CACHE( SIZE_IN_CELLS 10000000))
+        LIFETIME(2);
+    ''')
+
+    result = instance.query('''select dictGet(lib_dict_ckc, 'value1', tuple(toUInt64(0)));''')
+    assert(result.strip() == '100')
+    result = instance.query('''select dictGet(lib_dict_ckc, 'value2', tuple(toUInt64(0)));''')
+    assert(result.strip() == '200')
+    instance.query('DROP DICTIONARY lib_dict_ckc')
+
+
+def test_load_all_many_rows(ch_cluster):
+    num_rows = [1000, 10000, 100000, 1000000]
+    for num in num_rows:
+        instance.query('''
+            CREATE DICTIONARY lib_dict (key UInt64, value1 UInt64, value2 UInt64, value3 UInt64)
+            PRIMARY KEY key
+            SOURCE(library(
+                PATH '/etc/clickhouse-server/config.d/dictionaries_lib/dict_lib.so'
+                SETTINGS (num_rows {} test_type test_many_rows)))
+            LAYOUT(HASHED())
+            LIFETIME (MIN 0 MAX 10)
+        '''.format(num))
+
+        result = instance.query('SELECT * FROM lib_dict ORDER BY key')
+        expected = instance.query('SELECT number, number, number, number FROM numbers({})'.format(num))
+        instance.query('DROP DICTIONARY lib_dict')
+        assert(result == expected)
+
+
+def test_null_values(ch_cluster):
+    instance.query('SYSTEM RELOAD DICTIONARY dict2')
+    instance.query("""
+        CREATE TABLE IF NOT EXISTS `dict2_table` (
+             key UInt64, value1 UInt64, value2 UInt64, value3 UInt64
+        ) ENGINE = Dictionary(dict2)
+        """)
+
+    result = instance.query('SELECT * FROM dict2_table ORDER BY key')
+    expected = "0\t12\t12\t12\n"
+    assert(result == expected)
+
+
+if __name__ == '__main__':
+    cluster.start()
+    input("Cluster created, press any key to destroy...")
+    cluster.shutdown()
diff --git a/tests/integration/test_limited_replicated_fetches/configs/custom_settings.xml b/tests/integration/test_limited_replicated_fetches/configs/custom_settings.xml
new file mode 100644
index 00000000000..b5e6bb80891
--- /dev/null
+++ b/tests/integration/test_limited_replicated_fetches/configs/custom_settings.xml
@@ -0,0 +1,7 @@
+<yandex>
+    <profiles>
+        <default>
+            <background_fetches_pool_size>3</background_fetches_pool_size>
+        </default>
+    </profiles>
+</yandex>
diff --git a/tests/integration/test_limited_replicated_fetches/test.py b/tests/integration/test_limited_replicated_fetches/test.py
index 9b9b8befd67..7b0c7aed15d 100644
--- a/tests/integration/test_limited_replicated_fetches/test.py
+++ b/tests/integration/test_limited_replicated_fetches/test.py
@@ -6,12 +6,14 @@ from helpers.cluster import ClickHouseCluster
 from helpers.network import PartitionManager
 import random
 import string
+import os
 
 cluster = ClickHouseCluster(__file__)
-node1 = cluster.add_instance('node1', with_zookeeper=True)
-node2 = cluster.add_instance('node2', with_zookeeper=True)
+SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
+node1 = cluster.add_instance('node1', user_configs=['configs/custom_settings.xml'], with_zookeeper=True)
+node2 = cluster.add_instance('node2', user_configs=['configs/custom_settings.xml'], with_zookeeper=True)
 
-DEFAULT_MAX_THREADS_FOR_FETCH = 3
+MAX_THREADS_FOR_FETCH = 3
 
 @pytest.fixture(scope="module")
 def started_cluster():
@@ -64,11 +66,11 @@ def test_limited_fetches(started_cluster):
                 time.sleep(0.1)
 
     for concurrently_fetching_parts in fetches_result:
-        if len(concurrently_fetching_parts) > DEFAULT_MAX_THREADS_FOR_FETCH:
-            assert False, "Found more than {} concurrently fetching parts: {}".format(DEFAULT_MAX_THREADS_FOR_FETCH, ', '.join(concurrently_fetching_parts))
+        if len(concurrently_fetching_parts) > MAX_THREADS_FOR_FETCH:
+            assert False, "Found more than {} concurrently fetching parts: {}".format(MAX_THREADS_FOR_FETCH, ', '.join(concurrently_fetching_parts))
 
     assert max([len(parts) for parts in fetches_result]) == 3, "Strange, but we don't utilize max concurrent threads for fetches"
     assert(max(background_fetches_metric)) == 3, "Just checking metric consistent with table"
 
     node1.query("DROP TABLE IF EXISTS t SYNC")
-    node2.query("DROP TABLE IF EXISTS t SYNC")
\ No newline at end of file
+    node2.query("DROP TABLE IF EXISTS t SYNC")
diff --git a/tests/integration/test_mysql_protocol/test.py b/tests/integration/test_mysql_protocol/test.py
index 7f7d59674bc..43daeebeaf5 100644
--- a/tests/integration/test_mysql_protocol/test.py
+++ b/tests/integration/test_mysql_protocol/test.py
@@ -149,8 +149,8 @@ def test_mysql_client_exception(mysql_client, server_address):
         -e "CREATE TABLE default.t1_remote_mysql AS mysql('127.0.0.1:10086','default','t1_local','default','');"
     '''.format(host=server_address, port=server_port), demux=True)
 
-    assert stderr[0:266].decode() == "mysql: [Warning] Using a password on the command line interface can be insecure.\n" \
-                            "ERROR 1000 (00000) at line 1: Poco::Exception. Code: 1000, e.code() = 2002, e.displayText() = mysqlxx::ConnectionFailed: Can't connect to MySQL server on '127.0.0.1' (115) ((nullptr):0)"
+    assert stderr[0:258].decode() == "mysql: [Warning] Using a password on the command line interface can be insecure.\n" \
+            "ERROR 1000 (00000) at line 1: Poco::Exception. Code: 1000, e.code() = 0, e.displayText() = Exception: Connections to all replicas failed: default@127.0.0.1:10086 as user default"
 
 
 def test_mysql_affected_rows(mysql_client, server_address):
diff --git a/tests/integration/test_odbc_interaction/test.py b/tests/integration/test_odbc_interaction/test.py
index 2ef71927bdf..f6026e8dd3b 100644
--- a/tests/integration/test_odbc_interaction/test.py
+++ b/tests/integration/test_odbc_interaction/test.py
@@ -6,6 +6,7 @@ import pytest
 from helpers.cluster import ClickHouseCluster
 from helpers.test_tools import assert_eq_with_retry
 from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT
+from multiprocessing.dummy import Pool
 
 cluster = ClickHouseCluster(__file__)
 node1 = cluster.add_instance('node1', with_odbc_drivers=True, with_mysql=True,
@@ -269,7 +270,7 @@ def test_sqlite_odbc_cached_dictionary(started_cluster):
     node1.exec_in_container(["bash", "-c", "chmod a+rw /tmp"], privileged=True, user='root')
     node1.exec_in_container(["bash", "-c", "chmod a+rw {}".format(sqlite_db)], privileged=True, user='root')
 
-    node1.query("insert into table function odbc('DSN={};', '', 't3') values (200, 2, 7)".format(
+    node1.query("insert into table function odbc('DSN={};ReadOnly=0', '', 't3') values (200, 2, 7)".format(
         node1.odbc_drivers["SQLite3"]["DSN"]))
 
     assert node1.query("select dictGetUInt8('sqlite3_odbc_cached', 'Z', toUInt64(200))") == "7\n"  # new value
@@ -381,5 +382,126 @@ def test_odbc_postgres_date_data_type(started_cluster):
     expected = '1\t2020-12-01\n2\t2020-12-02\n3\t2020-12-03\n'
     result = node1.query('SELECT * FROM test_date');
     assert(result == expected)
+    cursor.execute("DROP TABLE IF EXISTS clickhouse.test_date")
+    node1.query("DROP TABLE IF EXISTS test_date")
 
 
+def test_odbc_postgres_conversions(started_cluster):
+    conn = get_postgres_conn()
+    cursor = conn.cursor()
+
+    cursor.execute(
+        '''CREATE TABLE IF NOT EXISTS clickhouse.test_types (
+        a smallint, b integer, c bigint, d real, e double precision, f serial, g bigserial,
+        h timestamp)''')
+
+    node1.query('''
+        INSERT INTO TABLE FUNCTION
+        odbc('DSN=postgresql_odbc; Servername=postgre-sql.local', 'clickhouse', 'test_types')
+        VALUES (-32768, -2147483648, -9223372036854775808, 1.12345, 1.1234567890, 2147483647, 9223372036854775807, '2000-05-12 12:12:12')''')
+
+    result = node1.query('''
+        SELECT a, b, c, d, e, f, g, h
+        FROM odbc('DSN=postgresql_odbc; Servername=postgre-sql.local', 'clickhouse', 'test_types')
+        ''')
+
+    assert(result == '-32768\t-2147483648\t-9223372036854775808\t1.12345\t1.123456789\t2147483647\t9223372036854775807\t2000-05-12 12:12:12\n')
+    cursor.execute("DROP TABLE IF EXISTS clickhouse.test_types")
+
+    cursor.execute("""CREATE TABLE IF NOT EXISTS clickhouse.test_types (column1 Timestamp, column2 Numeric)""")
+
+    node1.query(
+        '''
+        CREATE TABLE test_types (column1 DateTime64, column2 Decimal(5, 1))
+        ENGINE=ODBC('DSN=postgresql_odbc; Servername=postgre-sql.local', 'clickhouse', 'test_types')''')
+
+    node1.query(
+        """INSERT INTO test_types
+        SELECT toDateTime64('2019-01-01 00:00:00', 3, 'Europe/Moscow'), toDecimal32(1.1, 1)""")
+
+    expected = node1.query("SELECT toDateTime64('2019-01-01 00:00:00', 3, 'Europe/Moscow'), toDecimal32(1.1, 1)")
+    result = node1.query("SELECT * FROM test_types")
+    print(result)
+    cursor.execute("DROP TABLE IF EXISTS clickhouse.test_types")
+    assert(result == expected)
+
+
+def test_odbc_cyrillic_with_varchar(started_cluster):
+    conn = get_postgres_conn()
+    cursor = conn.cursor()
+
+    cursor.execute("DROP TABLE IF EXISTS clickhouse.test_cyrillic")
+    cursor.execute("CREATE TABLE clickhouse.test_cyrillic (name varchar(11))")
+
+    node1.query('''
+        CREATE TABLE test_cyrillic (name String)
+        ENGINE = ODBC('DSN=postgresql_odbc; Servername=postgre-sql.local', 'clickhouse', 'test_cyrillic')''')
+
+    cursor.execute("INSERT INTO clickhouse.test_cyrillic VALUES ('A-nice-word')")
+    cursor.execute("INSERT INTO clickhouse.test_cyrillic VALUES ('Красивенько')")
+
+    result = node1.query(''' SELECT * FROM test_cyrillic ORDER BY name''')
+    assert(result == 'A-nice-word\nКрасивенько\n')
+    result = node1.query(''' SELECT name FROM odbc('DSN=postgresql_odbc; Servername=postgre-sql.local', 'clickhouse', 'test_cyrillic') ''')
+    assert(result == 'A-nice-word\nКрасивенько\n')
+
+
+def test_many_connections(started_cluster):
+    conn = get_postgres_conn()
+    cursor = conn.cursor()
+
+    cursor.execute('DROP TABLE IF EXISTS clickhouse.test_pg_table')
+    cursor.execute('CREATE TABLE clickhouse.test_pg_table (key integer, value integer)')
+
+    node1.query('''
+        DROP TABLE IF EXISTS test_pg_table;
+        CREATE TABLE test_pg_table (key UInt32, value UInt32)
+        ENGINE = ODBC('DSN=postgresql_odbc; Servername=postgre-sql.local', 'clickhouse', 'test_pg_table')''')
+
+    node1.query("INSERT INTO test_pg_table SELECT number, number FROM numbers(10)")
+
+    query = "SELECT count() FROM ("
+    for i in range (24):
+        query += "SELECT key FROM {t} UNION ALL "
+    query += "SELECT key FROM {t})"
+
+    assert node1.query(query.format(t='test_pg_table')) == '250\n'
+
+
+def test_concurrent_queries(started_cluster):
+    conn = get_postgres_conn()
+    cursor = conn.cursor()
+
+    node1.query('''
+        DROP TABLE IF EXISTS test_pg_table;
+        CREATE TABLE test_pg_table (key UInt32, value UInt32)
+        ENGINE = ODBC('DSN=postgresql_odbc; Servername=postgre-sql.local', 'clickhouse', 'test_pg_table')''')
+
+    cursor.execute('DROP TABLE IF EXISTS clickhouse.test_pg_table')
+    cursor.execute('CREATE TABLE clickhouse.test_pg_table (key integer, value integer)')
+
+    def node_insert(_):
+        for i in range(5):
+            node1.query("INSERT INTO test_pg_table SELECT number, number FROM numbers(1000)", user='default')
+
+    busy_pool = Pool(5)
+    p = busy_pool.map_async(node_insert, range(5))
+    p.wait()
+    result = node1.query("SELECT count() FROM test_pg_table", user='default')
+    print(result)
+    assert(int(result) == 5 * 5 * 1000)
+
+    def node_insert_select(_):
+        for i in range(5):
+            result = node1.query("INSERT INTO test_pg_table SELECT number, number FROM numbers(1000)", user='default')
+            result = node1.query("SELECT * FROM test_pg_table LIMIT 100", user='default')
+
+    busy_pool = Pool(5)
+    p = busy_pool.map_async(node_insert_select, range(5))
+    p.wait()
+    result = node1.query("SELECT count() FROM test_pg_table", user='default')
+    print(result)
+    assert(int(result) == 5 * 5 * 1000  * 2)
+
+    node1.query('DROP TABLE test_pg_table;')
+    cursor.execute('DROP TABLE clickhouse.test_pg_table;')
diff --git a/tests/integration/test_replication_credentials/test.py b/tests/integration/test_replication_credentials/test.py
index 4f07d6966a6..9181c515adf 100644
--- a/tests/integration/test_replication_credentials/test.py
+++ b/tests/integration/test_replication_credentials/test.py
@@ -9,7 +9,6 @@ def _fill_nodes(nodes, shard):
         node.query(
             '''
                 CREATE DATABASE test;
-    
                 CREATE TABLE test_table(date Date, id UInt32, dummy UInt32)
                 ENGINE = ReplicatedMergeTree('/clickhouse/tables/test{shard}/replicated', '{replica}', date, id, 8192);
             '''.format(shard=shard, replica=node.name))
@@ -114,6 +113,32 @@ def test_different_credentials(different_credentials_cluster):
     assert node5.query("SELECT id FROM test_table order by id") == '111\n'
     assert node6.query("SELECT id FROM test_table order by id") == '222\n'
 
+    add_old = """
+    <yandex>
+        <interserver_http_port>9009</interserver_http_port>
+        <interserver_http_credentials>
+            <user>admin</user>
+            <password>222</password>
+            <old>
+                <user>root</user>
+                <password>111</password>
+            </old>
+            <old>
+                <user>aaa</user>
+                <password>333</password>
+            </old>
+        </interserver_http_credentials>
+    </yandex>
+    """
+
+    node5.replace_config("/etc/clickhouse-server/config.d/credentials1.xml", add_old)
+
+    node5.query("SYSTEM RELOAD CONFIG")
+    node5.query("INSERT INTO test_table values('2017-06-21', 333, 1)")
+    node6.query("SYSTEM SYNC REPLICA test_table", timeout=10)
+
+    assert node6.query("SELECT id FROM test_table order by id") == '111\n222\n333\n'
+
 
 node7 = cluster.add_instance('node7', main_configs=['configs/remote_servers.xml', 'configs/credentials1.xml'],
                              with_zookeeper=True)
@@ -146,3 +171,23 @@ def test_credentials_and_no_credentials(credentials_and_no_credentials_cluster):
 
     assert node7.query("SELECT id FROM test_table order by id") == '111\n'
     assert node8.query("SELECT id FROM test_table order by id") == '222\n'
+
+    allow_empty = """
+    <yandex>
+        <interserver_http_port>9009</interserver_http_port>
+        <interserver_http_credentials>
+            <user>admin</user>
+            <password>222</password>
+            <allow_empty>true</allow_empty>
+        </interserver_http_credentials>
+    </yandex>
+    """
+
+    # change state: Flip node7 to mixed auth/non-auth (allow node8)
+    node7.replace_config("/etc/clickhouse-server/config.d/credentials1.xml",
+                         allow_empty)
+
+    node7.query("SYSTEM RELOAD CONFIG")
+    node7.query("insert into test_table values ('2017-06-22', 333, 1)")
+    node8.query("SYSTEM SYNC REPLICA test_table", timeout=10)
+    assert node8.query("SELECT id FROM test_table order by id") == '111\n222\n333\n'
diff --git a/tests/integration/test_storage_kafka/test.py b/tests/integration/test_storage_kafka/test.py
index 9b2f54a49a0..99617367bb1 100644
--- a/tests/integration/test_storage_kafka/test.py
+++ b/tests/integration/test_storage_kafka/test.py
@@ -6,6 +6,7 @@ import subprocess
 import threading
 import time
 import io
+import string
 
 import avro.schema
 import avro.io
@@ -2533,6 +2534,382 @@ def test_kafka_csv_with_thread_per_consumer(kafka_cluster):
 
     kafka_check_result(result, True)
 
+def random_string(size=8):
+    return ''.join(random.choices(string.ascii_uppercase + string.digits, k=size))
+
+@pytest.mark.timeout(180)
+def test_kafka_engine_put_errors_to_stream(kafka_cluster):
+    instance.query('''
+        DROP TABLE IF EXISTS test.kafka;
+        DROP TABLE IF EXISTS test.kafka_data;
+        DROP TABLE IF EXISTS test.kafka_errors;
+        CREATE TABLE test.kafka (i Int64, s String)
+            ENGINE = Kafka
+            SETTINGS kafka_broker_list = 'kafka1:19092',
+                     kafka_topic_list = 'json',
+                     kafka_group_name = 'json',
+                     kafka_format = 'JSONEachRow',
+                     kafka_max_block_size = 128,
+                     kafka_handle_error_mode = 'stream';
+        CREATE MATERIALIZED VIEW test.kafka_data (i Int64, s String)
+            ENGINE = MergeTree
+            ORDER BY i
+            AS SELECT i, s FROM test.kafka WHERE length(_error) == 0;
+        CREATE MATERIALIZED VIEW test.kafka_errors (topic String, partition Int64, offset Int64, raw String, error String)
+            ENGINE = MergeTree
+            ORDER BY (topic, offset)
+            AS SELECT
+               _topic AS topic,
+               _partition AS partition,
+               _offset AS offset,
+               _raw_message AS raw,
+               _error AS error
+               FROM test.kafka WHERE length(_error) > 0;
+        ''')
+
+    messages = []
+    for i in range(128):
+        if i % 2 == 0:
+            messages.append(json.dumps({'i': i, 's': random_string(8)}))
+        else:
+            # Unexpected json content for table test.kafka.
+            messages.append(json.dumps({'i': 'n_' + random_string(4), 's': random_string(8)}))
+
+    kafka_produce('json', messages)
+
+    while True:
+      total_rows = instance.query('SELECT count() FROM test.kafka_data', ignore_error=True)
+      if total_rows == '64\n':
+        break
+
+    while True:
+      total_error_rows = instance.query('SELECT count() FROM test.kafka_errors', ignore_error=True)
+      if total_error_rows == '64\n':
+        break
+
+    instance.query('''
+        DROP TABLE test.kafka;
+        DROP TABLE test.kafka_data;
+        DROP TABLE test.kafka_errors;
+    ''')
+
+def gen_normal_json():
+    return '{"i":1000, "s":"ABC123abc"}'
+
+def gen_malformed_json():
+    return '{"i":"n1000", "s":"1000"}'
+
+def gen_message_with_jsons(jsons = 10, malformed = 0):
+    s = io.StringIO()
+    for i in range (jsons):
+        if malformed and random.randint(0,1) == 1:
+            s.write(gen_malformed_json())
+        else:
+            s.write(gen_normal_json())
+        s.write(' ')
+    return s.getvalue()
+
+
+def test_kafka_engine_put_errors_to_stream_with_random_malformed_json(kafka_cluster):
+    instance.query('''
+        DROP TABLE IF EXISTS test.kafka;
+        DROP TABLE IF EXISTS test.kafka_data;
+        DROP TABLE IF EXISTS test.kafka_errors;
+        CREATE TABLE test.kafka (i Int64, s String)
+            ENGINE = Kafka
+            SETTINGS kafka_broker_list = 'kafka1:19092',
+                     kafka_topic_list = 'json',
+                     kafka_group_name = 'json',
+                     kafka_format = 'JSONEachRow',
+                     kafka_max_block_size = 100,
+                     kafka_poll_max_batch_size = 1,
+                     kafka_handle_error_mode = 'stream';
+        CREATE MATERIALIZED VIEW test.kafka_data (i Int64, s String)
+            ENGINE = MergeTree
+            ORDER BY i
+            AS SELECT i, s FROM test.kafka WHERE length(_error) == 0;
+        CREATE MATERIALIZED VIEW test.kafka_errors (topic String, partition Int64, offset Int64, raw String, error String)
+            ENGINE = MergeTree
+            ORDER BY (topic, offset)
+            AS SELECT
+               _topic AS topic,
+               _partition AS partition,
+               _offset AS offset,
+               _raw_message AS raw,
+               _error AS error
+               FROM test.kafka WHERE length(_error) > 0;
+        ''')
+
+    messages = []
+    for i in range(128):
+        if i % 2 == 0:
+            messages.append(gen_message_with_jsons(10, 1))
+        else:
+            messages.append(gen_message_with_jsons(10, 0))
+
+    kafka_produce('json', messages)
+
+    while True:
+      total_rows = instance.query('SELECT count() FROM test.kafka_data', ignore_error=True)
+      if total_rows == '640\n':
+        break
+
+    while True:
+      total_error_rows = instance.query('SELECT count() FROM test.kafka_errors', ignore_error=True)
+      if total_error_rows == '64\n':
+        break
+
+    instance.query('''
+        DROP TABLE test.kafka;
+        DROP TABLE test.kafka_data;
+        DROP TABLE test.kafka_errors;
+    ''')
+
+@pytest.mark.timeout(120)
+def test_kafka_formats_with_broken_message(kafka_cluster):
+    # data was dumped from clickhouse itself in a following manner
+    # clickhouse-client --format=Native --query='SELECT toInt64(number) as id, toUInt16( intDiv( id, 65536 ) ) as blockNo, reinterpretAsString(19777) as val1, toFloat32(0.5) as val2, toUInt8(1) as val3 from numbers(100) ORDER BY id' | xxd -ps | tr -d '\n' | sed 's/\(..\)/\\x\1/g'
+
+    all_formats = {
+        ## Text formats ##
+        # dumped with clickhouse-client ... | perl -pe 's/\n/\\n/; s/\t/\\t/g;'
+        'JSONEachRow': {
+            'data_sample': [
+                '{"id":"0","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n',
+                '{"id":"1","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"2","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"3","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"4","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"5","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"6","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"7","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"8","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"9","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"10","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"11","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"12","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"13","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"14","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"15","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n',
+                '{"id":"0","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n',
+                # broken message
+                '{"id":"0","blockNo":"BAD","val1":"AM","val2":0.5,"val3":1}',
+            ],
+            'expected':'''{"raw_message":"{\\"id\\":\\"0\\",\\"blockNo\\":\\"BAD\\",\\"val1\\":\\"AM\\",\\"val2\\":0.5,\\"val3\\":1}","error":"Cannot parse input: expected '\\"' before: 'BAD\\",\\"val1\\":\\"AM\\",\\"val2\\":0.5,\\"val3\\":1}': (while reading the value of key blockNo)"}''',
+            'supports_empty_value': True,
+            'printable': True,
+        },
+        # JSONAsString doesn't fit to that test, and tested separately
+        'JSONCompactEachRow': {
+            'data_sample': [
+                '["0", 0, "AM", 0.5, 1]\n',
+                '["1", 0, "AM", 0.5, 1]\n["2", 0, "AM", 0.5, 1]\n["3", 0, "AM", 0.5, 1]\n["4", 0, "AM", 0.5, 1]\n["5", 0, "AM", 0.5, 1]\n["6", 0, "AM", 0.5, 1]\n["7", 0, "AM", 0.5, 1]\n["8", 0, "AM", 0.5, 1]\n["9", 0, "AM", 0.5, 1]\n["10", 0, "AM", 0.5, 1]\n["11", 0, "AM", 0.5, 1]\n["12", 0, "AM", 0.5, 1]\n["13", 0, "AM", 0.5, 1]\n["14", 0, "AM", 0.5, 1]\n["15", 0, "AM", 0.5, 1]\n',
+                '["0", 0, "AM", 0.5, 1]\n',
+                # broken message
+                '["0", "BAD", "AM", 0.5, 1]',
+            ],
+            'expected':'''{"raw_message":"[\\"0\\", \\"BAD\\", \\"AM\\", 0.5, 1]","error":"Cannot parse input: expected '\\"' before: 'BAD\\", \\"AM\\", 0.5, 1]': (while reading the value of key blockNo)"}''',
+            'supports_empty_value': True,
+            'printable':True,
+        },
+        'JSONCompactEachRowWithNamesAndTypes': {
+            'data_sample': [
+                '["id", "blockNo", "val1", "val2", "val3"]\n["Int64", "UInt16", "String", "Float32", "UInt8"]\n["0", 0, "AM", 0.5, 1]\n',
+                '["id", "blockNo", "val1", "val2", "val3"]\n["Int64", "UInt16", "String", "Float32", "UInt8"]\n["1", 0, "AM", 0.5, 1]\n["2", 0, "AM", 0.5, 1]\n["3", 0, "AM", 0.5, 1]\n["4", 0, "AM", 0.5, 1]\n["5", 0, "AM", 0.5, 1]\n["6", 0, "AM", 0.5, 1]\n["7", 0, "AM", 0.5, 1]\n["8", 0, "AM", 0.5, 1]\n["9", 0, "AM", 0.5, 1]\n["10", 0, "AM", 0.5, 1]\n["11", 0, "AM", 0.5, 1]\n["12", 0, "AM", 0.5, 1]\n["13", 0, "AM", 0.5, 1]\n["14", 0, "AM", 0.5, 1]\n["15", 0, "AM", 0.5, 1]\n',
+                '["id", "blockNo", "val1", "val2", "val3"]\n["Int64", "UInt16", "String", "Float32", "UInt8"]\n["0", 0, "AM", 0.5, 1]\n',
+                # broken message
+                '["0", "BAD", "AM", 0.5, 1]',
+            ],
+            'expected':'''{"raw_message":"[\\"0\\", \\"BAD\\", \\"AM\\", 0.5, 1]","error":"Cannot parse JSON string: expected opening quote"}''',
+            'printable':True,
+        },
+        'TSKV': {
+            'data_sample': [
+                'id=0\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\n',
+                'id=1\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=2\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=3\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=4\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=5\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=6\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=7\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=8\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=9\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=10\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=11\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=12\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=13\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=14\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=15\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\n',
+                'id=0\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\n',
+                # broken message
+                'id=0\tblockNo=BAD\tval1=AM\tval2=0.5\tval3=1\n',
+            ],
+            'expected':'{"raw_message":"id=0\\tblockNo=BAD\\tval1=AM\\tval2=0.5\\tval3=1\\n","error":"Found garbage after field in TSKV format: blockNo: (at row 1)\\n"}',
+            'printable':True,
+        },
+        'CSV': {
+            'data_sample': [
+                '0,0,"AM",0.5,1\n',
+                '1,0,"AM",0.5,1\n2,0,"AM",0.5,1\n3,0,"AM",0.5,1\n4,0,"AM",0.5,1\n5,0,"AM",0.5,1\n6,0,"AM",0.5,1\n7,0,"AM",0.5,1\n8,0,"AM",0.5,1\n9,0,"AM",0.5,1\n10,0,"AM",0.5,1\n11,0,"AM",0.5,1\n12,0,"AM",0.5,1\n13,0,"AM",0.5,1\n14,0,"AM",0.5,1\n15,0,"AM",0.5,1\n',
+                '0,0,"AM",0.5,1\n',
+                # broken message
+                '0,"BAD","AM",0.5,1\n',
+            ],
+            'expected':'''{"raw_message":"0,\\"BAD\\",\\"AM\\",0.5,1\\n","error":"Cannot parse input: expected '\\"' before: 'BAD\\",\\"AM\\",0.5,1\\\\n': Could not print diagnostic info because two last rows aren't in buffer (rare case)\\n"}''',
+            'printable':True,
+            'supports_empty_value': True,
+        },
+        'TSV': {
+            'data_sample': [
+                '0\t0\tAM\t0.5\t1\n',
+                '1\t0\tAM\t0.5\t1\n2\t0\tAM\t0.5\t1\n3\t0\tAM\t0.5\t1\n4\t0\tAM\t0.5\t1\n5\t0\tAM\t0.5\t1\n6\t0\tAM\t0.5\t1\n7\t0\tAM\t0.5\t1\n8\t0\tAM\t0.5\t1\n9\t0\tAM\t0.5\t1\n10\t0\tAM\t0.5\t1\n11\t0\tAM\t0.5\t1\n12\t0\tAM\t0.5\t1\n13\t0\tAM\t0.5\t1\n14\t0\tAM\t0.5\t1\n15\t0\tAM\t0.5\t1\n',
+                '0\t0\tAM\t0.5\t1\n',
+                # broken message
+                '0\tBAD\tAM\t0.5\t1\n',
+            ],
+            'expected':'''{"raw_message":"0\\tBAD\\tAM\\t0.5\\t1\\n","error":"Cannot parse input: expected '\\\\t' before: 'BAD\\\\tAM\\\\t0.5\\\\t1\\\\n': Could not print diagnostic info because two last rows aren't in buffer (rare case)\\n"}''',
+            'supports_empty_value': True,
+            'printable':True,
+        },
+        'CSVWithNames': {
+            'data_sample': [
+                '"id","blockNo","val1","val2","val3"\n0,0,"AM",0.5,1\n',
+                '"id","blockNo","val1","val2","val3"\n1,0,"AM",0.5,1\n2,0,"AM",0.5,1\n3,0,"AM",0.5,1\n4,0,"AM",0.5,1\n5,0,"AM",0.5,1\n6,0,"AM",0.5,1\n7,0,"AM",0.5,1\n8,0,"AM",0.5,1\n9,0,"AM",0.5,1\n10,0,"AM",0.5,1\n11,0,"AM",0.5,1\n12,0,"AM",0.5,1\n13,0,"AM",0.5,1\n14,0,"AM",0.5,1\n15,0,"AM",0.5,1\n',
+                '"id","blockNo","val1","val2","val3"\n0,0,"AM",0.5,1\n',
+                # broken message
+                '"id","blockNo","val1","val2","val3"\n0,"BAD","AM",0.5,1\n',
+            ],
+            'expected':'''{"raw_message":"\\"id\\",\\"blockNo\\",\\"val1\\",\\"val2\\",\\"val3\\"\\n0,\\"BAD\\",\\"AM\\",0.5,1\\n","error":"Cannot parse input: expected '\\"' before: 'BAD\\",\\"AM\\",0.5,1\\\\n': Could not print diagnostic info because two last rows aren't in buffer (rare case)\\n"}''',
+            'printable':True,
+        },
+        'Values': {
+            'data_sample': [
+                "(0,0,'AM',0.5,1)",
+                "(1,0,'AM',0.5,1),(2,0,'AM',0.5,1),(3,0,'AM',0.5,1),(4,0,'AM',0.5,1),(5,0,'AM',0.5,1),(6,0,'AM',0.5,1),(7,0,'AM',0.5,1),(8,0,'AM',0.5,1),(9,0,'AM',0.5,1),(10,0,'AM',0.5,1),(11,0,'AM',0.5,1),(12,0,'AM',0.5,1),(13,0,'AM',0.5,1),(14,0,'AM',0.5,1),(15,0,'AM',0.5,1)",
+                "(0,0,'AM',0.5,1)",
+                # broken message
+                "(0,'BAD','AM',0.5,1)",
+            ],
+            'expected':r'''{"raw_message":"(0,'BAD','AM',0.5,1)","error":"Cannot parse string 'BAD' as UInt16: syntax error at begin of string. Note: there are toUInt16OrZero and toUInt16OrNull functions, which returns zero\/NULL instead of throwing exception.: while executing 'FUNCTION CAST(assumeNotNull(_dummy_0) :: 2, 'UInt16' :: 1) -> CAST(assumeNotNull(_dummy_0), 'UInt16') UInt16 : 4'"}''',
+            'supports_empty_value': True,
+            'printable':True,
+        },
+        'TSVWithNames': {
+            'data_sample': [
+                'id\tblockNo\tval1\tval2\tval3\n0\t0\tAM\t0.5\t1\n',
+                'id\tblockNo\tval1\tval2\tval3\n1\t0\tAM\t0.5\t1\n2\t0\tAM\t0.5\t1\n3\t0\tAM\t0.5\t1\n4\t0\tAM\t0.5\t1\n5\t0\tAM\t0.5\t1\n6\t0\tAM\t0.5\t1\n7\t0\tAM\t0.5\t1\n8\t0\tAM\t0.5\t1\n9\t0\tAM\t0.5\t1\n10\t0\tAM\t0.5\t1\n11\t0\tAM\t0.5\t1\n12\t0\tAM\t0.5\t1\n13\t0\tAM\t0.5\t1\n14\t0\tAM\t0.5\t1\n15\t0\tAM\t0.5\t1\n',
+                'id\tblockNo\tval1\tval2\tval3\n0\t0\tAM\t0.5\t1\n',
+                # broken message
+                'id\tblockNo\tval1\tval2\tval3\n0\tBAD\tAM\t0.5\t1\n',
+            ],
+            'expected':'''{"raw_message":"id\\tblockNo\\tval1\\tval2\\tval3\\n0\\tBAD\\tAM\\t0.5\\t1\\n","error":"Cannot parse input: expected '\\\\t' before: 'BAD\\\\tAM\\\\t0.5\\\\t1\\\\n': Could not print diagnostic info because two last rows aren't in buffer (rare case)\\n"}''',
+            'supports_empty_value': True,
+            'printable':True,
+        },
+        'TSVWithNamesAndTypes': {
+            'data_sample': [
+                'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n0\t0\tAM\t0.5\t1\n',
+                'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n1\t0\tAM\t0.5\t1\n2\t0\tAM\t0.5\t1\n3\t0\tAM\t0.5\t1\n4\t0\tAM\t0.5\t1\n5\t0\tAM\t0.5\t1\n6\t0\tAM\t0.5\t1\n7\t0\tAM\t0.5\t1\n8\t0\tAM\t0.5\t1\n9\t0\tAM\t0.5\t1\n10\t0\tAM\t0.5\t1\n11\t0\tAM\t0.5\t1\n12\t0\tAM\t0.5\t1\n13\t0\tAM\t0.5\t1\n14\t0\tAM\t0.5\t1\n15\t0\tAM\t0.5\t1\n',
+                'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n0\t0\tAM\t0.5\t1\n',
+                # broken message
+                'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n0\tBAD\tAM\t0.5\t1\n',
+            ],
+            'expected':'''{"raw_message":"id\\tblockNo\\tval1\\tval2\\tval3\\nInt64\\tUInt16\\tString\\tFloat32\\tUInt8\\n0\\tBAD\\tAM\\t0.5\\t1\\n","error":"Cannot parse input: expected '\\\\t' before: 'BAD\\\\tAM\\\\t0.5\\\\t1\\\\n': Could not print diagnostic info because two last rows aren't in buffer (rare case)\\n"}''',
+            'printable':True,
+        },
+      'Native': {
+            'data_sample': [
+                b'\x05\x01\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x00\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x55\x49\x6e\x74\x31\x36\x00\x00\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01',
+                b'\x05\x0f\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x55\x49\x6e\x74\x31\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01',
+                b'\x05\x01\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x00\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x55\x49\x6e\x74\x31\x36\x00\x00\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01',
+                # broken message
+           b'\x05\x01\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x00\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x53\x74\x72\x69\x6e\x67\x03\x42\x41\x44\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01',
+            ],
+            'expected':'''{"raw_message":"050102696405496E743634000000000000000007626C6F636B4E6F06537472696E67034241440476616C3106537472696E6702414D0476616C3207466C6F617433320000003F0476616C330555496E743801","error":"Cannot convert: String to UInt16"}''',
+            'printable':False,
+        },
+        'RowBinary': {
+            'data_sample': [
+                b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
+                b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
+                b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
+                # broken message
+                b'\x00\x00\x00\x00\x00\x00\x00\x00\x03\x42\x41\x44\x02\x41\x4d\x00\x00\x00\x3f\x01',
+            ],
+            'expected':'{"raw_message":"00000000000000000342414402414D0000003F01","error":"Cannot read all data. Bytes read: 9. Bytes expected: 65.: (at row 1)\\n"}',
+            'printable':False,
+        },
+        'RowBinaryWithNamesAndTypes': {
+            'data_sample': [
+                b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x55\x49\x6e\x74\x31\x36\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
+                b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x55\x49\x6e\x74\x31\x36\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
+                b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x55\x49\x6e\x74\x31\x36\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
+                # broken message
+            b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x53\x74\x72\x69\x6e\x67\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x00\x00\x00\x00\x00\x00\x00\x00\x03\x42\x41\x44\x02\x41\x4d\x00\x00\x00\x3f\x01',
+            ],
+            'expected':'{"raw_message":"0502696407626C6F636B4E6F0476616C310476616C320476616C3305496E74363406537472696E6706537472696E6707466C6F617433320555496E743800000000000000000342414402414D0000003F01","error":"Cannot read all data. Bytes read: 9. Bytes expected: 65.: (at row 1)\\n"}',
+            'printable':False,
+        },
+        'ORC': {
+            'data_sample': [
+                b'\x4f\x52\x43\x11\x00\x00\x0a\x06\x12\x04\x08\x01\x50\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x30\x00\x00\xe3\x12\xe7\x62\x65\x00\x01\x21\x3e\x0e\x46\x25\x0e\x2e\x46\x03\x21\x46\x03\x09\xa6\x00\x06\x00\x32\x00\x00\xe3\x92\xe4\x62\x65\x00\x01\x21\x01\x0e\x46\x25\x2e\x2e\x26\x47\x5f\x21\x20\x96\x60\x09\x60\x00\x00\x36\x00\x00\xe3\x92\xe1\x62\x65\x00\x01\x21\x61\x0e\x46\x23\x5e\x2e\x46\x03\x21\x66\x03\x3d\x53\x29\x10\x11\xc0\x00\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\x05\x00\x00\xff\x00\x03\x00\x00\x30\x07\x00\x00\x40\x00\x80\x05\x00\x00\x41\x4d\x07\x00\x00\x42\x00\x80\x03\x00\x00\x0a\x07\x00\x00\x42\x00\x80\x05\x00\x00\xff\x01\x88\x00\x00\x4d\xca\xc1\x0a\x80\x30\x0c\x03\xd0\x2e\x6b\xcb\x98\x17\xf1\x14\x50\xfc\xff\xcf\xb4\x66\x1e\x3c\x84\x47\x9a\xce\x1c\xb9\x1b\xb7\xf9\xda\x48\x09\x9e\xb2\xf3\x92\xce\x5b\x86\xf6\x56\x7f\x21\x41\x2f\x51\xa6\x7a\xd7\x1d\xe5\xea\xae\x3d\xca\xd5\x83\x71\x60\xd8\x17\xfc\x62\x0f\xa8\x00\x00\xe3\x4a\xe6\x62\xe1\x60\x0c\x60\xe0\xe2\xe3\x60\x14\x62\xe3\x60\x10\x60\x90\x60\x08\x60\x88\x60\xe5\x12\xe0\x60\x54\xe2\xe0\x62\x34\x10\x62\x34\x90\x60\x02\x8a\x70\x71\x09\x01\x45\xb8\xb8\x98\x1c\x7d\x85\x80\x58\x82\x05\x28\xc6\xcd\x25\xca\xc1\x68\xc4\x0b\x52\xc5\x6c\xa0\x67\x2a\x05\x22\xc0\x4a\x21\x86\x31\x09\x30\x81\xb5\xb2\x02\x00\x36\x01\x00\x25\x8c\xbd\x0a\xc2\x30\x14\x85\x73\x6f\x92\xf6\x92\x6a\x09\x01\x21\x64\x92\x4e\x75\x91\x58\x71\xc9\x64\x27\x5d\x2c\x1d\x5d\xfd\x59\xc4\x42\x37\x5f\xc0\x17\xe8\x23\x9b\xc6\xe1\x3b\x70\x0f\xdf\xb9\xc4\xf5\x17\x5d\x41\x5c\x4f\x60\x37\xeb\x53\x0d\x55\x4d\x0b\x23\x01\xb9\x90\x2e\xbf\x0f\xe3\xe3\xdd\x8d\x0e\x5f\x4f\x27\x3e\xb7\x61\x97\xb2\x49\xb9\xaf\x90\x20\x92\x27\x32\x2a\x6b\xf4\xf3\x0d\x1e\x82\x20\xe8\x59\x28\x09\x4c\x46\x4c\x33\xcb\x7a\x76\x95\x41\x47\x9f\x14\x78\x03\xde\x62\x6c\x54\x30\xb1\x51\x0a\xdb\x8b\x89\x58\x11\xbb\x22\xac\x08\x9a\xe5\x6c\x71\xbf\x3d\xb8\x39\x92\xfa\x7f\x86\x1a\xd3\x54\x1e\xa7\xee\xcc\x7e\x08\x9e\x01\x10\x01\x18\x80\x80\x10\x22\x02\x00\x0c\x28\x57\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
+                b'\x4f\x52\x43\x11\x00\x00\x0a\x06\x12\x04\x08\x0f\x50\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x0f\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x30\x00\x00\xe3\x12\xe7\x62\x65\x00\x01\x21\x3e\x0e\x7e\x25\x0e\x2e\x46\x43\x21\x46\x4b\x09\xad\x00\x06\x00\x33\x00\x00\x0a\x17\x0a\x03\x00\x00\x00\x12\x10\x08\x0f\x22\x0a\x0a\x02\x41\x4d\x12\x02\x41\x4d\x18\x3c\x50\x00\x3a\x00\x00\xe3\x92\xe1\x62\x65\x00\x01\x21\x61\x0e\x7e\x23\x5e\x2e\x46\x03\x21\x66\x03\x3d\x53\x29\x66\x73\x3d\xd3\x00\x06\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x0f\x12\x06\x08\x02\x10\x02\x18\x1e\x50\x00\x05\x00\x00\x0c\x00\x2b\x00\x00\x31\x32\x33\x34\x35\x36\x37\x38\x39\x31\x30\x31\x31\x31\x32\x31\x33\x31\x34\x31\x35\x09\x00\x00\x06\x01\x03\x02\x09\x00\x00\xc0\x0e\x00\x00\x07\x00\x00\x42\x00\x80\x05\x00\x00\x41\x4d\x0a\x00\x00\xe3\xe2\x42\x01\x00\x09\x00\x00\xc0\x0e\x02\x00\x05\x00\x00\x0c\x01\x94\x00\x00\x2d\xca\xc1\x0e\x80\x30\x08\x03\xd0\xc1\x60\x2e\xf3\x62\x76\x6a\xe2\x0e\xfe\xff\x57\x5a\x3b\x0f\xe4\x51\xe8\x68\xbd\x5d\x05\xe7\xf8\x34\x40\x3a\x6e\x59\xb1\x64\xe0\x91\xa9\xbf\xb1\x97\xd2\x95\x9d\x1e\xca\x55\x3a\x6d\xb4\xd2\xdd\x0b\x74\x9a\x74\xf7\x12\x39\xbd\x97\x7f\x7c\x06\xbb\xa6\x8d\x97\x17\xb4\x00\x00\xe3\x4a\xe6\x62\xe1\xe0\x0f\x60\xe0\xe2\xe3\xe0\x17\x62\xe3\x60\x10\x60\x90\x60\x08\x60\x88\x60\xe5\x12\xe0\xe0\x57\xe2\xe0\x62\x34\x14\x62\xb4\x94\xd0\x02\x8a\xc8\x73\x09\x01\x45\xb8\xb8\x98\x1c\x7d\x85\x80\x58\xc2\x06\x28\x26\xc4\x25\xca\xc1\x6f\xc4\xcb\xc5\x68\x20\xc4\x6c\xa0\x67\x2a\xc5\x6c\xae\x67\x0a\x14\xe6\x87\x1a\xc6\x24\xc0\x24\x21\x07\x32\x0c\x00\x4a\x01\x00\xe3\x60\x16\x58\xc3\x24\xc5\xcd\xc1\x2c\x30\x89\x51\xc2\x4b\xc1\x57\x83\x5f\x49\x83\x83\x47\x88\x95\x91\x89\x99\x85\x55\x8a\x3d\x29\x27\x3f\x39\xdb\x2f\x5f\x8a\x29\x33\x45\x8a\xa5\x2c\x31\xc7\x10\x4c\x1a\x81\x49\x63\x25\x26\x0e\x46\x20\x66\x07\x63\x36\x0e\x3e\x0d\x26\x03\x10\x9f\xd1\x80\xdf\x8a\x85\x83\x3f\x80\xc1\x8a\x8f\x83\x5f\x88\x8d\x83\x41\x80\x41\x82\x21\x80\x21\x82\xd5\x4a\x80\x83\x5f\x89\x83\x8b\xd1\x50\x88\xd1\x52\x42\x0b\x28\x22\x6f\x25\x04\x14\xe1\xe2\x62\x72\xf4\x15\x02\x62\x09\x1b\xa0\x98\x90\x95\x28\x07\xbf\x11\x2f\x17\xa3\x81\x10\xb3\x81\x9e\xa9\x14\xb3\xb9\x9e\x29\x50\x98\x1f\x6a\x18\x93\x00\x93\x84\x1c\xc8\x30\x87\x09\x7e\x1e\x0c\x00\x08\xa8\x01\x10\x01\x18\x80\x80\x10\x22\x02\x00\x0c\x28\x5d\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
+                b'\x4f\x52\x43\x11\x00\x00\x0a\x06\x12\x04\x08\x01\x50\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x30\x00\x00\xe3\x12\xe7\x62\x65\x00\x01\x21\x3e\x0e\x46\x25\x0e\x2e\x46\x03\x21\x46\x03\x09\xa6\x00\x06\x00\x32\x00\x00\xe3\x92\xe4\x62\x65\x00\x01\x21\x01\x0e\x46\x25\x2e\x2e\x26\x47\x5f\x21\x20\x96\x60\x09\x60\x00\x00\x36\x00\x00\xe3\x92\xe1\x62\x65\x00\x01\x21\x61\x0e\x46\x23\x5e\x2e\x46\x03\x21\x66\x03\x3d\x53\x29\x10\x11\xc0\x00\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\x05\x00\x00\xff\x00\x03\x00\x00\x30\x07\x00\x00\x40\x00\x80\x05\x00\x00\x41\x4d\x07\x00\x00\x42\x00\x80\x03\x00\x00\x0a\x07\x00\x00\x42\x00\x80\x05\x00\x00\xff\x01\x88\x00\x00\x4d\xca\xc1\x0a\x80\x30\x0c\x03\xd0\x2e\x6b\xcb\x98\x17\xf1\x14\x50\xfc\xff\xcf\xb4\x66\x1e\x3c\x84\x47\x9a\xce\x1c\xb9\x1b\xb7\xf9\xda\x48\x09\x9e\xb2\xf3\x92\xce\x5b\x86\xf6\x56\x7f\x21\x41\x2f\x51\xa6\x7a\xd7\x1d\xe5\xea\xae\x3d\xca\xd5\x83\x71\x60\xd8\x17\xfc\x62\x0f\xa8\x00\x00\xe3\x4a\xe6\x62\xe1\x60\x0c\x60\xe0\xe2\xe3\x60\x14\x62\xe3\x60\x10\x60\x90\x60\x08\x60\x88\x60\xe5\x12\xe0\x60\x54\xe2\xe0\x62\x34\x10\x62\x34\x90\x60\x02\x8a\x70\x71\x09\x01\x45\xb8\xb8\x98\x1c\x7d\x85\x80\x58\x82\x05\x28\xc6\xcd\x25\xca\xc1\x68\xc4\x0b\x52\xc5\x6c\xa0\x67\x2a\x05\x22\xc0\x4a\x21\x86\x31\x09\x30\x81\xb5\xb2\x02\x00\x36\x01\x00\x25\x8c\xbd\x0a\xc2\x30\x14\x85\x73\x6f\x92\xf6\x92\x6a\x09\x01\x21\x64\x92\x4e\x75\x91\x58\x71\xc9\x64\x27\x5d\x2c\x1d\x5d\xfd\x59\xc4\x42\x37\x5f\xc0\x17\xe8\x23\x9b\xc6\xe1\x3b\x70\x0f\xdf\xb9\xc4\xf5\x17\x5d\x41\x5c\x4f\x60\x37\xeb\x53\x0d\x55\x4d\x0b\x23\x01\xb9\x90\x2e\xbf\x0f\xe3\xe3\xdd\x8d\x0e\x5f\x4f\x27\x3e\xb7\x61\x97\xb2\x49\xb9\xaf\x90\x20\x92\x27\x32\x2a\x6b\xf4\xf3\x0d\x1e\x82\x20\xe8\x59\x28\x09\x4c\x46\x4c\x33\xcb\x7a\x76\x95\x41\x47\x9f\x14\x78\x03\xde\x62\x6c\x54\x30\xb1\x51\x0a\xdb\x8b\x89\x58\x11\xbb\x22\xac\x08\x9a\xe5\x6c\x71\xbf\x3d\xb8\x39\x92\xfa\x7f\x86\x1a\xd3\x54\x1e\xa7\xee\xcc\x7e\x08\x9e\x01\x10\x01\x18\x80\x80\x10\x22\x02\x00\x0c\x28\x57\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
+                # broken message
+            b'\x4f\x52\x43\x0a\x0b\x0a\x03\x00\x00\x00\x12\x04\x08\x01\x50\x00\x0a\x15\x0a\x05\x00\x00\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x0a\x12\x0a\x06\x00\x00\x00\x00\x00\x00\x12\x08\x08\x01\x42\x02\x08\x06\x50\x00\x0a\x12\x0a\x06\x00\x00\x00\x00\x00\x00\x12\x08\x08\x01\x42\x02\x08\x04\x50\x00\x0a\x29\x0a\x04\x00\x00\x00\x00\x12\x21\x08\x01\x1a\x1b\x09\x00\x00\x00\x00\x00\x00\xe0\x3f\x11\x00\x00\x00\x00\x00\x00\xe0\x3f\x19\x00\x00\x00\x00\x00\x00\xe0\x3f\x50\x00\x0a\x15\x0a\x05\x00\x00\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\xff\x80\xff\x80\xff\x00\xff\x80\xff\x03\x42\x41\x44\xff\x80\xff\x02\x41\x4d\xff\x80\x00\x00\x00\x3f\xff\x80\xff\x01\x0a\x06\x08\x06\x10\x00\x18\x0d\x0a\x06\x08\x06\x10\x01\x18\x17\x0a\x06\x08\x06\x10\x02\x18\x14\x0a\x06\x08\x06\x10\x03\x18\x14\x0a\x06\x08\x06\x10\x04\x18\x2b\x0a\x06\x08\x06\x10\x05\x18\x17\x0a\x06\x08\x00\x10\x00\x18\x02\x0a\x06\x08\x00\x10\x01\x18\x02\x0a\x06\x08\x01\x10\x01\x18\x02\x0a\x06\x08\x00\x10\x02\x18\x02\x0a\x06\x08\x02\x10\x02\x18\x02\x0a\x06\x08\x01\x10\x02\x18\x03\x0a\x06\x08\x00\x10\x03\x18\x02\x0a\x06\x08\x02\x10\x03\x18\x02\x0a\x06\x08\x01\x10\x03\x18\x02\x0a\x06\x08\x00\x10\x04\x18\x02\x0a\x06\x08\x01\x10\x04\x18\x04\x0a\x06\x08\x00\x10\x05\x18\x02\x0a\x06\x08\x01\x10\x05\x18\x02\x12\x04\x08\x00\x10\x00\x12\x04\x08\x00\x10\x00\x12\x04\x08\x00\x10\x00\x12\x04\x08\x00\x10\x00\x12\x04\x08\x00\x10\x00\x12\x04\x08\x00\x10\x00\x1a\x03\x47\x4d\x54\x0a\x59\x0a\x04\x08\x01\x50\x00\x0a\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x0a\x08\x08\x01\x42\x02\x08\x06\x50\x00\x0a\x08\x08\x01\x42\x02\x08\x04\x50\x00\x0a\x21\x08\x01\x1a\x1b\x09\x00\x00\x00\x00\x00\x00\xe0\x3f\x11\x00\x00\x00\x00\x00\x00\xe0\x3f\x19\x00\x00\x00\x00\x00\x00\xe0\x3f\x50\x00\x0a\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\x08\x03\x10\xec\x02\x1a\x0c\x08\x03\x10\x8e\x01\x18\x1d\x20\xc1\x01\x28\x01\x22\x2e\x08\x0c\x12\x05\x01\x02\x03\x04\x05\x1a\x02\x69\x64\x1a\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x1a\x04\x76\x61\x6c\x31\x1a\x04\x76\x61\x6c\x32\x1a\x04\x76\x61\x6c\x33\x20\x00\x28\x00\x30\x00\x22\x08\x08\x04\x20\x00\x28\x00\x30\x00\x22\x08\x08\x08\x20\x00\x28\x00\x30\x00\x22\x08\x08\x08\x20\x00\x28\x00\x30\x00\x22\x08\x08\x05\x20\x00\x28\x00\x30\x00\x22\x08\x08\x01\x20\x00\x28\x00\x30\x00\x30\x01\x3a\x04\x08\x01\x50\x00\x3a\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x3a\x08\x08\x01\x42\x02\x08\x06\x50\x00\x3a\x08\x08\x01\x42\x02\x08\x04\x50\x00\x3a\x21\x08\x01\x1a\x1b\x09\x00\x00\x00\x00\x00\x00\xe0\x3f\x11\x00\x00\x00\x00\x00\x00\xe0\x3f\x19\x00\x00\x00\x00\x00\x00\xe0\x3f\x50\x00\x3a\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\x40\x90\x4e\x48\x01\x08\xd5\x01\x10\x00\x18\x80\x80\x04\x22\x02\x00\x0b\x28\x5b\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
+            ],
+            'expected':r'''{"raw_message":"4F52430A0B0A030000001204080150000A150A050000000000120C0801120608001000180050000A120A06000000000000120808014202080650000A120A06000000000000120808014202080450000A290A0400000000122108011A1B09000000000000E03F11000000000000E03F19000000000000E03F50000A150A050000000000120C080112060802100218025000FF80FF80FF00FF80FF03424144FF80FF02414DFF800000003FFF80FF010A0608061000180D0A060806100118170A060806100218140A060806100318140A0608061004182B0A060806100518170A060800100018020A060800100118020A060801100118020A060800100218020A060802100218020A060801100218030A060800100318020A060802100318020A060801100318020A060800100418020A060801100418040A060800100518020A060801100518021204080010001204080010001204080010001204080010001204080010001204080010001A03474D540A590A04080150000A0C0801120608001000180050000A0808014202080650000A0808014202080450000A2108011A1B09000000000000E03F11000000000000E03F19000000000000E03F50000A0C080112060802100218025000080310EC021A0C0803108E01181D20C1012801222E080C120501020304051A0269641A07626C6F636B4E6F1A0476616C311A0476616C321A0476616C33200028003000220808042000280030002208080820002800300022080808200028003000220808052000280030002208080120002800300030013A04080150003A0C0801120608001000180050003A0808014202080650003A0808014202080450003A2108011A1B09000000000000E03F11000000000000E03F19000000000000E03F50003A0C08011206080210021802500040904E480108D5011000188080042202000B285B300682F403034F524318","error":"Cannot parse string 'BAD' as UInt16: syntax error at begin of string. Note: there are toUInt16OrZero and toUInt16OrNull functions, which returns zero\/NULL instead of throwing exception."}''',
+            'printable':False,
+        }
+    }
+
+    topic_name_prefix = 'format_tests_4_stream_'
+    for format_name, format_opts in list(all_formats.items()):
+        print(('Set up {}'.format(format_name)))
+        topic_name = topic_name_prefix + '{}'.format(format_name)
+        data_sample = format_opts['data_sample']
+        data_prefix = []
+        raw_message = '_raw_message'
+        # prepend empty value when supported
+        if format_opts.get('supports_empty_value', False):
+            data_prefix = data_prefix + ['']
+        if format_opts.get('printable', False) == False:
+            raw_message = 'hex(_raw_message)'
+        kafka_produce(topic_name, data_prefix + data_sample)
+        instance.query('''
+            DROP TABLE IF EXISTS test.kafka_{format_name};
+
+            CREATE TABLE test.kafka_{format_name} (
+                id Int64,
+                blockNo UInt16,
+                val1 String,
+                val2 Float32,
+                val3 UInt8
+            ) ENGINE = Kafka()
+                SETTINGS kafka_broker_list = 'kafka1:19092',
+                        kafka_topic_list = '{topic_name}',
+                        kafka_group_name = '{topic_name}',
+                        kafka_format = '{format_name}',
+                        kafka_handle_error_mode = 'stream',
+                        kafka_flush_interval_ms = 1000 {extra_settings};
+
+            DROP TABLE IF EXISTS test.kafka_data_{format_name}_mv;
+            CREATE MATERIALIZED VIEW test.kafka_data_{format_name}_mv Engine=Log AS
+                SELECT *, _topic, _partition, _offset FROM test.kafka_{format_name}
+                WHERE length(_error) = 0;
+
+            DROP TABLE IF EXISTS test.kafka_errors_{format_name}_mv;
+            CREATE MATERIALIZED VIEW test.kafka_errors_{format_name}_mv Engine=Log AS
+                SELECT {raw_message} as raw_message, _error as error, _topic as topic, _partition as partition, _offset as offset FROM test.kafka_{format_name}
+                WHERE length(_error) > 0;
+            '''.format(topic_name=topic_name, format_name=format_name, raw_message=raw_message,
+                       extra_settings=format_opts.get('extra_settings') or ''))
+
+    for format_name, format_opts in list(all_formats.items()):
+        print(('Checking {}'.format(format_name)))
+        topic_name = topic_name_prefix + '{}'.format(format_name)
+        # shift offsets by 1 if format supports empty value
+        offsets = [1, 2, 3] if format_opts.get('supports_empty_value', False) else [0, 1, 2]
+        result = instance.query('SELECT * FROM test.kafka_data_{format_name}_mv;'.format(format_name=format_name))
+        expected = '''\
+0	0	AM	0.5	1	{topic_name}	0	{offset_0}
+1	0	AM	0.5	1	{topic_name}	0	{offset_1}
+2	0	AM	0.5	1	{topic_name}	0	{offset_1}
+3	0	AM	0.5	1	{topic_name}	0	{offset_1}
+4	0	AM	0.5	1	{topic_name}	0	{offset_1}
+5	0	AM	0.5	1	{topic_name}	0	{offset_1}
+6	0	AM	0.5	1	{topic_name}	0	{offset_1}
+7	0	AM	0.5	1	{topic_name}	0	{offset_1}
+8	0	AM	0.5	1	{topic_name}	0	{offset_1}
+9	0	AM	0.5	1	{topic_name}	0	{offset_1}
+10	0	AM	0.5	1	{topic_name}	0	{offset_1}
+11	0	AM	0.5	1	{topic_name}	0	{offset_1}
+12	0	AM	0.5	1	{topic_name}	0	{offset_1}
+13	0	AM	0.5	1	{topic_name}	0	{offset_1}
+14	0	AM	0.5	1	{topic_name}	0	{offset_1}
+15	0	AM	0.5	1	{topic_name}	0	{offset_1}
+0	0	AM	0.5	1	{topic_name}	0	{offset_2}
+'''.format(topic_name=topic_name, offset_0=offsets[0], offset_1=offsets[1], offset_2=offsets[2])
+        print(('Checking result\n {result} \n expected \n {expected}\n'.format(result=str(result), expected=str(expected))))
+        assert TSV(result) == TSV(expected), 'Proper result for format: {}'.format(format_name)
+        errors_result = instance.query('SELECT raw_message, error FROM test.kafka_errors_{format_name}_mv format JSONEachRow'.format(format_name=format_name))
+        errors_expected = format_opts['expected']
+        print(errors_result.strip())
+        print(errors_expected.strip())
+        assert  errors_result.strip() == errors_expected.strip(), 'Proper errors for format: {}'.format(format_name)
 
 if __name__ == '__main__':
     cluster.start()
diff --git a/tests/integration/test_storage_mysql/test.py b/tests/integration/test_storage_mysql/test.py
index 7b23e20e200..4520b3f3837 100644
--- a/tests/integration/test_storage_mysql/test.py
+++ b/tests/integration/test_storage_mysql/test.py
@@ -8,6 +8,8 @@ from helpers.cluster import ClickHouseCluster
 cluster = ClickHouseCluster(__file__)
 
 node1 = cluster.add_instance('node1', main_configs=['configs/remote_servers.xml'], with_mysql=True)
+node2 = cluster.add_instance('node2', main_configs=['configs/remote_servers.xml'], with_mysql_cluster=True)
+
 create_table_sql_template = """
     CREATE TABLE `clickhouse`.`{}` (
     `id` int(11) NOT NULL,
@@ -18,15 +20,30 @@ create_table_sql_template = """
     PRIMARY KEY (`id`)) ENGINE=InnoDB;
     """
 
+def get_mysql_conn(port=3308):
+    conn = pymysql.connect(user='root', password='clickhouse', host='127.0.0.1', port=port)
+    return conn
+
+
+def create_mysql_db(conn, name):
+    with conn.cursor() as cursor:
+        cursor.execute(
+            "CREATE DATABASE {} DEFAULT CHARACTER SET 'utf8'".format(name))
+
+
+def create_mysql_table(conn, tableName):
+    with conn.cursor() as cursor:
+        cursor.execute(create_table_sql_template.format(tableName))
+
 
 @pytest.fixture(scope="module")
 def started_cluster():
     try:
         cluster.start()
 
-        conn = get_mysql_conn()
         ## create mysql db and table
-        create_mysql_db(conn, 'clickhouse')
+        conn1 = get_mysql_conn(port=3308)
+        create_mysql_db(conn1, 'clickhouse')
         yield cluster
 
     finally:
@@ -52,6 +69,7 @@ CREATE TABLE {}(id UInt32, name String, age UInt32, money UInt32) ENGINE = MySQL
     assert node1.query(query.format(t=table_name)) == '250\n'
     conn.close()
 
+
 def test_insert_select(started_cluster):
     table_name = 'test_insert_select'
     conn = get_mysql_conn()
@@ -148,6 +166,7 @@ def test_table_function(started_cluster):
     assert node1.query("SELECT sum(`money`) FROM {}".format(table_function)).rstrip() == '60000'
     conn.close()
 
+
 def test_binary_type(started_cluster):
     conn = get_mysql_conn()
     with conn.cursor() as cursor:
@@ -156,6 +175,7 @@ def test_binary_type(started_cluster):
     node1.query("INSERT INTO {} VALUES (42, 'clickhouse')".format('TABLE FUNCTION ' + table_function))
     assert node1.query("SELECT * FROM {}".format(table_function)) == '42\tclickhouse\\0\\0\\0\\0\\0\\0\n'
 
+
 def test_enum_type(started_cluster):
     table_name = 'test_enum_type'
     conn = get_mysql_conn()
@@ -168,20 +188,76 @@ CREATE TABLE {}(id UInt32, name String, age UInt32, money UInt32, source Enum8('
     conn.close()
 
 
-def get_mysql_conn():
-    conn = pymysql.connect(user='root', password='clickhouse', host='127.0.0.1', port=3308)
-    return conn
+def test_mysql_distributed(started_cluster):
+    table_name = 'test_replicas'
 
+    conn1 = get_mysql_conn(port=3348)
+    conn2 = get_mysql_conn(port=3388)
+    conn3 = get_mysql_conn(port=3368)
+    conn4 = get_mysql_conn(port=3308)
 
-def create_mysql_db(conn, name):
-    with conn.cursor() as cursor:
-        cursor.execute(
-            "CREATE DATABASE {} DEFAULT CHARACTER SET 'utf8'".format(name))
+    create_mysql_db(conn1, 'clickhouse')
+    create_mysql_db(conn2, 'clickhouse')
+    create_mysql_db(conn3, 'clickhouse')
 
+    create_mysql_table(conn1, table_name)
+    create_mysql_table(conn2, table_name)
+    create_mysql_table(conn3, table_name)
+    create_mysql_table(conn4, table_name)
 
-def create_mysql_table(conn, tableName):
-    with conn.cursor() as cursor:
-        cursor.execute(create_table_sql_template.format(tableName))
+    # Storage with with 3 replicas
+    node2.query('''
+        CREATE TABLE test_replicas
+        (id UInt32, name String, age UInt32, money UInt32)
+        ENGINE = MySQL(`mysql{2|3|4}:3306`, 'clickhouse', 'test_replicas', 'root', 'clickhouse'); ''')
+
+    # Fill remote tables with different data to be able to check
+    nodes = [node1, node2, node2, node2]
+    for i in range(1, 5):
+        nodes[i-1].query('''
+            CREATE TABLE test_replica{}
+            (id UInt32, name String, age UInt32, money UInt32)
+            ENGINE = MySQL(`mysql{}:3306`, 'clickhouse', 'test_replicas', 'root', 'clickhouse');'''.format(i, i))
+        nodes[i-1].query("INSERT INTO test_replica{} (id, name) SELECT number, 'host{}' from numbers(10) ".format(i, i))
+
+    # test multiple ports parsing
+    result = node2.query('''SELECT DISTINCT(name) FROM mysql(`mysql{1|2|3}:3306`, 'clickhouse', 'test_replicas', 'root', 'clickhouse'); ''')
+    assert(result == 'host1\n' or result == 'host2\n' or result == 'host3\n')
+    result = node2.query('''SELECT DISTINCT(name) FROM mysql(`mysql1:3306|mysql2:3306|mysql3:3306`, 'clickhouse', 'test_replicas', 'root', 'clickhouse'); ''')
+    assert(result == 'host1\n' or result == 'host2\n' or result == 'host3\n')
+
+    # check all replicas are traversed
+    query = "SELECT * FROM ("
+    for i in range (3):
+        query += "SELECT name FROM test_replicas UNION DISTINCT "
+    query += "SELECT name FROM test_replicas)"
+
+    result = node2.query(query)
+    assert(result == 'host2\nhost3\nhost4\n')
+
+    # Storage with with two shards, each has 2 replicas
+    node2.query('''
+        CREATE TABLE test_shards
+        (id UInt32, name String, age UInt32, money UInt32)
+        ENGINE = ExternalDistributed('MySQL', `mysql{1|2}:3306,mysql{3|4}:3306`, 'clickhouse', 'test_replicas', 'root', 'clickhouse'); ''')
+
+    # Check only one replica in each shard is used
+    result = node2.query("SELECT DISTINCT(name) FROM test_shards ORDER BY name")
+    assert(result == 'host1\nhost3\n')
+
+    # check all replicas are traversed
+    query = "SELECT name FROM ("
+    for i in range (3):
+        query += "SELECT name FROM test_shards UNION DISTINCT "
+    query += "SELECT name FROM test_shards) ORDER BY name"
+    result = node2.query(query)
+    assert(result == 'host1\nhost2\nhost3\nhost4\n')
+
+    # disconnect mysql1
+    started_cluster.pause_container('mysql1')
+    result = node2.query("SELECT DISTINCT(name) FROM test_shards ORDER BY name")
+    started_cluster.unpause_container('mysql1')
+    assert(result == 'host2\nhost4\n' or result == 'host3\nhost4\n')
 
 
 if __name__ == '__main__':
diff --git a/tests/integration/test_storage_postgresql/test.py b/tests/integration/test_storage_postgresql/test.py
index 86a1d3b4547..b1ef58866bc 100644
--- a/tests/integration/test_storage_postgresql/test.py
+++ b/tests/integration/test_storage_postgresql/test.py
@@ -10,12 +10,14 @@ from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT
 
 cluster = ClickHouseCluster(__file__)
 node1 = cluster.add_instance('node1', main_configs=["configs/log_conf.xml"], with_postgres=True)
+node2 = cluster.add_instance('node2', main_configs=['configs/log_conf.xml'], with_postgres_cluster=True)
 
-def get_postgres_conn(database=False):
+def get_postgres_conn(database=False, port=5432):
     if database == True:
-        conn_string = "host='localhost' dbname='clickhouse' user='postgres' password='mysecretpassword'"
+        conn_string = "host='localhost' port={} dbname='clickhouse' user='postgres' password='mysecretpassword'".format(port)
     else:
-        conn_string = "host='localhost' user='postgres' password='mysecretpassword'"
+        conn_string = "host='localhost' port={} user='postgres' password='mysecretpassword'".format(port)
+
     conn = psycopg2.connect(conn_string)
     conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
     conn.autocommit = True
@@ -30,9 +32,20 @@ def create_postgres_db(conn, name):
 def started_cluster():
     try:
         cluster.start()
-        postgres_conn = get_postgres_conn()
-        print("postgres connected")
+
+        postgres_conn = get_postgres_conn(port=5432)
         create_postgres_db(postgres_conn, 'clickhouse')
+
+        postgres_conn = get_postgres_conn(port=5421)
+        create_postgres_db(postgres_conn, 'clickhouse')
+
+        postgres_conn = get_postgres_conn(port=5441)
+        create_postgres_db(postgres_conn, 'clickhouse')
+
+        postgres_conn = get_postgres_conn(port=5461)
+        create_postgres_db(postgres_conn, 'clickhouse')
+
+        print("postgres connected")
         yield cluster
 
     finally:
@@ -65,13 +78,19 @@ def test_postgres_conversions(started_cluster):
     cursor.execute(
         '''CREATE TABLE IF NOT EXISTS test_types (
         a smallint, b integer, c bigint, d real, e double precision, f serial, g bigserial,
-        h timestamp, i date, j decimal(5, 3), k numeric)''')
+        h timestamp, i date, j decimal(5, 3), k numeric, l boolean)''')
     node1.query('''
         INSERT INTO TABLE FUNCTION postgresql('postgres1:5432', 'clickhouse', 'test_types', 'postgres', 'mysecretpassword') VALUES
-        (-32768, -2147483648, -9223372036854775808, 1.12345, 1.1234567890, 2147483647, 9223372036854775807, '2000-05-12 12:12:12', '2000-05-12', 22.222, 22.222)''')
+        (-32768, -2147483648, -9223372036854775808, 1.12345, 1.1234567890, 2147483647, 9223372036854775807, '2000-05-12 12:12:12', '2000-05-12', 22.222, 22.222, 1)''')
     result = node1.query('''
-        SELECT a, b, c, d, e, f, g, h, i, j, toDecimal128(k, 3) FROM postgresql('postgres1:5432', 'clickhouse', 'test_types', 'postgres', 'mysecretpassword')''')
-    assert(result == '-32768\t-2147483648\t-9223372036854775808\t1.12345\t1.123456789\t2147483647\t9223372036854775807\t2000-05-12 12:12:12\t2000-05-12\t22.222\t22.222\n')
+        SELECT a, b, c, d, e, f, g, h, i, j, toDecimal128(k, 3), l FROM postgresql('postgres1:5432', 'clickhouse', 'test_types', 'postgres', 'mysecretpassword')''')
+    assert(result == '-32768\t-2147483648\t-9223372036854775808\t1.12345\t1.123456789\t2147483647\t9223372036854775807\t2000-05-12 12:12:12\t2000-05-12\t22.222\t22.222\t1\n')
+
+    cursor.execute("INSERT INTO test_types (l) VALUES (TRUE), (true), ('yes'), ('y'), ('1');")
+    cursor.execute("INSERT INTO test_types (l) VALUES (FALSE), (false), ('no'), ('off'), ('0');")
+    expected = "1\n1\n1\n1\n1\n1\n0\n0\n0\n0\n0\n"
+    result = node1.query('''SELECT l FROM postgresql('postgres1:5432', 'clickhouse', 'test_types', 'postgres', 'mysecretpassword')''')
+    assert(result == expected)
 
     cursor.execute(
         '''CREATE TABLE IF NOT EXISTS test_array_dimensions
@@ -219,6 +238,67 @@ def test_concurrent_queries(started_cluster):
     assert(int(count) == int(prev_count) + 16)
 
 
+def test_postgres_distributed(started_cluster):
+    conn0 = get_postgres_conn(port=5432, database=True)
+    conn1 = get_postgres_conn(port=5421, database=True)
+    conn2 = get_postgres_conn(port=5441, database=True)
+    conn3 = get_postgres_conn(port=5461, database=True)
+
+    cursor0 = conn0.cursor()
+    cursor1 = conn1.cursor()
+    cursor2 = conn2.cursor()
+    cursor3 = conn3.cursor()
+    cursors = [cursor0, cursor1, cursor2, cursor3]
+
+    for i in range(4):
+        cursors[i].execute('CREATE TABLE test_replicas (id Integer, name Text)')
+        cursors[i].execute("""INSERT INTO test_replicas select i, 'host{}' from generate_series(0, 99) as t(i);""".format(i + 1));
+
+    # test multiple ports parsing
+    result = node2.query('''SELECT DISTINCT(name) FROM postgresql(`postgres{1|2|3}:5432`, 'clickhouse', 'test_replicas', 'postgres', 'mysecretpassword'); ''')
+    assert(result == 'host1\n' or result == 'host2\n' or result == 'host3\n')
+    result = node2.query('''SELECT DISTINCT(name) FROM postgresql(`postgres2:5431|postgres3:5432`, 'clickhouse', 'test_replicas', 'postgres', 'mysecretpassword'); ''')
+    assert(result == 'host3\n' or result == 'host2\n')
+
+    # Create storage with with 3 replicas
+    node2.query('''
+        CREATE TABLE test_replicas
+        (id UInt32, name String)
+        ENGINE = PostgreSQL(`postgres{2|3|4}:5432`, 'clickhouse', 'test_replicas', 'postgres', 'mysecretpassword'); ''')
+
+    # Check all replicas are traversed
+    query = "SELECT name FROM ("
+    for i in range (3):
+        query += "SELECT name FROM test_replicas UNION DISTINCT "
+    query += "SELECT name FROM test_replicas) ORDER BY name"
+    result = node2.query(query)
+    assert(result == 'host2\nhost3\nhost4\n')
+
+    # Create storage with with two two shards, each has 2 replicas
+    node2.query('''
+        CREATE TABLE test_shards
+        (id UInt32, name String, age UInt32, money UInt32)
+        ENGINE = ExternalDistributed('PostgreSQL', `postgres{1|2}:5432,postgres{3|4}:5432`, 'clickhouse', 'test_replicas', 'postgres', 'mysecretpassword'); ''')
+
+    # Check only one replica in each shard is used
+    result = node2.query("SELECT DISTINCT(name) FROM test_shards ORDER BY name")
+    assert(result == 'host1\nhost3\n')
+
+    # Check all replicas are traversed
+    query = "SELECT name FROM ("
+    for i in range (3):
+        query += "SELECT name FROM test_shards UNION DISTINCT "
+    query += "SELECT name FROM test_shards) ORDER BY name"
+    result = node2.query(query)
+    assert(result == 'host1\nhost2\nhost3\nhost4\n')
+
+    # Disconnect postgres1
+    started_cluster.pause_container('postgres1')
+    result = node2.query("SELECT DISTINCT(name) FROM test_shards ORDER BY name")
+    started_cluster.unpause_container('postgres1')
+    assert(result == 'host2\nhost4\n' or result == 'host3\nhost4\n')
+
+
 if __name__ == '__main__':
     cluster.start()
     input("Cluster created, press any key to destroy...")
diff --git a/tests/integration/test_storage_s3/test.py b/tests/integration/test_storage_s3/test.py
index 8baa1cd64b0..9e91aae66b3 100644
--- a/tests/integration/test_storage_s3/test.py
+++ b/tests/integration/test_storage_s3/test.py
@@ -113,13 +113,18 @@ def run_query(instance, query, stdin=None, settings=None):
     return result
 
 
-# Test simple put.
-@pytest.mark.parametrize("maybe_auth,positive", [
-    ("", True),
-    ("'minio','minio123',", True),
-    ("'wrongid','wrongkey',", False)
+# Test simple put. Also checks that wrong credentials produce an error with every compression method.
+@pytest.mark.parametrize("maybe_auth,positive,compression", [
+    ("", True, 'auto'),
+    ("'minio','minio123',", True, 'auto'),
+    ("'wrongid','wrongkey',", False, 'auto'),
+    ("'wrongid','wrongkey',", False, 'gzip'),
+    ("'wrongid','wrongkey',", False, 'deflate'),
+    ("'wrongid','wrongkey',", False, 'brotli'),
+    ("'wrongid','wrongkey',", False, 'xz'),
+    ("'wrongid','wrongkey',", False, 'zstd')
 ])
-def test_put(cluster, maybe_auth, positive):
+def test_put(cluster, maybe_auth, positive, compression):
     # type: (ClickHouseCluster) -> None
 
     bucket = cluster.minio_bucket if not maybe_auth else cluster.minio_restricted_bucket
@@ -128,8 +133,8 @@ def test_put(cluster, maybe_auth, positive):
     values = "(1, 2, 3), (3, 2, 1), (78, 43, 45)"
     values_csv = "1,2,3\n3,2,1\n78,43,45\n"
     filename = "test.csv"
-    put_query = "insert into table function s3('http://{}:{}/{}/{}', {}'CSV', '{}') values {}".format(
-        cluster.minio_host, cluster.minio_port, bucket, filename, maybe_auth, table_format, values)
+    put_query = f"""insert into table function s3('http://{cluster.minio_host}:{cluster.minio_port}/{bucket}/{filename}',
+                    {maybe_auth}'CSV', '{table_format}', {compression}) values {values}"""
 
     try:
         run_query(instance, put_query)
diff --git a/tests/performance/ColumnMap.xml b/tests/performance/ColumnMap.xml
index f6393985377..874ed638224 100644
--- a/tests/performance/ColumnMap.xml
+++ b/tests/performance/ColumnMap.xml
@@ -26,10 +26,13 @@ FROM
         arrayMap(x -> toString(x), range(100)) AS keys,
         arrayMap(x -> toString(x * x), range(100)) AS values,
         cast((keys, values), 'Map(String, String)') AS map
-    FROM numbers(10000)
+    FROM numbers_mt(10000)
 )
+SETTINGS max_insert_threads = 8
     </create_query>
 
+    <fill_query>optimize table column_map_test final</fill_query>
+
     <query>SELECT count() FROM column_map_test WHERE NOT ignore(arrayMap(x -> map[CONCAT(toString(x), {key_suffix})], range(0, 100, 10)))</query>
 
     <drop_query>DROP TABLE IF EXISTS column_map_test</drop_query>
diff --git a/tests/performance/avg_weighted.xml b/tests/performance/avg_weighted.xml
index df9e7c21068..2476011e6a9 100644
--- a/tests/performance/avg_weighted.xml
+++ b/tests/performance/avg_weighted.xml
@@ -11,8 +11,8 @@
 
     <create_query>CREATE TABLE perf_avg(
         num UInt64,
-        num_u Decimal256(75) DEFAULT toDecimal256(num / 400000, 75),
-        num_f Float64 DEFAULT num / 100
+        num_u Decimal256(75) MATERIALIZED toDecimal256(num / 400000, 75),
+        num_f Float64 MATERIALIZED num / 100
         ) ENGINE = MergeTree() ORDER BY num
     </create_query>
 
@@ -23,6 +23,8 @@
         LIMIT 50000000
     </fill_query>
 
+    <fill_query>optimize table perf_avg final</fill_query>
+
     <query>SELECT avg(num)                  FROM perf_avg FORMAT Null</query>
     <query>SELECT avg(2 * num)              FROM perf_avg FORMAT Null</query>
     <query>SELECT avg(num_u)                FROM perf_avg FORMAT Null</query>
diff --git a/tests/performance/decimal_aggregates.xml b/tests/performance/decimal_aggregates.xml
index f7bc2ac1868..3fc1408d7e4 100644
--- a/tests/performance/decimal_aggregates.xml
+++ b/tests/performance/decimal_aggregates.xml
@@ -18,7 +18,7 @@
 
     <query>SELECT uniq(d32), uniqCombined(d32), uniqExact(d32), uniqHLL12(d32) FROM     (SELECT * FROM t LIMIT 10000000)</query>
     <query>SELECT uniq(d64), uniqCombined(d64), uniqExact(d64), uniqHLL12(d64) FROM     (SELECT * FROM t LIMIT 10000000)</query>
-    <query>SELECT uniq(d128), uniqCombined(d128), uniqExact(d128), uniqHLL12(d128) FROM (SELECT * FROM t LIMIT 1000000)</query>
+    <query>SELECT uniq(d128), uniqCombined(d128), uniqExact(d128), uniqHLL12(d128) FROM (SELECT * FROM t LIMIT 10000000)</query>
 
     <query>SELECT median(d32), medianExact(d32), medianExactWeighted(d32, 2) FROM    (SELECT * FROM t LIMIT 10000000)</query>
     <query>SELECT median(d64), medianExact(d64), medianExactWeighted(d64, 2) FROM    (SELECT * FROM t LIMIT 1000000)</query>
diff --git a/tests/performance/direct_dictionary.xml b/tests/performance/direct_dictionary.xml
index 97ecdfe3e95..e827ea0a76f 100644
--- a/tests/performance/direct_dictionary.xml
+++ b/tests/performance/direct_dictionary.xml
@@ -93,6 +93,12 @@
         LIMIT {elements_count}
         FORMAT Null;
     </query>
+    <query>
+        SELECT dictGet('default.simple_key_direct_dictionary', ('value_int', 'value_string', 'value_decimal', 'value_string_nullable'), number)
+        FROM system.numbers
+        LIMIT {elements_count}
+        FORMAT Null;
+    </query>
     <query>
         SELECT dictHas('default.simple_key_direct_dictionary', number)
         FROM system.numbers
@@ -106,6 +112,12 @@
         LIMIT {elements_count}
         FORMAT Null;
     </query>
+    <query>
+        SELECT dictGet('default.complex_key_direct_dictionary', ('value_int', 'value_string', 'value_decimal', 'value_string_nullable'), (number, toString(number)))
+        FROM system.numbers
+        LIMIT {elements_count}
+        FORMAT Null;
+    </query>
     <query>
         SELECT dictHas('default.complex_key_direct_dictionary', (number, toString(number)))
         FROM system.numbers
diff --git a/tests/performance/flat_dictionary.xml b/tests/performance/flat_dictionary.xml
index e3347358fb0..a571785a7f0 100644
--- a/tests/performance/flat_dictionary.xml
+++ b/tests/performance/flat_dictionary.xml
@@ -1,4 +1,8 @@
 <test max_ignored_relative_change="0.3">
+    <preconditions>
+        <table_exists>please_fix_me</table_exists>
+    </preconditions>
+
     <create_query>
         CREATE TABLE simple_key_flat_dictionary_source_table
         (
@@ -21,7 +25,7 @@
         )
         PRIMARY KEY id
         SOURCE(CLICKHOUSE(DB 'default' TABLE 'simple_key_flat_dictionary_source_table'))
-        LAYOUT(FLAT())
+        LAYOUT(FLAT(INITIAL_ARRAY_SIZE 50000 MAX_ARRAY_SIZE 5000000))
         LIFETIME(MIN 0 MAX 1000)
     </create_query>
 
@@ -29,7 +33,7 @@
         INSERT INTO simple_key_flat_dictionary_source_table
         SELECT number, number, toString(number), toDecimal64(number, 8), toString(number)
         FROM system.numbers
-        LIMIT 500000;
+        LIMIT 5000000;
     </fill_query>
 
     <substitutions>
@@ -46,10 +50,10 @@
         <substitution>
             <name>elements_count</name>
             <values>
-                <value>250000</value>
-                <value>500000</value>
-                <value>750000</value>
-                <value>1000000</value>
+                <value>2500000</value>
+                <value>5000000</value>
+                <value>7500000</value>
+                <value>10000000</value>
             </values>
         </substitution>
     </substitutions>
diff --git a/tests/performance/great_circle_dist.xml b/tests/performance/great_circle_dist.xml
index b5e271ddfa8..ad445f34417 100644
--- a/tests/performance/great_circle_dist.xml
+++ b/tests/performance/great_circle_dist.xml
@@ -2,6 +2,6 @@
     <!-- lon [-180; 180], lat [-90; 90] -->
     <query>SELECT count() FROM numbers(1000000) WHERE NOT ignore(greatCircleDistance((rand(1) % 360) * 1. - 180, (number % 150) * 1.2 - 90, (number % 360) + toFloat64(rand(2)) / 4294967296 - 180, (rand(3) % 180) * 1. - 90))</query>
     <!-- 55.755830, 37.617780 is center of Moscow -->
-    <query>SELECT count() FROM zeros(1000000) WHERE NOT ignore(greatCircleDistance(55. + toFloat64(rand(1)) / 4294967296, 37. + toFloat64(rand(2)) / 4294967296, 55. + toFloat64(rand(3)) / 4294967296, 37. + toFloat64(rand(4)) / 4294967296))</query>
+    <query>SELECT count() FROM zeros(10000000) WHERE NOT ignore(greatCircleDistance(55. + toFloat64(rand(1)) / 4294967296, 37. + toFloat64(rand(2)) / 4294967296, 55. + toFloat64(rand(3)) / 4294967296, 37. + toFloat64(rand(4)) / 4294967296))</query>
 </test>
 
diff --git a/tests/performance/if_array_string.xml b/tests/performance/if_array_string.xml
index 773509e1c4b..f1752767e76 100644
--- a/tests/performance/if_array_string.xml
+++ b/tests/performance/if_array_string.xml
@@ -4,5 +4,5 @@
     <query>SELECT count() FROM zeros(10000000) WHERE NOT ignore(rand() % 2 ? ['Hello', 'World'] : materialize(['a', 'b', 'c']))</query>
     <query>SELECT count() FROM zeros(10000000) WHERE NOT ignore(rand() % 2 ? materialize(['Hello', 'World']) : materialize(['a', 'b', 'c']))</query>
     <query>SELECT count() FROM zeros(10000000) WHERE NOT ignore(rand() % 2 ? materialize(['', '']) : emptyArrayString())</query>
-    <query>SELECT count() FROM zeros(1000000) WHERE NOT ignore(rand() % 2 ? materialize(['https://github.com/ClickHouse/ClickHouse/pull/1070', 'https://www.google.ru/search?newwindow=1&amp;site=&amp;source=hp&amp;q=zookeeper+wire+protocol+exists&amp;oq=zookeeper+wire+protocol+exists&amp;gs_l=psy-ab.3...330.6300.0.6687.33.28.0.0.0.0.386.4838.0j5j9j5.19.0....0...1.1.64.psy-ab..14.17.4448.0..0j35i39k1j0i131k1j0i22i30k1j0i19k1j33i21k1.r_3uFoNOrSU']) : emptyArrayString())</query>
+    <query>SELECT count() FROM zeros(10000000) WHERE NOT ignore(rand() % 2 ? materialize(['https://github.com/ClickHouse/ClickHouse/pull/1070', 'https://www.google.ru/search?newwindow=1&amp;site=&amp;source=hp&amp;q=zookeeper+wire+protocol+exists&amp;oq=zookeeper+wire+protocol+exists&amp;gs_l=psy-ab.3...330.6300.0.6687.33.28.0.0.0.0.386.4838.0j5j9j5.19.0....0...1.1.64.psy-ab..14.17.4448.0..0j35i39k1j0i131k1j0i22i30k1j0i19k1j33i21k1.r_3uFoNOrSU']) : emptyArrayString())</query>
 </test>
diff --git a/tests/performance/joins_in_memory.xml b/tests/performance/joins_in_memory.xml
index fac6f2659c6..158602e28ab 100644
--- a/tests/performance/joins_in_memory.xml
+++ b/tests/performance/joins_in_memory.xml
@@ -13,12 +13,12 @@
     <query short='1' tag='ANY LEFT IN'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042)</query>
 
     <query tag='INNER'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64 WHERE i32 = 20042</query>
-    <query tag='INNER KEY'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042</query>
+    <query tag='INNER KEY'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
     <query tag='INNER ON'>SELECT COUNT() FROM ints l INNER JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042</query>
     <query tag='INNER IN'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042)</query>
 
     <query tag='LEFT'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64 WHERE i32 = 20042</query>
-    <query tag='LEFT KEY'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042</query>
+    <query tag='LEFT KEY'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
     <query tag='LEFT ON'>SELECT COUNT() FROM ints l LEFT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042</query>
     <query tag='LEFT IN'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042)</query>
 
diff --git a/tests/performance/joins_in_memory_pmj.xml b/tests/performance/joins_in_memory_pmj.xml
index 87d1c0df14c..d122dba72c3 100644
--- a/tests/performance/joins_in_memory_pmj.xml
+++ b/tests/performance/joins_in_memory_pmj.xml
@@ -3,53 +3,54 @@
 
     <settings>
         <join_algorithm>partial_merge</join_algorithm>
+        <query_plan_filter_push_down>0</query_plan_filter_push_down>
     </settings>
 
-    <fill_query>INSERT INTO ints SELECT number AS i64, i64 AS i32, i64 AS i16, i64 AS i8 FROM numbers(10000)</fill_query>
-    <fill_query>INSERT INTO ints SELECT 10000 + number % 1000 AS i64, i64 AS i32, i64 AS i16, i64 AS i8 FROM numbers(10000)</fill_query>
-    <fill_query>INSERT INTO ints SELECT 20000 + number % 100 AS i64, i64 AS i32, i64 AS i16, i64 AS i8 FROM numbers(10000)</fill_query>
-    <fill_query>INSERT INTO ints SELECT 30000 + number % 10 AS i64, i64 AS i32, i64 AS i16, i64 AS i8 FROM numbers(10000)</fill_query>
-    <fill_query>INSERT INTO ints SELECT 40000 + number % 1 AS i64, i64 AS i32, i64 AS i16, i64 AS i8 FROM numbers(10000)</fill_query>
+    <fill_query>INSERT INTO ints SELECT number AS i64, i64 AS i32, i64 AS i16, i64 AS i8 FROM numbers(10000) settings query_plan_filter_push_down = 0</fill_query>
+    <fill_query>INSERT INTO ints SELECT 10000 + number % 1000 AS i64, i64 AS i32, i64 AS i16, i64 AS i8 FROM numbers(10000) settings query_plan_filter_push_down = 0</fill_query>
+    <fill_query>INSERT INTO ints SELECT 20000 + number % 100 AS i64, i64 AS i32, i64 AS i16, i64 AS i8 FROM numbers(10000) settings query_plan_filter_push_down = 0</fill_query>
+    <fill_query>INSERT INTO ints SELECT 30000 + number % 10 AS i64, i64 AS i32, i64 AS i16, i64 AS i8 FROM numbers(10000) settings query_plan_filter_push_down = 0</fill_query>
+    <fill_query>INSERT INTO ints SELECT 40000 + number % 1 AS i64, i64 AS i32, i64 AS i16, i64 AS i8 FROM numbers(10000) settings query_plan_filter_push_down = 0</fill_query>
 
-    <query short='1' tag='ANY LEFT'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64 WHERE i32 = 20042</query>
-    <query short='1' tag='ANY LEFT KEY'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042</query>
-    <query short='1' tag='ANY LEFT ON'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042</query>
-    <query short='1' tag='ANY LEFT IN'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042)</query>
+    <query short='1' tag='ANY LEFT'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query short='1' tag='ANY LEFT KEY'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query short='1' tag='ANY LEFT ON'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query short='1' tag='ANY LEFT IN'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) settings query_plan_filter_push_down = 0</query>
 
-    <query tag='INNER'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64 WHERE i32 = 20042</query>
-    <query tag='INNER KEY'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042</query>
-    <query tag='INNER ON'>SELECT COUNT() FROM ints l INNER JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042</query>
-    <query tag='INNER IN'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042)</query>
+    <query tag='INNER'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='INNER KEY'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='INNER ON'>SELECT COUNT() FROM ints l INNER JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='INNER IN'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) settings query_plan_filter_push_down = 0</query>
 
-    <query tag='LEFT'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64 WHERE i32 = 20042</query>
-    <query tag='LEFT KEY'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042</query>
-    <query tag='LEFT ON'>SELECT COUNT() FROM ints l LEFT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042</query>
-    <query tag='LEFT IN'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042)</query>
+    <query tag='LEFT'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='LEFT KEY'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='LEFT ON'>SELECT COUNT() FROM ints l LEFT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='LEFT IN'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) settings query_plan_filter_push_down = 0</query>
 
-    <query short='1' tag='ANY LEFT (noopt)'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0</query>
-    <query short='1' tag='ANY LEFT KEY (noopt)'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0</query>
-    <query short='1' tag='ANY LEFT ON (noopt)'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0</query>
-    <query short='1' tag='ANY LEFT IN (noopt)'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) SETTINGS partial_merge_join_optimizations = 0</query>
+    <query short='1' tag='ANY LEFT (noopt)'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
+    <query short='1' tag='ANY LEFT KEY (noopt)'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
+    <query short='1' tag='ANY LEFT ON (noopt)'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
+    <query short='1' tag='ANY LEFT IN (noopt)'>SELECT COUNT() FROM ints l ANY LEFT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
 
-    <query tag='INNER (noopt)'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0</query>
-    <query tag='INNER KEY (noopt)'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0</query>
-    <query tag='INNER ON (noopt)'>SELECT COUNT() FROM ints l INNER JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0</query>
-    <query tag='INNER IN (noopt)'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) SETTINGS partial_merge_join_optimizations = 0</query>
+    <query tag='INNER (noopt)'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
+    <query tag='INNER KEY (noopt)'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
+    <query tag='INNER ON (noopt)'>SELECT COUNT() FROM ints l INNER JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
+    <query tag='INNER IN (noopt)'>SELECT COUNT() FROM ints l INNER JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
 
-    <query tag='LEFT (noopt)'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0</query>
-    <query tag='LEFT KEY (noopt)'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0</query>
-    <query tag='LEFT ON (noopt)'>SELECT COUNT() FROM ints l LEFT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0</query>
-    <query tag='LEFT IN (noopt)'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) SETTINGS partial_merge_join_optimizations = 0</query>
+    <query tag='LEFT (noopt)'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
+    <query tag='LEFT KEY (noopt)'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
+    <query tag='LEFT ON (noopt)'>SELECT COUNT() FROM ints l LEFT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
+    <query tag='LEFT IN (noopt)'>SELECT COUNT() FROM ints l LEFT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) SETTINGS partial_merge_join_optimizations = 0, query_plan_filter_push_down = 0</query>
 
-    <query tag='RIGHT'>SELECT COUNT() FROM ints l RIGHT JOIN ints r USING i64 WHERE i32 = 20042</query>
-    <query tag='RIGHT KEY'>SELECT COUNT() FROM ints l RIGHT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042</query>
-    <query tag='RIGHT ON'>SELECT COUNT() FROM ints l RIGHT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042</query>
-    <query tag='RIGHT IN'>SELECT COUNT() FROM ints l RIGHT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042)</query>
+    <query tag='RIGHT'>SELECT COUNT() FROM ints l RIGHT JOIN ints r USING i64 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='RIGHT KEY'>SELECT COUNT() FROM ints l RIGHT JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='RIGHT ON'>SELECT COUNT() FROM ints l RIGHT JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='RIGHT IN'>SELECT COUNT() FROM ints l RIGHT JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) settings query_plan_filter_push_down = 0</query>
 
-    <query tag='FULL'>SELECT COUNT() FROM ints l FULL JOIN ints r USING i64 WHERE i32 = 20042</query>
-    <query tag='FULL KEY'>SELECT COUNT() FROM ints l FULL JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042</query>
-    <query tag='FULL ON'>SELECT COUNT() FROM ints l FULL JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042</query>
-    <query tag='FULL IN'>SELECT COUNT() FROM ints l FULL JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042)</query>
+    <query tag='FULL'>SELECT COUNT() FROM ints l FULL JOIN ints r USING i64 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='FULL KEY'>SELECT COUNT() FROM ints l FULL JOIN ints r USING i64,i32,i16,i8 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='FULL ON'>SELECT COUNT() FROM ints l FULL JOIN ints r ON l.i64 = r.i64 WHERE i32 = 20042 settings query_plan_filter_push_down = 0</query>
+    <query tag='FULL IN'>SELECT COUNT() FROM ints l FULL JOIN ints r USING i64 WHERE i32 IN(42, 10042, 20042, 30042, 40042) settings query_plan_filter_push_down = 0</query>
 
     <drop_query>DROP TABLE IF EXISTS ints</drop_query>
 </test>
diff --git a/tests/performance/json_extract_simdjson.xml b/tests/performance/json_extract_simdjson.xml
index f9f6df5140e..9ec3613d5e8 100644
--- a/tests/performance/json_extract_simdjson.xml
+++ b/tests/performance/json_extract_simdjson.xml
@@ -1,7 +1,4 @@
 <test>
-
-
-
     <substitutions>
         <substitution>
            <name>json</name>
@@ -21,19 +18,19 @@
         <allow_simdjson>1</allow_simdjson>
     </settings>
 
-    <query>SELECT 'simdjson-1', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractString(materialize({json}), 'sparam'))</query>
-    <query>SELECT 'simdjson-2', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractString(materialize({json}), 'sparam', 'nested_1'))</query>
-    <query>SELECT 'simdjson-3', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractInt(materialize({json}), 'nparam'))</query>
-    <query>SELECT 'simdjson-4', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractUInt(materialize({json}), 'nparam'))</query>
-    <query>SELECT 'simdjson-5', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractFloat(materialize({json}), 'fparam'))</query>
+    <query>SELECT 'simdjson-1',  count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractString(materialize({json}), 'sparam'))</query>
+    <query>SELECT 'simdjson-2',  count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractString(materialize({json}), 'sparam', 'nested_1'))</query>
+    <query>SELECT 'simdjson-3',  count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractInt(materialize({json}), 'nparam'))</query>
+    <query>SELECT 'simdjson-4',  count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractUInt(materialize({json}), 'nparam'))</query>
+    <query>SELECT 'simdjson-5',  count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractFloat(materialize({json}), 'fparam'))</query>
 
-    <query>SELECT 'simdjson-6', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractString(materialize({long_json}), 'sparam'))</query>
-    <query>SELECT 'simdjson-7', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractString(materialize({long_json}), 'sparam', 'nested_1'))</query>
-    <query>SELECT 'simdjson-8', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractInt(materialize({long_json}), 'nparam'))</query>
-    <query>SELECT 'simdjson-9', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractUInt(materialize({long_json}), 'nparam'))</query>
-    <query>SELECT 'simdjson-10', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractRaw(materialize({long_json}), 'fparam'))</query>
-    <query>SELECT 'simdjson-11', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractFloat(materialize({long_json}), 'fparam'))</query>
-    <query>SELECT 'simdjson-12', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractFloat(materialize({long_json}), 'fparam', 'nested_2', -2))</query>
-    <query>SELECT 'simdjson-13', count() FROM zeros(1000000) WHERE NOT ignore(JSONExtractBool(materialize({long_json}), 'bparam'))</query>
+    <query>SELECT 'simdjson-6',  count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractString(materialize({long_json}), 'sparam'))</query>
+    <query>SELECT 'simdjson-7',  count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractString(materialize({long_json}), 'sparam', 'nested_1'))</query>
+    <query>SELECT 'simdjson-8',  count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractInt(materialize({long_json}), 'nparam'))</query>
+    <query>SELECT 'simdjson-9',  count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractUInt(materialize({long_json}), 'nparam'))</query>
+    <query>SELECT 'simdjson-10', count() FROM zeros(3000000) WHERE NOT ignore(JSONExtractRaw(materialize({long_json}), 'fparam'))</query>
+    <query>SELECT 'simdjson-11', count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractFloat(materialize({long_json}), 'fparam'))</query>
+    <query>SELECT 'simdjson-12', count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractFloat(materialize({long_json}), 'fparam', 'nested_2', -2))</query>
+    <query>SELECT 'simdjson-13', count() FROM zeros(5000000) WHERE NOT ignore(JSONExtractBool(materialize({long_json}), 'bparam'))</query>
 
 </test>
diff --git a/tests/performance/order_by_decimals.xml b/tests/performance/order_by_decimals.xml
index 4889137865d..20b860f0a2d 100644
--- a/tests/performance/order_by_decimals.xml
+++ b/tests/performance/order_by_decimals.xml
@@ -4,13 +4,10 @@
         <tag>comparison</tag>
     </tags>
 
+    <query>SELECT toInt32(number)          AS n FROM numbers(10000000) ORDER BY n DESC FORMAT Null</query>
+    <query>SELECT toDecimal32(number, 0)   AS n FROM numbers(10000000) ORDER BY n      FORMAT Null</query>
 
-
-    <query>SELECT toInt32(number) AS n FROM numbers(1000000) ORDER BY n DESC FORMAT Null</query>
-    <query>SELECT toDecimal32(number, 0) AS n FROM numbers(1000000) ORDER BY n FORMAT Null</query>
-
-    <query>SELECT toDecimal32(number, 0) AS n FROM numbers(1000000) ORDER BY n DESC FORMAT Null</query>
-    <query>SELECT toDecimal64(number, 8) AS n FROM numbers(1000000) ORDER BY n DESC FORMAT Null</query>
-    <query>SELECT toDecimal128(number, 10) AS n FROM numbers(1000000) ORDER BY n DESC FORMAT Null</query>
-
+    <query>SELECT toDecimal32(number, 0)   AS n FROM numbers(10000000) ORDER BY n DESC FORMAT Null</query>
+    <query>SELECT toDecimal64(number, 8)   AS n FROM numbers(10000000) ORDER BY n DESC FORMAT Null</query>
+    <query>SELECT toDecimal128(number, 10) AS n FROM numbers(10000000) ORDER BY n DESC FORMAT Null</query>
 </test>
diff --git a/tests/performance/order_by_read_in_order.xml b/tests/performance/order_by_read_in_order.xml
index b91cd14baf4..cdbf477c335 100644
--- a/tests/performance/order_by_read_in_order.xml
+++ b/tests/performance/order_by_read_in_order.xml
@@ -3,10 +3,11 @@
         <table_exists>hits_100m_single</table_exists>
     </preconditions>
 
-<query>SELECT * FROM hits_100m_single ORDER BY CounterID, EventDate LIMIT 1000</query>
-<query>SELECT * FROM hits_100m_single ORDER BY CounterID DESC, toStartOfWeek(EventDate) DESC LIMIT 100</query>
+<!-- Some queries are almost instantaneous index lookups, so we mark them as short. -->
+<query short="1">SELECT * FROM hits_100m_single ORDER BY CounterID, EventDate LIMIT 100</query>
+<query short="1">SELECT * FROM hits_100m_single ORDER BY CounterID DESC, toStartOfWeek(EventDate) DESC LIMIT 100</query>
 <query>SELECT * FROM hits_100m_single ORDER BY CounterID, EventDate, URL LIMIT 100</query>
-<query>SELECT * FROM hits_100m_single WHERE CounterID IN (152220, 168777, 149234, 149234) ORDER BY CounterID DESC, EventDate DESC LIMIT 100</query>
+<query short="1">SELECT * FROM hits_100m_single WHERE CounterID IN (152220, 168777, 149234, 149234) ORDER BY CounterID DESC, EventDate DESC LIMIT 100</query>
 <query>SELECT * FROM hits_100m_single WHERE UserID=1988954671305023629 ORDER BY CounterID, EventDate LIMIT 100</query>
 
 </test>
diff --git a/tests/performance/parse_engine_file.xml b/tests/performance/parse_engine_file.xml
index d49670b36b5..d0226c3bb68 100644
--- a/tests/performance/parse_engine_file.xml
+++ b/tests/performance/parse_engine_file.xml
@@ -30,7 +30,7 @@
 
 <fill_query>INSERT INTO table_{format} SELECT * FROM test.hits LIMIT 100000</fill_query>
 
-<query>SELECT * FROM table_{format} FORMAT Null</query>
+<query short="'{format}' == 'Native'">SELECT * FROM table_{format} FORMAT Null</query>
 
 <drop_query>DROP TABLE IF EXISTS table_{format}</drop_query>
 
diff --git a/tests/performance/point_in_polygon.xml b/tests/performance/point_in_polygon.xml
index 403c2d62cba..31c24eb006f 100644
--- a/tests/performance/point_in_polygon.xml
+++ b/tests/performance/point_in_polygon.xml
@@ -1,5 +1,9 @@
 <test>
     <settings>
+        <!--
+            Not sure why it's needed. Maybe it has something to do with the
+            resulting block size of Memory table.
+         -->
         <optimize_trivial_insert_select>0</optimize_trivial_insert_select>
     </settings>
 
@@ -8,7 +12,8 @@
         INSERT INTO polygons
         WITH number + 1 AS radius
         SELECT [arrayMap(x -> (cos(x / 90. * pi()) * radius, sin(x / 90. * pi()) * radius), range(180))]
-        FROM numbers(1000000)
+        FROM numbers_mt(5000000)
+        SETTINGS max_insert_threads = 2, max_memory_usage = 30000000000
     </create_query>
 
     <query>SELECT pointInPolygon((100, 100), polygon) FROM polygons FORMAT Null</query>
diff --git a/tests/performance/questdb_sum_int32.xml b/tests/performance/questdb_sum_int32.xml
index ae13210107e..613ef3dc058 100644
--- a/tests/performance/questdb_sum_int32.xml
+++ b/tests/performance/questdb_sum_int32.xml
@@ -25,7 +25,8 @@
     </substitutions>
 
     <create_query>CREATE TABLE `zz_{type}_{engine}` (x {type}) ENGINE {engine}</create_query>
-    <fill_query>INSERT INTO `zz_{type}_{engine}` SELECT rand() FROM numbers(1000000000)</fill_query>
+    <fill_query>INSERT INTO `zz_{type}_{engine}` SELECT rand() FROM numbers_mt(1000000000) SETTINGS max_insert_threads = 8</fill_query>
+    <fill_query>OPTIMIZE TABLE `zz_{type}_MergeTree ORDER BY tuple()` FINAL</fill_query>
 
     <query>SELECT sum(x) FROM `zz_{type}_{engine}`</query>
 
diff --git a/tests/queries/0_stateless/00987_distributed_stack_overflow.sql b/tests/queries/0_stateless/00987_distributed_stack_overflow.sql
index 4baa6969b31..d2e2b8f37ef 100644
--- a/tests/queries/0_stateless/00987_distributed_stack_overflow.sql
+++ b/tests/queries/0_stateless/00987_distributed_stack_overflow.sql
@@ -5,13 +5,13 @@ DROP TABLE IF EXISTS distr2;
 CREATE TABLE distr (x UInt8) ENGINE = Distributed(test_shard_localhost, currentDatabase(), distr); -- { serverError 269 }
 
 CREATE TABLE distr0 (x UInt8) ENGINE = Distributed(test_shard_localhost, '', distr0);
-SELECT * FROM distr0; -- { serverError 306 }
+SELECT * FROM distr0; -- { serverError 581 }
 
 CREATE TABLE distr1 (x UInt8) ENGINE = Distributed(test_shard_localhost, currentDatabase(), distr2);
 CREATE TABLE distr2 (x UInt8) ENGINE = Distributed(test_shard_localhost, currentDatabase(), distr1);
 
-SELECT * FROM distr1; -- { serverError 306 }
-SELECT * FROM distr2; -- { serverError 306 }
+SELECT * FROM distr1; -- { serverError 581 }
+SELECT * FROM distr2; -- { serverError 581 }
 
 DROP TABLE distr0;
 DROP TABLE distr1;
diff --git a/tests/queries/0_stateless/01039_row_policy_dcl.sh b/tests/queries/0_stateless/01039_row_policy_dcl.sh
new file mode 100755
index 00000000000..8c2249f2981
--- /dev/null
+++ b/tests/queries/0_stateless/01039_row_policy_dcl.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+${CLICKHOUSE_CLIENT} -q "SHOW POLICIES ON $CLICKHOUSE_DATABASE.*"
diff --git a/tests/queries/0_stateless/01039_row_policy_dcl.sql b/tests/queries/0_stateless/01039_row_policy_dcl.sql
deleted file mode 100644
index 14742a72914..00000000000
--- a/tests/queries/0_stateless/01039_row_policy_dcl.sql
+++ /dev/null
@@ -1 +0,0 @@
-SHOW POLICIES;
diff --git a/tests/queries/0_stateless/01079_bad_alters_zookeeper_long.sh b/tests/queries/0_stateless/01079_bad_alters_zookeeper_long.sh
index 6452b830f38..6e79be90046 100755
--- a/tests/queries/0_stateless/01079_bad_alters_zookeeper_long.sh
+++ b/tests/queries/0_stateless/01079_bad_alters_zookeeper_long.sh
@@ -21,7 +21,7 @@ $CLICKHOUSE_CLIENT --query "ALTER TABLE table_for_bad_alters MODIFY COLUMN value
 
 sleep 2
 
-while [[ $($CLICKHOUSE_CLIENT --query "KILL MUTATION WHERE mutation_id='0000000000'" 2>&1) ]]; do
+while [[ $($CLICKHOUSE_CLIENT --query "KILL MUTATION WHERE mutation_id='0000000000' and database = '$CLICKHOUSE_DATABASE'" 2>&1) ]]; do
     sleep 1
 done
 
diff --git a/tests/queries/0_stateless/01151_storage_merge_filter_tables_by_virtual_column.reference b/tests/queries/0_stateless/01151_storage_merge_filter_tables_by_virtual_column.reference
new file mode 100644
index 00000000000..90755b06aa9
--- /dev/null
+++ b/tests/queries/0_stateless/01151_storage_merge_filter_tables_by_virtual_column.reference
@@ -0,0 +1,7 @@
+30	4995
+20	4950
+15	4700
+20	495
+20	4545
+15	470
+15	4520
diff --git a/tests/queries/0_stateless/01151_storage_merge_filter_tables_by_virtual_column.sql b/tests/queries/0_stateless/01151_storage_merge_filter_tables_by_virtual_column.sql
new file mode 100644
index 00000000000..2a250725654
--- /dev/null
+++ b/tests/queries/0_stateless/01151_storage_merge_filter_tables_by_virtual_column.sql
@@ -0,0 +1,26 @@
+drop table if exists src_table_1;
+drop table if exists src_table_2;
+drop table if exists src_table_3;
+drop table if exists set;
+
+create table src_table_1 (n UInt64) engine=Memory as select * from numbers(10);
+create table src_table_2 (n UInt64) engine=Log as select number * 10 from numbers(10);
+create table src_table_3 (n UInt64) engine=MergeTree order by n as select number * 100 from numbers(10);
+create table set (s String) engine=Set as select arrayJoin(['src_table_1', 'src_table_2']);
+
+create temporary table tmp (s String);
+insert into tmp values ('src_table_1'), ('src_table_3');
+
+select count(), sum(n) from merge(currentDatabase(), 'src_table');
+-- FIXME #21401 select count(), sum(n) from merge(currentDatabase(), 'src_table') where _table = 'src_table_1' or toInt8(substr(_table, 11, 1)) = 2;
+select count(), sum(n) from merge(currentDatabase(), 'src_table') where _table in ('src_table_2', 'src_table_3');
+select count(), sum(n) from merge(currentDatabase(), 'src_table') where _table in ('src_table_2', 'src_table_3') and n % 20 = 0;
+select count(), sum(n) from merge(currentDatabase(), 'src_table') where _table in set;
+select count(), sum(n) from merge(currentDatabase(), 'src_table') where _table in tmp;
+select count(), sum(n) from merge(currentDatabase(), 'src_table') where _table in set and n % 2 = 0;
+select count(), sum(n) from merge(currentDatabase(), 'src_table') where n % 2 = 0 and _table in tmp;
+
+drop table src_table_1;
+drop table src_table_2;
+drop table src_table_3;
+drop table set;
diff --git a/tests/queries/0_stateless/01294_create_settings_profile.reference b/tests/queries/0_stateless/01294_create_settings_profile.reference
index ab1b3833419..da47b084070 100644
--- a/tests/queries/0_stateless/01294_create_settings_profile.reference
+++ b/tests/queries/0_stateless/01294_create_settings_profile.reference
@@ -38,8 +38,12 @@ CREATE SETTINGS PROFILE s2_01294 SETTINGS max_memory_usage = 5000000
 CREATE SETTINGS PROFILE s3_01294 TO ALL
 CREATE SETTINGS PROFILE s4_01294 TO ALL
 CREATE SETTINGS PROFILE s1_01294 SETTINGS max_memory_usage = 6000000
+CREATE SETTINGS PROFILE s2_01294 SETTINGS max_memory_usage = 6000000
+CREATE SETTINGS PROFILE s3_01294 TO ALL
+CREATE SETTINGS PROFILE s4_01294 TO ALL
+CREATE SETTINGS PROFILE s1_01294 SETTINGS max_memory_usage = 6000000
 CREATE SETTINGS PROFILE s2_01294 SETTINGS max_memory_usage = 6000000 TO r1_01294
-CREATE SETTINGS PROFILE s3_01294 SETTINGS max_memory_usage = 6000000 TO r1_01294
+CREATE SETTINGS PROFILE s3_01294 TO r1_01294
 CREATE SETTINGS PROFILE s4_01294 TO r1_01294
 -- readonly ambiguity
 CREATE SETTINGS PROFILE s1_01294 SETTINGS readonly = 1
@@ -53,7 +57,8 @@ s1_01294	local directory	0	0	[]	[]
 s2_01294	local directory	1	0	['r1_01294']	[]
 s3_01294	local directory	1	0	['r1_01294']	[]
 s4_01294	local directory	1	0	['r1_01294']	[]
-s5_01294	local directory	3	1	[]	['r1_01294']
+s5_01294	local directory	3	0	['u1_01294']	[]
+s6_01294	local directory	0	1	[]	['r1_01294','u1_01294']
 -- system.settings_profile_elements
 s2_01294	\N	\N	0	readonly	0	\N	\N	\N	\N
 s3_01294	\N	\N	0	max_memory_usage	5000000	4000000	6000000	1	\N
diff --git a/tests/queries/0_stateless/01294_create_settings_profile.sql b/tests/queries/0_stateless/01294_create_settings_profile.sql
index 9dbabd3f068..b7dd91ad6ed 100644
--- a/tests/queries/0_stateless/01294_create_settings_profile.sql
+++ b/tests/queries/0_stateless/01294_create_settings_profile.sql
@@ -82,7 +82,8 @@ SELECT '-- multiple profiles in one command';
 CREATE PROFILE s1_01294, s2_01294 SETTINGS max_memory_usage=5000000;
 CREATE PROFILE s3_01294, s4_01294 TO ALL;
 SHOW CREATE PROFILE s1_01294, s2_01294, s3_01294, s4_01294;
-ALTER PROFILE s1_01294, s2_01294, s3_01294 SETTINGS max_memory_usage=6000000;
+ALTER PROFILE s1_01294, s2_01294 SETTINGS max_memory_usage=6000000;
+SHOW CREATE PROFILE s1_01294, s2_01294, s3_01294, s4_01294;
 ALTER PROFILE s2_01294, s3_01294, s4_01294 TO r1_01294;
 SHOW CREATE PROFILE s1_01294, s2_01294, s3_01294, s4_01294;
 DROP PROFILE s1_01294, s2_01294, s3_01294, s4_01294;
@@ -107,12 +108,13 @@ CREATE PROFILE s1_01294;
 CREATE PROFILE s2_01294 SETTINGS readonly=0 TO r1_01294;;
 CREATE PROFILE s3_01294 SETTINGS max_memory_usage=5000000 MIN 4000000 MAX 6000000 READONLY TO r1_01294;
 CREATE PROFILE s4_01294 SETTINGS max_memory_usage=5000000 TO r1_01294;
-CREATE PROFILE s5_01294 SETTINGS INHERIT default, readonly=0, max_memory_usage MAX 6000000 WRITABLE TO ALL EXCEPT r1_01294;
+CREATE PROFILE s5_01294 SETTINGS INHERIT default, readonly=0, max_memory_usage MAX 6000000 WRITABLE TO u1_01294;
+CREATE PROFILE s6_01294 TO ALL EXCEPT u1_01294, r1_01294;
 SELECT name, storage, num_elements, apply_to_all, apply_to_list, apply_to_except FROM system.settings_profiles WHERE name LIKE 's%\_01294' ORDER BY name;
 
 SELECT '-- system.settings_profile_elements';
 SELECT * FROM system.settings_profile_elements WHERE profile_name LIKE 's%\_01294' ORDER BY profile_name, index;
-DROP PROFILE s1_01294, s2_01294, s3_01294, s4_01294, s5_01294;
+DROP PROFILE s1_01294, s2_01294, s3_01294, s4_01294, s5_01294, s6_01294;
 
 DROP ROLE r1_01294;
 DROP USER u1_01294;
diff --git a/tests/queries/0_stateless/01318_long_unsuccessful_mutation_zookeeper.sh b/tests/queries/0_stateless/01318_long_unsuccessful_mutation_zookeeper.sh
index a05304c670c..13250e82079 100755
--- a/tests/queries/0_stateless/01318_long_unsuccessful_mutation_zookeeper.sh
+++ b/tests/queries/0_stateless/01318_long_unsuccessful_mutation_zookeeper.sh
@@ -47,7 +47,7 @@ done
 
 echo "$query_result"
 
-$CLICKHOUSE_CLIENT --query "KILL MUTATION WHERE mutation_id='$first_mutation_id'"
+$CLICKHOUSE_CLIENT --query "KILL MUTATION WHERE mutation_id='$first_mutation_id' and database='$CLICKHOUSE_DATABASE'"
 
 check_query="SELECT sum(parts_to_do) FROM system.mutations WHERE table='mutation_table' and database='$CLICKHOUSE_DATABASE'"
 
diff --git a/tests/queries/0_stateless/01370_client_autocomplete_word_break_characters.expect b/tests/queries/0_stateless/01370_client_autocomplete_word_break_characters.expect
index 50ef009dee9..a6d52b39918 100755
--- a/tests/queries/0_stateless/01370_client_autocomplete_word_break_characters.expect
+++ b/tests/queries/0_stateless/01370_client_autocomplete_word_break_characters.expect
@@ -23,7 +23,7 @@ set is_done 0
 while {$is_done == 0} {
     send -- "\t"
     expect {
-        "_connections" {
+        "_" {
             set is_done 1
         }
         default {
diff --git a/tests/queries/0_stateless/01386_negative_float_constant_key_condition.reference b/tests/queries/0_stateless/01386_negative_float_constant_key_condition.reference
index 44e0be8e356..bb0b1cf658d 100644
--- a/tests/queries/0_stateless/01386_negative_float_constant_key_condition.reference
+++ b/tests/queries/0_stateless/01386_negative_float_constant_key_condition.reference
@@ -1,4 +1,3 @@
 0
 0
 0
-0
diff --git a/tests/queries/0_stateless/01386_negative_float_constant_key_condition.sql b/tests/queries/0_stateless/01386_negative_float_constant_key_condition.sql
index 216f43c4285..c2191d6ab96 100644
--- a/tests/queries/0_stateless/01386_negative_float_constant_key_condition.sql
+++ b/tests/queries/0_stateless/01386_negative_float_constant_key_condition.sql
@@ -12,7 +12,7 @@ SETTINGS index_granularity = 8192;
 INSERT INTO t0 VALUES (0, 0);
 
 SELECT t0.c1 FROM t0 WHERE NOT (t0.c1 OR (t0.c0 AND -1524532316));
-SELECT t0.c1 FROM t0 WHERE NOT (t0.c1 OR (t0.c0 AND -1.0));
+SELECT t0.c1 FROM t0 WHERE NOT (t0.c1 OR (t0.c0 AND -1.0)); -- { serverError 70 }
 SELECT t0.c1 FROM t0 WHERE NOT (t0.c1 OR (t0.c0 AND inf));
 SELECT t0.c1 FROM t0 WHERE NOT (t0.c1 OR (t0.c0 AND nan));
 
diff --git a/tests/queries/0_stateless/01461_query_start_time_microseconds.sql b/tests/queries/0_stateless/01461_query_start_time_microseconds.sql
index 678b9b3d85e..be1d9897053 100644
--- a/tests/queries/0_stateless/01461_query_start_time_microseconds.sql
+++ b/tests/queries/0_stateless/01461_query_start_time_microseconds.sql
@@ -7,6 +7,8 @@ WITH (
           SELECT query_start_time_microseconds
           FROM system.query_log
           WHERE current_database = currentDatabase()
+            AND query like 'SELECT \'01461_query%'
+            AND event_date >= yesterday()
           ORDER BY query_start_time DESC
           LIMIT 1
       ) AS time_with_microseconds,
@@ -14,6 +16,8 @@ WITH (
           SELECT query_start_time
           FROM system.query_log
           WHERE current_database = currentDatabase()
+            AND query like 'SELECT \'01461_query%'
+            AND event_date >= yesterday()
           ORDER BY query_start_time DESC
           LIMIT 1
       ) AS t)
@@ -27,6 +31,8 @@ WITH (
           SELECT query_start_time_microseconds
           FROM system.query_thread_log
           WHERE current_database = currentDatabase()
+            AND query like 'SELECT \'01461_query%'
+            AND event_date >= yesterday()
           ORDER BY query_start_time DESC
           LIMIT 1
       ) AS time_with_microseconds,
@@ -34,6 +40,8 @@ WITH (
           SELECT query_start_time
           FROM system.query_thread_log
           WHERE current_database = currentDatabase()
+            AND query like 'SELECT \'01461_query%'
+            AND event_date >= yesterday()
           ORDER BY query_start_time DESC
           LIMIT 1
       ) AS t)
diff --git a/tests/queries/0_stateless/01483_merge_table_join_and_group_by.reference b/tests/queries/0_stateless/01483_merge_table_join_and_group_by.reference
index b2c3ea56b7f..4261ccd8a1f 100644
--- a/tests/queries/0_stateless/01483_merge_table_join_and_group_by.reference
+++ b/tests/queries/0_stateless/01483_merge_table_join_and_group_by.reference
@@ -5,3 +5,5 @@
 1
 0	1
 0	1
+1	0
+1
diff --git a/tests/queries/0_stateless/01483_merge_table_join_and_group_by.sql b/tests/queries/0_stateless/01483_merge_table_join_and_group_by.sql
index a6678ca9040..68b4e7d4015 100644
--- a/tests/queries/0_stateless/01483_merge_table_join_and_group_by.sql
+++ b/tests/queries/0_stateless/01483_merge_table_join_and_group_by.sql
@@ -17,6 +17,9 @@ SELECT ID FROM m INNER JOIN b USING(key) GROUP BY ID;
 SELECT * FROM m INNER JOIN b USING(key) WHERE ID = 1 HAVING ID = 1 ORDER BY ID;
 SELECT * FROM m INNER JOIN b USING(key) WHERE ID = 1 GROUP BY ID, key HAVING ID = 1 ORDER BY ID;
 
+SELECT sum(b.ID), sum(m.key) FROM m FULL JOIN b ON (m.key == b.key) GROUP BY key;
+SELECT sum(b.ID + m.key) FROM m FULL JOIN b ON (m.key == b.key) GROUP BY key;
+
 DROP TABLE IF EXISTS a;
 DROP TABLE IF EXISTS b;
 DROP TABLE IF EXISTS m;
diff --git a/tests/queries/0_stateless/01509_parallel_quorum_insert_no_replicas.sql b/tests/queries/0_stateless/01509_parallel_quorum_insert_no_replicas.sql
index 1b680cf26c1..16c4a4df936 100644
--- a/tests/queries/0_stateless/01509_parallel_quorum_insert_no_replicas.sql
+++ b/tests/queries/0_stateless/01509_parallel_quorum_insert_no_replicas.sql
@@ -1,16 +1,16 @@
-DROP TABLE IF EXISTS r1;
-DROP TABLE IF EXISTS r2;
+DROP TABLE IF EXISTS r1 SYNC;
+DROP TABLE IF EXISTS r2 SYNC;
 
 CREATE TABLE r1 (
     key UInt64, value String
 )
-ENGINE = ReplicatedMergeTree('/clickhouse/01509_no_repliacs', '1')
+ENGINE = ReplicatedMergeTree('/clickhouse/01509_parallel_quorum_insert_no_replicas', '1')
 ORDER BY tuple();
 
 CREATE TABLE r2 (
     key UInt64, value String
 )
-ENGINE = ReplicatedMergeTree('/clickhouse/01509_no_repliacs', '2')
+ENGINE = ReplicatedMergeTree('/clickhouse/01509_parallel_quorum_insert_no_replicas', '2')
 ORDER BY tuple();
 
 SET insert_quorum_parallel=1;
@@ -18,8 +18,13 @@ SET insert_quorum_parallel=1;
 SET insert_quorum=3;
 INSERT INTO r1 VALUES(1, '1'); --{serverError 285}
 
+-- retry should still fail despite the insert_deduplicate enabled
+INSERT INTO r1 VALUES(1, '1'); --{serverError 285}
+INSERT INTO r1 VALUES(1, '1'); --{serverError 285}
+
 SELECT 'insert to two replicas works';
 SET insert_quorum=2, insert_quorum_parallel=1;
+
 INSERT INTO r1 VALUES(1, '1');
 
 SELECT COUNT() FROM r1;
@@ -29,12 +34,18 @@ DETACH TABLE r2;
 
 INSERT INTO r1 VALUES(2, '2'); --{serverError 285}
 
+-- retry should fail despite the insert_deduplicate enabled
+INSERT INTO r1 VALUES(2, '2'); --{serverError 285}
+INSERT INTO r1 VALUES(2, '2'); --{serverError 285}
+
 SET insert_quorum=1, insert_quorum_parallel=1;
 SELECT 'insert to single replica works';
 INSERT INTO r1 VALUES(2, '2');
 
 ATTACH TABLE r2;
 
+INSERT INTO r2 VALUES(2, '2');
+
 SYSTEM SYNC REPLICA r2;
 
 SET insert_quorum=2, insert_quorum_parallel=1;
@@ -47,6 +58,17 @@ SELECT COUNT() FROM r2;
 SELECT 'deduplication works';
 INSERT INTO r2 VALUES(3, '3');
 
+-- still works if we relax quorum
+SET insert_quorum=1, insert_quorum_parallel=1;
+INSERT INTO r2 VALUES(3, '3');
+INSERT INTO r1 VALUES(3, '3');
+-- will start failing if we increase quorum
+SET insert_quorum=3, insert_quorum_parallel=1;
+INSERT INTO r1 VALUES(3, '3'); --{serverError 285}
+-- work back ok when quorum=2
+SET insert_quorum=2, insert_quorum_parallel=1;
+INSERT INTO r2 VALUES(3, '3');
+
 SELECT COUNT() FROM r1;
 SELECT COUNT() FROM r2;
 
@@ -56,8 +78,18 @@ SET insert_quorum_timeout=0;
 
 INSERT INTO r1 VALUES (4, '4'); -- { serverError 319 }
 
+-- retry should fail despite the insert_deduplicate enabled
+INSERT INTO r1 VALUES (4, '4'); -- { serverError 319 }
+INSERT INTO r1 VALUES (4, '4'); -- { serverError 319 }
+SELECT * FROM r2 WHERE key=4;
+
 SYSTEM START FETCHES r2;
 
+SET insert_quorum_timeout=6000000;
+
+-- now retry should be successful
+INSERT INTO r1 VALUES (4, '4');
+
 SYSTEM SYNC REPLICA r2;
 
 SELECT 'insert happened';
diff --git a/tests/queries/0_stateless/01568_window_functions_distributed.reference b/tests/queries/0_stateless/01568_window_functions_distributed.reference
new file mode 100644
index 00000000000..b441189303d
--- /dev/null
+++ b/tests/queries/0_stateless/01568_window_functions_distributed.reference
@@ -0,0 +1,5 @@
+-- { echo }
+set allow_experimental_window_functions = 1;
+select row_number() over (order by dummy) from (select * from remote('127.0.0.{1,2}', system, one));
+1
+2
diff --git a/tests/queries/0_stateless/01568_window_functions_distributed.sql b/tests/queries/0_stateless/01568_window_functions_distributed.sql
new file mode 100644
index 00000000000..754b996e00c
--- /dev/null
+++ b/tests/queries/0_stateless/01568_window_functions_distributed.sql
@@ -0,0 +1,4 @@
+-- { echo }
+set allow_experimental_window_functions = 1;
+
+select row_number() over (order by dummy) from (select * from remote('127.0.0.{1,2}', system, one));
diff --git a/tests/queries/0_stateless/01591_window_functions.reference b/tests/queries/0_stateless/01591_window_functions.reference
index 9067ee8d955..afc20f67406 100644
--- a/tests/queries/0_stateless/01591_window_functions.reference
+++ b/tests/queries/0_stateless/01591_window_functions.reference
@@ -942,8 +942,9 @@ FROM numbers(2)
 ;
 1	0
 1	1
--- optimize_read_in_order conflicts with sorting for window functions, must
--- be disabled.
+-- optimize_read_in_order conflicts with sorting for window functions, check that
+-- it is disabled.
+drop table if exists window_mt;
 create table window_mt engine MergeTree order by number
     as select number, mod(number, 3) p from numbers(100);
 select number, count(*) over (partition by p)
@@ -1096,7 +1097,7 @@ select count() over (order by toInt64(number) range between -1 preceding and unb
 select count() over (order by toInt64(number) range between -1 following and unbounded following) from numbers(1); -- { serverError 36 }
 select count() over (order by toInt64(number) range between unbounded preceding and -1 preceding) from numbers(1); -- { serverError 36 }
 select count() over (order by toInt64(number) range between unbounded preceding and -1 following) from numbers(1); -- { serverError 36 }
----- a test with aggregate function that allocates memory in arena
+-- a test with aggregate function that allocates memory in arena
 select sum(a[length(a)])
 from (
     select groupArray(number) over (partition by modulo(number, 11)
@@ -1104,3 +1105,6 @@ from (
     from numbers_mt(10000)
 ) settings max_block_size = 7;
 49995000
+-- -INT_MIN row offset that can lead to problems with negation, found when fuzzing
+-- under UBSan. Should be limited to at most INT_MAX.
+select count() over (rows between 2147483648 preceding and 2147493648 following) from numbers(2); -- { serverError 36 }
diff --git a/tests/queries/0_stateless/01591_window_functions.sql b/tests/queries/0_stateless/01591_window_functions.sql
index 85856dd797d..44b0bba0b27 100644
--- a/tests/queries/0_stateless/01591_window_functions.sql
+++ b/tests/queries/0_stateless/01591_window_functions.sql
@@ -329,8 +329,9 @@ SELECT
 FROM numbers(2)
 ;
 
--- optimize_read_in_order conflicts with sorting for window functions, must
--- be disabled.
+-- optimize_read_in_order conflicts with sorting for window functions, check that
+-- it is disabled.
+drop table if exists window_mt;
 create table window_mt engine MergeTree order by number
     as select number, mod(number, 3) p from numbers(100);
 
@@ -402,10 +403,14 @@ select count() over (order by toInt64(number) range between -1 following and unb
 select count() over (order by toInt64(number) range between unbounded preceding and -1 preceding) from numbers(1); -- { serverError 36 }
 select count() over (order by toInt64(number) range between unbounded preceding and -1 following) from numbers(1); -- { serverError 36 }
 
----- a test with aggregate function that allocates memory in arena
+-- a test with aggregate function that allocates memory in arena
 select sum(a[length(a)])
 from (
     select groupArray(number) over (partition by modulo(number, 11)
             order by modulo(number, 1111), number) a
     from numbers_mt(10000)
 ) settings max_block_size = 7;
+
+-- -INT_MIN row offset that can lead to problems with negation, found when fuzzing
+-- under UBSan. Should be limited to at most INT_MAX.
+select count() over (rows between 2147483648 preceding and 2147493648 following) from numbers(2); -- { serverError 36 }
diff --git a/tests/queries/0_stateless/01655_plan_optimizations.reference b/tests/queries/0_stateless/01655_plan_optimizations.reference
index 99b32b74ca7..22f5a2e73e3 100644
--- a/tests/queries/0_stateless/01655_plan_optimizations.reference
+++ b/tests/queries/0_stateless/01655_plan_optimizations.reference
@@ -123,3 +123,26 @@ Filter column: notEquals(y, 2)
 3	10
 
 0	37
+> filter is pushed down before CreatingSets
+CreatingSets
+Filter
+Filter
+1
+3
+> one condition of filter is pushed down before LEFT JOIN
+Join
+Filter column: notEquals(number, 1)
+Join
+0	0
+3	3
+> one condition of filter is pushed down before INNER JOIN
+Join
+Filter column: notEquals(number, 1)
+Join
+3	3
+> filter is pushed down before UNION
+Union
+Filter
+Filter
+2	3
+2	3
diff --git a/tests/queries/0_stateless/01655_plan_optimizations.sh b/tests/queries/0_stateless/01655_plan_optimizations.sh
index 3148dc4a597..148e6157773 100755
--- a/tests/queries/0_stateless/01655_plan_optimizations.sh
+++ b/tests/queries/0_stateless/01655_plan_optimizations.sh
@@ -150,3 +150,49 @@ $CLICKHOUSE_CLIENT -q "
     select * from (
         select y, sum(x) from (select number as x, number % 4 as y from numbers(10)) group by y with totals
     ) where y != 2"
+
+echo "> filter is pushed down before CreatingSets"
+$CLICKHOUSE_CLIENT -q "
+    explain select number from (
+        select number from numbers(5) where number in (select 1 + number from numbers(3))
+    ) where number != 2 settings enable_optimize_predicate_expression=0" |
+    grep -o "CreatingSets\|Filter"
+$CLICKHOUSE_CLIENT -q "
+    select number from (
+        select number from numbers(5) where number in (select 1 + number from numbers(3))
+    ) where number != 2 settings enable_optimize_predicate_expression=0"
+
+echo "> one condition of filter is pushed down before LEFT JOIN"
+$CLICKHOUSE_CLIENT -q "
+    explain actions = 1
+    select number as a, r.b from numbers(4) as l any left join (
+        select number + 2 as b from numbers(3)
+    ) as r on a = r.b where a != 1 and b != 2 settings enable_optimize_predicate_expression = 0" |
+    grep -o "Join\|Filter column: notEquals(number, 1)"
+$CLICKHOUSE_CLIENT -q "
+    select number as a, r.b from numbers(4) as l any left join (
+        select number + 2 as b from numbers(3)
+    ) as r on a = r.b where a != 1 and b != 2 settings enable_optimize_predicate_expression = 0"
+
+echo "> one condition of filter is pushed down before INNER JOIN"
+$CLICKHOUSE_CLIENT -q "
+    explain actions = 1
+    select number as a, r.b from numbers(4) as l any inner join (
+        select number + 2 as b from numbers(3)
+    ) as r on a = r.b where a != 1 and b != 2 settings enable_optimize_predicate_expression = 0" |
+    grep -o "Join\|Filter column: notEquals(number, 1)"
+$CLICKHOUSE_CLIENT -q "
+    select number as a, r.b from numbers(4) as l any inner join (
+        select number + 2 as b from numbers(3)
+    ) as r on a = r.b where a != 1 and b != 2 settings enable_optimize_predicate_expression = 0"
+
+echo "> filter is pushed down before UNION"
+$CLICKHOUSE_CLIENT -q "
+    explain select a, b from (
+        select number + 1 as a, number + 2 as b from numbers(2) union all select number + 1 as b, number + 2 as a from numbers(2)
+    ) where a != 1 settings enable_optimize_predicate_expression = 0" |
+    grep -o "Union\|Filter"
+$CLICKHOUSE_CLIENT -q "
+    select a, b from (
+        select number + 1 as a, number + 2 as b from numbers(2) union all select number + 1 as b, number + 2 as a from numbers(2)
+    ) where a != 1 settings enable_optimize_predicate_expression = 0"
diff --git a/tests/queries/0_stateless/01670_log_comment.sql b/tests/queries/0_stateless/01670_log_comment.sql
index c1496273784..2fb61eb5812 100644
--- a/tests/queries/0_stateless/01670_log_comment.sql
+++ b/tests/queries/0_stateless/01670_log_comment.sql
@@ -1,5 +1,5 @@
 SET log_comment = 'log_comment test', log_queries = 1;
 SELECT 1;
 SYSTEM FLUSH LOGS;
-SELECT type, query FROM system.query_log WHERE current_database = currentDatabase() AND log_comment = 'log_comment test' AND event_date >= yesterday() AND type = 1 ORDER BY event_time DESC LIMIT 1;
-SELECT type, query FROM system.query_log WHERE current_database = currentDatabase() AND log_comment = 'log_comment test' AND event_date >= yesterday() AND type = 2 ORDER BY event_time DESC LIMIT 1;
+SELECT type, query FROM system.query_log WHERE current_database = currentDatabase() AND log_comment = 'log_comment test' AND query LIKE 'SELECT 1%' AND event_date >= yesterday() AND type = 1 ORDER BY event_time_microseconds DESC LIMIT 1;
+SELECT type, query FROM system.query_log WHERE current_database = currentDatabase() AND log_comment = 'log_comment test' AND query LIKE 'SELECT 1%' AND event_date >= yesterday() AND type = 2 ORDER BY event_time_microseconds DESC LIMIT 1;
diff --git a/tests/queries/0_stateless/01702_system_query_log.reference b/tests/queries/0_stateless/01702_system_query_log.reference
index 6d8908249bf..1f329feac22 100644
--- a/tests/queries/0_stateless/01702_system_query_log.reference
+++ b/tests/queries/0_stateless/01702_system_query_log.reference
@@ -42,23 +42,17 @@ Alter	ALTER TABLE sqllt.table DROP COLUMN the_new_col;
 Alter	ALTER TABLE sqllt.table UPDATE i = i + 1 WHERE 1;
 Alter	ALTER TABLE sqllt.table DELETE WHERE i > 65535;
 Select	-- not done, seems to hard, so I\'ve skipped queries of ALTER-X, where X is:\n-- PARTITION\n-- ORDER BY\n-- SAMPLE BY\n-- INDEX\n-- CONSTRAINT\n-- TTL\n-- USER\n-- QUOTA\n-- ROLE\n-- ROW POLICY\n-- SETTINGS PROFILE\n\nSELECT \'SYSTEM queries\';
-System	SYSTEM RELOAD EMBEDDED DICTIONARIES;
-System	SYSTEM RELOAD DICTIONARIES;
-System	SYSTEM DROP DNS CACHE;
-System	SYSTEM DROP MARK CACHE;
-System	SYSTEM DROP UNCOMPRESSED CACHE;
 System	SYSTEM FLUSH LOGS;
-System	SYSTEM RELOAD CONFIG;
-System	SYSTEM STOP MERGES;
-System	SYSTEM START MERGES;
-System	SYSTEM STOP TTL MERGES;
-System	SYSTEM START TTL MERGES;
-System	SYSTEM STOP MOVES;
-System	SYSTEM START MOVES;
-System	SYSTEM STOP FETCHES;
-System	SYSTEM START FETCHES;
-System	SYSTEM STOP REPLICATED SENDS;
-System	SYSTEM START REPLICATED SENDS;
+System	SYSTEM STOP MERGES sqllt.table
+System	SYSTEM START MERGES sqllt.table
+System	SYSTEM STOP TTL MERGES sqllt.table
+System	SYSTEM START TTL MERGES sqllt.table
+System	SYSTEM STOP MOVES sqllt.table
+System	SYSTEM START MOVES sqllt.table
+System	SYSTEM STOP FETCHES sqllt.table
+System	SYSTEM START FETCHES sqllt.table
+System	SYSTEM STOP REPLICATED SENDS sqllt.table
+System	SYSTEM START REPLICATED SENDS sqllt.table
 Select	-- SYSTEM RELOAD DICTIONARY sqllt.dictionary; -- temporary out of order: Code: 210, Connection refused (localhost:9001) (version 21.3.1.1)\n-- DROP REPLICA\n-- haha, no\n-- SYSTEM KILL;\n-- SYSTEM SHUTDOWN;\n\n-- Since we don\'t really care about the actual output, suppress it with `FORMAT Null`.\nSELECT \'SHOW queries\';
 	SHOW CREATE TABLE sqllt.table FORMAT Null;
 	SHOW CREATE DICTIONARY sqllt.dictionary FORMAT Null;
diff --git a/tests/queries/0_stateless/01702_system_query_log.sql b/tests/queries/0_stateless/01702_system_query_log.sql
index 5c3de9cf912..e3ebf97edb7 100644
--- a/tests/queries/0_stateless/01702_system_query_log.sql
+++ b/tests/queries/0_stateless/01702_system_query_log.sql
@@ -64,23 +64,17 @@ ALTER TABLE sqllt.table DELETE WHERE i > 65535;
 -- SETTINGS PROFILE
 
 SELECT 'SYSTEM queries';
-SYSTEM RELOAD EMBEDDED DICTIONARIES;
-SYSTEM RELOAD DICTIONARIES;
-SYSTEM DROP DNS CACHE;
-SYSTEM DROP MARK CACHE;
-SYSTEM DROP UNCOMPRESSED CACHE;
 SYSTEM FLUSH LOGS;
-SYSTEM RELOAD CONFIG;
-SYSTEM STOP MERGES;
-SYSTEM START MERGES;
-SYSTEM STOP TTL MERGES;
-SYSTEM START TTL MERGES;
-SYSTEM STOP MOVES;
-SYSTEM START MOVES;
-SYSTEM STOP FETCHES;
-SYSTEM START FETCHES;
-SYSTEM STOP REPLICATED SENDS;
-SYSTEM START REPLICATED SENDS;
+SYSTEM STOP MERGES sqllt.table;
+SYSTEM START MERGES sqllt.table;
+SYSTEM STOP TTL MERGES sqllt.table;
+SYSTEM START TTL MERGES sqllt.table;
+SYSTEM STOP MOVES sqllt.table;
+SYSTEM START MOVES sqllt.table;
+SYSTEM STOP FETCHES sqllt.table;
+SYSTEM START FETCHES sqllt.table;
+SYSTEM STOP REPLICATED SENDS sqllt.table;
+SYSTEM START REPLICATED SENDS sqllt.table;
 
 -- SYSTEM RELOAD DICTIONARY sqllt.dictionary; -- temporary out of order: Code: 210, Connection refused (localhost:9001) (version 21.3.1.1)
 -- DROP REPLICA
diff --git a/tests/queries/0_stateless/01709_inactive_parts_to_delay_throw.sql b/tests/queries/0_stateless/01709_inactive_parts_to_delay_throw.sql
deleted file mode 100644
index fad890c4807..00000000000
--- a/tests/queries/0_stateless/01709_inactive_parts_to_delay_throw.sql
+++ /dev/null
@@ -1,12 +0,0 @@
-drop table if exists x;
-
-create table x (i int) engine MergeTree order by i settings old_parts_lifetime = 10000000000, min_bytes_for_wide_part = 0, inactive_parts_to_throw_insert = 1;
-
-insert into x values (1);
-insert into x values (2);
-
-optimize table x final;
-
-insert into x values (3); -- { serverError 252; }
-
-drop table if exists x;
diff --git a/tests/queries/0_stateless/01709_inactive_parts_to_throw_insert.reference b/tests/queries/0_stateless/01709_inactive_parts_to_throw_insert.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/queries/0_stateless/01709_inactive_parts_to_throw_insert.sql b/tests/queries/0_stateless/01709_inactive_parts_to_throw_insert.sql
new file mode 100644
index 00000000000..6de0d4f4e0c
--- /dev/null
+++ b/tests/queries/0_stateless/01709_inactive_parts_to_throw_insert.sql
@@ -0,0 +1,12 @@
+drop table if exists data_01709;
+
+create table data_01709 (i int) engine MergeTree order by i settings old_parts_lifetime = 10000000000, min_bytes_for_wide_part = 0, inactive_parts_to_throw_insert = 1;
+
+insert into data_01709 values (1);
+insert into data_01709 values (2);
+
+optimize table data_01709 final;
+
+insert into data_01709 values (3); -- { serverError 252; }
+
+drop table data_01709;
diff --git a/tests/queries/0_stateless/01715_table_function_view_fix.sql b/tests/queries/0_stateless/01715_table_function_view_fix.sql
index de5150b7b70..b96609391b5 100644
--- a/tests/queries/0_stateless/01715_table_function_view_fix.sql
+++ b/tests/queries/0_stateless/01715_table_function_view_fix.sql
@@ -1 +1,3 @@
 SELECT view(SELECT 1); -- { clientError 62 }
+
+SELECT sumIf(dummy, dummy) FROM remote('127.0.0.{1,2}', numbers(2, 100), view(SELECT CAST(NULL, 'Nullable(UInt8)') AS dummy FROM system.one)); -- { serverError 183 }
diff --git a/tests/queries/0_stateless/01753_max_uri_size.sh b/tests/queries/0_stateless/01753_max_uri_size.sh
index 5c63d9274fd..62bc4f2c26f 100755
--- a/tests/queries/0_stateless/01753_max_uri_size.sh
+++ b/tests/queries/0_stateless/01753_max_uri_size.sh
@@ -4,8 +4,14 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 # shellcheck source=../shell_config.sh
 . "$CURDIR"/../shell_config.sh
 
-# NOTE: since 'max_uri_size' doesn't affect the request itself, this test hardly depends on the default value of this setting (16Kb).
+# NOTE: since 'max_uri_size' doesn't affect the request itself, this test hardly depends on the default value of this setting (1 MiB).
 
-LONG_REQUEST=$(python3 -c "print('&max_uri_size=1'*2000, end='')")  # ~30K
+python3 -c "
+print('${CLICKHOUSE_URL}', end='')
+print('&hello=world'*100000, end='')
+print('&query=SELECT+1')
+" > "${CLICKHOUSE_TMP}/url.txt"
 
-${CLICKHOUSE_CURL} -sSv "${CLICKHOUSE_URL}${LONG_REQUEST}&query=SELECT+1" 2>&1 | grep -Fc "HTTP/1.1 400 Bad Request"
+wget --input-file "${CLICKHOUSE_TMP}/url.txt" 2>&1 | grep -Fc "400: Bad Request"
+
+rm "${CLICKHOUSE_TMP}/url.txt"
diff --git a/tests/queries/0_stateless/01756_optimize_skip_unused_shards_rewrite_in.reference b/tests/queries/0_stateless/01756_optimize_skip_unused_shards_rewrite_in.reference
new file mode 100644
index 00000000000..494e9ca3237
--- /dev/null
+++ b/tests/queries/0_stateless/01756_optimize_skip_unused_shards_rewrite_in.reference
@@ -0,0 +1,22 @@
+(0, 2)
+0	0
+0	0
+WITH CAST(\'default\', \'String\') AS id_no SELECT one.dummy, ignore(id_no) FROM system.one WHERE dummy IN (0, 2)
+WITH CAST(\'default\', \'String\') AS id_no SELECT one.dummy, ignore(id_no) FROM system.one WHERE dummy IN (0, 2)
+optimize_skip_unused_shards_rewrite_in(0, 2)
+0	0
+WITH CAST(\'default\', \'String\') AS id_02 SELECT one.dummy, ignore(id_02) FROM system.one WHERE dummy IN tuple(0)
+WITH CAST(\'default\', \'String\') AS id_02 SELECT one.dummy, ignore(id_02) FROM system.one WHERE dummy IN tuple(2)
+optimize_skip_unused_shards_rewrite_in(2,)
+WITH CAST(\'default\', \'String\') AS id_2 SELECT one.dummy, ignore(id_2) FROM system.one WHERE dummy IN tuple(2)
+optimize_skip_unused_shards_rewrite_in(0,)
+0	0
+WITH CAST(\'default\', \'String\') AS id_0 SELECT one.dummy, ignore(id_0) FROM system.one WHERE dummy IN tuple(0)
+errors
+others
+0
+0
+0
+optimize_skip_unused_shards_limit
+0
+0
diff --git a/tests/queries/0_stateless/01756_optimize_skip_unused_shards_rewrite_in.sql b/tests/queries/0_stateless/01756_optimize_skip_unused_shards_rewrite_in.sql
new file mode 100644
index 00000000000..59e2ad75fcc
--- /dev/null
+++ b/tests/queries/0_stateless/01756_optimize_skip_unused_shards_rewrite_in.sql
@@ -0,0 +1,127 @@
+-- NOTE: this test cannot use 'current_database = currentDatabase()',
+-- because it does not propagated via remote queries,
+-- hence it uses 'with (select currentDatabase()) as X'
+-- (with subquery to expand it on the initiator).
+
+drop table if exists dist_01756;
+drop table if exists dist_01756_str;
+drop table if exists data_01756_str;
+
+-- SELECT
+--     intHash64(0) % 2,
+--     intHash64(2) % 2
+-- ┌─modulo(intHash64(0), 2)─┬─modulo(intHash64(2), 2)─┐
+-- │                       0 │                       1 │
+-- └─────────────────────────┴─────────────────────────┘
+create table dist_01756 as system.one engine=Distributed(test_cluster_two_shards, system, one, intHash64(dummy));
+
+-- separate log entry for localhost queries
+set prefer_localhost_replica=0;
+set force_optimize_skip_unused_shards=2;
+set optimize_skip_unused_shards=1;
+set optimize_skip_unused_shards_rewrite_in=0;
+set log_queries=1;
+
+--
+-- w/o optimize_skip_unused_shards_rewrite_in=1
+--
+select '(0, 2)';
+with (select currentDatabase()) as id_no select *, ignore(id_no) from dist_01756 where dummy in (0, 2);
+system flush logs;
+select query from system.query_log where
+    event_date = today() and
+    event_time > now() - interval 1 hour and
+    not is_initial_query and
+    query not like '%system.query_log%' and
+    query like concat('WITH%', currentDatabase(), '%AS id_no %') and
+    type = 'QueryFinish'
+order by query;
+
+--
+-- w/ optimize_skip_unused_shards_rewrite_in=1
+--
+
+set optimize_skip_unused_shards_rewrite_in=1;
+
+-- detailed coverage for realistic examples
+select 'optimize_skip_unused_shards_rewrite_in(0, 2)';
+with (select currentDatabase()) as id_02 select *, ignore(id_02) from dist_01756 where dummy in (0, 2);
+system flush logs;
+select query from system.query_log where
+    event_date = today() and
+    event_time > now() - interval 1 hour and
+    not is_initial_query and
+    query not like '%system.query_log%' and
+    query like concat('WITH%', currentDatabase(), '%AS id_02 %') and
+    type = 'QueryFinish'
+order by query;
+
+select 'optimize_skip_unused_shards_rewrite_in(2,)';
+with (select currentDatabase()) as id_2 select *, ignore(id_2) from dist_01756 where dummy in (2,);
+system flush logs;
+select query from system.query_log where
+    event_date = today() and
+    event_time > now() - interval 1 hour and
+    not is_initial_query and
+    query not like '%system.query_log%' and
+    query like concat('WITH%', currentDatabase(), '%AS id_2 %') and
+    type = 'QueryFinish'
+order by query;
+
+select 'optimize_skip_unused_shards_rewrite_in(0,)';
+with (select currentDatabase()) as id_0 select *, ignore(id_0) from dist_01756 where dummy in (0,);
+system flush logs;
+select query from system.query_log where
+    event_date = today() and
+    event_time > now() - interval 1 hour and
+    not is_initial_query and
+    query not like '%system.query_log%' and
+    query like concat('WITH%', currentDatabase(), '%AS id_0 %') and
+    type = 'QueryFinish'
+order by query;
+
+--
+-- errors
+--
+select 'errors';
+
+-- not tuple
+select * from dist_01756 where dummy in (0); -- { serverError 507 }
+-- optimize_skip_unused_shards does not support non-constants
+select * from dist_01756 where dummy in (select * from system.one); -- { serverError 507 }
+select * from dist_01756 where dummy in (toUInt8(0)); -- { serverError 507 }
+-- wrong type
+select * from dist_01756 where dummy in ('0'); -- { serverError 507 }
+-- NOT IN does not supported
+select * from dist_01756 where dummy not in (0, 2); -- { serverError 507 }
+
+--
+-- others
+--
+select 'others';
+
+select * from dist_01756 where dummy not in (2, 3) and dummy in (0, 2);
+select * from dist_01756 where dummy in tuple(0, 2);
+select * from dist_01756 where dummy in tuple(0);
+select * from dist_01756 where dummy in tuple(2);
+-- Identifier is NULL
+select (2 IN (2,)), * from dist_01756 where dummy in (0, 2) format Null;
+-- Literal is NULL
+select (dummy IN (toUInt8(2),)), * from dist_01756 where dummy in (0, 2) format Null;
+
+-- different type
+create table data_01756_str (key String) engine=Memory();
+create table dist_01756_str as data_01756_str engine=Distributed(test_cluster_two_shards, currentDatabase(), data_01756_str, cityHash64(key));
+select * from dist_01756_str where key in ('0', '2');
+select * from dist_01756_str where key in ('0', Null); -- { serverError 507 }
+select * from dist_01756_str where key in (0, 2); -- { serverError 53 }
+select * from dist_01756_str where key in (0, Null); -- { serverError 53 }
+
+-- optimize_skip_unused_shards_limit
+select 'optimize_skip_unused_shards_limit';
+select * from dist_01756 where dummy in (0, 2) settings optimize_skip_unused_shards_limit=1; -- { serverError 507 }
+select * from dist_01756 where dummy in (0, 2) settings optimize_skip_unused_shards_limit=1, force_optimize_skip_unused_shards=0;
+
+drop table dist_01756;
+drop table dist_01756_str;
+drop table data_01756_str;
diff --git a/tests/queries/0_stateless/01763_max_distributed_depth.reference b/tests/queries/0_stateless/01763_max_distributed_depth.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/queries/0_stateless/01763_max_distributed_depth.sql b/tests/queries/0_stateless/01763_max_distributed_depth.sql
new file mode 100644
index 00000000000..d1bb9e4be90
--- /dev/null
+++ b/tests/queries/0_stateless/01763_max_distributed_depth.sql
@@ -0,0 +1,26 @@
+DROP TABLE IF EXISTS tt6;
+
+CREATE TABLE tt6
+(
+	`id` UInt32,
+	`first_column` UInt32,
+	`second_column` UInt32,
+	`third_column` UInt32,
+	`status` String
+
+)
+ENGINE = Distributed('test_shard_localhost', '', 'tt6', rand());
+
+INSERT INTO tt6 VALUES (1, 1, 1, 1, 'ok'); -- { serverError 581 }
+
+SELECT * FROM tt6; -- { serverError 581 }
+
+SET max_distributed_depth = 0;
+
+-- stack overflow
+INSERT INTO tt6 VALUES (1, 1, 1, 1, 'ok'); -- { serverError 306}
+
+-- stack overflow
+SELECT * FROM tt6; -- { serverError 306 }
+
+DROP TABLE tt6;
diff --git a/tests/queries/0_stateless/01781_merge_tree_deduplication.reference b/tests/queries/0_stateless/01781_merge_tree_deduplication.reference
new file mode 100644
index 00000000000..cb5a3f1ff52
--- /dev/null
+++ b/tests/queries/0_stateless/01781_merge_tree_deduplication.reference
@@ -0,0 +1,85 @@
+1	1
+1	1
+===============
+1	1
+1	1
+2	2
+3	3
+4	4
+===============
+1	1
+1	1
+2	2
+3	3
+4	4
+5	5
+6	6
+7	7
+===============
+1	1
+1	1
+2	2
+3	3
+4	4
+5	5
+6	6
+7	7
+8	8
+9	9
+10	10
+11	11
+12	12
+===============
+10	10
+12	12
+===============
+1	1
+1	1
+2	2
+3	3
+4	4
+5	5
+6	6
+8	8
+9	9
+11	11
+12	12
+===============
+88	11	11
+77	11	11
+77	12	12
+===============
+1	1	33
+1	1	33
+2	2	33
+3	3	33
+===============
+1	1	33
+1	1	33
+1	1	33
+1	1	33
+2	2	33
+3	3	33
+===============
+1	1	33
+1	1	33
+1	1	33
+1	1	33
+1	1	33
+2	2	33
+3	3	33
+===============
+1	1	44
+2	2	44
+3	3	44
+4	4	44
+===============
+1	1
+1	1
+===============
+1	1
+1	1
+1	1
+2	2
+3	3
+4	4
diff --git a/tests/queries/0_stateless/01781_merge_tree_deduplication.sql b/tests/queries/0_stateless/01781_merge_tree_deduplication.sql
new file mode 100644
index 00000000000..236f7b35b80
--- /dev/null
+++ b/tests/queries/0_stateless/01781_merge_tree_deduplication.sql
@@ -0,0 +1,187 @@
+DROP TABLE IF EXISTS merge_tree_deduplication;
+
+CREATE TABLE merge_tree_deduplication
+(
+    key UInt64,
+    value String,
+    part UInt8 DEFAULT 77
+)
+ENGINE=MergeTree()
+ORDER BY key
+PARTITION BY part
+SETTINGS non_replicated_deduplication_window=3;
+
+SYSTEM STOP MERGES merge_tree_deduplication;
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (1, '1');
+
+SELECT key, value FROM merge_tree_deduplication;
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (1, '1');
+
+SELECT key, value FROM merge_tree_deduplication;
+
+SELECT '===============';
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (2, '2');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (3, '3');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (4, '4');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (1, '1');
+
+SELECT key, value FROM merge_tree_deduplication ORDER BY key;
+
+SELECT '===============';
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (5, '5');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (6, '6');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (7, '7');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (5, '5');
+
+SELECT key, value FROM merge_tree_deduplication ORDER BY key;
+
+SELECT '===============';
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (8, '8');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (9, '9');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (10, '10');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (11, '11');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (12, '12');
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (10, '10');
+INSERT INTO merge_tree_deduplication (key, value) VALUES (11, '11');
+INSERT INTO merge_tree_deduplication (key, value) VALUES (12, '12');
+
+SELECT key, value FROM merge_tree_deduplication ORDER BY key;
+
+SELECT '===============';
+
+ALTER TABLE merge_tree_deduplication DROP PART '77_9_9_0'; -- some old part
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (10, '10');
+
+SELECT key, value FROM merge_tree_deduplication WHERE key = 10;
+
+ALTER TABLE merge_tree_deduplication DROP PART '77_13_13_0'; -- fresh part
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (12, '12');
+
+SELECT key, value FROM merge_tree_deduplication WHERE key = 12;
+
+DETACH TABLE merge_tree_deduplication;
+ATTACH TABLE merge_tree_deduplication;
+
+OPTIMIZE TABLE  merge_tree_deduplication FINAL;
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (11, '11'); -- deduplicated
+INSERT INTO merge_tree_deduplication (key, value) VALUES (12, '12'); -- deduplicated
+
+SELECT '===============';
+
+SELECT key, value FROM merge_tree_deduplication ORDER BY key;
+
+SELECT '===============';
+
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (11, '11', 88);
+
+ALTER TABLE merge_tree_deduplication DROP PARTITION 77;
+
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (11, '11', 88); --deduplicated
+
+INSERT INTO merge_tree_deduplication (key, value) VALUES (11, '11'); -- not deduplicated
+INSERT INTO merge_tree_deduplication (key, value) VALUES (12, '12'); -- not deduplicated
+
+SELECT part, key, value FROM merge_tree_deduplication ORDER BY key;
+
+-- Alters....
+
+ALTER TABLE merge_tree_deduplication MODIFY SETTING non_replicated_deduplication_window = 2;
+
+SELECT '===============';
+
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (1, '1', 33);
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (2, '2', 33);
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (3, '3', 33);
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (1, '1', 33);
+
+SELECT * FROM merge_tree_deduplication WHERE part = 33 ORDER BY key;
+
+SELECT '===============';
+
+ALTER TABLE merge_tree_deduplication MODIFY SETTING non_replicated_deduplication_window = 0;
+
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (1, '1', 33);
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (1, '1', 33);
+
+DETACH TABLE merge_tree_deduplication;
+ATTACH TABLE merge_tree_deduplication;
+
+SELECT * FROM merge_tree_deduplication WHERE part = 33 ORDER BY key;
+
+SELECT '===============';
+
+ALTER TABLE merge_tree_deduplication MODIFY SETTING non_replicated_deduplication_window = 3;
+
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (1, '1', 33);
+
+SELECT * FROM merge_tree_deduplication WHERE part = 33 ORDER BY key;
+
+SELECT '===============';
+
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (1, '1', 44);
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (2, '2', 44);
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (3, '3', 44);
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (1, '1', 44);
+
+INSERT INTO merge_tree_deduplication (key, value, part) VALUES (4, '4', 44);
+
+DETACH TABLE merge_tree_deduplication;
+ATTACH TABLE merge_tree_deduplication;
+
+SELECT * FROM merge_tree_deduplication WHERE part = 44 ORDER BY key;
+
+DROP TABLE IF EXISTS merge_tree_deduplication;
+
+SELECT '===============';
+
+DROP TABLE IF EXISTS merge_tree_no_deduplication;
+
+CREATE TABLE merge_tree_no_deduplication
+(
+    key UInt64,
+    value String
+)
+ENGINE=MergeTree()
+ORDER BY key;
+
+INSERT INTO merge_tree_no_deduplication (key, value) VALUES (1, '1');
+INSERT INTO merge_tree_no_deduplication (key, value) VALUES (1, '1');
+
+SELECT * FROM merge_tree_no_deduplication ORDER BY key;
+
+SELECT '===============';
+
+ALTER TABLE merge_tree_no_deduplication MODIFY SETTING non_replicated_deduplication_window = 3;
+
+INSERT INTO merge_tree_no_deduplication (key, value) VALUES (1, '1');
+INSERT INTO merge_tree_no_deduplication (key, value) VALUES (2, '2');
+INSERT INTO merge_tree_no_deduplication (key, value) VALUES (3, '3');
+
+DETACH TABLE merge_tree_no_deduplication;
+ATTACH TABLE merge_tree_no_deduplication;
+
+INSERT INTO merge_tree_no_deduplication (key, value) VALUES (1, '1');
+INSERT INTO merge_tree_no_deduplication (key, value) VALUES (4, '4');
+
+SELECT * FROM merge_tree_no_deduplication ORDER BY key;
+
+DROP TABLE IF EXISTS merge_tree_no_deduplication;
diff --git a/tests/queries/0_stateless/01783_merge_engine_join_key_condition.reference b/tests/queries/0_stateless/01783_merge_engine_join_key_condition.reference
new file mode 100644
index 00000000000..4068a6e00dd
--- /dev/null
+++ b/tests/queries/0_stateless/01783_merge_engine_join_key_condition.reference
@@ -0,0 +1,5 @@
+3	3
+1	4
+1	4
+1	4
+1	4
diff --git a/tests/queries/0_stateless/01783_merge_engine_join_key_condition.sql b/tests/queries/0_stateless/01783_merge_engine_join_key_condition.sql
new file mode 100644
index 00000000000..115ee42fe11
--- /dev/null
+++ b/tests/queries/0_stateless/01783_merge_engine_join_key_condition.sql
@@ -0,0 +1,23 @@
+DROP TABLE IF EXISTS foo;
+DROP TABLE IF EXISTS foo_merge;
+DROP TABLE IF EXISTS t2;
+
+CREATE TABLE foo(Id Int32, Val Int32) Engine=MergeTree PARTITION BY Val ORDER BY Id;
+INSERT INTO foo SELECT number, number%5 FROM numbers(100000);
+
+CREATE TABLE foo_merge as foo ENGINE=Merge(currentDatabase(), '^foo');
+
+CREATE TABLE t2 (Id Int32, Val Int32, X Int32) Engine=Memory;
+INSERT INTO t2 values (4, 3, 4);
+
+SET force_primary_key = 1;
+
+SELECT * FROM foo_merge WHERE Val = 3 AND Id = 3;
+SELECT count(), X FROM foo_merge JOIN t2 USING Val WHERE Val = 3 AND Id = 3 AND t2.X == 4 GROUP BY X;
+SELECT count(), X FROM foo_merge JOIN t2 USING Val WHERE Val = 3 AND (Id = 3 AND t2.X == 4) GROUP BY X;
+SELECT count(), X FROM foo_merge JOIN t2 USING Val WHERE Val = 3 AND Id = 3 GROUP BY X;
+SELECT count(), X FROM (SELECT * FROM foo_merge) f JOIN t2 USING Val WHERE Val = 3 AND Id = 3 GROUP BY X;
+
+DROP TABLE IF EXISTS foo;
+DROP TABLE IF EXISTS foo_merge;
+DROP TABLE IF EXISTS t2;
diff --git a/tests/queries/0_stateless/01785_dictionary_element_count.reference b/tests/queries/0_stateless/01785_dictionary_element_count.reference
new file mode 100644
index 00000000000..4b79788b4d4
--- /dev/null
+++ b/tests/queries/0_stateless/01785_dictionary_element_count.reference
@@ -0,0 +1,8 @@
+1	First
+simple_key_flat_dictionary	01785_db	1
+1	First
+simple_key_hashed_dictionary	01785_db	1
+1	First
+simple_key_cache_dictionary	01785_db	1
+1	FirstKey	First
+complex_key_hashed_dictionary	01785_db	1
diff --git a/tests/queries/0_stateless/01785_dictionary_element_count.sql b/tests/queries/0_stateless/01785_dictionary_element_count.sql
new file mode 100644
index 00000000000..6db65152a56
--- /dev/null
+++ b/tests/queries/0_stateless/01785_dictionary_element_count.sql
@@ -0,0 +1,91 @@
+DROP DATABASE IF EXISTS 01785_db;
+CREATE DATABASE 01785_db;
+
+DROP TABLE IF EXISTS 01785_db.simple_key_source_table;
+CREATE TABLE 01785_db.simple_key_source_table
+(
+    id UInt64,
+    value String
+) ENGINE = TinyLog();
+
+INSERT INTO 01785_db.simple_key_source_table VALUES (1, 'First');
+INSERT INTO 01785_db.simple_key_source_table VALUES (1, 'First');
+
+DROP DICTIONARY IF EXISTS 01785_db.simple_key_flat_dictionary;
+CREATE DICTIONARY 01785_db.simple_key_flat_dictionary
+(
+    id UInt64,
+    value String
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() DB '01785_db' TABLE 'simple_key_source_table'))
+LAYOUT(FLAT())
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT * FROM 01785_db.simple_key_flat_dictionary;
+SELECT name, database, element_count FROM system.dictionaries WHERE database = '01785_db' AND name = 'simple_key_flat_dictionary';
+
+DROP DICTIONARY 01785_db.simple_key_flat_dictionary;
+
+CREATE DICTIONARY 01785_db.simple_key_hashed_dictionary
+(
+    id UInt64,
+    value String
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() DB '01785_db' TABLE 'simple_key_source_table'))
+LAYOUT(HASHED())
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT * FROM 01785_db.simple_key_hashed_dictionary;
+SELECT name, database, element_count FROM system.dictionaries WHERE database = '01785_db' AND name = 'simple_key_hashed_dictionary';
+
+DROP DICTIONARY 01785_db.simple_key_hashed_dictionary;
+
+CREATE DICTIONARY 01785_db.simple_key_cache_dictionary
+(
+    id UInt64,
+    value String
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() DB '01785_db' TABLE 'simple_key_source_table'))
+LAYOUT(CACHE(SIZE_IN_CELLS 100000))
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT toUInt64(1) as key, dictGet('01785_db.simple_key_cache_dictionary', 'value', key);
+SELECT name, database, element_count FROM system.dictionaries WHERE database = '01785_db' AND name = 'simple_key_cache_dictionary';
+
+DROP DICTIONARY 01785_db.simple_key_cache_dictionary;
+
+DROP TABLE 01785_db.simple_key_source_table;
+
+DROP TABLE IF EXISTS 01785_db.complex_key_source_table;
+CREATE TABLE 01785_db.complex_key_source_table
+(
+    id UInt64,
+    id_key String,
+    value String
+) ENGINE = TinyLog();
+
+INSERT INTO 01785_db.complex_key_source_table VALUES (1, 'FirstKey', 'First');
+INSERT INTO 01785_db.complex_key_source_table VALUES (1, 'FirstKey', 'First');
+
+CREATE DICTIONARY 01785_db.complex_key_hashed_dictionary
+(
+    id UInt64,
+    id_key String,
+    value String
+)
+PRIMARY KEY id, id_key
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() DB '01785_db' TABLE 'complex_key_source_table'))
+LAYOUT(COMPLEX_KEY_HASHED())
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT * FROM 01785_db.complex_key_hashed_dictionary;
+SELECT name, database, element_count FROM system.dictionaries WHERE database = '01785_db' AND name = 'complex_key_hashed_dictionary';
+
+DROP DICTIONARY 01785_db.complex_key_hashed_dictionary;
+
+DROP TABLE 01785_db.complex_key_source_table;
+
+DROP DATABASE 01785_db;
diff --git a/tests/queries/0_stateless/01787_map_remote.reference b/tests/queries/0_stateless/01787_map_remote.reference
new file mode 100644
index 00000000000..1c488d4418e
--- /dev/null
+++ b/tests/queries/0_stateless/01787_map_remote.reference
@@ -0,0 +1,2 @@
+{'a':1,'b':2}
+{'a':1,'b':2}
diff --git a/tests/queries/0_stateless/01787_map_remote.sql b/tests/queries/0_stateless/01787_map_remote.sql
new file mode 100644
index 00000000000..854eafa0a50
--- /dev/null
+++ b/tests/queries/0_stateless/01787_map_remote.sql
@@ -0,0 +1 @@
+SELECT map('a', 1, 'b', 2) FROM remote('127.0.0.{1,2}', system, one);
\ No newline at end of file
diff --git a/tests/queries/0_stateless/01790_dist_INSERT_block_structure_mismatch_types_and_names.reference b/tests/queries/0_stateless/01790_dist_INSERT_block_structure_mismatch_types_and_names.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/queries/0_stateless/01790_dist_INSERT_block_structure_mismatch_types_and_names.sql b/tests/queries/0_stateless/01790_dist_INSERT_block_structure_mismatch_types_and_names.sql
new file mode 100644
index 00000000000..e921460ccfc
--- /dev/null
+++ b/tests/queries/0_stateless/01790_dist_INSERT_block_structure_mismatch_types_and_names.sql
@@ -0,0 +1,22 @@
+DROP TABLE IF EXISTS tmp_01781;
+DROP TABLE IF EXISTS dist_01781;
+
+SET prefer_localhost_replica=0;
+
+CREATE TABLE tmp_01781 (n LowCardinality(String)) ENGINE=Memory;
+CREATE TABLE dist_01781 (n LowCardinality(String)) Engine=Distributed(test_cluster_two_shards, currentDatabase(), tmp_01781, cityHash64(n));
+
+SET insert_distributed_sync=1;
+INSERT INTO dist_01781 VALUES ('1'),('2');
+-- different LowCardinality size
+INSERT INTO dist_01781 SELECT * FROM numbers(1000);
+
+SET insert_distributed_sync=0;
+SYSTEM STOP DISTRIBUTED SENDS dist_01781;
+INSERT INTO dist_01781 VALUES ('1'),('2');
+-- different LowCardinality size
+INSERT INTO dist_01781 SELECT * FROM numbers(1000);
+SYSTEM FLUSH DISTRIBUTED dist_01781;
+
+DROP TABLE tmp_01781;
+DROP TABLE dist_01781;
diff --git a/tests/queries/0_stateless/01791_dist_INSERT_block_structure_mismatch.reference b/tests/queries/0_stateless/01791_dist_INSERT_block_structure_mismatch.reference
new file mode 100644
index 00000000000..3bba1ac23c0
--- /dev/null
+++ b/tests/queries/0_stateless/01791_dist_INSERT_block_structure_mismatch.reference
@@ -0,0 +1,6 @@
+<Warning> DistributedBlockOutputStream: Structure does not match (remote: n Int8 Int8(size = 0), local: n UInt64 UInt64(size = 1)), implicit conversion will be done.
+<Warning> DistributedBlockOutputStream: Structure does not match (remote: n Int8 Int8(size = 0), local: n UInt64 UInt64(size = 1)), implicit conversion will be done.
+1
+1
+2
+2
diff --git a/tests/queries/0_stateless/01791_dist_INSERT_block_structure_mismatch.sh b/tests/queries/0_stateless/01791_dist_INSERT_block_structure_mismatch.sh
new file mode 100755
index 00000000000..e989696da03
--- /dev/null
+++ b/tests/queries/0_stateless/01791_dist_INSERT_block_structure_mismatch.sh
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+# NOTE: this is a partial copy of the 01683_dist_INSERT_block_structure_mismatch,
+# but this test also checks the log messages
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CUR_DIR"/../shell_config.sh
+
+$CLICKHOUSE_CLIENT --prefer_localhost_replica=0 -nm -q "
+    DROP TABLE IF EXISTS tmp_01683;
+    DROP TABLE IF EXISTS dist_01683;
+
+    CREATE TABLE tmp_01683 (n Int8) ENGINE=Memory;
+    CREATE TABLE dist_01683 (n UInt64) Engine=Distributed(test_cluster_two_shards, currentDatabase(), tmp_01683, n);
+
+    SET insert_distributed_sync=1;
+    INSERT INTO dist_01683 VALUES (1),(2);
+
+    SET insert_distributed_sync=0;
+    INSERT INTO dist_01683 VALUES (1),(2);
+    SYSTEM FLUSH DISTRIBUTED dist_01683;
+
+    -- TODO: cover distributed_directory_monitor_batch_inserts=1
+
+    SELECT * FROM tmp_01683 ORDER BY n;
+
+    DROP TABLE tmp_01683;
+    DROP TABLE dist_01683;
+" |& sed 's/^.*</</g'
diff --git a/tests/queries/0_stateless/01798_having_push_down.reference b/tests/queries/0_stateless/01798_having_push_down.reference
new file mode 100644
index 00000000000..3d6a36b087d
--- /dev/null
+++ b/tests/queries/0_stateless/01798_having_push_down.reference
@@ -0,0 +1,2 @@
+1	1	2
+1	\N
diff --git a/tests/queries/0_stateless/01798_having_push_down.sql b/tests/queries/0_stateless/01798_having_push_down.sql
new file mode 100644
index 00000000000..28b97b7f065
--- /dev/null
+++ b/tests/queries/0_stateless/01798_having_push_down.sql
@@ -0,0 +1,17 @@
+DROP TABLE IF EXISTS t_having;
+
+CREATE TABLE t_having (c0 Int32, c1 UInt64) ENGINE = Memory;
+
+INSERT INTO t_having SELECT number, number FROM numbers(1000);
+
+SELECT sum(c0 = 0), min(c0 + 1), sum(c0 + 2) FROM t_having
+GROUP BY c0 HAVING c0 = 0
+SETTINGS enable_optimize_predicate_expression=0;
+
+SELECT c0 + -1, sum(intDivOrZero(intDivOrZero(NULL, NULL), '2'), intDivOrZero(10000000000., intDivOrZero(intDivOrZero(intDivOrZero(NULL, NULL), 10), NULL))) FROM t_having GROUP BY c0 = 2, c0 = 10, intDivOrZero(intDivOrZero(intDivOrZero(NULL, NULL), NULL), NULL), c0 HAVING c0 = 2 SETTINGS enable_optimize_predicate_expression = 0;
+
+SELECT sum(c0 + 257) FROM t_having GROUP BY c0 = -9223372036854775808, NULL, -2147483649, c0 HAVING c0 = -9223372036854775808 SETTINGS enable_optimize_predicate_expression = 0;
+
+SELECT c0 + -2, c0 + -9223372036854775807, c0 = NULL FROM t_having GROUP BY c0 = 0.9998999834060669, 1023, c0 HAVING c0 = 0.9998999834060669 SETTINGS enable_optimize_predicate_expression = 0;
+
+DROP TABLE t_having;
diff --git a/tests/queries/0_stateless/018001_dateDiff_DateTime64.reference b/tests/queries/0_stateless/018001_dateDiff_DateTime64.reference
new file mode 100644
index 00000000000..f28cf4dc58e
--- /dev/null
+++ b/tests/queries/0_stateless/018001_dateDiff_DateTime64.reference
@@ -0,0 +1,113 @@
+-- { echo }
+
+-- DateTime64 vs DateTime64 same scale
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 00:00:10', 0, 'UTC'));
+10
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 00:10:00', 0, 'UTC'));
+600
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 01:00:00', 0, 'UTC'));
+3600
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 01:10:10', 0, 'UTC'));
+4210
+SELECT dateDiff('minute', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 00:10:00', 0, 'UTC'));
+10
+SELECT dateDiff('minute', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 10:00:00', 0, 'UTC'));
+600
+SELECT dateDiff('hour', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 10:00:00', 0, 'UTC'));
+10
+SELECT dateDiff('day', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-02 00:00:00', 0, 'UTC'));
+1
+SELECT dateDiff('month', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-02-01 00:00:00', 0, 'UTC'));
+1
+SELECT dateDiff('year', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1928-01-01 00:00:00', 0, 'UTC'));
+1
+-- DateTime64 vs DateTime64 different scale
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 00:00:10', 3, 'UTC'));
+10
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 00:10:00', 3, 'UTC'));
+600
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 01:00:00', 3, 'UTC'));
+3600
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 01:10:10', 3, 'UTC'));
+4210
+SELECT dateDiff('minute', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 00:10:00', 3, 'UTC'));
+10
+SELECT dateDiff('minute', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 10:00:00', 3, 'UTC'));
+600
+SELECT dateDiff('hour', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 10:00:00', 3, 'UTC'));
+10
+SELECT dateDiff('day', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-02 00:00:00', 3, 'UTC'));
+1
+SELECT dateDiff('month', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-02-01 00:00:00', 3, 'UTC'));
+1
+SELECT dateDiff('year', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1928-01-01 00:00:00', 3, 'UTC'));
+1
+-- With DateTime
+-- DateTime64 vs DateTime
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDateTime('2015-08-18 00:00:00', 'UTC'));
+0
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDateTime('2015-08-18 00:00:10', 'UTC'));
+10
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDateTime('2015-08-18 00:10:00', 'UTC'));
+600
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDateTime('2015-08-18 01:00:00', 'UTC'));
+3600
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDateTime('2015-08-18 01:10:10', 'UTC'));
+4210
+-- DateTime vs DateTime64
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), toDateTime64('2015-08-18 00:00:00', 3, 'UTC'));
+0
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), toDateTime64('2015-08-18 00:00:10', 3, 'UTC'));
+10
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), toDateTime64('2015-08-18 00:10:00', 3, 'UTC'));
+600
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), toDateTime64('2015-08-18 01:00:00', 3, 'UTC'));
+3600
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), toDateTime64('2015-08-18 01:10:10', 3, 'UTC'));
+4210
+-- With Date
+-- DateTime64 vs Date
+SELECT dateDiff('day', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDate('2015-08-19', 'UTC'));
+1
+-- Date vs DateTime64
+SELECT dateDiff('day', toDate('2015-08-18', 'UTC'), toDateTime64('2015-08-19 00:00:00', 3, 'UTC'));
+1
+-- Same thing but const vs non-const columns
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), materialize(toDateTime64('1927-01-01 00:00:10', 0, 'UTC')));
+10
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), materialize(toDateTime64('1927-01-01 00:00:10', 3, 'UTC')));
+10
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), materialize(toDateTime('2015-08-18 00:00:10', 'UTC')));
+10
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), materialize(toDateTime64('2015-08-18 00:00:10', 3, 'UTC')));
+10
+SELECT dateDiff('day', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), materialize(toDate('2015-08-19', 'UTC')));
+1
+SELECT dateDiff('day', toDate('2015-08-18', 'UTC'), materialize(toDateTime64('2015-08-19 00:00:00', 3, 'UTC')));
+1
+-- Same thing but non-const vs const columns
+SELECT dateDiff('second', materialize(toDateTime64('1927-01-01 00:00:00', 0, 'UTC')), toDateTime64('1927-01-01 00:00:10', 0, 'UTC'));
+10
+SELECT dateDiff('second', materialize(toDateTime64('1927-01-01 00:00:00', 6, 'UTC')), toDateTime64('1927-01-01 00:00:10', 3, 'UTC'));
+10
+SELECT dateDiff('second', materialize(toDateTime64('2015-08-18 00:00:00', 0, 'UTC')), toDateTime('2015-08-18 00:00:10', 'UTC'));
+10
+SELECT dateDiff('second', materialize(toDateTime('2015-08-18 00:00:00', 'UTC')), toDateTime64('2015-08-18 00:00:10', 3, 'UTC'));
+10
+SELECT dateDiff('day', materialize(toDateTime64('2015-08-18 00:00:00', 0, 'UTC')), toDate('2015-08-19', 'UTC'));
+1
+SELECT dateDiff('day', materialize(toDate('2015-08-18', 'UTC')), toDateTime64('2015-08-19 00:00:00', 3, 'UTC'));
+1
+-- Same thing but non-const vs non-const columns
+SELECT dateDiff('second', materialize(toDateTime64('1927-01-01 00:00:00', 0, 'UTC')), materialize(toDateTime64('1927-01-01 00:00:10', 0, 'UTC')));
+10
+SELECT dateDiff('second', materialize(toDateTime64('1927-01-01 00:00:00', 6, 'UTC')), materialize(toDateTime64('1927-01-01 00:00:10', 3, 'UTC')));
+10
+SELECT dateDiff('second', materialize(toDateTime64('2015-08-18 00:00:00', 0, 'UTC')), materialize(toDateTime('2015-08-18 00:00:10', 'UTC')));
+10
+SELECT dateDiff('second', materialize(toDateTime('2015-08-18 00:00:00', 'UTC')), materialize(toDateTime64('2015-08-18 00:00:10', 3, 'UTC')));
+10
+SELECT dateDiff('day', materialize(toDateTime64('2015-08-18 00:00:00', 0, 'UTC')), materialize(toDate('2015-08-19', 'UTC')));
+1
+SELECT dateDiff('day', materialize(toDate('2015-08-18', 'UTC')), materialize(toDateTime64('2015-08-19 00:00:00', 3, 'UTC')));
+1
diff --git a/tests/queries/0_stateless/018001_dateDiff_DateTime64.sql b/tests/queries/0_stateless/018001_dateDiff_DateTime64.sql
new file mode 100644
index 00000000000..020559f4e62
--- /dev/null
+++ b/tests/queries/0_stateless/018001_dateDiff_DateTime64.sql
@@ -0,0 +1,77 @@
+-- { echo }
+
+-- DateTime64 vs DateTime64 same scale
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 00:00:10', 0, 'UTC'));
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 00:10:00', 0, 'UTC'));
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 01:00:00', 0, 'UTC'));
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 01:10:10', 0, 'UTC'));
+
+SELECT dateDiff('minute', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 00:10:00', 0, 'UTC'));
+SELECT dateDiff('minute', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 10:00:00', 0, 'UTC'));
+
+SELECT dateDiff('hour', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-01 10:00:00', 0, 'UTC'));
+
+SELECT dateDiff('day', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-01-02 00:00:00', 0, 'UTC'));
+SELECT dateDiff('month', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1927-02-01 00:00:00', 0, 'UTC'));
+SELECT dateDiff('year', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), toDateTime64('1928-01-01 00:00:00', 0, 'UTC'));
+
+-- DateTime64 vs DateTime64 different scale
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 00:00:10', 3, 'UTC'));
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 00:10:00', 3, 'UTC'));
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 01:00:00', 3, 'UTC'));
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 01:10:10', 3, 'UTC'));
+
+SELECT dateDiff('minute', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 00:10:00', 3, 'UTC'));
+SELECT dateDiff('minute', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 10:00:00', 3, 'UTC'));
+
+SELECT dateDiff('hour', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-01 10:00:00', 3, 'UTC'));
+
+SELECT dateDiff('day', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-01-02 00:00:00', 3, 'UTC'));
+SELECT dateDiff('month', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1927-02-01 00:00:00', 3, 'UTC'));
+SELECT dateDiff('year', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), toDateTime64('1928-01-01 00:00:00', 3, 'UTC'));
+
+-- With DateTime
+-- DateTime64 vs DateTime
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDateTime('2015-08-18 00:00:00', 'UTC'));
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDateTime('2015-08-18 00:00:10', 'UTC'));
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDateTime('2015-08-18 00:10:00', 'UTC'));
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDateTime('2015-08-18 01:00:00', 'UTC'));
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDateTime('2015-08-18 01:10:10', 'UTC'));
+
+-- DateTime vs DateTime64
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), toDateTime64('2015-08-18 00:00:00', 3, 'UTC'));
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), toDateTime64('2015-08-18 00:00:10', 3, 'UTC'));
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), toDateTime64('2015-08-18 00:10:00', 3, 'UTC'));
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), toDateTime64('2015-08-18 01:00:00', 3, 'UTC'));
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), toDateTime64('2015-08-18 01:10:10', 3, 'UTC'));
+
+-- With Date
+-- DateTime64 vs Date
+SELECT dateDiff('day', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), toDate('2015-08-19', 'UTC'));
+
+-- Date vs DateTime64
+SELECT dateDiff('day', toDate('2015-08-18', 'UTC'), toDateTime64('2015-08-19 00:00:00', 3, 'UTC'));
+
+-- Same thing but const vs non-const columns
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 0, 'UTC'), materialize(toDateTime64('1927-01-01 00:00:10', 0, 'UTC')));
+SELECT dateDiff('second', toDateTime64('1927-01-01 00:00:00', 6, 'UTC'), materialize(toDateTime64('1927-01-01 00:00:10', 3, 'UTC')));
+SELECT dateDiff('second', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), materialize(toDateTime('2015-08-18 00:00:10', 'UTC')));
+SELECT dateDiff('second', toDateTime('2015-08-18 00:00:00', 'UTC'), materialize(toDateTime64('2015-08-18 00:00:10', 3, 'UTC')));
+SELECT dateDiff('day', toDateTime64('2015-08-18 00:00:00', 0, 'UTC'), materialize(toDate('2015-08-19', 'UTC')));
+SELECT dateDiff('day', toDate('2015-08-18', 'UTC'), materialize(toDateTime64('2015-08-19 00:00:00', 3, 'UTC')));
+
+-- Same thing but non-const vs const columns
+SELECT dateDiff('second', materialize(toDateTime64('1927-01-01 00:00:00', 0, 'UTC')), toDateTime64('1927-01-01 00:00:10', 0, 'UTC'));
+SELECT dateDiff('second', materialize(toDateTime64('1927-01-01 00:00:00', 6, 'UTC')), toDateTime64('1927-01-01 00:00:10', 3, 'UTC'));
+SELECT dateDiff('second', materialize(toDateTime64('2015-08-18 00:00:00', 0, 'UTC')), toDateTime('2015-08-18 00:00:10', 'UTC'));
+SELECT dateDiff('second', materialize(toDateTime('2015-08-18 00:00:00', 'UTC')), toDateTime64('2015-08-18 00:00:10', 3, 'UTC'));
+SELECT dateDiff('day', materialize(toDateTime64('2015-08-18 00:00:00', 0, 'UTC')), toDate('2015-08-19', 'UTC'));
+SELECT dateDiff('day', materialize(toDate('2015-08-18', 'UTC')), toDateTime64('2015-08-19 00:00:00', 3, 'UTC'));
+
+-- Same thing but non-const vs non-const columns
+SELECT dateDiff('second', materialize(toDateTime64('1927-01-01 00:00:00', 0, 'UTC')), materialize(toDateTime64('1927-01-01 00:00:10', 0, 'UTC')));
+SELECT dateDiff('second', materialize(toDateTime64('1927-01-01 00:00:00', 6, 'UTC')), materialize(toDateTime64('1927-01-01 00:00:10', 3, 'UTC')));
+SELECT dateDiff('second', materialize(toDateTime64('2015-08-18 00:00:00', 0, 'UTC')), materialize(toDateTime('2015-08-18 00:00:10', 'UTC')));
+SELECT dateDiff('second', materialize(toDateTime('2015-08-18 00:00:00', 'UTC')), materialize(toDateTime64('2015-08-18 00:00:10', 3, 'UTC')));
+SELECT dateDiff('day', materialize(toDateTime64('2015-08-18 00:00:00', 0, 'UTC')), materialize(toDate('2015-08-19', 'UTC')));
+SELECT dateDiff('day', materialize(toDate('2015-08-18', 'UTC')), materialize(toDateTime64('2015-08-19 00:00:00', 3, 'UTC')));
diff --git a/tests/queries/0_stateless/018002_formatDateTime_DateTime64_century.reference b/tests/queries/0_stateless/018002_formatDateTime_DateTime64_century.reference
new file mode 100644
index 00000000000..75c114cdd74
--- /dev/null
+++ b/tests/queries/0_stateless/018002_formatDateTime_DateTime64_century.reference
@@ -0,0 +1,27 @@
+-- { echo }
+
+SELECT formatDateTime(toDateTime64('1935-12-12 12:12:12', 0, 'Europe/Moscow'), '%C');
+19
+SELECT formatDateTime(toDateTime64('1969-12-12 12:12:12', 0, 'Europe/Moscow'), '%C');
+19
+SELECT formatDateTime(toDateTime64('1989-12-12 12:12:12', 0, 'Europe/Moscow'), '%C');
+19
+SELECT formatDateTime(toDateTime64('2019-09-16 19:20:12', 0, 'Europe/Moscow'), '%C');
+20
+SELECT formatDateTime(toDateTime64('2105-12-12 12:12:12', 0, 'Europe/Moscow'), '%C');
+21
+SELECT formatDateTime(toDateTime64('2205-12-12 12:12:12', 0, 'Europe/Moscow'), '%C');
+22
+-- non-zero scale
+SELECT formatDateTime(toDateTime64('1935-12-12 12:12:12', 6, 'Europe/Moscow'), '%C');
+19
+SELECT formatDateTime(toDateTime64('1969-12-12 12:12:12', 6, 'Europe/Moscow'), '%C');
+19
+SELECT formatDateTime(toDateTime64('1989-12-12 12:12:12', 6, 'Europe/Moscow'), '%C');
+19
+SELECT formatDateTime(toDateTime64('2019-09-16 19:20:12', 0, 'Europe/Moscow'), '%C');
+20
+SELECT formatDateTime(toDateTime64('2105-12-12 12:12:12', 6, 'Europe/Moscow'), '%C');
+21
+SELECT formatDateTime(toDateTime64('2205-01-12 12:12:12', 6, 'Europe/Moscow'), '%C');
+22
diff --git a/tests/queries/0_stateless/018002_formatDateTime_DateTime64_century.sql b/tests/queries/0_stateless/018002_formatDateTime_DateTime64_century.sql
new file mode 100644
index 00000000000..e368f45cbda
--- /dev/null
+++ b/tests/queries/0_stateless/018002_formatDateTime_DateTime64_century.sql
@@ -0,0 +1,16 @@
+-- { echo }
+
+SELECT formatDateTime(toDateTime64('1935-12-12 12:12:12', 0, 'Europe/Moscow'), '%C');
+SELECT formatDateTime(toDateTime64('1969-12-12 12:12:12', 0, 'Europe/Moscow'), '%C');
+SELECT formatDateTime(toDateTime64('1989-12-12 12:12:12', 0, 'Europe/Moscow'), '%C');
+SELECT formatDateTime(toDateTime64('2019-09-16 19:20:12', 0, 'Europe/Moscow'), '%C');
+SELECT formatDateTime(toDateTime64('2105-12-12 12:12:12', 0, 'Europe/Moscow'), '%C');
+SELECT formatDateTime(toDateTime64('2205-12-12 12:12:12', 0, 'Europe/Moscow'), '%C');
+
+-- non-zero scale
+SELECT formatDateTime(toDateTime64('1935-12-12 12:12:12', 6, 'Europe/Moscow'), '%C');
+SELECT formatDateTime(toDateTime64('1969-12-12 12:12:12', 6, 'Europe/Moscow'), '%C');
+SELECT formatDateTime(toDateTime64('1989-12-12 12:12:12', 6, 'Europe/Moscow'), '%C');
+SELECT formatDateTime(toDateTime64('2019-09-16 19:20:12', 0, 'Europe/Moscow'), '%C');
+SELECT formatDateTime(toDateTime64('2105-12-12 12:12:12', 6, 'Europe/Moscow'), '%C');
+SELECT formatDateTime(toDateTime64('2205-01-12 12:12:12', 6, 'Europe/Moscow'), '%C');
\ No newline at end of file
diff --git a/tests/queries/0_stateless/018002_toDateTime64_large_values.reference b/tests/queries/0_stateless/018002_toDateTime64_large_values.reference
new file mode 100644
index 00000000000..c44c61ab93a
--- /dev/null
+++ b/tests/queries/0_stateless/018002_toDateTime64_large_values.reference
@@ -0,0 +1,10 @@
+-- { echo }
+
+SELECT toDateTime64('2205-12-12 12:12:12', 0, 'UTC');
+2205-12-12 12:12:12
+SELECT toDateTime64('2205-12-12 12:12:12', 0, 'Europe/Moscow');
+2205-12-12 12:12:12
+SELECT toDateTime64('2205-12-12 12:12:12', 6, 'Europe/Moscow');
+2205-12-12 12:12:12.000000
+SELECT toDateTime64('2205-12-12 12:12:12', 6, 'Europe/Moscow');
+2205-12-12 12:12:12.000000
diff --git a/tests/queries/0_stateless/018002_toDateTime64_large_values.sql b/tests/queries/0_stateless/018002_toDateTime64_large_values.sql
new file mode 100644
index 00000000000..299111f43bc
--- /dev/null
+++ b/tests/queries/0_stateless/018002_toDateTime64_large_values.sql
@@ -0,0 +1,7 @@
+-- { echo }
+
+SELECT toDateTime64('2205-12-12 12:12:12', 0, 'UTC');
+SELECT toDateTime64('2205-12-12 12:12:12', 0, 'Europe/Moscow');
+
+SELECT toDateTime64('2205-12-12 12:12:12', 6, 'Europe/Moscow');
+SELECT toDateTime64('2205-12-12 12:12:12', 6, 'Europe/Moscow');
\ No newline at end of file
diff --git a/tests/queries/0_stateless/01800_log_nested.reference b/tests/queries/0_stateless/01800_log_nested.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/queries/0_stateless/01800_log_nested.sql b/tests/queries/0_stateless/01800_log_nested.sql
new file mode 100644
index 00000000000..6fe2b257905
--- /dev/null
+++ b/tests/queries/0_stateless/01800_log_nested.sql
@@ -0,0 +1,20 @@
+-- TinyTinyLog
+DROP TABLE IF EXISTS nested_01800_tiny_log;
+CREATE TABLE nested_01800_tiny_log (`column` Nested(name String, names Array(String), types Array(Enum8('PU' = 1, 'US' = 2, 'OTHER' = 3)))) ENGINE = TinyLog;
+INSERT INTO nested_01800_tiny_log VALUES (['Hello', 'World'], [['a'], ['b', 'c']], [['PU', 'US'], ['OTHER']]);
+SELECT 10 FROM nested_01800_tiny_log FORMAT Null;
+DROP TABLE nested_01800_tiny_log;
+
+-- StripeStripeLog
+DROP TABLE IF EXISTS nested_01800_stripe_log;
+CREATE TABLE nested_01800_stripe_log (`column` Nested(name String, names Array(String), types Array(Enum8('PU' = 1, 'US' = 2, 'OTHER' = 3)))) ENGINE = StripeLog;
+INSERT INTO nested_01800_stripe_log VALUES (['Hello', 'World'], [['a'], ['b', 'c']], [['PU', 'US'], ['OTHER']]);
+SELECT 10 FROM nested_01800_stripe_log FORMAT Null;
+DROP TABLE nested_01800_stripe_log;
+
+-- Log
+DROP TABLE IF EXISTS nested_01800_log;
+CREATE TABLE nested_01800_log (`column` Nested(name String, names Array(String), types Array(Enum8('PU' = 1, 'US' = 2, 'OTHER' = 3)))) ENGINE = Log;
+INSERT INTO nested_01800_log VALUES (['Hello', 'World'], [['a'], ['b', 'c']], [['PU', 'US'], ['OTHER']]);
+SELECT 10 FROM nested_01800_log FORMAT Null;
+DROP TABLE nested_01800_log;
diff --git a/tests/queries/0_stateless/01801_approx_total_rows_mergetree_reverse.reference b/tests/queries/0_stateless/01801_approx_total_rows_mergetree_reverse.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/queries/0_stateless/01801_approx_total_rows_mergetree_reverse.sql b/tests/queries/0_stateless/01801_approx_total_rows_mergetree_reverse.sql
new file mode 100644
index 00000000000..8809bf67a4c
--- /dev/null
+++ b/tests/queries/0_stateless/01801_approx_total_rows_mergetree_reverse.sql
@@ -0,0 +1,10 @@
+drop table if exists data_01801;
+create table data_01801 (key Int) engine=MergeTree() order by key settings index_granularity=10 as select number/10 from numbers(100);
+
+select * from data_01801 where key = 0 order by key settings max_rows_to_read=9 format Null; -- { serverError 158 }
+select * from data_01801 where key = 0 order by key desc settings max_rows_to_read=9 format Null; -- { serverError 158 }
+
+select * from data_01801 where key = 0 order by key settings max_rows_to_read=10 format Null;
+select * from data_01801 where key = 0 order by key desc settings max_rows_to_read=10 format Null;
+
+drop table data_01801;
diff --git a/tests/queries/0_stateless/01801_distinct_group_by_shard.reference b/tests/queries/0_stateless/01801_distinct_group_by_shard.reference
new file mode 100644
index 00000000000..d00491fd7e5
--- /dev/null
+++ b/tests/queries/0_stateless/01801_distinct_group_by_shard.reference
@@ -0,0 +1 @@
+1
diff --git a/tests/queries/0_stateless/01801_distinct_group_by_shard.sql b/tests/queries/0_stateless/01801_distinct_group_by_shard.sql
new file mode 100644
index 00000000000..ca6572b91ee
--- /dev/null
+++ b/tests/queries/0_stateless/01801_distinct_group_by_shard.sql
@@ -0,0 +1 @@
+SELECT DISTINCT a FROM remote('127.0.0.{1,2,3}', values('a UInt8, b UInt8', (1, 2), (1, 3))) GROUP BY a, b;
diff --git a/tests/queries/0_stateless/01801_nullable_low_cardinality_tsv.reference b/tests/queries/0_stateless/01801_nullable_low_cardinality_tsv.reference
new file mode 100644
index 00000000000..573541ac970
--- /dev/null
+++ b/tests/queries/0_stateless/01801_nullable_low_cardinality_tsv.reference
@@ -0,0 +1 @@
+0
diff --git a/tests/queries/0_stateless/01801_nullable_low_cardinality_tsv.sh b/tests/queries/0_stateless/01801_nullable_low_cardinality_tsv.sh
new file mode 100755
index 00000000000..935bfe18cfc
--- /dev/null
+++ b/tests/queries/0_stateless/01801_nullable_low_cardinality_tsv.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CUR_DIR"/../shell_config.sh
+
+$CLICKHOUSE_CLIENT --query="DROP TABLE IF EXISTS nullable_low_cardinality_tsv_test;";
+$CLICKHOUSE_CLIENT --multiquery --query="CREATE TABLE nullable_low_cardinality_tsv_test
+(
+    A Date,
+    S LowCardinality(Nullable(String)),
+    X Int32,
+    S1 LowCardinality(Nullable(String)),
+    S2 Array(String)
+) ENGINE=TinyLog";
+
+printf '2020-01-01\t\N\t32\t\N\n' | $CLICKHOUSE_CLIENT -q 'insert into nullable_low_cardinality_tsv_test format TSV' 2>&1 \
+    | grep -q "Code: 27"
+
+echo $?;
+
+$CLICKHOUSE_CLIENT --query="DROP TABLE nullable_low_cardinality_tsv_test";
diff --git a/tests/queries/0_stateless/01802_rank_corr_mann_whitney_over_window.reference b/tests/queries/0_stateless/01802_rank_corr_mann_whitney_over_window.reference
new file mode 100644
index 00000000000..42acbe4fbaf
--- /dev/null
+++ b/tests/queries/0_stateless/01802_rank_corr_mann_whitney_over_window.reference
@@ -0,0 +1,10 @@
+0.5060606060606061
+0.5083333333333333
+0.5119047619047619
+0.5178571428571428
+0.5285714285714286
+0.525
+0.55
+0.625
+0.5
+nan
diff --git a/tests/queries/0_stateless/01802_rank_corr_mann_whitney_over_window.sql b/tests/queries/0_stateless/01802_rank_corr_mann_whitney_over_window.sql
new file mode 100644
index 00000000000..3c1746a30f8
--- /dev/null
+++ b/tests/queries/0_stateless/01802_rank_corr_mann_whitney_over_window.sql
@@ -0,0 +1,22 @@
+DROP TABLE IF EXISTS 01802_empsalary;
+
+SET allow_experimental_window_functions=1;
+
+CREATE TABLE 01802_empsalary
+(
+    `depname` LowCardinality(String),
+    `empno` UInt64,
+    `salary` Int32,
+    `enroll_date` Date
+)
+ENGINE = MergeTree
+ORDER BY enroll_date
+SETTINGS index_granularity = 8192;
+
+INSERT INTO 01802_empsalary VALUES ('sales', 1, 5000, '2006-10-01'), ('develop', 8, 6000, '2006-10-01'), ('personnel', 2, 3900, '2006-12-23'), ('develop', 10, 5200, '2007-08-01'), ('sales', 3, 4800, '2007-08-01'), ('sales', 4, 4800, '2007-08-08'), ('develop', 11, 5200, '2007-08-15'), ('personnel', 5, 3500, '2007-12-10'), ('develop', 7, 4200, '2008-01-01'), ('develop', 9, 4500, '2008-01-01');
+
+SELECT mannWhitneyUTest(salary, salary) OVER (ORDER BY salary ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS func FROM 01802_empsalary; -- {serverError 36}
+
+SELECT rankCorr(salary, 0.5) OVER (ORDER BY salary ASC ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS func FROM 01802_empsalary;
+
+DROP TABLE IF EXISTS 01802_empsalary;
diff --git a/tests/queries/0_stateless/01803_const_nullable_map.reference b/tests/queries/0_stateless/01803_const_nullable_map.reference
new file mode 100644
index 00000000000..573541ac970
--- /dev/null
+++ b/tests/queries/0_stateless/01803_const_nullable_map.reference
@@ -0,0 +1 @@
+0
diff --git a/tests/queries/0_stateless/01803_const_nullable_map.sql b/tests/queries/0_stateless/01803_const_nullable_map.sql
new file mode 100644
index 00000000000..4ac9f925e24
--- /dev/null
+++ b/tests/queries/0_stateless/01803_const_nullable_map.sql
@@ -0,0 +1,9 @@
+DROP TABLE IF EXISTS t_map_null;
+
+SET allow_experimental_map_type = 1;
+
+CREATE TABLE t_map_null (a Map(String, String), b String) engine = MergeTree() ORDER BY a;
+INSERT INTO t_map_null VALUES (map('a', 'b', 'c', 'd'), 'foo');
+SELECT count() FROM t_map_null WHERE a = map('name', NULL, '', NULL);
+
+DROP TABLE t_map_null;
diff --git a/tests/queries/0_stateless/01803_untuple_subquery.reference b/tests/queries/0_stateless/01803_untuple_subquery.reference
new file mode 100644
index 00000000000..838ff3aa952
--- /dev/null
+++ b/tests/queries/0_stateless/01803_untuple_subquery.reference
@@ -0,0 +1,2 @@
+(0.5,'92233720368547758.07',NULL)		1.00	256	\N	\N
+\N
diff --git a/tests/queries/0_stateless/01803_untuple_subquery.sql b/tests/queries/0_stateless/01803_untuple_subquery.sql
new file mode 100644
index 00000000000..512b4c561af
--- /dev/null
+++ b/tests/queries/0_stateless/01803_untuple_subquery.sql
@@ -0,0 +1,3 @@
+SELECT (0.5, '92233720368547758.07', NULL), '', '1.00', untuple(('256', NULL)), NULL FROM (SELECT untuple(((NULL, untuple((('0.0000000100', (65536, NULL, (65535, 9223372036854775807), '25.7', (0.00009999999747378752, '10.25', 1048577), 65536)), '0.0000001024', '65537', NULL))), untuple((9223372036854775807, -inf, 0.5)), NULL, -9223372036854775808)), 257, 7, ('0.0001048575', (1024, NULL, (7, 3), (untuple(tuple(-NULL)), NULL, '0.0001048577', NULL), 0)), 0, (0, 0.9998999834060669, '65537'), untuple(tuple('10.25')));
+
+SELECT NULL FROM (SELECT untuple((NULL, dummy)));
diff --git a/tests/queries/0_stateless/01804_dictionary_decimal256_type.reference b/tests/queries/0_stateless/01804_dictionary_decimal256_type.reference
new file mode 100644
index 00000000000..1af9d45f72b
--- /dev/null
+++ b/tests/queries/0_stateless/01804_dictionary_decimal256_type.reference
@@ -0,0 +1,14 @@
+Flat dictionary
+5.00000
+Hashed dictionary
+5.00000
+Cache dictionary
+5.00000
+SSDCache dictionary
+5.00000
+Direct dictionary
+5.00000
+IPTrie dictionary
+5.00000
+Polygon dictionary
+5.00000
diff --git a/tests/queries/0_stateless/01804_dictionary_decimal256_type.sql b/tests/queries/0_stateless/01804_dictionary_decimal256_type.sql
new file mode 100644
index 00000000000..cc0ec598b70
--- /dev/null
+++ b/tests/queries/0_stateless/01804_dictionary_decimal256_type.sql
@@ -0,0 +1,141 @@
+SET allow_experimental_bigint_types = 1;
+
+DROP TABLE IF EXISTS dictionary_decimal_source_table;
+CREATE TABLE dictionary_decimal_source_table
+(
+    id UInt64,
+    decimal_value Decimal256(5)
+) ENGINE = TinyLog;
+
+INSERT INTO dictionary_decimal_source_table VALUES (1, 5.0);
+
+DROP DICTIONARY IF EXISTS flat_dictionary;
+CREATE DICTIONARY flat_dictionary
+(
+    id UInt64,
+    decimal_value Decimal256(5)
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'dictionary_decimal_source_table'))
+LIFETIME(MIN 1 MAX 1000)
+LAYOUT(FLAT());
+
+SELECT 'Flat dictionary';
+SELECT dictGet('flat_dictionary', 'decimal_value', toUInt64(1));
+
+DROP DICTIONARY IF EXISTS hashed_dictionary;
+CREATE DICTIONARY hashed_dictionary
+(
+    id UInt64,
+    decimal_value Decimal256(5)
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'dictionary_decimal_source_table'))
+LIFETIME(MIN 1 MAX 1000)
+LAYOUT(HASHED());
+
+SELECT 'Hashed dictionary';
+SELECT dictGet('hashed_dictionary', 'decimal_value', toUInt64(1));
+
+DROP DICTIONARY hashed_dictionary;
+
+DROP DICTIONARY IF EXISTS cache_dictionary;
+CREATE DICTIONARY cache_dictionary
+(
+    id UInt64,
+    decimal_value Decimal256(5)
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'dictionary_decimal_source_table'))
+LIFETIME(MIN 1 MAX 1000)
+LAYOUT(CACHE(SIZE_IN_CELLS 10));
+
+SELECT 'Cache dictionary';
+SELECT dictGet('cache_dictionary', 'decimal_value', toUInt64(1));
+
+DROP DICTIONARY cache_dictionary;
+
+DROP DICTIONARY IF EXISTS ssd_cache_dictionary;
+CREATE DICTIONARY ssd_cache_dictionary
+(
+    id UInt64,
+    decimal_value Decimal256(5)
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'dictionary_decimal_source_table'))
+LIFETIME(MIN 1 MAX 1000)
+LAYOUT(SSD_CACHE(BLOCK_SIZE 4096 FILE_SIZE 8192 PATH '/var/lib/clickhouse/clickhouse_dicts/0d'));
+
+SELECT 'SSDCache dictionary';
+SELECT dictGet('ssd_cache_dictionary', 'decimal_value', toUInt64(1));
+
+DROP DICTIONARY ssd_cache_dictionary;
+
+DROP DICTIONARY IF EXISTS direct_dictionary;
+CREATE DICTIONARY direct_dictionary
+(
+    id UInt64,
+    decimal_value Decimal256(5)
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'dictionary_decimal_source_table'))
+LAYOUT(DIRECT());
+
+SELECT 'Direct dictionary';
+SELECT dictGet('direct_dictionary', 'decimal_value', toUInt64(1));
+
+DROP DICTIONARY direct_dictionary;
+
+DROP TABLE dictionary_decimal_source_table;
+
+DROP TABLE IF EXISTS ip_trie_dictionary_decimal_source_table;
+CREATE TABLE ip_trie_dictionary_decimal_source_table
+(
+    prefix String,
+    decimal_value Decimal256(5)
+) ENGINE = TinyLog;
+
+INSERT INTO ip_trie_dictionary_decimal_source_table VALUES ('127.0.0.0', 5.0);
+
+DROP DICTIONARY IF EXISTS ip_trie_dictionary;
+CREATE DICTIONARY ip_trie_dictionary
+(
+    prefix String,
+    decimal_value Decimal256(5)
+)
+PRIMARY KEY prefix
+SOURCE(CLICKHOUSE(HOST 'localhost' port tcpPort() TABLE 'ip_trie_dictionary_decimal_source_table'))
+LIFETIME(MIN 10 MAX 1000)
+LAYOUT(IP_TRIE());
+
+SELECT 'IPTrie dictionary';
+SELECT dictGet('ip_trie_dictionary', 'decimal_value', tuple(IPv4StringToNum('127.0.0.0')));
+
+DROP DICTIONARY ip_trie_dictionary;
+DROP TABLE ip_trie_dictionary_decimal_source_table;
+
+DROP TABLE IF EXISTS dictionary_decimal_polygons_source_table;
+CREATE TABLE dictionary_decimal_polygons_source_table
+(
+    key Array(Array(Array(Tuple(Float64, Float64)))),
+    decimal_value Decimal256(5)
+) ENGINE = TinyLog;
+
+INSERT INTO dictionary_decimal_polygons_source_table VALUES ([[[(0, 0), (0, 1), (1, 1), (1, 0)]]], 5.0);
+
+DROP DICTIONARY IF EXISTS polygon_dictionary;
+CREATE DICTIONARY polygon_dictionary
+(
+    key Array(Array(Array(Tuple(Float64, Float64)))),
+    decimal_value Decimal256(5)
+)
+PRIMARY KEY key
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'dictionary_decimal_polygons_source_table'))
+LIFETIME(MIN 0 MAX 1000)
+LAYOUT(POLYGON());
+
+SELECT 'Polygon dictionary';
+SELECT dictGet('polygon_dictionary', 'decimal_value', tuple(0.5, 0.5));
+
+DROP DICTIONARY polygon_dictionary;
+DROP TABLE dictionary_decimal_polygons_source_table;
diff --git a/tests/queries/0_stateless/01804_uniq_up_to_ubsan.reference b/tests/queries/0_stateless/01804_uniq_up_to_ubsan.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/queries/0_stateless/01804_uniq_up_to_ubsan.sql b/tests/queries/0_stateless/01804_uniq_up_to_ubsan.sql
new file mode 100644
index 00000000000..fcbe585b70a
--- /dev/null
+++ b/tests/queries/0_stateless/01804_uniq_up_to_ubsan.sql
@@ -0,0 +1,2 @@
+SELECT uniqUpTo(1e100)(number) FROM numbers(5); -- { serverError 70 }
+SELECT uniqUpTo(-1e100)(number) FROM numbers(5); -- { serverError 70 }
diff --git a/tests/queries/0_stateless/01809_inactive_parts_to_delay_throw_insert.reference b/tests/queries/0_stateless/01809_inactive_parts_to_delay_throw_insert.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/queries/0_stateless/01809_inactive_parts_to_delay_throw_insert.sql b/tests/queries/0_stateless/01809_inactive_parts_to_delay_throw_insert.sql
new file mode 100644
index 00000000000..e9bbfe69421
--- /dev/null
+++ b/tests/queries/0_stateless/01809_inactive_parts_to_delay_throw_insert.sql
@@ -0,0 +1,12 @@
+drop table if exists data_01809;
+
+create table data_01809 (i int) engine MergeTree order by i settings old_parts_lifetime = 10000000000, min_bytes_for_wide_part = 0, inactive_parts_to_throw_insert = 0, inactive_parts_to_delay_insert = 1;
+
+insert into data_01809 values (1);
+insert into data_01809 values (2);
+
+optimize table data_01809 final;
+
+insert into data_01809 values (3);
+
+drop table data_01809;
diff --git a/tests/queries/0_stateless/01810_max_part_removal_threads_long.reference b/tests/queries/0_stateless/01810_max_part_removal_threads_long.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/queries/0_stateless/01810_max_part_removal_threads_long.sh b/tests/queries/0_stateless/01810_max_part_removal_threads_long.sh
new file mode 100755
index 00000000000..f2aa1f63197
--- /dev/null
+++ b/tests/queries/0_stateless/01810_max_part_removal_threads_long.sh
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+
+# NOTE: this done as not .sql since we need to Ordinary database
+# (to account threads in query_log for DROP TABLE query)
+# and we can do it compatible with parallel run only in .sh
+# (via $CLICKHOUSE_DATABASE)
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CUR_DIR"/../shell_config.sh
+
+$CLICKHOUSE_CLIENT -nm -q "create database ordinary_$CLICKHOUSE_DATABASE engine=Ordinary"
+
+# MergeTree
+$CLICKHOUSE_CLIENT -nm -q """
+    use ordinary_$CLICKHOUSE_DATABASE;
+    drop table if exists data_01810;
+    create table data_01810 (key Int) Engine=MergeTree() order by key partition by key settings max_part_removal_threads=10, concurrent_part_removal_threshold=49;
+    insert into data_01810 select * from numbers(50);
+    drop table data_01810 settings log_queries=1;
+    system flush logs;
+    select throwIf(length(thread_ids)<50) from system.query_log where event_date = today() and current_database = currentDatabase() and query = 'drop table data_01810 settings log_queries=1;' and type = 'QueryFinish' format Null;
+"""
+
+# ReplicatedMergeTree
+$CLICKHOUSE_CLIENT -nm -q """
+    use ordinary_$CLICKHOUSE_DATABASE;
+    drop table if exists rep_data_01810;
+    create table rep_data_01810 (key Int) Engine=ReplicatedMergeTree('/clickhouse/tables/$CLICKHOUSE_TEST_ZOOKEEPER_PREFIX/rep_data_01810', '1') order by key partition by key settings max_part_removal_threads=10, concurrent_part_removal_threshold=49;
+    insert into rep_data_01810 select * from numbers(50);
+    drop table rep_data_01810 settings log_queries=1;
+    system flush logs;
+    select throwIf(length(thread_ids)<50) from system.query_log where event_date = today() and current_database = currentDatabase() and query = 'drop table rep_data_01810 settings log_queries=1;' and type = 'QueryFinish' format Null;
+"""
+
+$CLICKHOUSE_CLIENT -nm -q "drop database ordinary_$CLICKHOUSE_DATABASE"
diff --git a/tests/queries/0_stateless/01811_filter_by_null.reference b/tests/queries/0_stateless/01811_filter_by_null.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/queries/0_stateless/01811_filter_by_null.sql b/tests/queries/0_stateless/01811_filter_by_null.sql
new file mode 100644
index 00000000000..496faf428ab
--- /dev/null
+++ b/tests/queries/0_stateless/01811_filter_by_null.sql
@@ -0,0 +1,9 @@
+DROP TABLE IF EXISTS test_01344;
+
+CREATE TABLE test_01344 (x String, INDEX idx (x) TYPE set(10) GRANULARITY 1) ENGINE = MergeTree ORDER BY tuple() SETTINGS min_bytes_for_wide_part = 0;
+INSERT INTO test_01344 VALUES ('Hello, world');
+SELECT NULL FROM test_01344 WHERE ignore(1) = NULL;
+SELECT NULL FROM test_01344 WHERE encrypt(ignore(encrypt(NULL, '0.0001048577', lcm(2, 65537), NULL, inf, NULL), lcm(-2, 1048575)), '-0.0000000001', lcm(NULL, NULL)) = NULL;
+SELECT NULL FROM test_01344 WHERE ignore(x, lcm(NULL, 1048576), -2) = NULL;
+
+DROP TABLE test_01344;
diff --git a/tests/queries/0_stateless/arcadia_skip_list.txt b/tests/queries/0_stateless/arcadia_skip_list.txt
index b97e2a63638..28e48ad27ad 100644
--- a/tests/queries/0_stateless/arcadia_skip_list.txt
+++ b/tests/queries/0_stateless/arcadia_skip_list.txt
@@ -224,4 +224,9 @@
 01306_polygons_intersection
 01702_system_query_log
 01759_optimize_skip_unused_shards_zero_shards
+01780_clickhouse_dictionary_source_loop
+01790_dist_INSERT_block_structure_mismatch_types_and_names
+01791_dist_INSERT_block_structure_mismatch
 01798_uniq_theta_sketch
+01801_distinct_group_by_shard
+01804_dictionary_decimal256_type
diff --git a/tests/queries/1_stateful/00163_column_oriented_formats.reference b/tests/queries/1_stateful/00163_column_oriented_formats.reference
new file mode 100644
index 00000000000..cb20aca4392
--- /dev/null
+++ b/tests/queries/1_stateful/00163_column_oriented_formats.reference
@@ -0,0 +1,12 @@
+Parquet
+6b397d4643bc1f920f3eb8aa87ee180c  -
+7fe6d8c57ddc5fe37bbdcb7f73c5fa78  -
+d8746733270cbeff7ab3550c9b944fb6  -
+Arrow
+6b397d4643bc1f920f3eb8aa87ee180c  -
+7fe6d8c57ddc5fe37bbdcb7f73c5fa78  -
+d8746733270cbeff7ab3550c9b944fb6  -
+ORC
+6b397d4643bc1f920f3eb8aa87ee180c  -
+7fe6d8c57ddc5fe37bbdcb7f73c5fa78  -
+d8746733270cbeff7ab3550c9b944fb6  -
diff --git a/tests/queries/1_stateful/00163_column_oriented_formats.sh b/tests/queries/1_stateful/00163_column_oriented_formats.sh
new file mode 100755
index 00000000000..1363ccf3c00
--- /dev/null
+++ b/tests/queries/1_stateful/00163_column_oriented_formats.sh
@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+
+FORMATS=('Parquet' 'Arrow' 'ORC')
+
+for format in "${FORMATS[@]}"
+do
+    echo $format
+    $CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS 00163_column_oriented SYNC"
+    $CLICKHOUSE_CLIENT -q "CREATE TABLE 00163_column_oriented(ClientEventTime DateTime, MobilePhoneModel String, ClientIP6 FixedString(16)) ENGINE=File($format)"
+    $CLICKHOUSE_CLIENT -q "INSERT INTO 00163_column_oriented SELECT ClientEventTime, MobilePhoneModel, ClientIP6 FROM test.hits ORDER BY ClientEventTime, MobilePhoneModel, ClientIP6 LIMIT 100"
+    $CLICKHOUSE_CLIENT -q "SELECT ClientEventTime from 00163_column_oriented" | md5sum
+    $CLICKHOUSE_CLIENT -q "SELECT MobilePhoneModel from 00163_column_oriented" | md5sum
+    $CLICKHOUSE_CLIENT -q "SELECT ClientIP6 from 00163_column_oriented" | md5sum
+    $CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS 00163_column_oriented SYNC"
+done
diff --git a/tests/queries/skip_list.json b/tests/queries/skip_list.json
index 90dbf3e65d8..d41a41bd524 100644
--- a/tests/queries/skip_list.json
+++ b/tests/queries/skip_list.json
@@ -148,6 +148,7 @@
         "00626_replace_partition_from_table",
         "00152_insert_different_granularity",
         "00054_merge_tree_partitions",
+        "01781_merge_tree_deduplication",
         /// Old syntax is not allowed
         "01062_alter_on_mutataion_zookeeper",
         "00925_zookeeper_empty_replicated_merge_tree_optimize_final",
@@ -675,6 +676,8 @@
         "01760_polygon_dictionaries",
         "01760_system_dictionaries",
         "01761_alter_decimal_zookeeper",
+        "01360_materialized_view_with_join_on_query_log", // creates and drops MVs on query_log, which may interrupt flushes.
+        "01509_parallel_quorum_insert_no_replicas", // It's ok to execute in parallel with oter tests but not several instances of the same test.
         "attach",
         "ddl_dictionaries",
         "dictionary",
@@ -696,6 +699,8 @@
         "01760_system_dictionaries",
         "01760_polygon_dictionaries",
         "01778_hierarchical_dictionaries",
-        "01780_clickhouse_dictionary_source_loop"
+        "01780_clickhouse_dictionary_source_loop",
+        "01785_dictionary_element_count",
+        "01804_dictionary_decimal256_type"
     ]
 }
diff --git a/utils/CMakeLists.txt b/utils/CMakeLists.txt
index afeda751ea5..04d9a07008e 100644
--- a/utils/CMakeLists.txt
+++ b/utils/CMakeLists.txt
@@ -37,7 +37,8 @@ if (NOT DEFINED ENABLE_UTILS OR ENABLE_UTILS)
         add_subdirectory (keeper-data-dumper)
     endif ()
 
-    if (NOT OS_DARWIN)
+    # memcpy_jart.S contains position dependent code
+    if (NOT CMAKE_POSITION_INDEPENDENT_CODE AND NOT OS_DARWIN)
         add_subdirectory (memcpy-bench)
     endif ()
 endif ()
diff --git a/utils/github/backport.py b/utils/github/backport.py
index 7fddbbee241..d2687b893a4 100644
--- a/utils/github/backport.py
+++ b/utils/github/backport.py
@@ -76,7 +76,7 @@ class Backport:
 
             # First pass. Find all must-backports
             for label in pr['labels']['nodes']:
-                if label['name'] == 'pr-bugfix':
+                if label['name'] == 'pr-bugfix' or label['name'] == 'pr-must-backport':
                     backport_map[pr['number']] = branch_set.copy()
                     continue
                 matched = RE_MUST_BACKPORT.match(label['name'])
diff --git a/utils/list-versions/version_date.tsv b/utils/list-versions/version_date.tsv
index 3e1073b8529..bf9ef37e2b7 100644
--- a/utils/list-versions/version_date.tsv
+++ b/utils/list-versions/version_date.tsv
@@ -1,12 +1,19 @@
+v21.4.3.21-stable	2021-04-12
+v21.3.6.55-lts	2021-04-12
+v21.3.5.42-lts	2021-04-07
 v21.3.4.25-lts	2021-03-28
 v21.3.3.14-lts	2021-03-19
 v21.3.2.5-lts	2021-03-12
+v21.2.9.41-stable	2021-04-12
+v21.2.8.31-stable	2021-04-07
 v21.2.7.11-stable	2021-03-28
 v21.2.6.1-stable	2021-03-15
 v21.2.5.5-stable	2021-03-02
 v21.2.4.6-stable	2021-02-20
 v21.2.3.15-stable	2021-02-14
 v21.2.2.8-stable	2021-02-07
+v21.1.9.41-stable	2021-04-13
+v21.1.8.30-stable	2021-04-07
 v21.1.7.1-stable	2021-03-15
 v21.1.6.13-stable	2021-03-02
 v21.1.5.4-stable	2021-02-20
@@ -39,6 +46,8 @@ v20.9.5.5-stable	2020-11-13
 v20.9.4.76-stable	2020-10-29
 v20.9.3.45-stable	2020-10-09
 v20.9.2.20-stable	2020-09-22
+v20.8.17.25-lts	2021-04-08
+v20.8.16.20-lts	2021-04-06
 v20.8.15.11-lts	2021-04-01
 v20.8.14.4-lts	2021-03-03
 v20.8.13.15-lts	2021-02-20
diff --git a/utils/memcpy-bench/memcpy-bench.cpp b/utils/memcpy-bench/memcpy-bench.cpp
index b607c45370d..025c9100f75 100644
--- a/utils/memcpy-bench/memcpy-bench.cpp
+++ b/utils/memcpy-bench/memcpy-bench.cpp
@@ -299,8 +299,8 @@ static void * memcpySSE2Unrolled8(void * __restrict destination, const void * __
 
 
 //static __attribute__((__always_inline__, __target__("sse2")))
-__attribute__((__always_inline__))
-void memcpy_my_medium_sse(uint8_t * __restrict & dst, const uint8_t * __restrict & src, size_t & size)
+__attribute__((__always_inline__)) inline void
+memcpy_my_medium_sse(uint8_t * __restrict & dst, const uint8_t * __restrict & src, size_t & size)
 {
     /// Align destination to 16 bytes boundary.
     size_t padding = (16 - (reinterpret_cast<size_t>(dst) & 15)) & 15;
diff --git a/website/benchmark/dbms/queries.js b/website/benchmark/dbms/queries.js
index c92353ab0f2..f3cf25f2c8d 100644
--- a/website/benchmark/dbms/queries.js
+++ b/website/benchmark/dbms/queries.js
@@ -1,4 +1,4 @@
-var current_data_size = 1000000000;
+var current_data_size = 100000000;
 
 var current_systems = ["ClickHouse", "Vertica", "Greenplum"];
 
diff --git a/website/benchmark/hardware/index.html b/website/benchmark/hardware/index.html
index a57930b279d..71d3333432e 100644
--- a/website/benchmark/hardware/index.html
+++ b/website/benchmark/hardware/index.html
@@ -76,6 +76,7 @@ Results for Digitalocean (Storage-intesinve VMs) + (CPU/GP) are from <b>Yiğit K
 Results for 2x AMD EPYC 7F72 3.2 Ghz (Total 96 Cores, IBM Cloud's Bare Metal Service) from <b>Yiğit Konur</b> and <b>Metehan Çetinkaya</b> of seo.do.<br/>
 Results for 2x AMD EPYC 7742 (128 physical cores, 1 TB DDR4-3200 RAM) from <b>Yedige Davletgaliyev</b> and <b>Nikita Zhavoronkov</b> of blockchair.com.<br/>
 Results for ASUS A15 (Ryzen laptop) are from <b>Kimmo Linna</b>.<br/>
+Results for MacBook Air M1 are from <b>Denis Glazachev</b>.<br/>
 </p>
     </div>
 </div>
diff --git a/website/benchmark/hardware/results/amd_ryzen_9_3950x.json b/website/benchmark/hardware/results/amd_ryzen_9_3950x.json
index 8760a235521..caa5a443e54 100644
--- a/website/benchmark/hardware/results/amd_ryzen_9_3950x.json
+++ b/website/benchmark/hardware/results/amd_ryzen_9_3950x.json
@@ -1,6 +1,6 @@
 [
     {
-        "system":       "AMD Ryzen 9",
+        "system":       "AMD Ryzen 9 (2020)",
         "system_full":       "AMD Ryzen 9 3950X 16-Core Processor, 64 GiB RAM, Intel Optane 900P 280 GB",
         "time":         "2020-03-14 00:00:00",
         "kind":         "desktop",
@@ -52,7 +52,7 @@
         ]
     },
     {
-        "system":       "AMD Ryzen 9",
+        "system":       "AMD Ryzen 9 (2021)",
         "system_full":       "AMD Ryzen 9 3950X 16-Core Processor, 64 GiB RAM, Samsung evo 970 plus 1TB",
         "time":         "2021-03-08 00:00:00",
         "kind":         "desktop",
diff --git a/website/benchmark/hardware/results/macbook_air_m1.json b/website/benchmark/hardware/results/macbook_air_m1.json
new file mode 100644
index 00000000000..33f15d02480
--- /dev/null
+++ b/website/benchmark/hardware/results/macbook_air_m1.json
@@ -0,0 +1,54 @@
+[
+    {
+        "system":       "MacBook Air M1",
+        "system_full":  "MacBook Air M1 13\" 2020, 8‑core CPU, 16 GiB RAM, 512 GB SSD",
+        "time":         "2021-04-11 00:00:00",
+        "kind":         "laptop",
+        "result":
+        [
+[0.003, 0.001, 0.001],
+[0.019, 0.014, 0.014],
+[0.042, 0.034, 0.033],
+[0.101, 0.043, 0.041],
+[0.100, 0.102, 0.101],
+[0.394, 0.283, 0.289],
+[0.029, 0.027, 0.027],
+[0.018, 0.018, 0.018],
+[0.511, 0.489, 0.494],
+[0.620, 0.615, 0.618],
+[0.217, 0.200, 0.197],
+[0.237, 0.235, 0.242],
+[0.774, 0.762, 0.761],
+[0.969, 0.982, 0.969],
+[0.896, 0.887, 0.861],
+[0.999, 0.943, 0.945],
+[3.343, 2.426, 2.366],
+[1.463, 1.414, 1.382],
+[4.958, 4.268, 4.257],
+[0.056, 0.050, 0.049],
+[1.696, 0.851, 0.846],
+[1.036, 1.104, 1.174],
+[4.326, 2.224, 2.255],
+[1.397, 1.038, 1.055],
+[0.317, 0.310, 0.305],
+[0.274, 0.284, 0.269],
+[0.317, 0.316, 0.313],
+[0.943, 0.952, 0.951],
+[2.794, 1.427, 1.433],
+[1.606, 1.600, 1.605],
+[0.751, 0.691, 0.679],
+[1.532, 1.000, 0.952],
+[9.679, 8.895, 7.967],
+[7.001, 4.472, 4.050],
+[4.790, 3.971, 3.987],
+[1.215, 1.204, 1.256],
+[0.129, 0.125, 0.119],
+[0.057, 0.061, 0.056],
+[0.045, 0.043, 0.043],
+[0.256, 0.247, 0.249],
+[0.020, 0.014, 0.013],
+[0.013, 0.011, 0.012],
+[0.009, 0.009, 0.009]
+        ]
+    }
+]
diff --git a/website/templates/index/hero.html b/website/templates/index/hero.html
index 55d0111ac61..efa4643e841 100644
--- a/website/templates/index/hero.html
+++ b/website/templates/index/hero.html
@@ -22,12 +22,8 @@
             <div class="row lead">
 
                 <div class="col-lg pb-2">
-                    <a href="https://play.clickhouse.tech/?file=welcome" class="btn btn-lg btn-yellow w-100 mb-2" role="button" target="_blank" rel="external nofollow">
-                        <div class="py-2">
-                            <h2>Try online demo</h2>
-                            <div class="lead">Powered by Yandex.Cloud</div>
-                        </div>
-                    </a>
+                    <a href="https://play.clickhouse.tech/?file=welcome" class="btn btn-lg btn-yellow w-100 mb-3" role="button" target="_blank" rel="external nofollow">Try online demo</a>
+                    <a href="docs/en/commercial/support/" class="btn btn-lg btn-yellow w-100" role="button">Request support</a>
                 </div>
                 <div class="col-lg pb-2">
                     <a href="#quick-start" class="btn btn-lg btn-outline-orange w-100 mb-3" role="button">Quick start</a>
diff --git a/website/templates/index/quickstart.html b/website/templates/index/quickstart.html
index 454fc68151d..0d967e7b96c 100644
--- a/website/templates/index/quickstart.html
+++ b/website/templates/index/quickstart.html
@@ -36,7 +36,7 @@
            target="_blank">
             official Docker images of ClickHouse</a>, this is not the only <a href="https://clickhouse.tech/docs/en/getting-started/">option</a> though.
         Alternatively, you can easily get a running ClickHouse instance or cluster at
-        <a href="https://cloud.yandex.com/services/managed-clickhouse?utm_source=referrals&utm_medium=clickhouseofficialsite&utm_campaign=link1" rel="external nofollow noreferrer" target="_blank">
+        <a href="https://cloud.yandex.com/services/managed-clickhouse?utm_source=referrals&amp;utm_medium=clickhouseofficialsite&amp;utm_campaign=link1" rel="external nofollow noreferrer" target="_blank">
             Yandex Managed Service for ClickHouse</a>.
     </p>