Merge branch 'master' into improve_if_with_floating

2024-11-25 09:02:00 +00:00 · 2024-01-26 19:21:49 +08:00 · 2024-01-26 19:21:49 +08:00 · 56db02c953
commit 56db02c953
parent 29b3cf60a6 10d4f1fd87
841 changed files with 4087 additions and 4446 deletions
--- a/base/poco/Foundation/include/Poco/Logger.h
+++ b/base/poco/Foundation/include/Poco/Logger.h
@ -33,7 +33,8 @@ namespace Poco


 class Exception;
-
+class Logger;
+using LoggerPtr = std::shared_ptr<Logger>;

 class Foundation_API Logger : public Channel
 /// Logger is a special Channel that acts as the main
@ -870,6 +871,11 @@ public:
    /// If the Logger does not yet exist, it is created, based
    /// on its parent logger.

+    static LoggerPtr getShared(const std::string & name);
+    /// Returns a shared pointer to the Logger with the given name.
+    /// If the Logger does not yet exist, it is created, based
+    /// on its parent logger.
+
    static Logger & unsafeGet(const std::string & name);
    /// Returns a reference to the Logger with the given name.
    /// If the Logger does not yet exist, it is created, based
@ -885,6 +891,11 @@ public:
    /// given name. The Logger's Channel and log level as set as
    /// specified.

+    static LoggerPtr createShared(const std::string & name, Channel * pChannel, int level = Message::PRIO_INFORMATION);
+    /// Creates and returns a shared pointer to a Logger with the
+    /// given name. The Logger's Channel and log level as set as
+    /// specified.
+
    static Logger & root();
    /// Returns a reference to the root logger, which is the ultimate
    /// ancestor of all Loggers.
@ -893,7 +904,7 @@ public:
    /// Returns a pointer to the Logger with the given name if it
    /// exists, or a null pointer otherwise.

-    static void destroy(const std::string & name);
+    static bool destroy(const std::string & name);
    /// Destroys the logger with the specified name. Does nothing
    /// if the logger is not found.
    ///
@ -938,6 +949,7 @@ protected:
    void log(const std::string & text, Message::Priority prio, const char * file, int line);

    static std::string format(const std::string & fmt, int argc, std::string argv[]);
+    static Logger & unsafeCreate(const std::string & name, Channel * pChannel, int level = Message::PRIO_INFORMATION);
    static Logger & parent(const std::string & name);
    static void add(Logger * pLogger);
    static Logger * find(const std::string & name);
@ -952,7 +964,6 @@ private:
    std::atomic_int _level;

    static LoggerMap * _pLoggerMap;
-    static Mutex _mapMtx;
 };


--- a/base/poco/Foundation/include/Poco/RefCountedObject.h
+++ b/base/poco/Foundation/include/Poco/RefCountedObject.h
@ -38,15 +38,15 @@ public:
    /// Creates the RefCountedObject.
    /// The initial reference count is one.

-    void duplicate() const;
-    /// Increments the object's reference count.
+    size_t duplicate() const;
+    /// Increments the object's reference count, returns reference count before call.

-    void release() const throw();
+    size_t release() const throw();
    /// Decrements the object's reference count
    /// and deletes the object if the count
-    /// reaches zero.
+    /// reaches zero, returns reference count before call.

-    int referenceCount() const;
+    size_t referenceCount() const;
    /// Returns the reference count.

 protected:
@ -57,36 +57,40 @@ private:
    RefCountedObject(const RefCountedObject &);
    RefCountedObject & operator=(const RefCountedObject &);

-    mutable AtomicCounter _counter;
+    mutable std::atomic<size_t> _counter;
 };


 //
 // inlines
 //
-inline int RefCountedObject::referenceCount() const
+inline size_t RefCountedObject::referenceCount() const
 {
-    return _counter.value();
+    return _counter.load(std::memory_order_acquire);
 }


-inline void RefCountedObject::duplicate() const
+inline size_t RefCountedObject::duplicate() const
 {
-    ++_counter;
+    return _counter.fetch_add(1, std::memory_order_acq_rel);
 }


-inline void RefCountedObject::release() const throw()
+inline size_t RefCountedObject::release() const throw()
 {
+    size_t reference_count_before = _counter.fetch_sub(1, std::memory_order_acq_rel);
+
    try
    {
-        if (--_counter == 0)
+        if (reference_count_before == 1)
            delete this;
    }
    catch (...)
    {
        poco_unexpected();
    }
+
+    return reference_count_before;
 }


--- a/base/poco/Foundation/src/Logger.cpp
+++ b/base/poco/Foundation/src/Logger.cpp
@ -20,12 +20,29 @@
 #include "Poco/NumberParser.h"
 #include "Poco/String.h"

+#include <mutex>
+
+namespace
+{
+
+std::mutex & getLoggerMutex()
+{
+	auto get_logger_mutex_placeholder_memory = []()
+	{
+		static char buffer[sizeof(std::mutex)]{};
+		return buffer;
+	};
+
+	static std::mutex * logger_mutex = new (get_logger_mutex_placeholder_memory()) std::mutex();
+	return *logger_mutex;
+}
+
+}

 namespace Poco {


 Logger::LoggerMap* Logger::_pLoggerMap = 0;
-Mutex Logger::_mapMtx;
 const std::string Logger::ROOT;


@ -73,7 +90,7 @@ void Logger::setProperty(const std::string& name, const std::string& value)
 		setChannel(LoggingRegistry::defaultRegistry().channelForName(value));
 	else if (name == "level")
 		setLevel(value);
-	else 
+	else
 		Channel::setProperty(name, value);
 }

@ -112,14 +129,14 @@ void Logger::dump(const std::string& msg, const void* buffer, std::size_t length

 void Logger::setLevel(const std::string& name, int level)
 {
-	Mutex::ScopedLock lock(_mapMtx);
+	std::lock_guard<std::mutex> lock(getLoggerMutex());

 	if (_pLoggerMap)
 	{
 		std::string::size_type len = name.length();
 		for (LoggerMap::iterator it = _pLoggerMap->begin(); it != _pLoggerMap->end(); ++it)
 		{
-			if (len == 0 || 
+			if (len == 0 ||
 				(it->first.compare(0, len, name) == 0 && (it->first.length() == len || it->first[len] == '.')))
 			{
 				it->second->setLevel(level);
@ -131,7 +148,7 @@ void Logger::setLevel(const std::string& name, int level)

 void Logger::setChannel(const std::string& name, Channel* pChannel)
 {
-	Mutex::ScopedLock lock(_mapMtx);
+	std::lock_guard<std::mutex> lock(getLoggerMutex());

 	if (_pLoggerMap)
 	{
@ -150,7 +167,7 @@ void Logger::setChannel(const std::string& name, Channel* pChannel)

 void Logger::setProperty(const std::string& loggerName, const std::string& propertyName, const std::string& value)
 {
-	Mutex::ScopedLock lock(_mapMtx);
+	std::lock_guard<std::mutex> lock(getLoggerMutex());

 	if (_pLoggerMap)
 	{
@ -280,13 +297,41 @@ void Logger::formatDump(std::string& message, const void* buffer, std::size_t le
 }


+namespace
+{
+
+struct LoggerDeleter
+{
+	void operator()(Poco::Logger * logger)
+	{
+		if (Logger::destroy(logger->name()))
+			return;
+
+		logger->release();
+	}
+};
+
+inline LoggerPtr makeLoggerPtr(Logger & logger)
+{
+	logger.duplicate();
+	return std::shared_ptr<Logger>(&logger, LoggerDeleter());
+}
+
+}
+
 Logger& Logger::get(const std::string& name)
 {
-	Mutex::ScopedLock lock(_mapMtx);
+	std::lock_guard<std::mutex> lock(getLoggerMutex());

 	return unsafeGet(name);
 }

+LoggerPtr Logger::getShared(const std::string & name)
+{
+	std::lock_guard<std::mutex> lock(getLoggerMutex());
+
+	return makeLoggerPtr(unsafeGet(name));
+}

 Logger& Logger::unsafeGet(const std::string& name)
 {
@ -310,18 +355,21 @@ Logger& Logger::unsafeGet(const std::string& name)

 Logger& Logger::create(const std::string& name, Channel* pChannel, int level)
 {
-	Mutex::ScopedLock lock(_mapMtx);
+	std::lock_guard<std::mutex> lock(getLoggerMutex());

-	if (find(name)) throw ExistsException();
-	Logger* pLogger = new Logger(name, pChannel, level);
-	add(pLogger);
-	return *pLogger;
+	return unsafeCreate(name, pChannel, level);
 }

+LoggerPtr Logger::createShared(const std::string & name, Channel * pChannel, int level)
+{
+	std::lock_guard<std::mutex> lock(getLoggerMutex());
+
+	return makeLoggerPtr(unsafeCreate(name, pChannel, level));
+}

 Logger& Logger::root()
 {
-	Mutex::ScopedLock lock(_mapMtx);
+	std::lock_guard<std::mutex> lock(getLoggerMutex());

 	return unsafeGet(ROOT);
 }
@ -329,7 +377,7 @@ Logger& Logger::root()

 Logger* Logger::has(const std::string& name)
 {
-	Mutex::ScopedLock lock(_mapMtx);
+	std::lock_guard<std::mutex> lock(getLoggerMutex());

 	return find(name);
 }
@ -337,7 +385,7 @@ Logger* Logger::has(const std::string& name)

 void Logger::shutdown()
 {
-	Mutex::ScopedLock lock(_mapMtx);
+	std::lock_guard<std::mutex> lock(getLoggerMutex());

 	if (_pLoggerMap)
 	{
@ -363,25 +411,29 @@ Logger* Logger::find(const std::string& name)
 }


-void Logger::destroy(const std::string& name)
+bool Logger::destroy(const std::string& name)
 {
-	Mutex::ScopedLock lock(_mapMtx);
+	std::lock_guard<std::mutex> lock(getLoggerMutex());

 	if (_pLoggerMap)
 	{
 		LoggerMap::iterator it = _pLoggerMap->find(name);
 		if (it != _pLoggerMap->end())
 		{
-			it->second->release();
-			_pLoggerMap->erase(it);
+			if (it->second->release() == 1)
+				_pLoggerMap->erase(it);
+
+			return true;
 		}
 	}
+
+	return false;
 }


 void Logger::names(std::vector<std::string>& names)
 {
-	Mutex::ScopedLock lock(_mapMtx);
+	std::lock_guard<std::mutex> lock(getLoggerMutex());

 	names.clear();
 	if (_pLoggerMap)
@ -393,6 +445,14 @@ void Logger::names(std::vector<std::string>& names)
 	}
 }

+Logger& Logger::unsafeCreate(const std::string & name, Channel * pChannel, int level)
+{
+	if (find(name)) throw ExistsException();
+	Logger* pLogger = new Logger(name, pChannel, level);
+	add(pLogger);
+
+	return *pLogger;
+}

 Logger& Logger::parent(const std::string& name)
 {
--- a/docker/test/stateless/run.sh
+++ b/docker/test/stateless/run.sh
@ -247,12 +247,15 @@ stop_logs_replication

 # Try to get logs while server is running
 successfuly_saved=0
-for table in query_log zookeeper_log trace_log transactions_info_log
+for table in query_log zookeeper_log trace_log transactions_info_log metric_log
 do
-    clickhouse-client -q "select * from system.$table format TSVWithNamesAndTypes" | zstd --threads=0 > /test_output/$table.tsv.zst || successfuly_saved=$((successfuly_saved+$?))
+    clickhouse-client -q "select * from system.$table format TSVWithNamesAndTypes" | zstd --threads=0 > /test_output/$table.tsv.zst
+    successfuly_saved=$?
    if [[ -n "$USE_DATABASE_REPLICATED" ]] && [[ "$USE_DATABASE_REPLICATED" -eq 1 ]]; then
-        clickhouse-client -q "select * from system.$table format TSVWithNamesAndTypes" | zstd --threads=0 > /test_output/$table.1.tsv.zst || successfuly_saved=$((successfuly_saved+$?))
-        clickhouse-client -q "select * from system.$table format TSVWithNamesAndTypes" | zstd --threads=0 > /test_output/$table.2.tsv.zst || successfuly_saved=$((successfuly_saved+$?))
+        clickhouse-client -q "select * from system.$table format TSVWithNamesAndTypes" | zstd --threads=0 > /test_output/$table.1.tsv.zst
+        successfuly_saved=$((successfuly_saved | $?))
+        clickhouse-client -q "select * from system.$table format TSVWithNamesAndTypes" | zstd --threads=0 > /test_output/$table.2.tsv.zst
+        successfuly_saved=$((successfuly_saved | $?))
    fi
 done

@ -285,7 +288,7 @@ if [ $successfuly_saved -ne 0 ]; then
    #   directly
    # - even though ci auto-compress some files (but not *.tsv) it does this only
    #   for files >64MB, we want this files to be compressed explicitly
-    for table in query_log zookeeper_log trace_log transactions_info_log
+    for table in query_log zookeeper_log trace_log transactions_info_log metric_log
    do
        clickhouse-local "$data_path_config" --only-system-tables -q "select * from system.$table format TSVWithNamesAndTypes" | zstd --threads=0 > /test_output/$table.tsv.zst ||:
        if [[ -n "$USE_DATABASE_REPLICATED" ]] && [[ "$USE_DATABASE_REPLICATED" -eq 1 ]]; then
--- a/docs/changelogs/v23.9.1.1854-stable.md
+++ b/docs/changelogs/v23.9.1.1854-stable.md
@ -11,6 +11,7 @@ sidebar_label: 2023
 * Remove the `status_info` configuration option and dictionaries status from the default Prometheus handler. [#54090](https://github.com/ClickHouse/ClickHouse/pull/54090) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
 * The experimental parts metadata cache is removed from the codebase. [#54215](https://github.com/ClickHouse/ClickHouse/pull/54215) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
 * Disable setting `input_format_json_try_infer_numbers_from_strings` by default, so we don't try to infer numbers from strings in JSON formats by default to avoid possible parsing errors when sample data contains strings that looks like a number. [#55099](https://github.com/ClickHouse/ClickHouse/pull/55099) ([Kruglov Pavel](https://github.com/Avogar)).
+* IPv6 bloom filter indexes created prior to March 2023 are not compatible with current version and have to be rebuilt. [#54200](https://github.com/ClickHouse/ClickHouse/pull/54200) ([Yakov Olkhovskiy](https://github.com/yakov-olkhovskiy)).

 #### New Feature
 * Added new type of authentication based on SSH keys. It works only for Native TCP protocol. [#41109](https://github.com/ClickHouse/ClickHouse/pull/41109) ([George Gamezardashvili](https://github.com/InfJoker)).
--- a/docs/en/engines/table-engines/mergetree-family/mergetree.md
+++ b/docs/en/engines/table-engines/mergetree-family/mergetree.md
@ -39,8 +39,8 @@ If you need to update rows frequently, we recommend using the [`ReplacingMergeTr
 ``` sql
 CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
 (
-    name1 [type1] [[NOT] NULL] [DEFAULT|MATERIALIZED|ALIAS|EPHEMERAL expr1] [COMMENT ...] [CODEC(codec1)] [STATISTIC(stat1)] [TTL expr1] [PRIMARY KEY],
-    name2 [type2] [[NOT] NULL] [DEFAULT|MATERIALIZED|ALIAS|EPHEMERAL expr2] [COMMENT ...] [CODEC(codec2)] [STATISTIC(stat2)] [TTL expr2] [PRIMARY KEY],
+    name1 [type1] [[NOT] NULL] [DEFAULT|MATERIALIZED|ALIAS|EPHEMERAL expr1] [COMMENT ...] [CODEC(codec1)] [STATISTIC(stat1)] [TTL expr1] [PRIMARY KEY] [SETTINGS (name = value, ...)],
+    name2 [type2] [[NOT] NULL] [DEFAULT|MATERIALIZED|ALIAS|EPHEMERAL expr2] [COMMENT ...] [CODEC(codec2)] [STATISTIC(stat2)] [TTL expr2] [PRIMARY KEY] [SETTINGS (name = value, ...)],
    ...
    INDEX index_name1 expr1 TYPE type1(...) [GRANULARITY value1],
    INDEX index_name2 expr2 TYPE type2(...) [GRANULARITY value2],
@ -56,7 +56,7 @@ ORDER BY expr
    [DELETE|TO DISK 'xxx'|TO VOLUME 'xxx' [, ...] ]
    [WHERE conditions]
    [GROUP BY key_expr [SET v1 = aggr_func(v1) [, v2 = aggr_func(v2) ...]] ] ]
-[SETTINGS name=value, ...]
+[SETTINGS name = value, ...]
 ```

 For a description of parameters, see the [CREATE query description](/docs/en/sql-reference/statements/create/table.md).
@ -620,7 +620,7 @@ The `TTL` clause can’t be used for key columns.
 #### Creating a table with `TTL`:

 ``` sql
-CREATE TABLE example_table
+CREATE TABLE tab
 (
    d DateTime,
    a Int TTL d + INTERVAL 1 MONTH,
@ -635,7 +635,7 @@ ORDER BY d;
 #### Adding TTL to a column of an existing table

 ``` sql
-ALTER TABLE example_table
+ALTER TABLE tab
    MODIFY COLUMN
    c String TTL d + INTERVAL 1 DAY;
 ```
@ -643,7 +643,7 @@ ALTER TABLE example_table
 #### Altering TTL of the column

 ``` sql
-ALTER TABLE example_table
+ALTER TABLE tab
    MODIFY COLUMN
    c String TTL d + INTERVAL 1 MONTH;
 ```
@ -681,7 +681,7 @@ If a column is not part of the `GROUP BY` expression and is not set explicitly i
 #### Creating a table with `TTL`:

 ``` sql
-CREATE TABLE example_table
+CREATE TABLE tab
 (
    d DateTime,
    a Int
@ -697,7 +697,7 @@ TTL d + INTERVAL 1 MONTH DELETE,
 #### Altering `TTL` of the table:

 ``` sql
-ALTER TABLE example_table
+ALTER TABLE tab
    MODIFY TTL d + INTERVAL 1 DAY;
 ```

@ -1366,7 +1366,7 @@ In this sample configuration:
 The statistic declaration is in the columns section of the `CREATE` query for tables from the `*MergeTree*` Family when we enable `set allow_experimental_statistic = 1`.

 ``` sql
-CREATE TABLE example_table
+CREATE TABLE tab
 (
    a Int64 STATISTIC(tdigest),
    b Float64
@ -1378,8 +1378,8 @@ ORDER BY a
 We can also manipulate statistics with `ALTER` statements.

 ```sql
-ALTER TABLE example_table ADD STATISTIC b TYPE tdigest;
-ALTER TABLE example_table DROP STATISTIC a TYPE tdigest;
+ALTER TABLE tab ADD STATISTIC b TYPE tdigest;
+ALTER TABLE tab DROP STATISTIC a TYPE tdigest;
 ```

 These lightweight statistics aggregate information about distribution of values in columns.
@ -1390,3 +1390,42 @@ They can be used for query optimization when we enable `set allow_statistic_opti
 -   `tdigest`

    Stores distribution of values from numeric columns in [TDigest](https://github.com/tdunning/t-digest) sketch.
+
+## Column-level Settings {#column-level-settings}
+
+Certain MergeTree settings can be override at column level:
+
+- `max_compress_block_size` — Maximum size of blocks of uncompressed data before compressing for writing to a table.
+- `min_compress_block_size` — Minimum size of blocks of uncompressed data required for compression when writing the next mark.
+
+Example:
+
+```sql
+CREATE TABLE tab
+(
+    id Int64,
+    document String SETTINGS (min_compress_block_size = 16777216, max_compress_block_size = 16777216)
+)
+ENGINE = MergeTree
+ORDER BY id
+```
+
+Column-level settings can be modified or removed using [ALTER MODIFY COLUMN](/docs/en/sql-reference/statements/alter/column.md), for example:
+
+- Remove `SETTINGS` from column declaration:
+
+```sql
+ALTER TABLE tab MODIFY COLUMN document REMOVE SETTINGS;
+```
+
+- Modify a setting:
+
+```sql
+ALTER TABLE tab MODIFY COLUMN document MODIFY SETTING min_compress_block_size = 8192;
+```
+
+- Reset one or more settings, also removes the setting declaration in the column expression of the table's CREATE query.
+
+```sql
+ALTER TABLE tab MODIFY COLUMN document RESET SETTING min_compress_block_size;
+```
--- a/docs/en/operations/settings/settings.md
+++ b/docs/en/operations/settings/settings.md
@ -5197,3 +5197,13 @@ The value 0 means that you can delete all tables without any restrictions.
 :::note
 This query setting overwrites its server setting equivalent, see [max_table_size_to_drop](/docs/en/operations/server-configuration-parameters/settings.md/#max-table-size-to-drop)
 :::
+
+## iceberg_engine_ignore_schema_evolution {#iceberg_engine_ignore_schema_evolution}
+
+Allow to ignore schema evolution in Iceberg table engine and read all data using schema specified by the user on table creation or latest schema parsed from metadata on table creation.
+
+:::note
+Enabling this setting can lead to incorrect result as in case of evolved schema all data files will be read using the same schema.
+:::
+
+Default value: 'false'.
--- a/docs/en/operations/system-tables/asynchronous_metric_log.md
+++ b/docs/en/operations/system-tables/asynchronous_metric_log.md
@ -10,7 +10,7 @@ Columns:
 - `hostname` ([LowCardinality(String)](../../sql-reference/data-types/string.md)) — Hostname of the server executing the query.
 - `event_date` ([Date](../../sql-reference/data-types/date.md)) — Event date.
 - `event_time` ([DateTime](../../sql-reference/data-types/datetime.md)) — Event time.
- `name` ([String](../../sql-reference/data-types/string.md)) — Metric name.
+- `metric` ([String](../../sql-reference/data-types/string.md)) — Metric name.
 - `value` ([Float64](../../sql-reference/data-types/float.md)) — Metric value.

 **Example**
--- a/docs/en/sql-reference/data-types/float.md
+++ b/docs/en/sql-reference/data-types/float.md
@ -35,8 +35,8 @@ Types are equivalent to types of C:

 Aliases:

- `Float32` — `FLOAT`.
- `Float64` — `DOUBLE`.
+- `Float32` — `FLOAT`, `REAL`, `SINGLE`.
+- `Float64` — `DOUBLE`, `DOUBLE PRECISION`.

 When creating tables, numeric parameters for floating point numbers can be set (e.g. `FLOAT(12)`, `FLOAT(15, 22)`, `DOUBLE(12)`, `DOUBLE(4, 18)`), but ClickHouse ignores them.

--- a/docs/en/sql-reference/data-types/int-uint.md
+++ b/docs/en/sql-reference/data-types/int-uint.md
@ -21,10 +21,10 @@ When creating tables, numeric parameters for integer numbers can be set (e.g. `T

 Aliases:

- `Int8` — `TINYINT`, `BOOL`, `BOOLEAN`, `INT1`.
- `Int16` — `SMALLINT`, `INT2`.
- `Int32` — `INT`, `INT4`, `INTEGER`.
- `Int64` — `BIGINT`.
+- `Int8` — `TINYINT`, `INT1`, `BYTE`, `TINYINT SIGNED`, `INT1 SIGNED`.
+- `Int16` — `SMALLINT`, `SMALLINT SIGNED`.
+- `Int32` — `INT`, `INTEGER`, `MEDIUMINT`, `MEDIUMINT SIGNED`, `INT SIGNED`, `INTEGER SIGNED`.
+- `Int64` — `BIGINT`, `SIGNED`, `BIGINT SIGNED`, `TIME`.

 ## UInt Ranges

@ -34,3 +34,11 @@ Aliases:
 - `UInt64` — \[0 : 18446744073709551615\]
 - `UInt128` — \[0 : 340282366920938463463374607431768211455\]
 - `UInt256` — \[0 : 115792089237316195423570985008687907853269984665640564039457584007913129639935\]
+
+Aliases:
+
+- `UInt8` — `TINYINT UNSIGNED`, `INT1 UNSIGNED`.
+- `UInt16` — `SMALLINT UNSIGNED`.
+- `UInt32` — `MEDIUMINT UNSIGNED`, `INT UNSIGNED`, `INTEGER UNSIGNED`
+- `UInt64` — `UNSIGNED`, `BIGINT UNSIGNED`, `BIT`, `SET`
+
--- a/docs/en/sql-reference/statements/alter/column.md
+++ b/docs/en/sql-reference/statements/alter/column.md
@ -23,10 +23,11 @@ The following actions are supported:
 - [RENAME COLUMN](#rename-column) — Renames an existing column.
 - [CLEAR COLUMN](#clear-column) — Resets column values.
 - [COMMENT COLUMN](#comment-column) — Adds a text comment to the column.
- [MODIFY COLUMN](#modify-column) — Changes column’s type, default expression and TTL.
+- [MODIFY COLUMN](#modify-column) — Changes column’s type, default expression, TTL, and column settings.
 - [MODIFY COLUMN REMOVE](#modify-column-remove) — Removes one of the column properties.
+- [MODIFY COLUMN MODIFY SETTING](#modify-column-modify-setting) - Changes column settings.
+- [MODIFY COLUMN RESET SETTING](#modify-column-reset-setting) - Reset column settings.
 - [MATERIALIZE COLUMN](#materialize-column) — Materializes the column in the parts where the column is missing.
-
 These actions are described in detail below.

 ## ADD COLUMN
@ -75,7 +76,7 @@ Deletes the column with the name `name`. If the `IF EXISTS` clause is specified,

 Deletes data from the file system. Since this deletes entire files, the query is completed almost instantly.

-:::tip    
+:::tip
 You can’t delete a column if it is referenced by [materialized view](/docs/en/sql-reference/statements/create/view.md/#materialized). Otherwise, it returns an error.
 :::

@ -208,7 +209,7 @@ The `ALTER` query for changing columns is replicated. The instructions are saved

 ## MODIFY COLUMN REMOVE

-Removes one of the column properties: `DEFAULT`, `ALIAS`, `MATERIALIZED`, `CODEC`, `COMMENT`, `TTL`.
+Removes one of the column properties: `DEFAULT`, `ALIAS`, `MATERIALIZED`, `CODEC`, `COMMENT`, `TTL`, `SETTING`.

 Syntax:

@ -228,6 +229,43 @@ ALTER TABLE table_with_ttl MODIFY COLUMN column_ttl REMOVE TTL;

 - [REMOVE TTL](ttl.md).

+
+## MODIFY COLUMN MODIFY SETTING
+
+Modify a column setting.
+
+Syntax:
+
+```sql
+ALTER TABLE table_name MODIFY COLUMN MODIFY SETTING name=value,...;
+```
+
+**Example**
+
+Modify column's `max_compress_block_size` to `1MB`:
+
+```sql
+ALTER TABLE table_name MODIFY COLUMN MODIFY SETTING max_compress_block_size = 1048576;
+```
+
+## MODIFY COLUMN RESET SETTING
+
+Reset a column setting, also removes the setting declaration in the column expression of the table's CREATE query.
+
+Syntax:
+
+```sql
+ALTER TABLE table_name MODIFY COLUMN RESET SETTING name,...;
+```
+
+**Example**
+
+Remove column setting `max_compress_block_size` to `1MB`:
+
+```sql
+ALTER TABLE table_name MODIFY COLUMN REMOVE SETTING max_compress_block_size;
+```
+
 ## MATERIALIZE COLUMN

 Materializes or updates a column with an expression for a default value (`DEFAULT` or `MATERIALIZED`).
--- a/docs/en/sql-reference/statements/alter/partition.md
+++ b/docs/en/sql-reference/statements/alter/partition.md
@ -112,7 +112,7 @@ Note that:
 For the query to run successfully, the following conditions must be met:

 - Both tables must have the same structure.
- Both tables must have the same order by key and the same primary key.
+- Both tables must have the same partition key, the same order by key and the same primary key.
 - Both tables must have the same indices and projections.
 - Both tables must have the same storage policy.

--- a/docs/en/sql-reference/statements/rename.md
+++ b/docs/en/sql-reference/statements/rename.md
@ -9,10 +9,6 @@ sidebar_label: RENAME
 Renames databases, tables, or dictionaries. Several entities can be renamed in a single query.
 Note that the `RENAME` query with several entities is non-atomic operation. To swap entities names atomically, use the [EXCHANGE](./exchange.md) statement.

-:::note    
-The `RENAME` query is supported by the [Atomic](../../engines/database-engines/atomic.md) database engine only.
-:::
-
 **Syntax**

 ```sql
--- a/docs/en/sql-reference/table-functions/executable.md
+++ b/docs/en/sql-reference/table-functions/executable.md
@ -7,7 +7,7 @@ keywords: [udf, user defined function, clickhouse, executable, table, function]

 # executable Table Function for UDFs

-The `executable` table function creates a table based on the output of a user-defined function (UDF) that you define in a script that outputs rows to **stdout**. The executable script is stored in the `users_scripts` directory and can read data from any source.
+The `executable` table function creates a table based on the output of a user-defined function (UDF) that you define in a script that outputs rows to **stdout**. The executable script is stored in the `users_scripts` directory and can read data from any source. Make sure your ClickHouse server has all the required packages to run the executable script. For example, if it is a Python script, ensure that the server has the necessary Python packages installed.

 You can optionally include one or more input queries that stream their results to **stdin** for the script to read.

--- a/programs/copier/ClusterCopier.h
+++ b/programs/copier/ClusterCopier.h
@ -20,7 +20,7 @@ public:
                  const String & host_id_,
                  const String & proxy_database_name_,
                  ContextMutablePtr context_,
-                  Poco::Logger * log_)
+                  LoggerRawPtr log_)
            : WithMutableContext(context_),
            task_zookeeper_path(task_path_),
            host_id(host_id_),
@ -230,7 +230,7 @@ private:

    bool experimental_use_sample_offset{false};

-    Poco::Logger * log;
+    LoggerRawPtr log;

    UInt64 max_table_tries = 3;
    UInt64 max_shard_partition_tries = 3;
--- a/programs/copier/ZooKeeperStaff.h
+++ b/programs/copier/ZooKeeperStaff.h
@ -177,7 +177,7 @@ public:
        auto watch_callback =
                [my_stale = stale] (const Coordination::WatchResponse & rsp)
                {
-                    auto logger = &Poco::Logger::get("ClusterCopier");
+                    auto logger = getLogger("ClusterCopier");
                    if (rsp.error == Coordination::Error::ZOK)
                    {
                        switch (rsp.type)
--- a/programs/disks/DisksApp.cpp
+++ b/programs/disks/DisksApp.cpp
@ -160,7 +160,7 @@ int DisksApp::main(const std::vector<String> & /*args*/)
    }
    else
    {
-        throw Exception(ErrorCodes::BAD_ARGUMENTS, "No config-file specifiged");
+        throw Exception(ErrorCodes::BAD_ARGUMENTS, "No config-file specified");
    }

    if (config().has("save-logs"))
--- a/programs/keeper-client/KeeperClient.cpp
+++ b/programs/keeper-client/KeeperClient.cpp
@ -375,7 +375,7 @@ int KeeperClient::main(const std::vector<String> & /* args */)

    if (!config().has("host") && !config().has("port") && !keys.empty())
    {
-        LOG_INFO(&Poco::Logger::get("KeeperClient"), "Found keeper node in the config.xml, will use it for connection");
+        LOG_INFO(getLogger("KeeperClient"), "Found keeper node in the config.xml, will use it for connection");

        for (const auto & key : keys)
        {
--- a/programs/keeper-converter/KeeperConverter.cpp
+++ b/programs/keeper-converter/KeeperConverter.cpp
@ -28,7 +28,7 @@ int mainEntryClickHouseKeeperConverter(int argc, char ** argv)
    po::store(po::command_line_parser(argc, argv).options(desc).run(), options);
    Poco::AutoPtr<Poco::ConsoleChannel> console_channel(new Poco::ConsoleChannel);

-    Poco::Logger * logger = &Poco::Logger::get("KeeperConverter");
+    LoggerPtr logger = getLogger("KeeperConverter");
    logger->setChannel(console_channel);

    if (options.count("help"))
--- a/programs/keeper/Keeper.cpp
+++ b/programs/keeper/Keeper.cpp
@ -624,7 +624,7 @@ catch (...)

 void Keeper::logRevision() const
 {
-    LOG_INFO(&Poco::Logger::get("Application"),
+    LOG_INFO(getLogger("Application"),
        "Starting ClickHouse Keeper {} (revision: {}, git hash: {}, build id: {}), PID {}",
        VERSION_STRING,
        ClickHouseRevision::getVersionRevision(),
--- a/programs/library-bridge/CatBoostLibraryHandlerFactory.cpp
+++ b/programs/library-bridge/CatBoostLibraryHandlerFactory.cpp
@ -13,7 +13,7 @@ CatBoostLibraryHandlerFactory & CatBoostLibraryHandlerFactory::instance()
 }

 CatBoostLibraryHandlerFactory::CatBoostLibraryHandlerFactory()
-    : log(&Poco::Logger::get("CatBoostLibraryHandlerFactory"))
+    : log(getLogger("CatBoostLibraryHandlerFactory"))
 {
 }

--- a/programs/library-bridge/CatBoostLibraryHandlerFactory.h
+++ b/programs/library-bridge/CatBoostLibraryHandlerFactory.h
@ -31,7 +31,7 @@ private:
    /// map: model path --> catboost library handler
    std::unordered_map<String, CatBoostLibraryHandlerPtr> library_handlers TSA_GUARDED_BY(mutex);
    std::mutex mutex;
-    Poco::Logger * log;
+    LoggerPtr log;
 };

 }
--- a/programs/library-bridge/ExternalDictionaryLibraryAPI.cpp
+++ b/programs/library-bridge/ExternalDictionaryLibraryAPI.cpp
@ -9,40 +9,40 @@ const char DICT_LOGGER_NAME[] = "LibraryDictionarySourceExternal";

 void ExternalDictionaryLibraryAPI::log(LogLevel level, CString msg)
 {
-    auto & logger = Poco::Logger::get(DICT_LOGGER_NAME);
+    auto logger = getLogger(DICT_LOGGER_NAME);
    switch (level)
    {
        case LogLevel::TRACE:
-            if (logger.trace())
-                logger.trace(msg);
+            if (logger->trace())
+                logger->trace(msg);
            break;
        case LogLevel::DEBUG:
-            if (logger.debug())
-                logger.debug(msg);
+            if (logger->debug())
+                logger->debug(msg);
            break;
        case LogLevel::INFORMATION:
-            if (logger.information())
-                logger.information(msg);
+            if (logger->information())
+                logger->information(msg);
            break;
        case LogLevel::NOTICE:
-            if (logger.notice())
-                logger.notice(msg);
+            if (logger->notice())
+                logger->notice(msg);
            break;
        case LogLevel::WARNING:
-            if (logger.warning())
-                logger.warning(msg);
+            if (logger->warning())
+                logger->warning(msg);
            break;
        case LogLevel::ERROR:
-            if (logger.error())
-                logger.error(msg);
+            if (logger->error())
+                logger->error(msg);
            break;
        case LogLevel::CRITICAL:
-            if (logger.critical())
-                logger.critical(msg);
+            if (logger->critical())
+                logger->critical(msg);
            break;
        case LogLevel::FATAL:
-            if (logger.fatal())
-                logger.fatal(msg);
+            if (logger->fatal())
+                logger->fatal(msg);
            break;
    }
 }
--- a/programs/library-bridge/ExternalDictionaryLibraryHandlerFactory.cpp
+++ b/programs/library-bridge/ExternalDictionaryLibraryHandlerFactory.cpp
@ -26,7 +26,7 @@ void ExternalDictionaryLibraryHandlerFactory::create(

    if (library_handlers.contains(dictionary_id))
    {
-        LOG_WARNING(&Poco::Logger::get("ExternalDictionaryLibraryHandlerFactory"), "Library handler with dictionary id {} already exists", dictionary_id);
+        LOG_WARNING(getLogger("ExternalDictionaryLibraryHandlerFactory"), "Library handler with dictionary id {} already exists", dictionary_id);
        return;
    }

--- a/programs/library-bridge/LibraryBridgeHandlerFactory.cpp
+++ b/programs/library-bridge/LibraryBridgeHandlerFactory.cpp
@ -12,7 +12,7 @@ LibraryBridgeHandlerFactory::LibraryBridgeHandlerFactory(
    size_t keep_alive_timeout_,
    ContextPtr context_)
    : WithContext(context_)
-    , log(&Poco::Logger::get(name_))
+    , log(getLogger(name_))
    , name(name_)
    , keep_alive_timeout(keep_alive_timeout_)
 {
--- a/programs/library-bridge/LibraryBridgeHandlerFactory.h
+++ b/programs/library-bridge/LibraryBridgeHandlerFactory.h
@ -19,7 +19,7 @@ public:
    std::unique_ptr<HTTPRequestHandler> createRequestHandler(const HTTPServerRequest & request) override;

 private:
-    Poco::Logger * log;
+    LoggerPtr log;
    const std::string name;
    const size_t keep_alive_timeout;
 };
--- a/programs/library-bridge/LibraryBridgeHandlers.cpp
+++ b/programs/library-bridge/LibraryBridgeHandlers.cpp
@ -47,7 +47,7 @@ namespace
        if (!response.sent())
            *response.send() << message << '\n';

-        LOG_WARNING(&Poco::Logger::get("LibraryBridge"), fmt::runtime(message));
+        LOG_WARNING(getLogger("LibraryBridge"), fmt::runtime(message));
    }

    std::shared_ptr<Block> parseColumns(String && column_string)
@ -92,7 +92,7 @@ static void writeData(Block data, OutputFormatPtr format)
 ExternalDictionaryLibraryBridgeRequestHandler::ExternalDictionaryLibraryBridgeRequestHandler(size_t keep_alive_timeout_, ContextPtr context_)
    : WithContext(context_)
    , keep_alive_timeout(keep_alive_timeout_)
-    , log(&Poco::Logger::get("ExternalDictionaryLibraryBridgeRequestHandler"))
+    , log(getLogger("ExternalDictionaryLibraryBridgeRequestHandler"))
 {
 }

@ -380,7 +380,7 @@ void ExternalDictionaryLibraryBridgeRequestHandler::handleRequest(HTTPServerRequ
 ExternalDictionaryLibraryBridgeExistsHandler::ExternalDictionaryLibraryBridgeExistsHandler(size_t keep_alive_timeout_, ContextPtr context_)
    : WithContext(context_)
    , keep_alive_timeout(keep_alive_timeout_)
-    , log(&Poco::Logger::get("ExternalDictionaryLibraryBridgeExistsHandler"))
+    , log(getLogger("ExternalDictionaryLibraryBridgeExistsHandler"))
 {
 }

@ -419,7 +419,7 @@ CatBoostLibraryBridgeRequestHandler::CatBoostLibraryBridgeRequestHandler(
    size_t keep_alive_timeout_, ContextPtr context_)
    : WithContext(context_)
    , keep_alive_timeout(keep_alive_timeout_)
-    , log(&Poco::Logger::get("CatBoostLibraryBridgeRequestHandler"))
+    , log(getLogger("CatBoostLibraryBridgeRequestHandler"))
 {
 }

@ -623,7 +623,7 @@ void CatBoostLibraryBridgeRequestHandler::handleRequest(HTTPServerRequest & requ
 CatBoostLibraryBridgeExistsHandler::CatBoostLibraryBridgeExistsHandler(size_t keep_alive_timeout_, ContextPtr context_)
    : WithContext(context_)
    , keep_alive_timeout(keep_alive_timeout_)
-    , log(&Poco::Logger::get("CatBoostLibraryBridgeExistsHandler"))
+    , log(getLogger("CatBoostLibraryBridgeExistsHandler"))
 {
 }

--- a/programs/library-bridge/LibraryBridgeHandlers.h
+++ b/programs/library-bridge/LibraryBridgeHandlers.h
@ -26,7 +26,7 @@ private:
    static constexpr inline auto FORMAT = "RowBinary";

    const size_t keep_alive_timeout;
-    Poco::Logger * log;
+    LoggerPtr log;
 };


@ -40,7 +40,7 @@ public:

 private:
    const size_t keep_alive_timeout;
-    Poco::Logger * log;
+    LoggerPtr log;
 };


@ -69,7 +69,7 @@ public:

 private:
    const size_t keep_alive_timeout;
-    Poco::Logger * log;
+    LoggerPtr log;
 };


@ -83,7 +83,7 @@ public:

 private:
    const size_t keep_alive_timeout;
-    Poco::Logger * log;
+    LoggerPtr log;
 };

 }
--- a/programs/local/LocalServer.cpp
+++ b/programs/local/LocalServer.cpp
@ -221,7 +221,7 @@ void LocalServer::tryInitPath()
    {
        // The path is not provided explicitly - use a unique path in the system temporary directory
        // (or in the current dir if temporary don't exist)
-        Poco::Logger * log = &logger();
+        LoggerRawPtr log = &logger();
        std::filesystem::path parent_folder;
        std::filesystem::path default_path;

@ -631,7 +631,7 @@ void LocalServer::processConfig()

    tryInitPath();

-    Poco::Logger * log = &logger();
+    LoggerRawPtr log = &logger();

    /// Maybe useless
    if (config().has("macros"))
--- a/programs/odbc-bridge/ColumnInfoHandler.h
+++ b/programs/odbc-bridge/ColumnInfoHandler.h
@ -18,7 +18,7 @@ class ODBCColumnsInfoHandler : public HTTPRequestHandler, WithContext
 public:
    ODBCColumnsInfoHandler(size_t keep_alive_timeout_, ContextPtr context_)
        : WithContext(context_)
-        , log(&Poco::Logger::get("ODBCColumnsInfoHandler"))
+        , log(getLogger("ODBCColumnsInfoHandler"))
        , keep_alive_timeout(keep_alive_timeout_)
    {
    }
@ -26,7 +26,7 @@ public:
    void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response, const ProfileEvents::Event & write_event) override;

 private:
-    Poco::Logger * log;
+    LoggerPtr log;
    size_t keep_alive_timeout;
 };

--- a/programs/odbc-bridge/IdentifierQuoteHandler.h
+++ b/programs/odbc-bridge/IdentifierQuoteHandler.h
@ -16,7 +16,7 @@ class IdentifierQuoteHandler : public HTTPRequestHandler, WithContext
 public:
    IdentifierQuoteHandler(size_t keep_alive_timeout_, ContextPtr context_)
        : WithContext(context_)
-        , log(&Poco::Logger::get("IdentifierQuoteHandler"))
+        , log(getLogger("IdentifierQuoteHandler"))
        , keep_alive_timeout(keep_alive_timeout_)
    {
    }
@ -24,7 +24,7 @@ public:
    void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response, const ProfileEvents::Event & write_event) override;

 private:
-    Poco::Logger * log;
+    LoggerPtr log;
    size_t keep_alive_timeout;
 };

--- a/programs/odbc-bridge/MainHandler.h
+++ b/programs/odbc-bridge/MainHandler.h
@ -24,7 +24,7 @@ public:
        ContextPtr context_,
        const String & mode_)
        : WithContext(context_)
-        , log(&Poco::Logger::get("ODBCHandler"))
+        , log(getLogger("ODBCHandler"))
        , keep_alive_timeout(keep_alive_timeout_)
        , mode(mode_)
    {
@ -33,7 +33,7 @@ public:
    void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response, const ProfileEvents::Event & write_event) override;

 private:
-    Poco::Logger * log;
+    LoggerPtr log;

    size_t keep_alive_timeout;
    String mode;
--- a/programs/odbc-bridge/ODBCBlockInputStream.cpp
+++ b/programs/odbc-bridge/ODBCBlockInputStream.cpp
@ -23,7 +23,7 @@ namespace ErrorCodes
 ODBCSource::ODBCSource(
    nanodbc::ConnectionHolderPtr connection_holder, const std::string & query_str, const Block & sample_block, const UInt64 max_block_size_)
    : ISource(sample_block)
-    , log(&Poco::Logger::get("ODBCSource"))
+    , log(getLogger("ODBCSource"))
    , max_block_size{max_block_size_}
    , query(query_str)
 {
--- a/programs/odbc-bridge/ODBCBlockInputStream.h
+++ b/programs/odbc-bridge/ODBCBlockInputStream.h
@ -30,7 +30,7 @@ private:
        column.insertFrom(sample_column, 0);
    }

-    Poco::Logger * log;
+    LoggerPtr log;
    const UInt64 max_block_size;
    ExternalResultDescription description;

--- a/programs/odbc-bridge/ODBCBlockOutputStream.cpp
+++ b/programs/odbc-bridge/ODBCBlockOutputStream.cpp
@ -19,7 +19,7 @@ ODBCSink::ODBCSink(
    ContextPtr local_context_,
    IdentifierQuotingStyle quoting_)
    : ISink(sample_block_)
-    , log(&Poco::Logger::get("ODBCSink"))
+    , log(getLogger("ODBCSink"))
    , connection_holder(std::move(connection_holder_))
    , db_name(remote_database_name_)
    , table_name(remote_table_name_)
--- a/programs/odbc-bridge/ODBCBlockOutputStream.h
+++ b/programs/odbc-bridge/ODBCBlockOutputStream.h
@ -30,7 +30,7 @@ protected:
    void consume(Chunk chunk) override;

 private:
-    Poco::Logger * log;
+    LoggerPtr log;

    nanodbc::ConnectionHolderPtr connection_holder;
    std::string db_name;
--- a/programs/odbc-bridge/ODBCHandlerFactory.cpp
+++ b/programs/odbc-bridge/ODBCHandlerFactory.cpp
@ -11,7 +11,7 @@ namespace DB

 ODBCBridgeHandlerFactory::ODBCBridgeHandlerFactory(const std::string & name_, size_t keep_alive_timeout_, ContextPtr context_)
    : WithContext(context_)
-    , log(&Poco::Logger::get(name_))
+    , log(getLogger(name_))
    , name(name_)
    , keep_alive_timeout(keep_alive_timeout_)
 {
--- a/programs/odbc-bridge/ODBCHandlerFactory.h
+++ b/programs/odbc-bridge/ODBCHandlerFactory.h
@ -22,7 +22,7 @@ public:
    std::unique_ptr<HTTPRequestHandler> createRequestHandler(const HTTPServerRequest & request) override;

 private:
-    Poco::Logger * log;
+    LoggerPtr log;
    std::string name;
    size_t keep_alive_timeout;
 };
--- a/programs/odbc-bridge/ODBCPooledConnectionFactory.h
+++ b/programs/odbc-bridge/ODBCPooledConnectionFactory.h
@ -97,7 +97,7 @@ T execute(nanodbc::ConnectionHolderPtr connection_holder, std::function<T(nanodb
        /// https://docs.microsoft.com/ru-ru/sql/odbc/reference/appendixes/appendix-a-odbc-error-codes?view=sql-server-ver15
        bool is_retriable = e.state().starts_with("08") || e.state().starts_with("24") || e.state().starts_with("25");
        LOG_ERROR(
-            &Poco::Logger::get("ODBCConnection"),
+            getLogger("ODBCConnection"),
            "ODBC query failed with error: {}, state: {}, native code: {}{}",
            e.what(), e.state(), e.native(), is_retriable ? ", will retry" : "");

--- a/programs/odbc-bridge/SchemaAllowedHandler.h
+++ b/programs/odbc-bridge/SchemaAllowedHandler.h
@ -19,7 +19,7 @@ class SchemaAllowedHandler : public HTTPRequestHandler, WithContext
 public:
    SchemaAllowedHandler(size_t keep_alive_timeout_, ContextPtr context_)
        : WithContext(context_)
-        , log(&Poco::Logger::get("SchemaAllowedHandler"))
+        , log(getLogger("SchemaAllowedHandler"))
        , keep_alive_timeout(keep_alive_timeout_)
    {
    }
@ -27,7 +27,7 @@ public:
    void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response, const ProfileEvents::Event & write_event) override;

 private:
-    Poco::Logger * log;
+    LoggerPtr log;
    size_t keep_alive_timeout;
 };

--- a/programs/odbc-bridge/getIdentifierQuote.cpp
+++ b/programs/odbc-bridge/getIdentifierQuote.cpp
@ -26,7 +26,7 @@ std::string getIdentifierQuote(nanodbc::ConnectionHolderPtr connection_holder)
    }
    catch (...)
    {
-        LOG_WARNING(&Poco::Logger::get("ODBCGetIdentifierQuote"), "Cannot fetch identifier quote. Default double quote is used. Reason: {}", getCurrentExceptionMessage(false));
+        LOG_WARNING(getLogger("ODBCGetIdentifierQuote"), "Cannot fetch identifier quote. Default double quote is used. Reason: {}", getCurrentExceptionMessage(false));
        return "\"";
    }

--- a/programs/server/Server.cpp
+++ b/programs/server/Server.cpp
@ -365,7 +365,7 @@ void Server::createServer(
 namespace
 {

-void setOOMScore(int value, Poco::Logger * log)
+void setOOMScore(int value, LoggerRawPtr log)
 {
    try
    {
@ -450,7 +450,7 @@ void checkForUsersNotInMainConfig(
    const Poco::Util::AbstractConfiguration & config,
    const std::string & config_path,
    const std::string & users_config_path,
-    Poco::Logger * log)
+    LoggerPtr log)
 {
    if (config.getBool("skip_check_for_incorrect_settings", false))
        return;
@ -1740,6 +1740,17 @@ try
    LOG_INFO(log, "Loading metadata from {}", path_str);

    LoadTaskPtrs load_metadata_tasks;
+
+    // Make sure that if exception is thrown during startup async, new async loading jobs are not going to be called.
+    // This is important for the case when exception is thrown from loading of metadata with `async_load_databases = false`
+    // to avoid simultaneously running table startups and destructing databases.
+    SCOPE_EXIT_SAFE(
+        LOG_INFO(log, "Stopping AsyncLoader.");
+
+        // Waits for all currently running jobs to finish and do not run any other pending jobs.
+        global_context->getAsyncLoader().stop();
+    );
+
    try
    {
        auto & database_catalog = DatabaseCatalog::instance();
@ -1888,6 +1899,7 @@ try

        /// Must be done after initialization of `servers`, because async_metrics will access `servers` variable from its thread.
        async_metrics.start();
+        global_context->setAsynchronousMetrics(&async_metrics);

        main_config_reloader->start();
        access_control.startPeriodicReloading();
@ -2478,7 +2490,7 @@ void Server::stopServers(
    const ServerType & server_type
 ) const
 {
-    Poco::Logger * log = &logger();
+    LoggerRawPtr log = &logger();

    /// Remove servers once all their connections are closed
    auto check_server = [&log](const char prefix[], auto & server)
@ -2517,7 +2529,7 @@ void Server::updateServers(
    std::vector<ProtocolServerAdapter> & servers,
    std::vector<ProtocolServerAdapter> & servers_to_start_before_tables)
 {
-    Poco::Logger * log = &logger();
+    LoggerRawPtr log = &logger();

    const auto listen_hosts = getListenHosts(config);
    const auto interserver_listen_hosts = getInterserverListenHosts(config);
--- a/src/Access/AccessControl.cpp
+++ b/src/Access/AccessControl.cpp
@ -47,7 +47,7 @@ namespace
        const Poco::Util::AbstractConfiguration & config,
        const std::string & config_path,
        const std::string & users_config_path,
-        Poco::Logger * log)
+        LoggerPtr log)
    {
        if (config.getBool("skip_check_for_incorrect_settings", false))
            return;
--- a/src/Access/AccessRights.cpp
+++ b/src/Access/AccessRights.cpp
@ -443,7 +443,7 @@ public:
            optimizeTree();
    }

-    void logTree(Poco::Logger * log, const String & title) const
+    void logTree(LoggerPtr log, const String & title) const
    {
        LOG_TRACE(log, "Tree({}): level={}, name={}, flags={}, min_flags={}, max_flags={}, num_children={}",
            title, level, node_name ? *node_name : "NULL", flags.toString(),
@ -1158,7 +1158,7 @@ AccessRights AccessRights::getFullAccess()

 void AccessRights::logTree() const
 {
-    auto * log = &Poco::Logger::get("AccessRights");
+    auto log = getLogger("AccessRights");
    if (root)
    {
        root->logTree(log, "");
--- a/src/Access/Common/AccessType.h
+++ b/src/Access/Common/AccessType.h
@ -170,6 +170,7 @@ enum class AccessType
    M(SYSTEM_RELOAD_MODEL, "SYSTEM RELOAD MODELS, RELOAD MODEL, RELOAD MODELS", GLOBAL, SYSTEM_RELOAD) \
    M(SYSTEM_RELOAD_FUNCTION, "SYSTEM RELOAD FUNCTIONS, RELOAD FUNCTION, RELOAD FUNCTIONS", GLOBAL, SYSTEM_RELOAD) \
    M(SYSTEM_RELOAD_EMBEDDED_DICTIONARIES, "RELOAD EMBEDDED DICTIONARIES", GLOBAL, SYSTEM_RELOAD) /* implicitly enabled by the grant SYSTEM_RELOAD_DICTIONARY ON *.* */\
+    M(SYSTEM_RELOAD_ASYNCHRONOUS_METRICS, "RELOAD ASYNCHRONOUS METRICS", GLOBAL, SYSTEM_RELOAD) \
    M(SYSTEM_RELOAD, "", GROUP, SYSTEM) \
    M(SYSTEM_RESTART_DISK, "SYSTEM RESTART DISK", GLOBAL, SYSTEM) \
    M(SYSTEM_MERGES, "SYSTEM STOP MERGES, SYSTEM START MERGES, STOP MERGES, START MERGES", TABLE, SYSTEM) \
--- a/src/Access/Common/AllowedClientHosts.cpp
+++ b/src/Access/Common/AllowedClientHosts.cpp
@ -514,7 +514,7 @@ bool AllowedClientHosts::contains(const IPAddress & client_address) const
                throw;
            /// Try to ignore DNS errors: if host cannot be resolved, skip it and try next.
            LOG_WARNING(
-                &Poco::Logger::get("AddressPatterns"),
+                getLogger("AddressPatterns"),
                "Failed to check if the allowed client hosts contain address {}. {}, code = {}",
                client_address.toString(), e.displayText(), e.code());
            return false;
@ -556,7 +556,7 @@ bool AllowedClientHosts::contains(const IPAddress & client_address) const
                throw;
            /// Try to ignore DNS errors: if host cannot be resolved, skip it and try next.
            LOG_WARNING(
-                &Poco::Logger::get("AddressPatterns"),
+                getLogger("AddressPatterns"),
                "Failed to check if the allowed client hosts contain address {}. {}, code = {}",
                client_address.toString(), e.displayText(), e.code());
            return false;
--- a/src/Access/ContextAccess.cpp
+++ b/src/Access/ContextAccess.cpp
@ -298,7 +298,7 @@ void ContextAccess::setUser(const UserPtr & user_) const
    }

    user_name = user->getName();
-    trace_log = &Poco::Logger::get("ContextAccess (" + user_name + ")");
+    trace_log = getLogger("ContextAccess (" + user_name + ")");

    std::vector<UUID> current_roles, current_roles_with_admin_option;
    if (params.use_default_roles)
--- a/src/Access/ContextAccess.h
+++ b/src/Access/ContextAccess.h
@ -185,9 +185,10 @@ private:

    mutable std::atomic<bool> initialized = false; // can be removed after Bug 5504 is resolved
    mutable std::atomic<bool> user_was_dropped = false;
-    mutable std::atomic<Poco::Logger *> trace_log = nullptr;

    mutable std::mutex mutex;
+    /// TODO: Fix race
+    mutable LoggerPtr trace_log;
    mutable UserPtr user TSA_GUARDED_BY(mutex);
    mutable String user_name TSA_GUARDED_BY(mutex);
    mutable scope_guard subscription_for_user_change TSA_GUARDED_BY(mutex);
--- a/src/Access/DiskAccessStorage.cpp
+++ b/src/Access/DiskAccessStorage.cpp
@ -47,7 +47,7 @@ namespace
    }


-    AccessEntityPtr tryReadEntityFile(const String & file_path, Poco::Logger & log)
+    AccessEntityPtr tryReadEntityFile(const String & file_path, LoggerPtr log)
    {
        try
        {
@ -55,7 +55,7 @@ namespace
        }
        catch (...)
        {
-            tryLogCurrentException(&log);
+            tryLogCurrentException(log);
            return nullptr;
        }
    }
@ -378,7 +378,7 @@ void DiskAccessStorage::reloadAllAndRebuildLists()
            continue;

        const auto access_entity_file_path = getEntityFilePath(directory_path, id);
-        auto entity = tryReadEntityFile(access_entity_file_path, *getLogger());
+        auto entity = tryReadEntityFile(access_entity_file_path, getLogger());
        if (!entity)
            continue;

--- a/src/Access/ExternalAuthenticators.cpp
+++ b/src/Access/ExternalAuthenticators.cpp
@ -279,7 +279,7 @@ void ExternalAuthenticators::reset()
    resetImpl();
 }

-void ExternalAuthenticators::setConfiguration(const Poco::Util::AbstractConfiguration & config, Poco::Logger * log)
+void ExternalAuthenticators::setConfiguration(const Poco::Util::AbstractConfiguration & config, LoggerPtr log)
 {
    std::lock_guard lock(mutex);
    resetImpl();
--- a/src/Access/ExternalAuthenticators.h
+++ b/src/Access/ExternalAuthenticators.h
@ -36,7 +36,7 @@ class ExternalAuthenticators
 {
 public:
    void reset();
-    void setConfiguration(const Poco::Util::AbstractConfiguration & config, Poco::Logger * log);
+    void setConfiguration(const Poco::Util::AbstractConfiguration & config, LoggerPtr log);

    // The name and readiness of the credentials must be verified before calling these.
    bool checkLDAPCredentials(const String & server, const BasicCredentials & credentials,
--- a/src/Access/GSSAcceptor.cpp
+++ b/src/Access/GSSAcceptor.cpp
@ -328,7 +328,7 @@ void GSSAcceptorContext::initHandles()
    }
 }

-String GSSAcceptorContext::processToken(const String & input_token, Poco::Logger * log)
+String GSSAcceptorContext::processToken(const String & input_token, LoggerPtr log)
 {
    std::lock_guard lock(gss_global_mutex);

@ -455,7 +455,7 @@ void GSSAcceptorContext::initHandles()
 {
 }

-String GSSAcceptorContext::processToken(const String &, Poco::Logger *)
+String GSSAcceptorContext::processToken(const String &, LoggerPtr)
 {
    throw Exception(ErrorCodes::FEATURE_IS_NOT_ENABLED_AT_BUILD_TIME, "ClickHouse was built without GSS-API/Kerberos support");
 }
--- a/src/Access/GSSAcceptor.h
+++ b/src/Access/GSSAcceptor.h
@ -3,6 +3,7 @@
 #include "config.h"

 #include <Access/Credentials.h>
+#include <Common/Logger.h>
 #include <base/types.h>
 #include <memory>

@ -42,7 +43,7 @@ public:

    const String & getRealm() const;
    bool isFailed() const;
-    MAYBE_NORETURN String processToken(const String & input_token, Poco::Logger * log);
+    MAYBE_NORETURN String processToken(const String & input_token, LoggerPtr log);

 private:
    void reset();
--- a/src/Access/IAccessStorage.cpp
+++ b/src/Access/IAccessStorage.cpp
@ -6,6 +6,7 @@
 #include <Backups/BackupEntriesCollector.h>
 #include <Common/Exception.h>
 #include <Common/quoteString.h>
+#include <Common/callOnce.h>
 #include <IO/WriteHelpers.h>
 #include <Interpreters/Context.h>
 #include <Poco/UUIDGenerator.h>
@ -615,7 +616,7 @@ UUID IAccessStorage::generateRandomID()
 }


-void IAccessStorage::clearConflictsInEntitiesList(std::vector<std::pair<UUID, AccessEntityPtr>> & entities, const Poco::Logger * log_)
+void IAccessStorage::clearConflictsInEntitiesList(std::vector<std::pair<UUID, AccessEntityPtr>> & entities, const LoggerPtr log_)
 {
    std::unordered_map<UUID, size_t> positions_by_id;
    std::unordered_map<std::string_view, size_t> positions_by_type_and_name[static_cast<size_t>(AccessEntityType::MAX)];
@ -671,12 +672,13 @@ void IAccessStorage::clearConflictsInEntitiesList(std::vector<std::pair<UUID, Ac
 }


-Poco::Logger * IAccessStorage::getLogger() const
+LoggerPtr IAccessStorage::getLogger() const
 {
-    Poco::Logger * ptr = log.load();
-    if (!ptr)
-        log.store(ptr = &Poco::Logger::get("Access(" + storage_name + ")"), std::memory_order_relaxed);
-    return ptr;
+    callOnce(log_initialized, [&] {
+        log = ::getLogger("Access(" + storage_name + ")");
+    });
+
+    return log;
 }


--- a/src/Access/IAccessStorage.h
+++ b/src/Access/IAccessStorage.h
@ -6,6 +6,7 @@
 #include <Parsers/IParser.h>
 #include <Parsers/parseIdentifierOrStringLiteral.h>
 #include <Common/SettingsChanges.h>
+#include <Common/callOnce.h>

 #include <atomic>
 #include <functional>
@ -225,9 +226,9 @@ protected:
        SettingsChanges & settings) const;
    virtual bool isAddressAllowed(const User & user, const Poco::Net::IPAddress & address) const;
    static UUID generateRandomID();
-    Poco::Logger * getLogger() const;
+    LoggerPtr getLogger() const;
    static String formatEntityTypeWithName(AccessEntityType type, const String & name) { return AccessEntityTypeInfo::get(type).formatEntityNameWithType(name); }
-    static void clearConflictsInEntitiesList(std::vector<std::pair<UUID, AccessEntityPtr>> & entities, const Poco::Logger * log_);
+    static void clearConflictsInEntitiesList(std::vector<std::pair<UUID, AccessEntityPtr>> & entities, const LoggerPtr log_);
    [[noreturn]] void throwNotFound(const UUID & id) const;
    [[noreturn]] void throwNotFound(AccessEntityType type, const String & name) const;
    [[noreturn]] static void throwBadCast(const UUID & id, AccessEntityType type, const String & name, AccessEntityType required_type);
@ -246,7 +247,9 @@ protected:

 private:
    const String storage_name;
-    mutable std::atomic<Poco::Logger *> log = nullptr;
+
+    mutable OnceFlag log_initialized;
+    mutable LoggerPtr log = nullptr;
 };


--- a/src/Access/KerberosInit.cpp
+++ b/src/Access/KerberosInit.cpp
@ -63,7 +63,7 @@ String KerberosInit::fmtError(krb5_error_code code) const

 void KerberosInit::init(const String & keytab_file, const String & principal, const String & cache_name)
 {
-    auto * log = &Poco::Logger::get("KerberosInit");
+    auto log = getLogger("KerberosInit");
    LOG_TRACE(log,"Trying to authenticate with Kerberos v5");

    krb5_error_code ret;
--- a/src/Access/LDAPClient.cpp
+++ b/src/Access/LDAPClient.cpp
@ -532,7 +532,7 @@ LDAPClient::SearchResults LDAPClient::search(const SearchParams & search_params)

                    for (size_t i = 0; referrals[i]; ++i)
                    {
-                        LOG_WARNING(&Poco::Logger::get("LDAPClient"), "Received reference during LDAP search but not following it: {}", referrals[i]);
+                        LOG_WARNING(getLogger("LDAPClient"), "Received reference during LDAP search but not following it: {}", referrals[i]);
                    }
                }

--- a/src/Access/RowPolicyCache.cpp
+++ b/src/Access/RowPolicyCache.cpp
@ -91,7 +91,7 @@ void RowPolicyCache::PolicyInfo::setPolicy(const RowPolicyPtr & policy_)
        catch (...)
        {
            tryLogCurrentException(
-                &Poco::Logger::get("RowPolicy"),
+                getLogger("RowPolicy"),
                String("Could not parse the condition ") + toString(filter_type) + " of row policy "
                    + backQuote(policy->getName()));
        }
--- a/src/Access/SettingsAuthResponseParser.cpp
+++ b/src/Access/SettingsAuthResponseParser.cpp
@ -37,7 +37,7 @@ SettingsAuthResponseParser::parse(const Poco::Net::HTTPResponse & response, std:
    }
    catch (...)
    {
-        LOG_INFO(&Poco::Logger::get("HTTPAuthentication"), "Failed to parse settings from authentication response. Skip it.");
+        LOG_INFO(getLogger("HTTPAuthentication"), "Failed to parse settings from authentication response. Skip it.");
    }
    return result;
 }
--- a/src/AggregateFunctions/AggregateFunctionGroupArray.cpp
+++ b/src/AggregateFunctions/AggregateFunctionGroupArray.cpp
@ -440,7 +440,7 @@ struct GroupArrayNodeGeneral : public GroupArrayNodeBase<GroupArrayNodeGeneral>
        return node;
    }

-    void insertInto(IColumn & column) { column.deserializeAndInsertFromArena(data()); }
+    void insertInto(IColumn & column) { std::ignore = column.deserializeAndInsertFromArena(data()); }
 };

 template <typename Node, bool has_sampler>
--- a/src/AggregateFunctions/AggregateFunctionTopK.cpp
+++ b/src/AggregateFunctions/AggregateFunctionTopK.cpp
@ -19,6 +19,7 @@
 #include <Common/assert_cast.h>

 #include <AggregateFunctions/IAggregateFunction.h>
+#include <AggregateFunctions/KeyHolderHelpers.h>


 namespace DB
@ -153,8 +154,6 @@ private:
    UInt64 threshold;
    UInt64 reserved;

-    static void deserializeAndInsert(StringRef str, IColumn & data_to);
-
 public:
    AggregateFunctionTopKGeneric(
        UInt64 threshold_, UInt64 load_factor, const DataTypes & argument_types_, const Array & params)
@ -251,12 +250,7 @@ public:
        offsets_to.push_back(offsets_to.back() + result_vec.size());

        for (auto & elem : result_vec)
-        {
-            if constexpr (is_plain_column)
-                data_to.insertData(elem.key.data, elem.key.size);
-            else
-                data_to.deserializeAndInsertFromArena(elem.key.data);
-        }
+            deserializeAndInsert<is_plain_column>(elem.key, data_to);
    }
 };

--- a/src/AggregateFunctions/KeyHolderHelpers.h
+++ b/src/AggregateFunctions/KeyHolderHelpers.h
@ -29,7 +29,7 @@ static void deserializeAndInsert(StringRef str, IColumn & data_to)
    if constexpr (is_plain_column)
        data_to.insertData(str.data, str.size);
    else
-        data_to.deserializeAndInsertFromArena(str.data);
+        std::ignore = data_to.deserializeAndInsertFromArena(str.data);
 }

 }
--- a/src/Analyzer/Passes/RewriteSumFunctionWithSumAndCountPass.cpp
+++ b/src/Analyzer/Passes/RewriteSumFunctionWithSumAndCountPass.cpp
@ -10,14 +10,6 @@
 namespace DB
 {

-/** Rewrites `sum(column +/- literal)` into two individual functions
- * `sum(column)` and `literal * count(column)`.
- * sum(column + literal) -> sum(column) + literal * count(column)
- * sum(literal + column) -> literal * count(column) + sum(column)
- * sum(column - literal) -> sum(column) - literal * count(column)
- * sum(literal - column) -> literal * count(column) - sum(column)
- */
-
 namespace
 {

@ -29,6 +21,9 @@ public:

    void enterImpl(QueryTreeNodePtr & node)
    {
+        if (!getSettings().optimize_arithmetic_operations_in_aggregate_functions)
+            return;
+
        static const std::unordered_set<String> func_supported = {
            "plus",
            "minus"
--- a/src/Analyzer/Passes/RewriteSumFunctionWithSumAndCountPass.h
+++ b/src/Analyzer/Passes/RewriteSumFunctionWithSumAndCountPass.h
@ -5,6 +5,14 @@
 namespace DB
 {

+/**
+ * Rewrites `sum(column +/- literal)` into two individual functions
+ * `sum(column)` and `literal * count(column)`.
+ * sum(column + literal) -> sum(column) + literal * count(column)
+ * sum(literal + column) -> literal * count(column) + sum(column)
+ * sum(column - literal) -> sum(column) - literal * count(column)
+ * sum(literal - column) -> literal * count(column) - sum(column)
+ */
 class RewriteSumFunctionWithSumAndCountPass final : public IQueryTreePass
 {
 public:
--- a/src/Analyzer/Utils.cpp
+++ b/src/Analyzer/Utils.cpp
@ -326,6 +326,68 @@ void addTableExpressionOrJoinIntoTablesInSelectQuery(ASTPtr & tables_in_select_q
    }
 }

+QueryTreeNodes extractAllTableReferences(const QueryTreeNodePtr & tree)
+{
+    QueryTreeNodes result;
+
+    QueryTreeNodes nodes_to_process;
+    nodes_to_process.push_back(tree);
+
+    while (!nodes_to_process.empty())
+    {
+        auto node_to_process = std::move(nodes_to_process.back());
+        nodes_to_process.pop_back();
+
+        auto node_type = node_to_process->getNodeType();
+
+        switch (node_type)
+        {
+            case QueryTreeNodeType::TABLE:
+            {
+                result.push_back(std::move(node_to_process));
+                break;
+            }
+            case QueryTreeNodeType::QUERY:
+            {
+                nodes_to_process.push_back(node_to_process->as<QueryNode>()->getJoinTree());
+                break;
+            }
+            case QueryTreeNodeType::UNION:
+            {
+                for (const auto & union_node : node_to_process->as<UnionNode>()->getQueries().getNodes())
+                    nodes_to_process.push_back(union_node);
+                break;
+            }
+            case QueryTreeNodeType::TABLE_FUNCTION:
+            {
+                // Arguments of table function can't contain TableNodes.
+                break;
+            }
+            case QueryTreeNodeType::ARRAY_JOIN:
+            {
+                nodes_to_process.push_back(node_to_process->as<ArrayJoinNode>()->getTableExpression());
+                break;
+            }
+            case QueryTreeNodeType::JOIN:
+            {
+                auto & join_node = node_to_process->as<JoinNode &>();
+                nodes_to_process.push_back(join_node.getRightTableExpression());
+                nodes_to_process.push_back(join_node.getLeftTableExpression());
+                break;
+            }
+            default:
+            {
+                throw Exception(ErrorCodes::LOGICAL_ERROR,
+                                "Unexpected node type for table expression. "
+                                "Expected table, table function, query, union, join or array join. Actual {}",
+                                node_to_process->getNodeTypeName());
+            }
+        }
+    }
+
+    return result;
+}
+
 QueryTreeNodes extractTableExpressions(const QueryTreeNodePtr & join_tree_node, bool add_array_join)
 {
    QueryTreeNodes result;
--- a/src/Analyzer/Utils.h
+++ b/src/Analyzer/Utils.h
@ -50,10 +50,13 @@ std::optional<bool> tryExtractConstantFromConditionNode(const QueryTreeNodePtr &
  */
 void addTableExpressionOrJoinIntoTablesInSelectQuery(ASTPtr & tables_in_select_query_ast, const QueryTreeNodePtr & table_expression, const IQueryTreeNode::ConvertToASTOptions & convert_to_ast_options);

-/// Extract table, table function, query, union from join tree
+/// Extract all TableNodes from the query tree.
+QueryTreeNodes extractAllTableReferences(const QueryTreeNodePtr & tree);
+
+/// Extract table, table function, query, union from join tree.
 QueryTreeNodes extractTableExpressions(const QueryTreeNodePtr & join_tree_node, bool add_array_join = false);

-/// Extract left table expression from join tree
+/// Extract left table expression from join tree.
 QueryTreeNodePtr extractLeftTableExpression(const QueryTreeNodePtr & join_tree_node);

 /** Build table expressions stack that consists from table, table function, query, union, join, array join from join tree.
--- a/src/Backups/BackupCoordinationLocal.cpp
+++ b/src/Backups/BackupCoordinationLocal.cpp
@ -9,7 +9,7 @@ namespace DB
 {

 BackupCoordinationLocal::BackupCoordinationLocal(bool plain_backup_)
-    : log(&Poco::Logger::get("BackupCoordinationLocal")), file_infos(plain_backup_)
+    : log(getLogger("BackupCoordinationLocal")), file_infos(plain_backup_)
 {
 }

--- a/src/Backups/BackupCoordinationLocal.h
+++ b/src/Backups/BackupCoordinationLocal.h
@ -57,7 +57,7 @@ public:
    bool hasConcurrentBackups(const std::atomic<size_t> & num_active_backups) const override;

 private:
-    Poco::Logger * const log;
+    LoggerPtr const log;

    BackupCoordinationReplicatedTables TSA_GUARDED_BY(replicated_tables_mutex) replicated_tables;
    BackupCoordinationReplicatedAccess TSA_GUARDED_BY(replicated_access_mutex) replicated_access;
--- a/src/Backups/BackupCoordinationRemote.cpp
+++ b/src/Backups/BackupCoordinationRemote.cpp
@ -173,7 +173,7 @@ BackupCoordinationRemote::BackupCoordinationRemote(
    , current_host_index(findCurrentHostIndex(all_hosts, current_host))
    , plain_backup(plain_backup_)
    , is_internal(is_internal_)
-    , log(&Poco::Logger::get("BackupCoordinationRemote"))
+    , log(getLogger("BackupCoordinationRemote"))
    , with_retries(
        log,
        get_zookeeper_,
--- a/src/Backups/BackupCoordinationRemote.h
+++ b/src/Backups/BackupCoordinationRemote.h
@ -102,7 +102,7 @@ private:
    const size_t current_host_index;
    const bool plain_backup;
    const bool is_internal;
-    Poco::Logger * const log;
+    LoggerPtr const log;

    /// The order of these two fields matters, because stage_sync holds a reference to with_retries object
    mutable WithRetries with_retries;
--- a/src/Backups/BackupCoordinationStageSync.cpp
+++ b/src/Backups/BackupCoordinationStageSync.cpp
@ -24,7 +24,7 @@ namespace ErrorCodes
 BackupCoordinationStageSync::BackupCoordinationStageSync(
    const String & root_zookeeper_path_,
    WithRetries & with_retries_,
-    Poco::Logger * log_)
+    LoggerPtr log_)
    : zookeeper_path(root_zookeeper_path_ + "/stage")
    , with_retries(with_retries_)
    , log(log_)
--- a/src/Backups/BackupCoordinationStageSync.h
+++ b/src/Backups/BackupCoordinationStageSync.h
@ -12,7 +12,7 @@ public:
    BackupCoordinationStageSync(
        const String & root_zookeeper_path_,
        WithRetries & with_retries_,
-        Poco::Logger * log_);
+        LoggerPtr log_);

    /// Sets the stage of the current host and signal other hosts if there were other hosts waiting for that.
    void set(const String & current_host, const String & new_stage, const String & message, const bool & all_hosts = false);
@ -36,7 +36,7 @@ private:
    String zookeeper_path;
    /// A reference to the field of parent object - BackupCoordinationRemote or RestoreCoordinationRemote
    WithRetries & with_retries;
-    Poco::Logger * log;
+    LoggerPtr log;
 };

 }
--- a/src/Backups/BackupEntriesCollector.cpp
+++ b/src/Backups/BackupEntriesCollector.cpp
@ -97,7 +97,7 @@ BackupEntriesCollector::BackupEntriesCollector(
    , max_sleep_before_next_attempt_to_collect_metadata(
          context->getConfigRef().getUInt64("backups.max_sleep_before_next_attempt_to_collect_metadata", 5000))
    , compare_collected_metadata(context->getConfigRef().getBool("backups.compare_collected_metadata", true))
-    , log(&Poco::Logger::get("BackupEntriesCollector"))
+    , log(getLogger("BackupEntriesCollector"))
    , global_zookeeper_retries_info(
          context->getSettingsRef().backup_restore_keeper_max_retries,
          context->getSettingsRef().backup_restore_keeper_retry_initial_backoff_ms,
--- a/src/Backups/BackupEntriesCollector.h
+++ b/src/Backups/BackupEntriesCollector.h
@ -129,7 +129,7 @@ private:
    /// Whether we should collect the metadata after a successful attempt one more time and check that nothing has changed.
    const bool compare_collected_metadata;

-    Poco::Logger * log;
+    LoggerPtr log;
    /// Unfortunately we can use ZooKeeper for collecting information for backup
    /// and we need to retry...
    ZooKeeperRetriesInfo global_zookeeper_retries_info;
--- a/src/Backups/BackupFileInfo.cpp
+++ b/src/Backups/BackupFileInfo.cpp
@ -102,7 +102,7 @@ BackupFileInfo buildFileInfoForBackupEntry(
    const BackupEntryPtr & backup_entry,
    const BackupPtr & base_backup,
    const ReadSettings & read_settings,
-    Poco::Logger * log)
+    LoggerPtr log)
 {
    auto adjusted_path = removeLeadingSlash(file_name);

@ -129,7 +129,7 @@ BackupFileInfo buildFileInfoForBackupEntry(
    }

    if (!log)
-        log = &Poco::Logger::get("FileInfoFromBackupEntry");
+        log = getLogger("FileInfoFromBackupEntry");

    std::optional<SizeAndChecksum> base_backup_file_info = getInfoAboutFileFromBaseBackupIfExists(base_backup, adjusted_path);

@ -216,7 +216,7 @@ BackupFileInfos buildFileInfosForBackupEntries(const BackupEntries & backup_entr
    std::exception_ptr exception;

    auto thread_group = CurrentThread::getGroup();
-    Poco::Logger * log = &Poco::Logger::get("FileInfosFromBackupEntries");
+    LoggerPtr log = getLogger("FileInfosFromBackupEntries");

    for (size_t i = 0; i != backup_entries.size(); ++i)
    {
--- a/src/Backups/BackupFileInfo.h
+++ b/src/Backups/BackupFileInfo.h
@ -2,8 +2,7 @@

 #include <Core/Types.h>
 #include <Common/ThreadPool_fwd.h>
-
-namespace Poco { class Logger; }
+#include <Common/Logger.h>

 namespace DB
 {
@ -77,7 +76,7 @@ struct BackupFileInfo
 using BackupFileInfos = std::vector<BackupFileInfo>;

 /// Builds a BackupFileInfo for a specified backup entry.
-BackupFileInfo buildFileInfoForBackupEntry(const String & file_name, const BackupEntryPtr & backup_entry, const BackupPtr & base_backup, const ReadSettings & read_settings, Poco::Logger * log);
+BackupFileInfo buildFileInfoForBackupEntry(const String & file_name, const BackupEntryPtr & backup_entry, const BackupPtr & base_backup, const ReadSettings & read_settings, LoggerPtr log);

 /// Builds a vector of BackupFileInfos for specified backup entries.
 BackupFileInfos buildFileInfosForBackupEntries(const BackupEntries & backup_entries, const BackupPtr & base_backup, const ReadSettings & read_settings, ThreadPool & thread_pool, QueryStatusPtr process_list_element);
--- a/src/Backups/BackupIO_Default.cpp
+++ b/src/Backups/BackupIO_Default.cpp
@ -10,7 +10,7 @@
 namespace DB
 {

-BackupReaderDefault::BackupReaderDefault(const ReadSettings & read_settings_, const WriteSettings & write_settings_, Poco::Logger * log_)
+BackupReaderDefault::BackupReaderDefault(const ReadSettings & read_settings_, const WriteSettings & write_settings_, LoggerPtr log_)
    : log(log_)
    , read_settings(read_settings_)
    , write_settings(write_settings_)
@ -36,7 +36,7 @@ void BackupReaderDefault::copyFileToDisk(const String & path_in_backup, size_t f
    write_buffer->finalize();
 }

-BackupWriterDefault::BackupWriterDefault(const ReadSettings & read_settings_, const WriteSettings & write_settings_, Poco::Logger * log_)
+BackupWriterDefault::BackupWriterDefault(const ReadSettings & read_settings_, const WriteSettings & write_settings_, LoggerPtr log_)
    : log(log_)
    , read_settings(read_settings_)
    , write_settings(write_settings_)
--- a/src/Backups/BackupIO_Default.h
+++ b/src/Backups/BackupIO_Default.h
@ -18,7 +18,7 @@ enum class WriteMode;
 class BackupReaderDefault : public IBackupReader
 {
 public:
-    BackupReaderDefault(const ReadSettings & read_settings_, const WriteSettings & write_settings_, Poco::Logger * log_);
+    BackupReaderDefault(const ReadSettings & read_settings_, const WriteSettings & write_settings_, LoggerPtr log_);
    ~BackupReaderDefault() override = default;

    /// The function copyFileToDisk() can be much faster than reading the file with readFile() and then writing it to some disk.
@ -33,7 +33,7 @@ public:
    size_t getWriteBufferSize() const override { return write_buffer_size; }

 protected:
-    Poco::Logger * const log;
+    LoggerPtr const log;
    const ReadSettings read_settings;

    /// The write settings are used to write to the source disk in copyFileToDisk().
@ -45,7 +45,7 @@ protected:
 class BackupWriterDefault : public IBackupWriter
 {
 public:
-    BackupWriterDefault(const ReadSettings & read_settings_, const WriteSettings & write_settings_, Poco::Logger * log_);
+    BackupWriterDefault(const ReadSettings & read_settings_, const WriteSettings & write_settings_, LoggerPtr log_);
    ~BackupWriterDefault() override = default;

    bool fileContentsEqual(const String & file_name, const String & expected_file_contents) override;
@ -60,7 +60,7 @@ protected:
    /// Here readFile() is used only to implement fileContentsEqual().
    virtual std::unique_ptr<ReadBuffer> readFile(const String & file_name, size_t expected_file_size) = 0;

-    Poco::Logger * const log;
+    LoggerPtr const log;

    /// The read settings are used to read from the source disk in copyFileFromDisk().
    const ReadSettings read_settings;
--- a/src/Backups/BackupIO_Disk.cpp
+++ b/src/Backups/BackupIO_Disk.cpp
@ -9,7 +9,7 @@ namespace DB
 {

 BackupReaderDisk::BackupReaderDisk(const DiskPtr & disk_, const String & root_path_, const ReadSettings & read_settings_, const WriteSettings & write_settings_)
-    : BackupReaderDefault(read_settings_, write_settings_, &Poco::Logger::get("BackupReaderDisk"))
+    : BackupReaderDefault(read_settings_, write_settings_, getLogger("BackupReaderDisk"))
    , disk(disk_)
    , root_path(root_path_)
    , data_source_description(disk->getDataSourceDescription())
@ -57,7 +57,7 @@ void BackupReaderDisk::copyFileToDisk(const String & path_in_backup, size_t file


 BackupWriterDisk::BackupWriterDisk(const DiskPtr & disk_, const String & root_path_, const ReadSettings & read_settings_, const WriteSettings & write_settings_)
-    : BackupWriterDefault(read_settings_, write_settings_, &Poco::Logger::get("BackupWriterDisk"))
+    : BackupWriterDefault(read_settings_, write_settings_, getLogger("BackupWriterDisk"))
    , disk(disk_)
    , root_path(root_path_)
    , data_source_description(disk->getDataSourceDescription())
--- a/src/Backups/BackupIO_File.cpp
+++ b/src/Backups/BackupIO_File.cpp
@ -17,7 +17,7 @@ namespace ErrorCodes
 }

 BackupReaderFile::BackupReaderFile(const String & root_path_, const ReadSettings & read_settings_, const WriteSettings & write_settings_)
-    : BackupReaderDefault(read_settings_, write_settings_, &Poco::Logger::get("BackupReaderFile"))
+    : BackupReaderDefault(read_settings_, write_settings_, getLogger("BackupReaderFile"))
    , root_path(root_path_)
    , data_source_description(DiskLocal::getLocalDataSourceDescription(root_path))
 {
@ -75,7 +75,7 @@ void BackupReaderFile::copyFileToDisk(const String & path_in_backup, size_t file


 BackupWriterFile::BackupWriterFile(const String & root_path_, const ReadSettings & read_settings_, const WriteSettings & write_settings_)
-    : BackupWriterDefault(read_settings_, write_settings_, &Poco::Logger::get("BackupWriterFile"))
+    : BackupWriterDefault(read_settings_, write_settings_, getLogger("BackupWriterFile"))
    , root_path(root_path_)
    , data_source_description(DiskLocal::getLocalDataSourceDescription(root_path))
 {
--- a/src/Backups/BackupIO_S3.cpp
+++ b/src/Backups/BackupIO_S3.cpp
@ -124,7 +124,7 @@ BackupReaderS3::BackupReaderS3(
    const ReadSettings & read_settings_,
    const WriteSettings & write_settings_,
    const ContextPtr & context_)
-    : BackupReaderDefault(read_settings_, write_settings_, &Poco::Logger::get("BackupReaderS3"))
+    : BackupReaderDefault(read_settings_, write_settings_, getLogger("BackupReaderS3"))
    , s3_uri(s3_uri_)
    , data_source_description{DataSourceType::ObjectStorage, ObjectStorageType::S3, MetadataStorageType::None, s3_uri.endpoint, false, false}
    , s3_settings(context_->getStorageS3Settings().getSettings(s3_uri.uri.toString()))
@ -214,7 +214,7 @@ BackupWriterS3::BackupWriterS3(
    const ReadSettings & read_settings_,
    const WriteSettings & write_settings_,
    const ContextPtr & context_)
-    : BackupWriterDefault(read_settings_, write_settings_, &Poco::Logger::get("BackupWriterS3"))
+    : BackupWriterDefault(read_settings_, write_settings_, getLogger("BackupWriterS3"))
    , s3_uri(s3_uri_)
    , data_source_description{DataSourceType::ObjectStorage, ObjectStorageType::S3, MetadataStorageType::None, s3_uri.endpoint, false, false}
    , s3_settings(context_->getStorageS3Settings().getSettings(s3_uri.uri.toString()))
--- a/src/Backups/BackupImpl.cpp
+++ b/src/Backups/BackupImpl.cpp
@ -105,7 +105,7 @@ BackupImpl::BackupImpl(
    , version(INITIAL_BACKUP_VERSION)
    , base_backup_info(base_backup_info_)
    , use_same_s3_credentials_for_base_backup(use_same_s3_credentials_for_base_backup_)
-    , log(&Poco::Logger::get("BackupImpl"))
+    , log(getLogger("BackupImpl"))
 {
    open();
 }
@ -136,7 +136,7 @@ BackupImpl::BackupImpl(
    , base_backup_info(base_backup_info_)
    , deduplicate_files(deduplicate_files_)
    , use_same_s3_credentials_for_base_backup(use_same_s3_credentials_for_base_backup_)
-    , log(&Poco::Logger::get("BackupImpl"))
+    , log(getLogger("BackupImpl"))
 {
    open();
 }
--- a/src/Backups/BackupImpl.h
+++ b/src/Backups/BackupImpl.h
@ -153,7 +153,7 @@ private:
    bool writing_finalized = false;
    bool deduplicate_files = true;
    bool use_same_s3_credentials_for_base_backup = false;
-    const Poco::Logger * log;
+    const LoggerPtr log;
 };

 }
--- a/src/Backups/BackupsWorker.cpp
+++ b/src/Backups/BackupsWorker.cpp
@ -380,7 +380,7 @@ BackupsWorker::BackupsWorker(ContextMutablePtr global_context, size_t num_backup
    , allow_concurrent_backups(allow_concurrent_backups_)
    , allow_concurrent_restores(allow_concurrent_restores_)
    , test_inject_sleep(test_inject_sleep_)
-    , log(&Poco::Logger::get("BackupsWorker"))
+    , log(getLogger("BackupsWorker"))
    , backup_log(global_context->getBackupLog())
    , process_list(global_context->getProcessList())
 {
--- a/src/Backups/BackupsWorker.h
+++ b/src/Backups/BackupsWorker.h
@ -127,7 +127,7 @@ private:
    const bool allow_concurrent_restores;
    const bool test_inject_sleep;

-    Poco::Logger * log;
+    LoggerPtr log;

    struct ExtendedOperationInfo
    {
--- a/src/Backups/RestoreCoordinationLocal.cpp
+++ b/src/Backups/RestoreCoordinationLocal.cpp
@ -6,7 +6,7 @@
 namespace DB
 {

-RestoreCoordinationLocal::RestoreCoordinationLocal() : log(&Poco::Logger::get("RestoreCoordinationLocal"))
+RestoreCoordinationLocal::RestoreCoordinationLocal() : log(getLogger("RestoreCoordinationLocal"))
 {
 }

--- a/src/Backups/RestoreCoordinationLocal.h
+++ b/src/Backups/RestoreCoordinationLocal.h
@ -51,7 +51,7 @@ public:
    bool hasConcurrentRestores(const std::atomic<size_t> & num_active_restores) const override;

 private:
-    Poco::Logger * const log;
+    LoggerPtr const log;

    std::set<std::pair<String /* database_zk_path */, String /* table_name */>> acquired_tables_in_replicated_databases;
    std::unordered_set<String /* table_zk_path */> acquired_data_in_replicated_tables;
--- a/src/Backups/RestoreCoordinationRemote.cpp
+++ b/src/Backups/RestoreCoordinationRemote.cpp
@ -32,7 +32,7 @@ RestoreCoordinationRemote::RestoreCoordinationRemote(
    , current_host(current_host_)
    , current_host_index(BackupCoordinationRemote::findCurrentHostIndex(all_hosts, current_host))
    , is_internal(is_internal_)
-    , log(&Poco::Logger::get("RestoreCoordinationRemote"))
+    , log(getLogger("RestoreCoordinationRemote"))
    , with_retries(
        log,
        get_zookeeper_,
--- a/src/Backups/RestoreCoordinationRemote.h
+++ b/src/Backups/RestoreCoordinationRemote.h
@ -73,7 +73,7 @@ private:
    const String current_host;
    const size_t current_host_index;
    const bool is_internal;
-    Poco::Logger * const log;
+    LoggerPtr const log;

    mutable WithRetries with_retries;
    std::optional<BackupCoordinationStageSync> stage_sync;
--- a/src/Backups/RestorerFromBackup.cpp
+++ b/src/Backups/RestorerFromBackup.cpp
@ -89,7 +89,7 @@ RestorerFromBackup::RestorerFromBackup(
    , process_list_element(context->getProcessListElement())
    , on_cluster_first_sync_timeout(context->getConfigRef().getUInt64("backups.on_cluster_first_sync_timeout", 180000))
    , create_table_timeout(context->getConfigRef().getUInt64("backups.create_table_timeout", 300000))
-    , log(&Poco::Logger::get("RestorerFromBackup"))
+    , log(getLogger("RestorerFromBackup"))
    , tables_dependencies("RestorerFromBackup")
 {
 }
--- a/src/Backups/RestorerFromBackup.h
+++ b/src/Backups/RestorerFromBackup.h
@ -79,7 +79,7 @@ private:
    QueryStatusPtr process_list_element;
    std::chrono::milliseconds on_cluster_first_sync_timeout;
    std::chrono::milliseconds create_table_timeout;
-    Poco::Logger * log;
+    LoggerPtr log;

    Strings all_hosts;
    DDLRenamingMap renaming_map;
--- a/src/Backups/WithRetries.cpp
+++ b/src/Backups/WithRetries.cpp
@ -21,7 +21,7 @@ WithRetries::KeeperSettings WithRetries::KeeperSettings::fromContext(ContextPtr
 }

 WithRetries::WithRetries(
-    Poco::Logger * log_, zkutil::GetZooKeeper get_zookeeper_, const KeeperSettings & settings_, QueryStatusPtr process_list_element_, RenewerCallback callback_)
+    LoggerPtr log_, zkutil::GetZooKeeper get_zookeeper_, const KeeperSettings & settings_, QueryStatusPtr process_list_element_, RenewerCallback callback_)
    : log(log_)
    , get_zookeeper(get_zookeeper_)
    , settings(settings_)
--- a/src/Backups/WithRetries.h
+++ b/src/Backups/WithRetries.h
@ -52,7 +52,7 @@ public:
    };

    RetriesControlHolder createRetriesControlHolder(const String & name);
-    WithRetries(Poco::Logger * log, zkutil::GetZooKeeper get_zookeeper_, const KeeperSettings & settings, QueryStatusPtr process_list_element_, RenewerCallback callback);
+    WithRetries(LoggerPtr log, zkutil::GetZooKeeper get_zookeeper_, const KeeperSettings & settings, QueryStatusPtr process_list_element_, RenewerCallback callback);

    /// Used to re-establish new connection inside a retry loop.
    void renewZooKeeper(FaultyKeeper my_faulty_zookeeper) const;
@ -62,7 +62,7 @@ private:
    /// This will provide a special wrapper which is useful for testing
    FaultyKeeper getFaultyZooKeeper() const;

-    Poco::Logger * log;
+    LoggerPtr log;
    zkutil::GetZooKeeper get_zookeeper;
    KeeperSettings settings;
    QueryStatusPtr process_list_element;
--- a/src/BridgeHelper/IBridgeHelper.h
+++ b/src/BridgeHelper/IBridgeHelper.h
@ -51,7 +51,7 @@ protected:

    virtual const Poco::Util::AbstractConfiguration & getConfig() const = 0;

-    virtual Poco::Logger * getLog() const = 0;
+    virtual LoggerPtr getLog() const = 0;

    virtual Poco::Timespan getHTTPTimeout() const = 0;

--- a/src/BridgeHelper/LibraryBridgeHelper.cpp
+++ b/src/BridgeHelper/LibraryBridgeHelper.cpp
@ -8,7 +8,7 @@ namespace DB
 LibraryBridgeHelper::LibraryBridgeHelper(ContextPtr context_)
    : IBridgeHelper(context_)
    , config(context_->getConfigRef())
-    , log(&Poco::Logger::get("LibraryBridgeHelper"))
+    , log(getLogger("LibraryBridgeHelper"))
    , http_timeout(context_->getGlobalContext()->getSettingsRef().http_receive_timeout.value)
    , bridge_host(config.getString("library_bridge.host", DEFAULT_HOST))
    , bridge_port(config.getUInt("library_bridge.port", DEFAULT_PORT))
--- a/src/BridgeHelper/LibraryBridgeHelper.h
+++ b/src/BridgeHelper/LibraryBridgeHelper.h
@ -31,7 +31,7 @@ protected:

    const Poco::Util::AbstractConfiguration & getConfig() const override { return config; }

-    Poco::Logger * getLog() const override { return log; }
+    LoggerPtr getLog() const override { return log; }

    Poco::Timespan getHTTPTimeout() const override { return http_timeout; }

@ -40,7 +40,7 @@ protected:
    static constexpr inline size_t DEFAULT_PORT = 9012;

    const Poco::Util::AbstractConfiguration & config;
-    Poco::Logger * log;
+    LoggerPtr log;
    const Poco::Timespan http_timeout;
    std::string bridge_host;
    size_t bridge_port;
--- a/src/BridgeHelper/XDBCBridgeHelper.h
+++ b/src/BridgeHelper/XDBCBridgeHelper.h
@ -65,7 +65,7 @@ public:
            const std::string & connection_string_,
            bool use_connection_pooling_)
        : IXDBCBridgeHelper(context_->getGlobalContext())
-        , log(&Poco::Logger::get(BridgeHelperMixin::getName() + "BridgeHelper"))
+        , log(getLogger(BridgeHelperMixin::getName() + "BridgeHelper"))
        , connection_string(connection_string_)
        , use_connection_pooling(use_connection_pooling_)
        , http_timeout(http_timeout_)
@ -123,7 +123,7 @@ protected:

    const Poco::Util::AbstractConfiguration & getConfig() const override { return config; }

-    Poco::Logger * getLog() const override { return log; }
+    LoggerPtr getLog() const override { return log; }

    bool startBridgeManually() const override { return BridgeHelperMixin::startBridgeManually(); }

@ -146,7 +146,7 @@ protected:
 private:
    using Configuration = Poco::Util::AbstractConfiguration;

-    Poco::Logger * log;
+    LoggerPtr log;
    std::string connection_string;
    bool use_connection_pooling;
    Poco::Timespan http_timeout;
--- a/src/Client/Connection.h
+++ b/src/Client/Connection.h
@ -4,6 +4,7 @@
 #include <Poco/Net/StreamSocket.h>

 #include <Common/SSH/Wrappers.h>
+#include <Common/callOnce.h>
 #include <Client/IServerConnection.h>
 #include <Core/Defines.h>

@ -244,16 +245,18 @@ private:
        {
        }

-        Poco::Logger * get()
+        LoggerPtr get()
        {
-            if (!log)
-                log = &Poco::Logger::get("Connection (" + parent.getDescription() + ")");
+            callOnce(log_initialized, [&] {
+                log = getLogger("Connection (" + parent.getDescription() + ")");
+            });

            return log;
        }

    private:
-        std::atomic<Poco::Logger *> log;
+        OnceFlag log_initialized;
+        LoggerPtr log;
        Connection & parent;
    };

--- a/src/Client/ConnectionEstablisher.cpp
+++ b/src/Client/ConnectionEstablisher.cpp
@ -25,7 +25,7 @@ ConnectionEstablisher::ConnectionEstablisher(
    IConnectionPool * pool_,
    const ConnectionTimeouts * timeouts_,
    const Settings & settings_,
-    Poco::Logger * log_,
+    LoggerPtr log_,
    const QualifiedTableName * table_to_check_)
    : pool(pool_), timeouts(timeouts_), settings(settings_), log(log_), table_to_check(table_to_check_), is_finished(false)
 {
@ -114,7 +114,7 @@ ConnectionEstablisherAsync::ConnectionEstablisherAsync(
    IConnectionPool * pool_,
    const ConnectionTimeouts * timeouts_,
    const Settings & settings_,
-    Poco::Logger * log_,
+    LoggerPtr log_,
    const QualifiedTableName * table_to_check_)
    : AsyncTaskExecutor(std::make_unique<Task>(*this)), connection_establisher(pool_, timeouts_, settings_, log_, table_to_check_)
 {
--- a/src/Client/ConnectionEstablisher.h
+++ b/src/Client/ConnectionEstablisher.h
@ -23,7 +23,7 @@ public:
    ConnectionEstablisher(IConnectionPool * pool_,
                          const ConnectionTimeouts * timeouts_,
                          const Settings & settings_,
-                          Poco::Logger * log,
+                          LoggerPtr log,
                          const QualifiedTableName * table_to_check = nullptr);

    /// Establish connection and save it in result, write possible exception message in fail_message.
@ -38,7 +38,7 @@ private:
    IConnectionPool * pool;
    const ConnectionTimeouts * timeouts;
    const Settings & settings;
-    Poco::Logger * log;
+    LoggerPtr log;
    const QualifiedTableName * table_to_check;

    bool is_finished;
@ -61,7 +61,7 @@ public:
    ConnectionEstablisherAsync(IConnectionPool * pool_,
                               const ConnectionTimeouts * timeouts_,
                               const Settings & settings_,
-                               Poco::Logger * log_,
+                               LoggerPtr log_,
                               const QualifiedTableName * table_to_check_ = nullptr);

    /// Get file descriptor that can be added in epoll and be polled,
--- a/Show More
+++ b/Show More