update to master

2024-11-27 01:51:59 +00:00 · 2023-06-16 21:30:47 +02:00 · 2023-06-16 21:30:47 +02:00 · 1c10578f14
commit 1c10578f14
parent 00a5df684b 10d597676c
98 changed files with 1307 additions and 393 deletions
--- a/contrib/jemalloc-cmake/CMakeLists.txt
+++ b/contrib/jemalloc-cmake/CMakeLists.txt
@ -4,7 +4,7 @@ if (SANITIZE OR NOT (
 ))
    if (ENABLE_JEMALLOC)
        message (${RECONFIGURE_MESSAGE_LEVEL}
-                 "jemalloc is disabled implicitly: it doesn't work with sanitizers and can only be used with x86_64, aarch64, or ppc64le Linux or FreeBSD builds and RelWithDebInfo macOS builds.")
+                 "jemalloc is disabled implicitly: it doesn't work with sanitizers and can only be used with x86_64, aarch64, or ppc64le Linux or FreeBSD builds and RelWithDebInfo macOS builds. Use -DENABLE_JEMALLOC=0")
    endif ()
    set (ENABLE_JEMALLOC OFF)
 else ()
--- a/docs/en/engines/table-engines/integrations/hdfs.md
+++ b/docs/en/engines/table-engines/integrations/hdfs.md
@ -233,6 +233,12 @@ libhdfs3 support HDFS namenode HA.
 - `_path` — Path to the file.
 - `_file` — Name of the file.

+## Storage Settings {#storage-settings}
+
+- [hdfs_truncate_on_insert](/docs/en/operations/settings/settings.md#hdfs-truncate-on-insert) - allows to truncate file before insert into it. Disabled by default.
+- [hdfs_create_multiple_files](/docs/en/operations/settings/settings.md#hdfs_allow_create_multiple_files) - allows to create a new file on each insert if format has suffix. Disabled by default.
+- [hdfs_skip_empty_files](/docs/en/operations/settings/settings.md#hdfs_skip_empty_files) - allows to skip empty files while reading. Disabled by default.
+
 **See Also**

 - [Virtual columns](../../../engines/table-engines/index.md#table_engines-virtual_columns)
--- a/docs/en/engines/table-engines/integrations/s3.md
+++ b/docs/en/engines/table-engines/integrations/s3.md
@ -127,6 +127,12 @@ CREATE TABLE table_with_asterisk (name String, value UInt32)
    ENGINE = S3('https://clickhouse-public-datasets.s3.amazonaws.com/my-bucket/{some,another}_folder/*', 'CSV');
 ```

+## Storage Settings {#storage-settings}
+
+- [s3_truncate_on_insert](/docs/en/operations/settings/settings.md#s3-truncate-on-insert) - allows to truncate file before insert into it. Disabled by default.
+- [s3_create_multiple_files](/docs/en/operations/settings/settings.md#s3_allow_create_multiple_files) - allows to create a new file on each insert if format has suffix. Disabled by default.
+- [s3_skip_empty_files](/docs/en/operations/settings/settings.md#s3_skip_empty_files) - allows to skip empty files while reading. Disabled by default.
+
 ## S3-related Settings {#settings}

 The following settings can be set before query execution or placed into configuration file.
--- a/docs/en/engines/table-engines/special/file.md
+++ b/docs/en/engines/table-engines/special/file.md
@ -92,3 +92,11 @@ $ echo -e "1,2\n3,4" | clickhouse-local -q "CREATE TABLE table (a Int64, b Int64
 `PARTITION BY` — Optional.  It is possible to create separate files by partitioning the data on a partition key. In most cases, you don't need a partition key, and if it is needed you generally don't need a partition key more granular than by month. Partitioning does not speed up queries (in contrast to the ORDER BY expression). You should never use too granular partitioning. Don't partition your data by client identifiers or names (instead, make client identifier or name the first column in the ORDER BY expression).

 For partitioning by month, use the `toYYYYMM(date_column)` expression, where `date_column` is a column with a date of the type [Date](/docs/en/sql-reference/data-types/date.md). The partition names here have the `"YYYYMM"` format.
+
+## Settings {#settings}
+
+- [engine_file_empty_if_not_exists](/docs/en/operations/settings/settings.md#engine-file-emptyif-not-exists) - allows to select empty data from a file that doesn't exist. Disabled by default.
+- [engine_file_truncate_on_insert](/docs/en/operations/settings/settings.md#engine-file-truncate-on-insert) - allows to truncate file before insert into it. Disabled by default.
+- [engine_file_allow_create_multiple_files](/docs/en/operations/settings/settings.md#engine_file_allow_create_multiple_files) - allows to create a new file on each insert if format has suffix. Disabled by default.
+- [engine_file_skip_empty_files](/docs/en/operations/settings/settings.md#engine_file_skip_empty_files) - allows to skip empty files while reading. Disabled by default.
+- [storage_file_read_method](/docs/en/operations/settings/settings.md#engine-file-emptyif-not-exists) - method of reading data from storage file, one of: `read`, `pread`, `mmap`. The mmap method does not apply to clickhouse-server (it's intended for clickhouse-local). Default value: `pread` for clickhouse-server, `mmap` for clickhouse-local.
--- a/docs/en/engines/table-engines/special/url.md
+++ b/docs/en/engines/table-engines/special/url.md
@ -102,3 +102,7 @@ SELECT * FROM url_engine_table
 `PARTITION BY` — Optional.  It is possible to create separate files by partitioning the data on a partition key. In most cases, you don't need a partition key, and if it is needed you generally don't need a partition key more granular than by month. Partitioning does not speed up queries (in contrast to the ORDER BY expression). You should never use too granular partitioning. Don't partition your data by client identifiers or names (instead, make client identifier or name the first column in the ORDER BY expression).

 For partitioning by month, use the `toYYYYMM(date_column)` expression, where `date_column` is a column with a date of the type [Date](/docs/en/sql-reference/data-types/date.md). The partition names here have the `"YYYYMM"` format.
+
+## Storage Settings {#storage-settings}
+
+- [engine_url_skip_empty_files](/docs/en/operations/settings/settings.md#engine_url_skip_empty_files) - allows to skip empty files while reading. Disabled by default.
--- a/docs/en/interfaces/formats.md
+++ b/docs/en/interfaces/formats.md
@ -470,6 +470,7 @@ The CSV format supports the output of totals and extremes the same way as `TabSe
 - [input_format_csv_detect_header](/docs/en/operations/settings/settings-formats.md/#input_format_csv_detect_header) - automatically detect header with names and types in CSV format. Default value - `true`.
 - [input_format_csv_skip_trailing_empty_lines](/docs/en/operations/settings/settings-formats.md/#input_format_csv_skip_trailing_empty_lines) - skip trailing empty lines at the end of data. Default value - `false`.
 - [input_format_csv_trim_whitespaces](/docs/en/operations/settings/settings-formats.md/#input_format_csv_trim_whitespaces) - trim spaces and tabs in non-quoted CSV strings. Default value - `true`.
+- [input_format_csv_allow_whitespace_or_tab_as_delimiter](/docs/en/operations/settings/settings-formats.md/# input_format_csv_allow_whitespace_or_tab_as_delimiter) - Allow to use whitespace or tab as field delimiter in CSV strings. Default value - `false`.

 ## CSVWithNames {#csvwithnames}

@ -1877,13 +1878,13 @@ The table below shows supported data types and how they match ClickHouse [data t
 | `string (uuid)` \**                         | [UUID](/docs/en/sql-reference/data-types/uuid.md)                                                                             | `string (uuid)` \**           |
 | `fixed(16)`                                 | [Int128/UInt128](/docs/en/sql-reference/data-types/int-uint.md)                                                               | `fixed(16)`                   |
 | `fixed(32)`                                 | [Int256/UInt256](/docs/en/sql-reference/data-types/int-uint.md)                                                               | `fixed(32)`                   |
+| `record`                                    | [Tuple](/docs/en/sql-reference/data-types/tuple.md)                                                                           | `record`                      |
+


 \* `bytes` is default, controlled by [output_format_avro_string_column_pattern](/docs/en/operations/settings/settings-formats.md/#output_format_avro_string_column_pattern)
 \** [Avro logical types](https://avro.apache.org/docs/current/spec.html#Logical+Types)

-Unsupported Avro data types: `record` (non-root), `map`
-
 Unsupported Avro logical data types: `time-millis`, `time-micros`, `duration`

 ### Inserting Data {#inserting-data-1}
@ -1922,7 +1923,26 @@ Output Avro file compression and sync interval can be configured with [output_fo

 Using the ClickHouse [DESCRIBE](/docs/en/sql-reference/statements/describe-table) function, you can quickly view the inferred format of an Avro file like the following example. This example includes the URL of a publicly accessible Avro file in the ClickHouse S3 public bucket:

-``` DESCRIBE url('https://clickhouse-public-datasets.s3.eu-central-1.amazonaws.com/hits.avro','Avro');
+```
+DESCRIBE url('https://clickhouse-public-datasets.s3.eu-central-1.amazonaws.com/hits.avro','Avro);
+```
+```
+┌─name───────────────────────┬─type────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
+│ WatchID                    │ Int64           │              │                    │         │                  │                │
+│ JavaEnable                 │ Int32           │              │                    │         │                  │                │
+│ Title                      │ String          │              │                    │         │                  │                │
+│ GoodEvent                  │ Int32           │              │                    │         │                  │                │
+│ EventTime                  │ Int32           │              │                    │         │                  │                │
+│ EventDate                  │ Date32          │              │                    │         │                  │                │
+│ CounterID                  │ Int32           │              │                    │         │                  │                │
+│ ClientIP                   │ Int32           │              │                    │         │                  │                │
+│ ClientIP6                  │ FixedString(16) │              │                    │         │                  │                │
+│ RegionID                   │ Int32           │              │                    │         │                  │                │
+...
+│ IslandID                   │ FixedString(16) │              │                    │         │                  │                │
+│ RequestNum                 │ Int32           │              │                    │         │                  │                │
+│ RequestTry                 │ Int32           │              │                    │         │                  │                │
+└────────────────────────────┴─────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
 ```

 ## AvroConfluent {#data-format-avro-confluent}
--- a/docs/en/operations/settings/settings-formats.md
+++ b/docs/en/operations/settings/settings-formats.md
@ -932,6 +932,38 @@ Result
 "  string  "
 ```

+### input_format_csv_allow_whitespace_or_tab_as_delimiter {#input_format_csv_allow_whitespace_or_tab_as_delimiter}
+
+Allow to use whitespace or tab as field delimiter in CSV strings.
+
+Default value: `false`.
+
+**Examples**
+
+Query
+
+```bash
+echo 'a b' | ./clickhouse local -q  "select * from table FORMAT CSV" --input-format="CSV" --input_format_csv_allow_whitespace_or_tab_as_delimiter=true --format_csv_delimiter=' '
+```
+
+Result
+
+```text
+a  b
+```
+
+Query
+
+```bash
+echo 'a         b' | ./clickhouse local -q  "select * from table FORMAT CSV" --input-format="CSV" --input_format_csv_allow_whitespace_or_tab_as_delimiter=true --format_csv_delimiter='\t'
+```
+
+Result
+
+```text
+a  b
+```
+
 ## Values format settings {#values-format-settings}

 ### input_format_values_interpret_expressions {#input_format_values_interpret_expressions}
--- a/docs/en/operations/settings/settings.md
+++ b/docs/en/operations/settings/settings.md
@ -3328,7 +3328,35 @@ Possible values:

 Default value: `0`.

-## s3_truncate_on_insert
+## engine_file_allow_create_multiple_files {#engine_file_allow_create_multiple_files}
+
+Enables or disables creating a new file on each insert in file engine tables if the format has the suffix (`JSON`, `ORC`, `Parquet`, etc.). If enabled, on each insert a new file will be created with a name following this pattern:
+
+`data.Parquet` -> `data.1.Parquet` -> `data.2.Parquet`, etc.
+
+Possible values:
+- 0 — `INSERT` query appends new data to the end of the file.
+- 1 — `INSERT` query creates a new file.
+
+Default value: `0`.
+
+## engine_file_skip_empty_files {#engine_file_skip_empty_files}
+
+Enables or disables skipping empty files in [File](../../engines/table-engines/special/file.md) engine tables.
+
+Possible values:
+- 0 — `SELECT` throws an exception if empty file is not compatible with requested format.
+- 1 — `SELECT` returns empty result for empty file.
+
+Default value: `0`.
+
+## storage_file_read_method {#storage_file_read_method}
+
+Method of reading data from storage file, one of: `read`, `pread`, `mmap`. The mmap method does not apply to clickhouse-server (it's intended for clickhouse-local).
+
+Default value: `pread` for clickhouse-server, `mmap` for clickhouse-local.
+
+## s3_truncate_on_insert {#s3_truncate_on_insert}

 Enables or disables truncate before inserts in s3 engine tables. If disabled, an exception will be thrown on insert attempts if an S3 object already exists.

@ -3338,7 +3366,29 @@ Possible values:

 Default value: `0`.

-## hdfs_truncate_on_insert
+## s3_create_new_file_on_insert {#s3_create_new_file_on_insert}
+
+Enables or disables creating a new file on each insert in s3 engine tables. If enabled, on each insert a new S3 object will be created with the key, similar to this pattern:
+
+initial: `data.Parquet.gz` -> `data.1.Parquet.gz` -> `data.2.Parquet.gz`, etc.
+
+Possible values:
+- 0 — `INSERT` query appends new data to the end of the file.
+- 1 — `INSERT` query creates a new file.
+
+Default value: `0`.
+
+## s3_skip_empty_files {#s3_skip_empty_files}
+
+Enables or disables skipping empty files in [S3](../../engines/table-engines/integrations/s3.md) engine tables.
+
+Possible values:
+- 0 — `SELECT` throws an exception if empty file is not compatible with requested format.
+- 1 — `SELECT` returns empty result for empty file.
+
+Default value: `0`.
+
+## hdfs_truncate_on_insert {#hdfs_truncate_on_insert}

 Enables or disables truncation before an insert in hdfs engine tables. If disabled, an exception will be thrown on an attempt to insert if a file in HDFS already exists.

@ -3348,31 +3398,7 @@ Possible values:

 Default value: `0`.

-## engine_file_allow_create_multiple_files
-
-Enables or disables creating a new file on each insert in file engine tables if the format has the suffix (`JSON`, `ORC`, `Parquet`, etc.). If enabled, on each insert a new file will be created with a name following this pattern:
-
-`data.Parquet` -> `data.1.Parquet` -> `data.2.Parquet`, etc.
-
-Possible values:
- 0 — `INSERT` query appends new data to the end of the file.
- 1 — `INSERT` query replaces existing content of the file with the new data.
-
-Default value: `0`.
-
-## s3_create_new_file_on_insert
-
-Enables or disables creating a new file on each insert in s3 engine tables. If enabled, on each insert a new S3 object will be created with the key, similar to this pattern:
-
-initial: `data.Parquet.gz` -> `data.1.Parquet.gz` -> `data.2.Parquet.gz`, etc.
-
-Possible values:
- 0 — `INSERT` query appends new data to the end of the file.
- 1 — `INSERT` query replaces existing content of the file with the new data.
-
-Default value: `0`.
-
-## hdfs_create_new_file_on_insert
+## hdfs_create_new_file_on_insert {#hdfs_create_new_file_on_insert

 Enables or disables creating a new file on each insert in HDFS engine tables. If enabled, on each insert a new HDFS file will be created with the name, similar to this pattern:

@ -3380,7 +3406,27 @@ initial: `data.Parquet.gz` -> `data.1.Parquet.gz` -> `data.2.Parquet.gz`, etc.

 Possible values:
 - 0 — `INSERT` query appends new data to the end of the file.
- 1 — `INSERT` query replaces existing content of the file with the new data.
+- 1 — `INSERT` query creates a new file.
+
+Default value: `0`.
+
+## hdfs_skip_empty_files {#hdfs_skip_empty_files}
+
+Enables or disables skipping empty files in [HDFS](../../engines/table-engines/integrations/hdfs.md) engine tables.
+
+Possible values:
+- 0 — `SELECT` throws an exception if empty file is not compatible with requested format.
+- 1 — `SELECT` returns empty result for empty file.
+
+Default value: `0`.
+
+## engine_url_skip_empty_files {#engine_url_skip_empty_files}
+
+Enables or disables skipping empty files in [URL](../../engines/table-engines/special/url.md) engine tables.
+
+Possible values:
+- 0 — `SELECT` throws an exception if empty file is not compatible with requested format.
+- 1 — `SELECT` returns empty result for empty file.

 Default value: `0`.

--- a/docs/en/sql-reference/table-functions/file.md
+++ b/docs/en/sql-reference/table-functions/file.md
@ -196,6 +196,16 @@ SELECT count(*) FROM file('big_dir/**/file002', 'CSV', 'name String, value UInt3
 - `_path` — Path to the file.
 - `_file` — Name of the file.

+## Settings
+
+- [engine_file_empty_if_not_exists](/docs/en/operations/settings/settings.md#engine-file-emptyif-not-exists) - allows to select empty data from a file that doesn't exist. Disabled by default.
+- [engine_file_truncate_on_insert](/docs/en/operations/settings/settings.md#engine-file-truncate-on-insert) - allows to truncate file before insert into it. Disabled by default.
+- [engine_file_allow_create_multiple_files](/docs/en/operations/settings/settings.md#engine_file_allow_create_multiple_files) - allows to create a new file on each insert if format has suffix. Disabled by default.
+- [engine_file_skip_empty_files](/docs/en/operations/settings/settings.md#engine_file_skip_empty_files) - allows to skip empty files while reading. Disabled by default.
+- [storage_file_read_method](/docs/en/operations/settings/settings.md#engine-file-emptyif-not-exists) - method of reading data from storage file, one of: read, pread, mmap (only for clickhouse-local). Default value: `pread` for clickhouse-server, `mmap` for clickhouse-local.
+
+
+
 **See Also**

 - [Virtual columns](/docs/en/engines/table-engines/index.md#table_engines-virtual_columns)
--- a/docs/en/sql-reference/table-functions/hdfs.md
+++ b/docs/en/sql-reference/table-functions/hdfs.md
@ -97,6 +97,12 @@ FROM hdfs('hdfs://hdfs1:9000/big_dir/file{0..9}{0..9}{0..9}', 'CSV', 'name Strin
 - `_path` — Path to the file.
 - `_file` — Name of the file.

+## Storage Settings {#storage-settings}
+
+- [hdfs_truncate_on_insert](/docs/en/operations/settings/settings.md#hdfs-truncate-on-insert) - allows to truncate file before insert into it. Disabled by default.
+- [hdfs_create_multiple_files](/docs/en/operations/settings/settings.md#hdfs_allow_create_multiple_files) - allows to create a new file on each insert if format has suffix. Disabled by default.
+- [hdfs_skip_empty_files](/docs/en/operations/settings/settings.md#hdfs_skip_empty_files) - allows to skip empty files while reading. Disabled by default.
+
 **See Also**

 - [Virtual columns](../../engines/table-engines/index.md#table_engines-virtual_columns)
--- a/docs/en/sql-reference/table-functions/redis.md
+++ b/docs/en/sql-reference/table-functions/redis.md
@ -1,10 +1,10 @@
 ---
 slug: /en/sql-reference/table-functions/redis
-sidebar_position: 10
-sidebar_label: Redis
+sidebar_position: 43
+sidebar_label: redis
 ---

-# Redis
+# redis

 This table function allows integrating ClickHouse with [Redis](https://redis.io/).

--- a/docs/en/sql-reference/table-functions/s3.md
+++ b/docs/en/sql-reference/table-functions/s3.md
@ -202,6 +202,12 @@ FROM s3(
 LIMIT 5;
 ```

+## Storage Settings {#storage-settings}
+
+- [s3_truncate_on_insert](/docs/en/operations/settings/settings.md#s3-truncate-on-insert) - allows to truncate file before insert into it. Disabled by default.
+- [s3_create_multiple_files](/docs/en/operations/settings/settings.md#s3_allow_create_multiple_files) - allows to create a new file on each insert if format has suffix. Disabled by default.
+- [s3_skip_empty_files](/docs/en/operations/settings/settings.md#s3_skip_empty_files) - allows to skip empty files while reading. Disabled by default.
+
 **See Also**

 - [S3 engine](../../engines/table-engines/integrations/s3.md)
--- a/docs/en/sql-reference/table-functions/url.md
+++ b/docs/en/sql-reference/table-functions/url.md
@ -53,6 +53,10 @@ Character `|` inside patterns is used to specify failover addresses. They are it
 - `_path` — Path to the `URL`.
 - `_file` — Resource name of the `URL`.

+## Storage Settings {#storage-settings}
+
+- [engine_url_skip_empty_files](/docs/en/operations/settings/settings.md#engine_url_skip_empty_files) - allows to skip empty files while reading. Disabled by default.
+
 **See Also**

 - [Virtual columns](/docs/en/engines/table-engines/index.md#table_engines-virtual_columns)
--- a/programs/CMakeLists.txt
+++ b/programs/CMakeLists.txt
@ -409,8 +409,15 @@ if (ENABLE_CLICKHOUSE_KEEPER_CONVERTER)
    list(APPEND CLICKHOUSE_BUNDLE clickhouse-keeper-converter)
 endif ()
 if (ENABLE_CLICKHOUSE_KEEPER_CLIENT)
-    add_custom_target (clickhouse-keeper-client ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-keeper-client DEPENDS clickhouse)
-    install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-keeper-client" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
+    if (NOT BUILD_STANDALONE_KEEPER)
+        add_custom_target (clickhouse-keeper-client ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-keeper-client DEPENDS clickhouse)
+        install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-keeper-client" DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
+    # symlink to standalone keeper binary
+    else ()
+        add_custom_target (clickhouse-keeper-client ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse-keeper clickhouse-keeper-client DEPENDS clickhouse-keeper)
+        install (FILES "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-keeper-client" DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT clickhouse-keeper)
+    endif ()
+
    list(APPEND CLICKHOUSE_BUNDLE clickhouse-keeper-client)
 endif ()
 if (ENABLE_CLICKHOUSE_DISKS)
--- a/programs/keeper/CMakeLists.txt
+++ b/programs/keeper/CMakeLists.txt
@ -112,6 +112,18 @@ if (BUILD_STANDALONE_KEEPER)
        clickhouse-keeper.cpp
    )

+    # List of resources for clickhouse-keeper client
+    if (ENABLE_CLICKHOUSE_KEEPER_CLIENT)
+        list(APPEND CLICKHOUSE_KEEPER_STANDALONE_SOURCES
+            ${CMAKE_CURRENT_SOURCE_DIR}/../../programs/keeper-client/KeeperClient.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/../../programs/keeper-client/Commands.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/../../programs/keeper-client/Parser.cpp
+
+            ${CMAKE_CURRENT_SOURCE_DIR}/../../src/Client/LineReader.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/../../src/Client/ReplxxLineReader.cpp
+        )
+    endif()
+
    clickhouse_add_executable(clickhouse-keeper ${CLICKHOUSE_KEEPER_STANDALONE_SOURCES})

    # Remove some redundant dependencies
@ -122,6 +134,10 @@ if (BUILD_STANDALONE_KEEPER)
    target_include_directories(clickhouse-keeper PUBLIC "${CMAKE_CURRENT_BINARY_DIR}/../../src/Core/include") # uses some includes from core
    target_include_directories(clickhouse-keeper PUBLIC "${CMAKE_CURRENT_BINARY_DIR}/../../src") # uses some includes from common

+    if (ENABLE_CLICKHOUSE_KEEPER_CLIENT AND TARGET ch_rust::skim)
+        target_link_libraries(clickhouse-keeper PRIVATE ch_rust::skim)
+    endif()
+
    target_link_libraries(clickhouse-keeper
        PRIVATE
            ch_contrib::abseil_swiss_tables
--- a/programs/keeper/Keeper.cpp
+++ b/programs/keeper/Keeper.cpp
@ -34,6 +34,8 @@
 #include "Core/Defines.h"
 #include "config.h"
 #include "config_version.h"
+#include "config_tools.h"
+

 #if USE_SSL
 #    include <Poco/Net/Context.h>
@ -131,7 +133,10 @@ int Keeper::run()
    if (config().hasOption("help"))
    {
        Poco::Util::HelpFormatter help_formatter(Keeper::options());
-        auto header_str = fmt::format("{} [OPTION] [-- [ARG]...]\n"
+        auto header_str = fmt::format("{0} [OPTION] [-- [ARG]...]\n"
+#if ENABLE_CLICKHOUSE_KEEPER_CLIENT
+                                      "{0} client [OPTION]\n"
+#endif
                                      "positional arguments can be used to rewrite config.xml properties, for example, --http_port=8010",
                                      commandName());
        help_formatter.setHeader(header_str);
--- a/programs/keeper/clickhouse-keeper.cpp
+++ b/programs/keeper/clickhouse-keeper.cpp
@ -1,6 +1,30 @@
+#include <Common/StringUtils/StringUtils.h>
+#include "config_tools.h"
+
+
 int mainEntryClickHouseKeeper(int argc, char ** argv);

+#if ENABLE_CLICKHOUSE_KEEPER_CLIENT
+int mainEntryClickHouseKeeperClient(int argc, char ** argv);
+#endif
+
 int main(int argc_, char ** argv_)
 {
+#if ENABLE_CLICKHOUSE_KEEPER_CLIENT
+
+    if (argc_ >= 2)
+    {
+        /// 'clickhouse-keeper --client ...' and 'clickhouse-keeper client ...' are OK
+        if (strcmp(argv_[1], "--client") == 0 || strcmp(argv_[1], "client") == 0)
+        {
+            argv_[1] = argv_[0];
+            return mainEntryClickHouseKeeperClient(--argc_, argv_ + 1);
+        }
+    }
+
+    if (argc_ > 0 && (strcmp(argv_[0], "clickhouse-keeper-client") == 0 || endsWith(argv_[0], "/clickhouse-keeper-client")))
+        return mainEntryClickHouseKeeperClient(argc_, argv_);
+#endif
+
    return mainEntryClickHouseKeeper(argc_, argv_);
 }
--- a/src/Backups/BackupCoordinationStageSync.cpp
+++ b/src/Backups/BackupCoordinationStageSync.cpp
@ -85,6 +85,9 @@ void BackupCoordinationStageSync::setError(const String & current_host, const Ex
        writeException(exception, buf, true);
        zookeeper->createIfNotExists(zookeeper_path + "/error", buf.str());

+        /// When backup/restore fails, it removes the nodes from Zookeeper.
+        /// Sometimes it fails to remove all nodes. It's possible that it removes /error node, but fails to remove /stage node,
+        /// so the following line tries to preserve the error status.
        auto code = zookeeper->trySet(zookeeper_path, Stage::ERROR);
        if (code != Coordination::Error::ZOK)
            throw zkutil::KeeperException(code, zookeeper_path);
--- a/src/Backups/BackupsWorker.cpp
+++ b/src/Backups/BackupsWorker.cpp
@ -152,8 +152,7 @@ namespace
        }
        catch (...)
        {
-            if (coordination)
-                coordination->setError(Exception(getCurrentExceptionMessageAndPattern(true, true), getCurrentExceptionCode()));
+            sendExceptionToCoordination(coordination, Exception(getCurrentExceptionMessageAndPattern(true, true), getCurrentExceptionCode()));
        }
    }

--- a/src/Columns/ColumnArray.h
+++ b/src/Columns/ColumnArray.h
@ -151,13 +151,13 @@ public:

    ColumnPtr compress() const override;

-    void forEachSubcolumn(ColumnCallback callback) const override
+    void forEachSubcolumn(MutableColumnCallback callback) override
    {
        callback(offsets);
        callback(data);
    }

-    void forEachSubcolumnRecursively(RecursiveColumnCallback callback) const override
+    void forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback) override
    {
        callback(*offsets);
        offsets->forEachSubcolumnRecursively(callback);
--- a/src/Columns/ColumnLowCardinality.h
+++ b/src/Columns/ColumnLowCardinality.h
@ -166,7 +166,7 @@ public:
    size_t byteSizeAt(size_t n) const override { return getDictionary().byteSizeAt(getIndexes().getUInt(n)); }
    size_t allocatedBytes() const override { return idx.getPositions()->allocatedBytes() + getDictionary().allocatedBytes(); }

-    void forEachSubcolumn(ColumnCallback callback) const override
+    void forEachSubcolumn(MutableColumnCallback callback) override
    {
        callback(idx.getPositionsPtr());

@ -175,7 +175,7 @@ public:
            callback(dictionary.getColumnUniquePtr());
    }

-    void forEachSubcolumnRecursively(RecursiveColumnCallback callback) const override
+    void forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback) override
    {
        callback(*idx.getPositionsPtr());
        idx.getPositionsPtr()->forEachSubcolumnRecursively(callback);
@ -340,7 +340,7 @@ private:
        explicit Dictionary(MutableColumnPtr && column_unique, bool is_shared);
        explicit Dictionary(ColumnPtr column_unique, bool is_shared);

-        const ColumnPtr & getColumnUniquePtr() const { return column_unique; }
+        const WrappedPtr & getColumnUniquePtr() const { return column_unique; }
        WrappedPtr & getColumnUniquePtr() { return column_unique; }

        const IColumnUnique & getColumnUnique() const { return static_cast<const IColumnUnique &>(*column_unique); }
--- a/src/Columns/ColumnMap.cpp
+++ b/src/Columns/ColumnMap.cpp
@ -273,12 +273,12 @@ void ColumnMap::getExtremes(Field & min, Field & max) const
    max = std::move(map_max_value);
 }

-void ColumnMap::forEachSubcolumn(ColumnCallback callback) const
+void ColumnMap::forEachSubcolumn(MutableColumnCallback callback)
 {
    callback(nested);
 }

-void ColumnMap::forEachSubcolumnRecursively(RecursiveColumnCallback callback) const
+void ColumnMap::forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback)
 {
    callback(*nested);
    nested->forEachSubcolumnRecursively(callback);
--- a/src/Columns/ColumnMap.h
+++ b/src/Columns/ColumnMap.h
@ -88,8 +88,8 @@ public:
    size_t byteSizeAt(size_t n) const override;
    size_t allocatedBytes() const override;
    void protect() override;
-    void forEachSubcolumn(ColumnCallback callback) const override;
-    void forEachSubcolumnRecursively(RecursiveColumnCallback callback) const override;
+    void forEachSubcolumn(MutableColumnCallback callback) override;
+    void forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback) override;
    bool structureEquals(const IColumn & rhs) const override;
    double getRatioOfDefaultRows(double sample_ratio) const override;
    UInt64 getNumberOfDefaultRows() const override;
--- a/src/Columns/ColumnNullable.h
+++ b/src/Columns/ColumnNullable.h
@ -130,13 +130,13 @@ public:

    ColumnPtr compress() const override;

-    void forEachSubcolumn(ColumnCallback callback) const override
+    void forEachSubcolumn(MutableColumnCallback callback) override
    {
        callback(nested_column);
        callback(null_map);
    }

-    void forEachSubcolumnRecursively(RecursiveColumnCallback callback) const override
+    void forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback) override
    {
        callback(*nested_column);
        nested_column->forEachSubcolumnRecursively(callback);
--- a/src/Columns/ColumnObject.cpp
+++ b/src/Columns/ColumnObject.cpp
@ -664,18 +664,18 @@ size_t ColumnObject::allocatedBytes() const
    return res;
 }

-void ColumnObject::forEachSubcolumn(ColumnCallback callback) const
+void ColumnObject::forEachSubcolumn(MutableColumnCallback callback)
 {
-    for (const auto & entry : subcolumns)
-        for (const auto & part : entry->data.data)
+    for (auto & entry : subcolumns)
+        for (auto & part : entry->data.data)
            callback(part);
 }

-void ColumnObject::forEachSubcolumnRecursively(RecursiveColumnCallback callback) const
+void ColumnObject::forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback)
 {
-    for (const auto & entry : subcolumns)
+    for (auto & entry : subcolumns)
    {
-        for (const auto & part : entry->data.data)
+        for (auto & part : entry->data.data)
        {
            callback(*part);
            part->forEachSubcolumnRecursively(callback);
--- a/src/Columns/ColumnObject.h
+++ b/src/Columns/ColumnObject.h
@ -206,8 +206,8 @@ public:
    size_t size() const override;
    size_t byteSize() const override;
    size_t allocatedBytes() const override;
-    void forEachSubcolumn(ColumnCallback callback) const override;
-    void forEachSubcolumnRecursively(RecursiveColumnCallback callback) const override;
+    void forEachSubcolumn(MutableColumnCallback callback) override;
+    void forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback) override;
    void insert(const Field & field) override;
    void insertDefault() override;
    void insertFrom(const IColumn & src, size_t n) override;
--- a/src/Columns/ColumnSparse.cpp
+++ b/src/Columns/ColumnSparse.cpp
@ -751,13 +751,13 @@ bool ColumnSparse::structureEquals(const IColumn & rhs) const
    return false;
 }

-void ColumnSparse::forEachSubcolumn(ColumnCallback callback) const
+void ColumnSparse::forEachSubcolumn(MutableColumnCallback callback)
 {
    callback(values);
    callback(offsets);
 }

-void ColumnSparse::forEachSubcolumnRecursively(RecursiveColumnCallback callback) const
+void ColumnSparse::forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback)
 {
    callback(*values);
    values->forEachSubcolumnRecursively(callback);
--- a/src/Columns/ColumnSparse.h
+++ b/src/Columns/ColumnSparse.h
@ -140,8 +140,8 @@ public:

    ColumnPtr compress() const override;

-    void forEachSubcolumn(ColumnCallback callback) const override;
-    void forEachSubcolumnRecursively(RecursiveColumnCallback callback) const override;
+    void forEachSubcolumn(MutableColumnCallback callback) override;
+    void forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback) override;

    bool structureEquals(const IColumn & rhs) const override;

--- a/src/Columns/ColumnString.cpp
+++ b/src/Columns/ColumnString.cpp
@ -31,14 +31,12 @@ ColumnString::ColumnString(const ColumnString & src)
    offsets(src.offsets.begin(), src.offsets.end()),
    chars(src.chars.begin(), src.chars.end())
 {
-    if (!offsets.empty())
-    {
-        Offset last_offset = offsets.back();
-
-        /// This will also prevent possible overflow in offset.
-        if (chars.size() != last_offset)
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "String offsets has data inconsistent with chars array");
-    }
+    Offset last_offset = offsets.empty() ? 0 : offsets.back();
+    /// This will also prevent possible overflow in offset.
+    if (last_offset != chars.size())
+        throw Exception(ErrorCodes::LOGICAL_ERROR,
+            "String offsets has data inconsistent with chars array. Last offset: {}, array length: {}",
+            last_offset, chars.size());
 }


@ -157,6 +155,7 @@ ColumnPtr ColumnString::filter(const Filter & filt, ssize_t result_size_hint) co
    Offsets & res_offsets = res->offsets;

    filterArraysImpl<UInt8>(chars, offsets, res_chars, res_offsets, filt, result_size_hint);
+
    return res;
 }

@ -571,10 +570,11 @@ void ColumnString::protect()

 void ColumnString::validate() const
 {
-    if (!offsets.empty() && offsets.back() != chars.size())
+    Offset last_offset = offsets.empty() ? 0 : offsets.back();
+    if (last_offset != chars.size())
        throw Exception(ErrorCodes::LOGICAL_ERROR,
                        "ColumnString validation failed: size mismatch (internal logical error) {} != {}",
-                        offsets.back(), chars.size());
+                        last_offset, chars.size());
 }

 }
--- a/src/Columns/ColumnTuple.cpp
+++ b/src/Columns/ColumnTuple.cpp
@ -495,15 +495,15 @@ void ColumnTuple::getExtremes(Field & min, Field & max) const
    max = max_tuple;
 }

-void ColumnTuple::forEachSubcolumn(ColumnCallback callback) const
+void ColumnTuple::forEachSubcolumn(MutableColumnCallback callback)
 {
-    for (const auto & column : columns)
+    for (auto & column : columns)
        callback(column);
 }

-void ColumnTuple::forEachSubcolumnRecursively(RecursiveColumnCallback callback) const
+void ColumnTuple::forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback)
 {
-    for (const auto & column : columns)
+    for (auto & column : columns)
    {
        callback(*column);
        column->forEachSubcolumnRecursively(callback);
--- a/src/Columns/ColumnTuple.h
+++ b/src/Columns/ColumnTuple.h
@ -96,8 +96,8 @@ public:
    size_t byteSizeAt(size_t n) const override;
    size_t allocatedBytes() const override;
    void protect() override;
-    void forEachSubcolumn(ColumnCallback callback) const override;
-    void forEachSubcolumnRecursively(RecursiveColumnCallback callback) const override;
+    void forEachSubcolumn(MutableColumnCallback callback) override;
+    void forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback) override;
    bool structureEquals(const IColumn & rhs) const override;
    bool isCollationSupported() const override;
    ColumnPtr compress() const override;
--- a/src/Columns/IColumn.cpp
+++ b/src/Columns/IColumn.cpp
@ -62,19 +62,19 @@ ColumnPtr IColumn::createWithOffsets(const Offsets & offsets, const Field & defa
    return res;
 }

-void IColumn::forEachSubcolumn(MutableColumnCallback callback)
+void IColumn::forEachSubcolumn(ColumnCallback callback) const
 {
-    std::as_const(*this).forEachSubcolumn([&callback](const WrappedPtr & subcolumn)
+    const_cast<IColumn*>(this)->forEachSubcolumn([&callback](WrappedPtr & subcolumn)
    {
-        callback(const_cast<WrappedPtr &>(subcolumn));
+        callback(std::as_const(subcolumn));
    });
 }

-void IColumn::forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback)
+void IColumn::forEachSubcolumnRecursively(RecursiveColumnCallback callback) const
 {
-    std::as_const(*this).forEachSubcolumnRecursively([&callback](const IColumn & subcolumn)
+    const_cast<IColumn*>(this)->forEachSubcolumnRecursively([&callback](IColumn & subcolumn)
    {
-        callback(const_cast<IColumn &>(subcolumn));
+        callback(std::as_const(subcolumn));
    });
 }

--- a/src/Columns/IColumn.h
+++ b/src/Columns/IColumn.h
@ -418,21 +418,23 @@ public:
    /// If the column contains subcolumns (such as Array, Nullable, etc), do callback on them.
    /// Shallow: doesn't do recursive calls; don't do call for itself.

-    using ColumnCallback = std::function<void(const WrappedPtr &)>;
-    virtual void forEachSubcolumn(ColumnCallback) const {}
-
    using MutableColumnCallback = std::function<void(WrappedPtr &)>;
-    virtual void forEachSubcolumn(MutableColumnCallback callback);
+    virtual void forEachSubcolumn(MutableColumnCallback) {}
+
+    /// Default implementation calls the mutable overload using const_cast.
+    using ColumnCallback = std::function<void(const WrappedPtr &)>;
+    virtual void forEachSubcolumn(ColumnCallback) const;

    /// Similar to forEachSubcolumn but it also do recursive calls.
    /// In recursive calls it's prohibited to replace pointers
    /// to subcolumns, so we use another callback function.

-    using RecursiveColumnCallback = std::function<void(const IColumn &)>;
-    virtual void forEachSubcolumnRecursively(RecursiveColumnCallback) const {}
-
    using RecursiveMutableColumnCallback = std::function<void(IColumn &)>;
-    virtual void forEachSubcolumnRecursively(RecursiveMutableColumnCallback callback);
+    virtual void forEachSubcolumnRecursively(RecursiveMutableColumnCallback) {}
+
+    /// Default implementation calls the mutable overload using const_cast.
+    using RecursiveColumnCallback = std::function<void(const IColumn &)>;
+    virtual void forEachSubcolumnRecursively(RecursiveColumnCallback) const;

    /// Columns have equal structure.
    /// If true - you can use "compareAt", "insertFrom", etc. methods.
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@ -96,6 +96,7 @@ class IColumn;
    M(Bool, s3_truncate_on_insert, false, "Enables or disables truncate before insert in s3 engine tables.", 0) \
    M(Bool, azure_truncate_on_insert, false, "Enables or disables truncate before insert in azure engine tables.", 0) \
    M(Bool, s3_create_new_file_on_insert, false, "Enables or disables creating a new file on each insert in s3 engine tables", 0) \
+    M(Bool, s3_skip_empty_files, false, "Allow to skip empty files in s3 table engine", 0) \
    M(Bool, azure_create_new_file_on_insert, false, "Enables or disables creating a new file on each insert in azure engine tables", 0) \
    M(Bool, s3_check_objects_after_upload, false, "Check each uploaded object to s3 with head request to be sure that upload was successful", 0) \
    M(Bool, s3_allow_parallel_part_upload, true, "Use multiple threads for s3 multipart upload. It may lead to slightly higher memory usage", 0) \
@ -105,6 +106,7 @@ class IColumn;
    M(UInt64, hdfs_replication, 0, "The actual number of replications can be specified when the hdfs file is created.", 0) \
    M(Bool, hdfs_truncate_on_insert, false, "Enables or disables truncate before insert in s3 engine tables", 0) \
    M(Bool, hdfs_create_new_file_on_insert, false, "Enables or disables creating a new file on each insert in hdfs engine tables", 0) \
+    M(Bool, hdfs_skip_empty_files, false, "Allow to skip empty files in hdfs table engine", 0) \
    M(UInt64, hsts_max_age, 0, "Expired time for hsts. 0 means disable HSTS.", 0) \
    M(Bool, extremes, false, "Calculate minimums and maximums of the result columns. They can be output in JSON-formats.", IMPORTANT) \
    M(Bool, use_uncompressed_cache, false, "Whether to use the cache of uncompressed blocks.", 0) \
@ -612,6 +614,8 @@ class IColumn;
    M(Bool, engine_file_empty_if_not_exists, false, "Allows to select data from a file engine table without file", 0) \
    M(Bool, engine_file_truncate_on_insert, false, "Enables or disables truncate before insert in file engine tables", 0) \
    M(Bool, engine_file_allow_create_multiple_files, false, "Enables or disables creating a new file on each insert in file engine tables if format has suffix.", 0) \
+    M(Bool, engine_file_skip_empty_files, false, "Allows to skip empty files in file table engine", 0) \
+    M(Bool, engine_url_skip_empty_files, false, "Allows to skip empty files in url table engine", 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(Bool, database_replicated_enforce_synchronous_settings, false, "Enforces synchronous waiting for some queries (see also database_atomic_wait_for_drop_and_detach_synchronously, mutation_sync, alter_sync). Not recommended to enable these settings.", 0) \
@ -860,6 +864,7 @@ class IColumn;
    M(Bool, input_format_csv_use_best_effort_in_schema_inference, true, "Use some tweaks and heuristics to infer schema in CSV format", 0) \
    M(Bool, input_format_tsv_use_best_effort_in_schema_inference, true, "Use some tweaks and heuristics to infer schema in TSV format", 0) \
    M(Bool, input_format_csv_detect_header, true, "Automatically detect header with names and types in CSV format", 0) \
+    M(Bool, input_format_csv_allow_whitespace_or_tab_as_delimiter, false, "Allow to use spaces and tabs(\\t) as field delimiter in the CSV strings", 0) \
    M(Bool, input_format_csv_trim_whitespaces, true, "Trims spaces and tabs (\\t) characters at the beginning and end in CSV strings", 0) \
    M(Bool, input_format_tsv_detect_header, true, "Automatically detect header with names and types in TSV format", 0) \
    M(Bool, input_format_custom_detect_header, true, "Automatically detect header with names and types in CustomSeparated format", 0) \
--- a/src/DataTypes/Serializations/SerializationLowCardinality.cpp
+++ b/src/DataTypes/Serializations/SerializationLowCardinality.cpp
@ -300,49 +300,6 @@ namespace
        MutableColumnPtr additional_keys_map;
    };

-    template <typename T>
-    IndexMapsWithAdditionalKeys mapIndexWithAdditionalKeysRef(PaddedPODArray<T> & index, size_t dict_size)
-    {
-        PaddedPODArray<T> copy(index.cbegin(), index.cend());
-
-        HashMap<T, T> dict_map;
-        HashMap<T, T> add_keys_map;
-
-        for (auto val : index)
-        {
-            if (val < dict_size)
-                dict_map.insert({val, dict_map.size()});
-            else
-                add_keys_map.insert({val, add_keys_map.size()});
-        }
-
-        auto dictionary_map = ColumnVector<T>::create(dict_map.size());
-        auto additional_keys_map = ColumnVector<T>::create(add_keys_map.size());
-        auto & dict_data = dictionary_map->getData();
-        auto & add_keys_data = additional_keys_map->getData();
-
-        for (auto val : dict_map)
-            dict_data[val.second] = val.first;
-
-        for (auto val : add_keys_map)
-            add_keys_data[val.second] = val.first - dict_size;
-
-        for (auto & val : index)
-            val = val < dict_size ? dict_map[val]
-                                  : add_keys_map[val] + dict_map.size();
-
-        for (size_t i = 0; i < index.size(); ++i)
-        {
-            T expected = index[i] < dict_data.size() ? dict_data[index[i]]
-                                                     : add_keys_data[index[i] - dict_data.size()] + dict_size;
-            if (expected != copy[i])
-                throw Exception(ErrorCodes::LOGICAL_ERROR, "Expected {}, but got {}", toString(expected), toString(copy[i]));
-
-        }
-
-        return {std::move(dictionary_map), std::move(additional_keys_map)};
-    }
-
    template <typename T>
    IndexMapsWithAdditionalKeys mapIndexWithAdditionalKeys(PaddedPODArray<T> & index, size_t dict_size)
    {
--- a/src/Formats/FormatFactory.cpp
+++ b/src/Formats/FormatFactory.cpp
@ -71,6 +71,7 @@ FormatSettings getFormatSettings(ContextPtr context, const Settings & settings)
    format_settings.csv.try_detect_header = settings.input_format_csv_detect_header;
    format_settings.csv.skip_trailing_empty_lines = settings.input_format_csv_skip_trailing_empty_lines;
    format_settings.csv.trim_whitespaces = settings.input_format_csv_trim_whitespaces;
+    format_settings.csv.allow_whitespace_or_tab_as_delimiter = settings.input_format_csv_allow_whitespace_or_tab_as_delimiter;
    format_settings.hive_text.fields_delimiter = settings.input_format_hive_text_fields_delimiter;
    format_settings.hive_text.collection_items_delimiter = settings.input_format_hive_text_collection_items_delimiter;
    format_settings.hive_text.map_keys_delimiter = settings.input_format_hive_text_map_keys_delimiter;
--- a/src/Formats/FormatSettings.h
+++ b/src/Formats/FormatSettings.h
@ -139,6 +139,7 @@ struct FormatSettings
        bool try_detect_header = true;
        bool skip_trailing_empty_lines = false;
        bool trim_whitespaces = true;
+        bool allow_whitespace_or_tab_as_delimiter = false;
    } csv;

    struct HiveText
--- a/src/IO/FileEncryptionCommon.cpp
+++ b/src/IO/FileEncryptionCommon.cpp
@ -8,10 +8,11 @@
 #include <Common/SipHash.h>
 #include <Common/safe_cast.h>

-#include <boost/algorithm/string/predicate.hpp>
-#include <cassert>
-#include <random>
+#    include <cassert>
+#    include <boost/algorithm/string/predicate.hpp>

+#    include <openssl/err.h>
+#    include <openssl/rand.h>

 namespace DB
 {
@ -20,6 +21,7 @@ namespace ErrorCodes
 {
    extern const int BAD_ARGUMENTS;
    extern const int DATA_ENCRYPTION_ERROR;
+    extern const int OPENSSL_ERROR;
 }

 namespace FileEncryption
@ -260,12 +262,11 @@ void InitVector::write(WriteBuffer & out) const

 InitVector InitVector::random()
 {
-    std::random_device rd;
-    std::mt19937 gen{rd()};
-    std::uniform_int_distribution<UInt128::base_type> dis;
    UInt128 counter;
-    for (auto & i : counter.items)
-        i = dis(gen);
+    auto * buf = reinterpret_cast<unsigned char *>(counter.items);
+    auto ret = RAND_bytes(buf, sizeof(counter.items));
+    if (ret != 1)
+        throw Exception(DB::ErrorCodes::OPENSSL_ERROR, "OpenSSL error code: {}", ERR_get_error());
    return InitVector{counter};
 }

--- a/src/Processors/Formats/Impl/CSVRowInputFormat.cpp
+++ b/src/Processors/Formats/Impl/CSVRowInputFormat.cpp
@ -25,8 +25,12 @@ namespace ErrorCodes

 namespace
 {
-    void checkBadDelimiter(char delimiter)
+    void checkBadDelimiter(char delimiter, bool allow_whitespace_or_tab_as_delimiter)
    {
+        if ((delimiter == ' ' || delimiter == '\t') && allow_whitespace_or_tab_as_delimiter)
+        {
+            return;
+        }
        constexpr std::string_view bad_delimiters = " \t\"'.UL";
        if (bad_delimiters.find(delimiter) != std::string_view::npos)
            throw Exception(
@ -68,7 +72,7 @@ CSVRowInputFormat::CSVRowInputFormat(
        format_settings_.csv.try_detect_header),
    buf(std::move(in_))
 {
-    checkBadDelimiter(format_settings_.csv.delimiter);
+    checkBadDelimiter(format_settings_.csv.delimiter, format_settings_.csv.allow_whitespace_or_tab_as_delimiter);
 }

 CSVRowInputFormat::CSVRowInputFormat(
@ -90,7 +94,7 @@ CSVRowInputFormat::CSVRowInputFormat(
        format_settings_.csv.try_detect_header),
    buf(std::move(in_))
 {
-    checkBadDelimiter(format_settings_.csv.delimiter);
+    checkBadDelimiter(format_settings_.csv.delimiter, format_settings_.csv.allow_whitespace_or_tab_as_delimiter);
 }

 void CSVRowInputFormat::syncAfterError()
@ -134,8 +138,12 @@ static void skipEndOfLine(ReadBuffer & in)
 }

 /// Skip `whitespace` symbols allowed in CSV.
-static inline void skipWhitespacesAndTabs(ReadBuffer & in)
+static inline void skipWhitespacesAndTabs(ReadBuffer & in, const bool & allow_whitespace_or_tab_as_delimiter)
 {
+    if (allow_whitespace_or_tab_as_delimiter)
+    {
+        return;
+    }
    while (!in.eof() && (*in.position() == ' ' || *in.position() == '\t'))
        ++in.position();
 }
@ -146,7 +154,7 @@ CSVFormatReader::CSVFormatReader(PeekableReadBuffer & buf_, const FormatSettings

 void CSVFormatReader::skipFieldDelimiter()
 {
-    skipWhitespacesAndTabs(*buf);
+    skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);
    assertChar(format_settings.csv.delimiter, *buf);
 }

@ -154,7 +162,7 @@ template <bool read_string>
 String CSVFormatReader::readCSVFieldIntoString()
 {
    if (format_settings.csv.trim_whitespaces) [[likely]]
-        skipWhitespacesAndTabs(*buf);
+        skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);

    String field;
    if constexpr (read_string)
@ -166,14 +174,14 @@ String CSVFormatReader::readCSVFieldIntoString()

 void CSVFormatReader::skipField()
 {
-    skipWhitespacesAndTabs(*buf);
+    skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);
    NullOutput out;
    readCSVStringInto(out, *buf, format_settings.csv);
 }

 void CSVFormatReader::skipRowEndDelimiter()
 {
-    skipWhitespacesAndTabs(*buf);
+    skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);

    if (buf->eof())
        return;
@ -182,7 +190,7 @@ void CSVFormatReader::skipRowEndDelimiter()
    if (*buf->position() == format_settings.csv.delimiter)
        ++buf->position();

-    skipWhitespacesAndTabs(*buf);
+    skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);
    if (buf->eof())
        return;

@ -194,7 +202,7 @@ void CSVFormatReader::skipHeaderRow()
    do
    {
        skipField();
-        skipWhitespacesAndTabs(*buf);
+        skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);
    } while (checkChar(format_settings.csv.delimiter, *buf));

    skipRowEndDelimiter();
@ -207,7 +215,7 @@ std::vector<String> CSVFormatReader::readRowImpl()
    do
    {
        fields.push_back(readCSVFieldIntoString<is_header>());
-        skipWhitespacesAndTabs(*buf);
+        skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);
    } while (checkChar(format_settings.csv.delimiter, *buf));

    skipRowEndDelimiter();
@ -220,7 +228,7 @@ bool CSVFormatReader::parseFieldDelimiterWithDiagnosticInfo(WriteBuffer & out)

    try
    {
-        skipWhitespacesAndTabs(*buf);
+        skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);
        assertChar(delimiter, *buf);
    }
    catch (const DB::Exception &)
@ -246,7 +254,7 @@ bool CSVFormatReader::parseFieldDelimiterWithDiagnosticInfo(WriteBuffer & out)

 bool CSVFormatReader::parseRowEndWithDiagnosticInfo(WriteBuffer & out)
 {
-    skipWhitespacesAndTabs(*buf);
+    skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);

    if (buf->eof())
        return true;
@ -255,7 +263,7 @@ bool CSVFormatReader::parseRowEndWithDiagnosticInfo(WriteBuffer & out)
    if (*buf->position() == format_settings.csv.delimiter)
    {
        ++buf->position();
-        skipWhitespacesAndTabs(*buf);
+        skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);
        if (buf->eof())
            return true;
    }
@ -283,7 +291,7 @@ bool CSVFormatReader::readField(
    const String & /*column_name*/)
 {
    if (format_settings.csv.trim_whitespaces || !isStringOrFixedString(removeNullable(type))) [[likely]]
-        skipWhitespacesAndTabs(*buf);
+        skipWhitespacesAndTabs(*buf, format_settings.csv.allow_whitespace_or_tab_as_delimiter);

    const bool at_delimiter = !buf->eof() && *buf->position() == format_settings.csv.delimiter;
    const bool at_last_column_line_end = is_last_file_column && (buf->eof() || *buf->position() == '\n' || *buf->position() == '\r');
--- a/src/Storages/HDFS/StorageHDFS.cpp
+++ b/src/Storages/HDFS/StorageHDFS.cpp
@ -64,10 +64,9 @@ namespace ErrorCodes
 namespace
 {
    /// Forward-declared to use in LSWithFoldedRegexpMatching w/o circular dependency.
-    Strings LSWithRegexpMatching(const String & path_for_ls,
-                                 const HDFSFSPtr & fs,
-                                 const String & for_match,
-                                 std::unordered_map<String, time_t> * last_mod_times);
+    std::vector<StorageHDFS::PathWithInfo> LSWithRegexpMatching(const String & path_for_ls,
+                                                                const HDFSFSPtr & fs,
+                                                                const String & for_match);

    /*
     * When `{...}` has any `/`s, it must be processed in a different way:
@ -77,15 +76,14 @@ namespace
     * Instead, it goes many levels down (until the approximate max_depth is reached) and compares this multi-dir path to a glob.
     * StorageFile.cpp has the same logic.
    */
-    Strings LSWithFoldedRegexpMatching(const String & path_for_ls,
-                                       const HDFSFSPtr & fs,
-                                       std::unordered_map<String, time_t> * last_mod_times,
-                                       const String & processed_suffix,
-                                       const String & suffix_with_globs,
-                                       const String & current_glob,
-                                       re2::RE2 & matcher,
-                                       const size_t max_depth,
-                                       const size_t next_slash_after_glob_pos)
+    std::vector<StorageHDFS::PathWithInfo> LSWithFoldedRegexpMatching(const String & path_for_ls,
+        const HDFSFSPtr & fs,
+        const String & processed_suffix,
+        const String & suffix_with_globs,
+        const String & current_glob,
+        re2::RE2 & matcher,
+        const size_t max_depth,
+        const size_t next_slash_after_glob_pos)
    {
        /// We don't need to go all the way in every directory if max_depth is reached
        /// as it is upper limit of depth by simply counting `/`s in curly braces
@ -101,7 +99,8 @@ namespace
                ErrorCodes::ACCESS_DENIED, "Cannot list directory {}: {}", path_for_ls, String(hdfsGetLastError()));
        }

-        Strings result;
+        std::vector<StorageHDFS::PathWithInfo> result;
+
        if (!ls.file_info && ls.length > 0)
            throw Exception(ErrorCodes::LOGICAL_ERROR, "file_info shouldn't be null");

@ -116,22 +115,25 @@ namespace
            {
                if (next_slash_after_glob_pos == std::string::npos)
                {
-                    result.push_back(String(ls.file_info[i].mName));
-                    if (last_mod_times)
-                        (*last_mod_times)[result.back()] = ls.file_info[i].mLastMod;
+//                    result.push_back(String(ls.file_info[i].mName));
+//                    if (last_mod_times)
+//                        (*last_mod_times)[result.back()] = ls.file_info[i].mLastMod;
+                    result.emplace_back(
+                        String(ls.file_info[i].mName),
+                        StorageHDFS::PathInfo{ls.file_info[i].mLastMod, static_cast<size_t>(ls.file_info[i].mSize)});
                }
                else
                {
-                    Strings result_part = LSWithRegexpMatching(fs::path(full_path) / "" , fs,
-                                                suffix_with_globs.substr(next_slash_after_glob_pos), last_mod_times);
+                    std::vector<StorageHDFS::PathWithInfo> result_part = LSWithRegexpMatching(
+                        fs::path(full_path) / "" , fs, suffix_with_globs.substr(next_slash_after_glob_pos));
                    std::move(result_part.begin(), result_part.end(), std::back_inserter(result));
                }
            }
            else if (is_directory)
            {
-                Strings result_part = LSWithFoldedRegexpMatching(fs::path(full_path),
-                                           fs, last_mod_times, processed_suffix + dir_or_file_name, suffix_with_globs, current_glob, matcher,
-                                                      max_depth - 1, next_slash_after_glob_pos);
+                std::vector<StorageHDFS::PathWithInfo> result_part = LSWithFoldedRegexpMatching(
+                    fs::path(full_path), fs, processed_suffix + dir_or_file_name,
+                    suffix_with_globs, current_glob, matcher, max_depth - 1, next_slash_after_glob_pos);
                std::move(result_part.begin(), result_part.end(), std::back_inserter(result));
            }
        }
@ -141,10 +143,17 @@ namespace
    /* Recursive directory listing with matched paths as a result.
     * Have the same method in StorageFile.
     */
-    Strings LSWithRegexpMatching(const String & path_for_ls,
-                                 const HDFSFSPtr & fs,
-                                 const String & for_match,
-                                 std::unordered_map<String, time_t> * last_mod_times)
+//<<<<<<< HEAD
+//    Strings LSWithRegexpMatching(const String & path_for_ls,
+//                                 const HDFSFSPtr & fs,
+//                                 const String & for_match,
+//                                 std::unordered_map<String, time_t> * last_mod_times)
+//=======
+    std::vector<StorageHDFS::PathWithInfo> LSWithRegexpMatching(
+        const String & path_for_ls,
+        const HDFSFSPtr & fs,
+        const String & for_match)
+//>>>>>>> 10d597676c81cb25da8e0b4bea2f4ed9a0c650d8
    {
        const size_t first_glob_pos = for_match.find_first_of("*?{");
        const bool has_glob = first_glob_pos != std::string::npos;
@ -186,9 +195,8 @@ namespace

        if (slashes_in_glob)
        {
-            return LSWithFoldedRegexpMatching(fs::path(prefix_without_globs), fs, last_mod_times,
-                                              "", suffix_with_globs, current_glob, matcher,
-                                              slashes_in_glob, next_slash_after_glob_pos);
+            return LSWithFoldedRegexpMatching(fs::path(prefix_without_globs), fs, "", suffix_with_globs, current_glob,
+                                              matcher, slashes_in_glob, next_slash_after_glob_pos);
        }

        HDFSFileInfo ls;
@ -199,7 +207,7 @@ namespace
            throw Exception(
                ErrorCodes::ACCESS_DENIED, "Cannot list directory {}: {}", prefix_without_globs, String(hdfsGetLastError()));
        }
-        Strings result;
+        std::vector<StorageHDFS::PathWithInfo> result;
        if (!ls.file_info && ls.length > 0)
            throw Exception(ErrorCodes::LOGICAL_ERROR, "file_info shouldn't be null");
        for (int i = 0; i < ls.length; ++i)
@ -213,17 +221,19 @@ namespace
            if (!is_directory && !looking_for_directory)
            {
                if (re2::RE2::FullMatch(file_name, matcher))
-                {
-                    result.push_back(String(ls.file_info[i].mName));
-                    if (last_mod_times)
-                        (*last_mod_times)[result.back()] = ls.file_info[i].mLastMod;
-                }
+                    result.emplace_back(
+                        String(ls.file_info[i].mName),
+                        StorageHDFS::PathInfo{ls.file_info[i].mLastMod, static_cast<size_t>(ls.file_info[i].mSize)});
            }
            else if (is_directory && looking_for_directory)
            {
                if (re2::RE2::FullMatch(file_name, matcher))
                {
-                    Strings result_part = LSWithRegexpMatching(fs::path(full_path) / "", fs, suffix_with_globs.substr(next_slash_after_glob_pos), last_mod_times);
+//<<<<<<< HEAD
+//                    Strings result_part = LSWithRegexpMatching(fs::path(full_path) / "", fs, suffix_with_globs.substr(next_slash_after_glob_pos), last_mod_times);
+//=======
+                    std::vector<StorageHDFS::PathWithInfo> result_part = LSWithRegexpMatching(fs::path(full_path) / "", fs, suffix_with_globs.substr(next_slash_after_glob_pos));
+//>>>>>>> 10d597676c81cb25da8e0b4bea2f4ed9a0c650d8
                    /// Recursion depth is limited by pattern. '*' works only for depth = 1, for depth = 2 pattern path is '*/*'. So we do not need additional check.
                    std::move(result_part.begin(), result_part.end(), std::back_inserter(result));
                }
@ -246,12 +256,12 @@ namespace
        throw Exception(ErrorCodes::BAD_ARGUMENTS, "Storage HDFS requires valid URL to be set");
    }

-    std::vector<String> getPathsList(const String & path_from_uri, const String & uri_without_path, ContextPtr context, std::unordered_map<String, time_t> * last_mod_times = nullptr)
+    std::vector<StorageHDFS::PathWithInfo> getPathsList(const String & path_from_uri, const String & uri_without_path, ContextPtr context)
    {
        HDFSBuilderWrapper builder = createHDFSBuilder(uri_without_path + "/", context->getGlobalContext()->getConfigRef());
        HDFSFSPtr fs = createHDFSFS(builder.get());

-        return LSWithRegexpMatching("/", fs, path_from_uri, last_mod_times);
+        return LSWithRegexpMatching("/", fs, path_from_uri);
    }
 }

@ -310,9 +320,8 @@ ColumnsDescription StorageHDFS::getTableStructureFromData(
    ContextPtr ctx)
 {
    const auto [path_from_uri, uri_without_path] = getPathFromUriAndUriWithoutPath(uri);
-    std::unordered_map<String, time_t> last_mod_time;
-    auto paths = getPathsList(path_from_uri, uri, ctx, &last_mod_time);
-    if (paths.empty() && !FormatFactory::instance().checkIfFormatHasExternalSchemaReader(format))
+    auto paths_with_info = getPathsList(path_from_uri, uri, ctx);
+    if (paths_with_info.empty() && !FormatFactory::instance().checkIfFormatHasExternalSchemaReader(format))
        throw Exception(
            ErrorCodes::CANNOT_EXTRACT_TABLE_STRUCTURE,
            "Cannot extract table structure from {} format file, because there are no files in HDFS with provided path."
@ -320,26 +329,47 @@ ColumnsDescription StorageHDFS::getTableStructureFromData(

    std::optional<ColumnsDescription> columns_from_cache;
    if (ctx->getSettingsRef().schema_inference_use_cache_for_hdfs)
-        columns_from_cache = tryGetColumnsFromCache(paths, path_from_uri, last_mod_time, format, ctx);
+        columns_from_cache = tryGetColumnsFromCache(paths_with_info, path_from_uri, format, ctx);

-    ReadBufferIterator read_buffer_iterator = [&, my_uri_without_path = uri_without_path, it = paths.begin()](ColumnsDescription &) mutable -> std::unique_ptr<ReadBuffer>
+    ReadBufferIterator read_buffer_iterator
+        = [&, my_uri_without_path = uri_without_path, it = paths_with_info.begin(), first = true](
+              ColumnsDescription &) mutable -> std::unique_ptr<ReadBuffer>
    {
-        if (it == paths.end())
-            return nullptr;
-        auto compression = chooseCompressionMethod(*it, compression_method);
-        auto impl = std::make_unique<ReadBufferFromHDFS>(my_uri_without_path, *it++, ctx->getGlobalContext()->getConfigRef(), ctx->getReadSettings());
-        const Int64 zstd_window_log_max = ctx->getSettingsRef().zstd_window_log_max;
-        return wrapReadBufferWithCompressionMethod(std::move(impl), compression, static_cast<int>(zstd_window_log_max));
+        PathWithInfo path_with_info;
+        while (true)
+        {
+            if (it == paths_with_info.end())
+            {
+                if (first)
+                    throw Exception(ErrorCodes::CANNOT_EXTRACT_TABLE_STRUCTURE,
+                                    "Cannot extract table structure from {} format file, because all files are empty. "
+                                    "You must specify table structure manually", format);
+                return nullptr;
+            }
+
+            path_with_info = *it++;
+            if (ctx->getSettingsRef().hdfs_skip_empty_files && path_with_info.info && path_with_info.info->size == 0)
+                continue;
+
+            auto compression = chooseCompressionMethod(path_with_info.path, compression_method);
+            auto impl = std::make_unique<ReadBufferFromHDFS>(my_uri_without_path, path_with_info.path, ctx->getGlobalContext()->getConfigRef(), ctx->getReadSettings());
+            if (!ctx->getSettingsRef().hdfs_skip_empty_files || !impl->eof())
+            {
+                const Int64 zstd_window_log_max = ctx->getSettingsRef().zstd_window_log_max;
+                first = false;
+                return wrapReadBufferWithCompressionMethod(std::move(impl), compression, static_cast<int>(zstd_window_log_max));
+            }
+        }
    };

    ColumnsDescription columns;
    if (columns_from_cache)
        columns = *columns_from_cache;
    else
-        columns = readSchemaFromFormat(format, std::nullopt, read_buffer_iterator, paths.size() > 1, ctx);
+        columns = readSchemaFromFormat(format, std::nullopt, read_buffer_iterator, paths_with_info.size() > 1, ctx);

    if (ctx->getSettingsRef().schema_inference_use_cache_for_hdfs)
-        addColumnsToCache(paths, path_from_uri, columns, format, ctx);
+        addColumnsToCache(paths_with_info, path_from_uri, columns, format, ctx);

    return columns;
 }
@ -352,11 +382,11 @@ public:
        const auto [path_from_uri, uri_without_path] = getPathFromUriAndUriWithoutPath(uri);
        uris = getPathsList(path_from_uri, uri_without_path, context_);
        for (auto & elem : uris)
-            elem = uri_without_path + elem;
+            elem.path = uri_without_path + elem.path;
        uris_iter = uris.begin();
    }

-    String next()
+    StorageHDFS::PathWithInfo next()
    {
        std::lock_guard lock(mutex);
        if (uris_iter != uris.end())
@ -369,8 +399,8 @@ public:
    }
 private:
    std::mutex mutex;
-    Strings uris;
-    Strings::iterator uris_iter;
+    std::vector<StorageHDFS::PathWithInfo> uris;
+    std::vector<StorageHDFS::PathWithInfo>::iterator uris_iter;
 };

 class HDFSSource::URISIterator::Impl
@ -390,14 +420,14 @@ public:
        uris_iter = uris.begin();
    }

-    String next()
+    StorageHDFS::PathWithInfo next()
    {
        std::lock_guard lock(mutex);
        if (uris_iter == uris.end())
-            return "";
+            return {"", {}};
        auto key = *uris_iter;
        ++uris_iter;
-        return key;
+        return {key, {}};
    }

 private:
@ -409,7 +439,7 @@ private:
 HDFSSource::DisclosedGlobIterator::DisclosedGlobIterator(ContextPtr context_, const String & uri)
    : pimpl(std::make_shared<HDFSSource::DisclosedGlobIterator::Impl>(context_, uri)) {}

-String HDFSSource::DisclosedGlobIterator::next()
+StorageHDFS::PathWithInfo HDFSSource::DisclosedGlobIterator::next()
 {
    return pimpl->next();
 }
@ -419,7 +449,7 @@ HDFSSource::URISIterator::URISIterator(const std::vector<String> & uris_, Contex
 {
 }

-String HDFSSource::URISIterator::next()
+StorageHDFS::PathWithInfo HDFSSource::URISIterator::next()
 {
    return pimpl->next();
 }
@ -454,17 +484,29 @@ HDFSSource::HDFSSource(

 bool HDFSSource::initialize()
 {
-    current_path = (*file_iterator)();
-    if (current_path.empty())
-        return false;
+    bool skip_empty_files = getContext()->getSettingsRef().hdfs_skip_empty_files;
+    while (true)
+    {
+        auto path_with_info = (*file_iterator)();
+        if (path_with_info.path.empty())
+            return false;

-    const auto [path_from_uri, uri_without_path] = getPathFromUriAndUriWithoutPath(current_path);
+        if (path_with_info.info && skip_empty_files && path_with_info.info->size == 0)
+            continue;

-    auto compression = chooseCompressionMethod(path_from_uri, storage->compression_method);
-    auto impl = std::make_unique<ReadBufferFromHDFS>(
-        uri_without_path, path_from_uri, getContext()->getGlobalContext()->getConfigRef(), getContext()->getReadSettings());
-    const Int64 zstd_window_log_max = getContext()->getSettingsRef().zstd_window_log_max;
-    read_buf = wrapReadBufferWithCompressionMethod(std::move(impl), compression, static_cast<int>(zstd_window_log_max));
+        current_path = path_with_info.path;
+        const auto [path_from_uri, uri_without_path] = getPathFromUriAndUriWithoutPath(current_path);
+
+        auto compression = chooseCompressionMethod(path_from_uri, storage->compression_method);
+        auto impl = std::make_unique<ReadBufferFromHDFS>(
+            uri_without_path, path_from_uri, getContext()->getGlobalContext()->getConfigRef(), getContext()->getReadSettings());
+        if (!skip_empty_files || !impl->eof())
+        {
+            const Int64 zstd_window_log_max = getContext()->getSettingsRef().zstd_window_log_max;
+            read_buf = wrapReadBufferWithCompressionMethod(std::move(impl), compression, static_cast<int>(zstd_window_log_max));
+            break;
+        }
+    }

    auto input_format = getContext()->getInputFormat(storage->format_name, *read_buf, block_for_format, max_block_size);

@ -665,8 +707,8 @@ Pipe StorageHDFS::read(
    if (distributed_processing)
    {
        iterator_wrapper = std::make_shared<HDFSSource::IteratorWrapper>(
-            [callback = context_->getReadTaskCallback()]() -> String {
-                return callback();
+            [callback = context_->getReadTaskCallback()]() -> StorageHDFS::PathWithInfo {
+                return StorageHDFS::PathWithInfo{callback(), std::nullopt};
        });
    }
    else if (is_path_with_globs)
@ -873,24 +915,22 @@ SchemaCache & StorageHDFS::getSchemaCache(const ContextPtr & ctx)
 }

 std::optional<ColumnsDescription> StorageHDFS::tryGetColumnsFromCache(
-    const Strings & paths,
+    const std::vector<StorageHDFS::PathWithInfo> & paths_with_info,
    const String & uri_without_path,
-    std::unordered_map<String, time_t> & last_mod_time,
    const String & format_name,
    const ContextPtr & ctx)
 {
    auto & schema_cache = getSchemaCache(ctx);
-    for (const auto & path : paths)
+    for (const auto & path_with_info : paths_with_info)
    {
        auto get_last_mod_time = [&]() -> std::optional<time_t>
        {
-            auto it = last_mod_time.find(path);
-            if (it == last_mod_time.end())
-                return std::nullopt;
-            return it->second;
+            if (path_with_info.info)
+                return path_with_info.info->last_mod_time;
+            return std::nullopt;
        };

-        String url = fs::path(uri_without_path) / path;
+        String url = fs::path(uri_without_path) / path_with_info.path;
        auto cache_key = getKeyForSchemaCache(url, format_name, {}, ctx);
        auto columns = schema_cache.tryGet(cache_key, get_last_mod_time);
        if (columns)
@ -901,7 +941,7 @@ std::optional<ColumnsDescription> StorageHDFS::tryGetColumnsFromCache(
 }

 void StorageHDFS::addColumnsToCache(
-    const Strings & paths,
+    const std::vector<StorageHDFS::PathWithInfo> & paths_with_info,
    const String & uri_without_path,
    const ColumnsDescription & columns,
    const String & format_name,
@ -909,8 +949,8 @@ void StorageHDFS::addColumnsToCache(
 {
    auto & schema_cache = getSchemaCache(ctx);
    Strings sources;
-    sources.reserve(paths.size());
-    std::transform(paths.begin(), paths.end(), std::back_inserter(sources), [&](const String & path){ return fs::path(uri_without_path) / path; });
+    sources.reserve(paths_with_info.size());
+    std::transform(paths_with_info.begin(), paths_with_info.end(), std::back_inserter(sources), [&](const PathWithInfo & path_with_info){ return fs::path(uri_without_path) / path_with_info.path; });
    auto cache_keys = getKeysForSchemaCache(sources, format_name, {}, ctx);
    schema_cache.addMany(cache_keys, columns);
 }
--- a/src/Storages/HDFS/StorageHDFS.h
+++ b/src/Storages/HDFS/StorageHDFS.h
@ -18,6 +18,18 @@ namespace DB
 class StorageHDFS final : public IStorage, WithContext
 {
 public:
+    struct PathInfo
+    {
+        time_t last_mod_time;
+        size_t size;
+    };
+
+    struct PathWithInfo
+    {
+        String path;
+        std::optional<PathInfo> info;
+    };
+
    StorageHDFS(
        const String & uri_,
        const StorageID & table_id_,
@ -72,14 +84,13 @@ protected:

 private:
    static std::optional<ColumnsDescription> tryGetColumnsFromCache(
-        const Strings & paths,
+        const std::vector<StorageHDFS::PathWithInfo> & paths_with_info,
        const String & uri_without_path,
-        std::unordered_map<String, time_t> & last_mod_time,
        const String & format_name,
        const ContextPtr & ctx);

    static void addColumnsToCache(
-        const Strings & paths,
+        const std::vector<StorageHDFS::PathWithInfo> & paths,
        const String & uri_without_path,
        const ColumnsDescription & columns,
        const String & format_name,
@ -105,7 +116,7 @@ public:
    {
        public:
            DisclosedGlobIterator(ContextPtr context_, const String & uri_);
-            String next();
+            StorageHDFS::PathWithInfo next();
        private:
            class Impl;
            /// shared_ptr to have copy constructor
@ -116,14 +127,14 @@ public:
    {
        public:
            URISIterator(const std::vector<String> & uris_, ContextPtr context);
-            String next();
+            StorageHDFS::PathWithInfo next();
        private:
            class Impl;
            /// shared_ptr to have copy constructor
            std::shared_ptr<Impl> pimpl;
    };

-    using IteratorWrapper = std::function<String()>;
+    using IteratorWrapper = std::function<StorageHDFS::PathWithInfo()>;
    using StorageHDFSPtr = std::shared_ptr<StorageHDFS>;

    static Block getHeader(Block sample_block, const std::vector<NameAndTypePair> & requested_virtual_columns);
--- a/src/Storages/HDFS/StorageHDFSCluster.cpp
+++ b/src/Storages/HDFS/StorageHDFSCluster.cpp
@ -79,7 +79,7 @@ void StorageHDFSCluster::addColumnsStructureToQuery(ASTPtr & query, const String
 RemoteQueryExecutor::Extension StorageHDFSCluster::getTaskIteratorExtension(ASTPtr, const ContextPtr & context) const
 {
    auto iterator = std::make_shared<HDFSSource::DisclosedGlobIterator>(context, uri);
-    auto callback = std::make_shared<HDFSSource::IteratorWrapper>([iter = std::move(iterator)]() mutable -> String { return iter->next(); });
+    auto callback = std::make_shared<std::function<String()>>([iter = std::move(iterator)]() mutable -> String { return iter->next().path; });
    return RemoteQueryExecutor::Extension{.task_iterator = std::move(callback)};
 }

--- a/src/Storages/MergeTree/IMergeTreeDataPart.cpp
+++ b/src/Storages/MergeTree/IMergeTreeDataPart.cpp
@ -492,13 +492,17 @@ void IMergeTreeDataPart::removeIfNeeded()

        if (is_temp)
        {
-            String file_name = fileName(getDataPartStorage().getPartDirectory());
+            const auto & part_directory = getDataPartStorage().getPartDirectory();
+
+            String file_name = fileName(part_directory);

            if (file_name.empty())
                throw Exception(ErrorCodes::LOGICAL_ERROR, "relative_path {} of part {} is invalid or not set",
                                getDataPartStorage().getPartDirectory(), name);

-            if (!startsWith(file_name, "tmp") && !endsWith(file_name, ".tmp_proj"))
+            const auto part_parent_directory = directoryPath(part_directory);
+            bool is_moving_part = part_parent_directory.ends_with("moving/");
+            if (!startsWith(file_name, "tmp") && !endsWith(file_name, ".tmp_proj") && !is_moving_part)
            {
                LOG_ERROR(
                    storage.log,
@ -507,6 +511,11 @@ void IMergeTreeDataPart::removeIfNeeded()
                    path);
                return;
            }
+
+            if (is_moving_part)
+            {
+                LOG_TRACE(storage.log, "Removing unneeded moved part from {}", path);
+            }
        }

        remove();
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@ -19,6 +19,7 @@
 #include <Common/CurrentMetrics.h>
 #include <Common/ThreadFuzzer.h>
 #include <Common/getNumberOfPhysicalCPUCores.h>
+#include <Common/Config/ConfigHelper.h>
 #include <Compression/CompressedReadBuffer.h>
 #include <Core/QueryProcessingStage.h>
 #include <DataTypes/DataTypeEnum.h>
@ -1916,7 +1917,10 @@ try

            ++num_loaded_parts;
            if (res.is_broken)
+            {
+                forcefullyRemoveBrokenOutdatedPartFromZooKeeperBeforeDetaching(res.part->name);
                res.part->renameToDetached("broken-on-start"); /// detached parts must not have '_' in prefixes
+            }
            else if (res.part->is_duplicate)
                res.part->remove();
            else
@ -2011,6 +2015,21 @@ static bool isOldPartDirectory(const DiskPtr & disk, const String & directory_pa


 size_t MergeTreeData::clearOldTemporaryDirectories(size_t custom_directories_lifetime_seconds, const NameSet & valid_prefixes)
+{
+    size_t cleared_count = 0;
+
+    cleared_count += clearOldTemporaryDirectories(relative_data_path, custom_directories_lifetime_seconds, valid_prefixes);
+
+    if (allowRemoveStaleMovingParts())
+    {
+        /// Clear _all_ parts from the `moving` directory
+        cleared_count += clearOldTemporaryDirectories(fs::path(relative_data_path) / "moving", custom_directories_lifetime_seconds, {""});
+    }
+
+    return cleared_count;
+}
+
+size_t MergeTreeData::clearOldTemporaryDirectories(const String & root_path, size_t custom_directories_lifetime_seconds, const NameSet & valid_prefixes)
 {
    /// If the method is already called from another thread, then we don't need to do anything.
    std::unique_lock lock(clear_old_temporary_directories_mutex, std::defer_lock);
@ -2029,7 +2048,7 @@ size_t MergeTreeData::clearOldTemporaryDirectories(size_t custom_directories_lif
        if (disk->isBroken())
            continue;

-        for (auto it = disk->iterateDirectory(relative_data_path); it->isValid(); it->next())
+        for (auto it = disk->iterateDirectory(root_path); it->isValid(); it->next())
        {
            const std::string & basename = it->name();
            bool start_with_valid_prefix = false;
@ -7854,7 +7873,7 @@ MovePartsOutcome MergeTreeData::moveParts(const CurrentlyMovingPartsTaggerPtr &
    for (const auto & moving_part : moving_tagger->parts_to_move)
    {
        Stopwatch stopwatch;
-        MutableDataPartPtr cloned_part;
+        MergeTreePartsMover::TemporaryClonedPart cloned_part;
        ProfileEventsScope profile_events_scope;

        auto write_part_log = [&](const ExecutionStatus & execution_status)
@ -7864,7 +7883,7 @@ MovePartsOutcome MergeTreeData::moveParts(const CurrentlyMovingPartsTaggerPtr &
                execution_status,
                stopwatch.elapsed(),
                moving_part.part->name,
-                cloned_part,
+                cloned_part.part,
                {moving_part.part},
                nullptr,
                profile_events_scope.getSnapshot());
@ -7940,9 +7959,6 @@ MovePartsOutcome MergeTreeData::moveParts(const CurrentlyMovingPartsTaggerPtr &
        catch (...)
        {
            write_part_log(ExecutionStatus::fromCurrentException("", true));
-            if (cloned_part)
-                cloned_part->remove();
-
            throw;
        }
    }
@ -8457,6 +8473,11 @@ MergeTreeData::MutableDataPartPtr MergeTreeData::createEmptyPart(
    return new_data_part;
 }

+bool MergeTreeData::allowRemoveStaleMovingParts() const
+{
+    return ConfigHelper::getBool(getContext()->getConfigRef(), "allow_remove_stale_moving_parts");
+}
+
 CurrentlySubmergingEmergingTagger::~CurrentlySubmergingEmergingTagger()
 {
    std::lock_guard lock(storage.currently_submerging_emerging_mutex);
--- a/src/Storages/MergeTree/MergeTreeData.h
+++ b/src/Storages/MergeTree/MergeTreeData.h
@ -646,6 +646,9 @@ public:
    /// For active parts it's unsafe because this method modifies fields of part (rename) while some other thread can try to read it.
    void forcefullyMovePartToDetachedAndRemoveFromMemory(const DataPartPtr & part, const String & prefix = "", bool restore_covered = false);

+    /// This method should not be here, but async loading of Outdated parts is implemented in MergeTreeData
+    virtual void forcefullyRemoveBrokenOutdatedPartFromZooKeeperBeforeDetaching(const String & /*part_name*/) {}
+
    /// Outdate broken part, set remove time to zero (remove as fast as possible) and make clone in detached directory.
    void outdateBrokenPartAndCloneToDetached(const DataPartPtr & part, const String & prefix);

@ -676,6 +679,7 @@ public:
    /// Delete all directories which names begin with "tmp"
    /// Must be called with locked lockForShare() because it's using relative_data_path.
    size_t clearOldTemporaryDirectories(size_t custom_directories_lifetime_seconds, const NameSet & valid_prefixes = {"tmp_", "tmp-fetch_"});
+    size_t clearOldTemporaryDirectories(const String & root_path, size_t custom_directories_lifetime_seconds, const NameSet & valid_prefixes);

    size_t clearEmptyParts();

@ -1061,6 +1065,9 @@ public:
    void waitForOutdatedPartsToBeLoaded() const;
    bool canUsePolymorphicParts() const;

+    /// TODO: make enabled by default in the next release if no problems found.
+    bool allowRemoveStaleMovingParts() const;
+
 protected:
    friend class IMergeTreeDataPart;
    friend class MergeTreeDataMergerMutator;
--- a/src/Storages/MergeTree/MergeTreePartsMover.cpp
+++ b/src/Storages/MergeTree/MergeTreePartsMover.cpp
@ -11,6 +11,7 @@ namespace DB
 namespace ErrorCodes
 {
    extern const int ABORTED;
+    extern const int DIRECTORY_ALREADY_EXISTS;
 }

 namespace
@ -203,7 +204,7 @@ bool MergeTreePartsMover::selectPartsForMove(
        return false;
 }

-MergeTreeMutableDataPartPtr MergeTreePartsMover::clonePart(const MergeTreeMoveEntry & moving_part) const
+MergeTreePartsMover::TemporaryClonedPart MergeTreePartsMover::clonePart(const MergeTreeMoveEntry & moving_part) const
 {
    if (moves_blocker.isCancelled())
        throw Exception(ErrorCodes::ABORTED, "Cancelled moving parts.");
@ -212,6 +213,8 @@ MergeTreeMutableDataPartPtr MergeTreePartsMover::clonePart(const MergeTreeMoveEn
    auto part = moving_part.part;
    auto disk = moving_part.reserved_space->getDisk();
    LOG_DEBUG(log, "Cloning part {} from '{}' to '{}'", part->name, part->getDataPartStorage().getDiskName(), disk->getName());
+    TemporaryClonedPart cloned_part;
+    cloned_part.temporary_directory_lock = data->getTemporaryPartDirectoryHolder(part->name);

    MutableDataPartStoragePtr cloned_part_storage;
    if (disk->supportZeroCopyReplication() && settings->allow_remote_fs_zero_copy_replication)
@ -222,8 +225,10 @@ MergeTreeMutableDataPartPtr MergeTreePartsMover::clonePart(const MergeTreeMoveEn
        String relative_path = part->getDataPartStorage().getPartDirectory();
        if (disk->exists(path_to_clone + relative_path))
        {
-            LOG_WARNING(log, "Path {} already exists. Will remove it and clone again.", fullPath(disk, path_to_clone + relative_path));
-            disk->removeRecursive(fs::path(path_to_clone) / relative_path / "");
+            throw Exception(ErrorCodes::DIRECTORY_ALREADY_EXISTS,
+                "Cannot clone part {} from '{}' to '{}': path '{}' already exists",
+                part->name, part->getDataPartStorage().getDiskName(), disk->getName(),
+                fullPath(disk, path_to_clone + relative_path));
        }

        disk->createDirectories(path_to_clone);
@ -242,37 +247,48 @@ MergeTreeMutableDataPartPtr MergeTreePartsMover::clonePart(const MergeTreeMoveEn
    }

    MergeTreeDataPartBuilder builder(*data, part->name, cloned_part_storage);
-    auto cloned_part = std::move(builder).withPartFormatFromDisk().build();
-    LOG_TRACE(log, "Part {} was cloned to {}", part->name, cloned_part->getDataPartStorage().getFullPath());
+    cloned_part.part = std::move(builder).withPartFormatFromDisk().build();
+    LOG_TRACE(log, "Part {} was cloned to {}", part->name, cloned_part.part->getDataPartStorage().getFullPath());

-    cloned_part->loadColumnsChecksumsIndexes(true, true);
-    cloned_part->loadVersionMetadata();
-    cloned_part->modification_time = cloned_part->getDataPartStorage().getLastModified().epochTime();
+    cloned_part.part->is_temp = data->allowRemoveStaleMovingParts();
+    cloned_part.part->loadColumnsChecksumsIndexes(true, true);
+    cloned_part.part->loadVersionMetadata();
+    cloned_part.part->modification_time = cloned_part.part->getDataPartStorage().getLastModified().epochTime();
    return cloned_part;
 }


-void MergeTreePartsMover::swapClonedPart(const MergeTreeMutableDataPartPtr & cloned_part) const
+void MergeTreePartsMover::swapClonedPart(TemporaryClonedPart & cloned_part) const
 {
    if (moves_blocker.isCancelled())
        throw Exception(ErrorCodes::ABORTED, "Cancelled moving parts.");

-    auto active_part = data->getActiveContainingPart(cloned_part->name);
+    auto active_part = data->getActiveContainingPart(cloned_part.part->name);

    /// It's ok, because we don't block moving parts for merges or mutations
-    if (!active_part || active_part->name != cloned_part->name)
+    if (!active_part || active_part->name != cloned_part.part->name)
    {
-        LOG_INFO(log, "Failed to swap {}. Active part doesn't exist. Possible it was merged or mutated. Will remove copy on path '{}'.", cloned_part->name, cloned_part->getDataPartStorage().getFullPath());
+        LOG_INFO(log,
+            "Failed to swap {}. Active part doesn't exist (containing part {}). "
+            "Possible it was merged or mutated. Part on path '{}' {}",
+            cloned_part.part->name,
+            active_part ? active_part->name : "doesn't exist",
+            cloned_part.part->getDataPartStorage().getFullPath(),
+            data->allowRemoveStaleMovingParts() ? "will be removed" : "will remain intact (set <allow_remove_stale_moving_parts> in config.xml, exercise caution when using)");
        return;
    }

+    cloned_part.part->is_temp = false;
+
    /// Don't remove new directory but throw an error because it may contain part which is currently in use.
-    cloned_part->renameTo(active_part->name, false);
+    cloned_part.part->renameTo(active_part->name, false);

    /// TODO what happen if server goes down here?
-    data->swapActivePart(cloned_part);
+    data->swapActivePart(cloned_part.part);

-    LOG_TRACE(log, "Part {} was moved to {}", cloned_part->name, cloned_part->getDataPartStorage().getFullPath());
+    LOG_TRACE(log, "Part {} was moved to {}", cloned_part.part->name, cloned_part.part->getDataPartStorage().getFullPath());
+
+    cloned_part.temporary_directory_lock = {};
 }

 }
--- a/src/Storages/MergeTree/MergeTreePartsMover.h
+++ b/src/Storages/MergeTree/MergeTreePartsMover.h
@ -3,6 +3,7 @@
 #include <functional>
 #include <optional>
 #include <vector>
+#include <base/scope_guard.h>
 #include <Disks/StoragePolicy.h>
 #include <Storages/MergeTree/IMergeTreeDataPart.h>
 #include <Storages/MergeTree/MovesList.h>
@ -43,12 +44,19 @@ private:
    using AllowedMovingPredicate = std::function<bool(const std::shared_ptr<const IMergeTreeDataPart> &, String * reason)>;

 public:
+
    explicit MergeTreePartsMover(MergeTreeData * data_)
        : data(data_)
        , log(&Poco::Logger::get("MergeTreePartsMover"))
    {
    }

+    struct TemporaryClonedPart
+    {
+        MergeTreeMutableDataPartPtr part;
+        scope_guard temporary_directory_lock;
+    };
+
    /// Select parts for background moves according to storage_policy configuration.
    /// Returns true if at least one part was selected for move.
    bool selectPartsForMove(
@ -57,14 +65,14 @@ public:
        const std::lock_guard<std::mutex> & moving_parts_lock);

    /// Copies part to selected reservation in detached folder. Throws exception if part already exists.
-    MergeTreeMutableDataPartPtr clonePart(const MergeTreeMoveEntry & moving_part) const;
+    TemporaryClonedPart clonePart(const MergeTreeMoveEntry & moving_part) const;

    /// Replaces cloned part from detached directory into active data parts set.
    /// Replacing part changes state to DeleteOnDestroy and will be removed from disk after destructor of
    /// IMergeTreeDataPart called. If replacing part doesn't exists or not active (committed) than
    /// cloned part will be removed and log message will be reported. It may happen in case of concurrent
    /// merge or mutation.
-    void swapClonedPart(const MergeTreeMutableDataPartPtr & cloned_parts) const;
+    void swapClonedPart(TemporaryClonedPart & cloned_part) const;

    /// Can stop background moves and moves from queries
    ActionBlocker moves_blocker;
--- a/src/Storages/StorageFile.cpp
+++ b/src/Storages/StorageFile.cpp
@ -353,35 +353,40 @@ std::unique_ptr<ReadBuffer> selectReadBuffer(
    return res;
 }

-std::unique_ptr<ReadBuffer> createReadBuffer(
-    const String & current_path,
-    bool use_table_fd,
-    const String & storage_name,
-    int table_fd,
-    const String & compression_method,
-    ContextPtr context)
+struct stat getFileStat(const String & current_path, bool use_table_fd, int table_fd, const String & storage_name)
 {
-    CompressionMethod method;
-
    struct stat file_stat{};
-
    if (use_table_fd)
    {
        /// Check if file descriptor allows random reads (and reading it twice).
        if (0 != fstat(table_fd, &file_stat))
            throwFromErrno("Cannot stat table file descriptor, inside " + storage_name, ErrorCodes::CANNOT_STAT);
-
-        method = chooseCompressionMethod("", compression_method);
    }
    else
    {
        /// Check if file descriptor allows random reads (and reading it twice).
        if (0 != stat(current_path.c_str(), &file_stat))
            throwFromErrno("Cannot stat file " + current_path, ErrorCodes::CANNOT_STAT);
-
-        method = chooseCompressionMethod(current_path, compression_method);
    }

+    return file_stat;
+}
+
+std::unique_ptr<ReadBuffer> createReadBuffer(
+    const String & current_path,
+    const struct stat & file_stat,
+    bool use_table_fd,
+    int table_fd,
+    const String & compression_method,
+    ContextPtr context)
+{
+    CompressionMethod method;
+
+    if (use_table_fd)
+        method = chooseCompressionMethod("", compression_method);
+    else
+        method = chooseCompressionMethod(current_path, compression_method);
+
    std::unique_ptr<ReadBuffer> nested_buffer = selectReadBuffer(current_path, use_table_fd, table_fd, file_stat, context);

    /// For clickhouse-local and clickhouse-client add progress callback to display progress bar.
@ -451,7 +456,8 @@ ColumnsDescription StorageFile::getTableStructureFromFileDescriptor(ContextPtr c
    {
        /// We will use PeekableReadBuffer to create a checkpoint, so we need a place
        /// where we can store the original read buffer.
-        read_buffer_from_fd = createReadBuffer("", true, getName(), table_fd, compression_method, context);
+        auto file_stat = getFileStat("", true, table_fd, getName());
+        read_buffer_from_fd = createReadBuffer("", file_stat, true, table_fd, compression_method, context);
        auto read_buf = std::make_unique<PeekableReadBuffer>(*read_buffer_from_fd);
        read_buf->setCheckpoint();
        return read_buf;
@ -492,12 +498,29 @@ ColumnsDescription StorageFile::getTableStructureFromFile(
    if (context->getSettingsRef().schema_inference_use_cache_for_file)
        columns_from_cache = tryGetColumnsFromCache(paths, format, format_settings, context);

-    ReadBufferIterator read_buffer_iterator = [&, it = paths.begin()](ColumnsDescription &) mutable -> std::unique_ptr<ReadBuffer>
+    ReadBufferIterator read_buffer_iterator = [&, it = paths.begin(), first = true](ColumnsDescription &) mutable -> std::unique_ptr<ReadBuffer>
    {
-        if (it == paths.end())
-            return nullptr;
+        String path;
+        struct stat file_stat;
+        do
+        {
+            if (it == paths.end())
+            {
+                if (first)
+                    throw Exception(
+                        ErrorCodes::CANNOT_EXTRACT_TABLE_STRUCTURE,
+                        "Cannot extract table structure from {} format file, because all files are empty. You must specify table structure manually",
+                        format);
+                return nullptr;
+            }

-        return createReadBuffer(*it++, false, "File", -1, compression_method, context);
+            path = *it++;
+            file_stat = getFileStat(path, false, -1, "File");
+        }
+        while (context->getSettingsRef().engine_file_skip_empty_files && file_stat.st_size == 0);
+
+        first = false;
+        return createReadBuffer(path, file_stat, false, -1, compression_method, context);
    };

    ColumnsDescription columns;
@ -786,7 +809,12 @@ public:
                }

                if (!read_buf)
-                    read_buf = createReadBuffer(current_path, storage->use_table_fd, storage->getName(), storage->table_fd, storage->compression_method, context);
+                {
+                    auto file_stat = getFileStat(current_path, storage->use_table_fd, storage->table_fd, storage->getName());
+                    if (context->getSettingsRef().engine_file_skip_empty_files && file_stat.st_size == 0)
+                        continue;
+                    read_buf = createReadBuffer(current_path, file_stat, storage->use_table_fd, storage->table_fd, storage->compression_method, context);
+                }

                const Settings & settings = context->getSettingsRef();
                chassert(!storage->paths.empty());
--- a/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/src/Storages/StorageReplicatedMergeTree.cpp
@ -1226,12 +1226,53 @@ static time_t tryGetPartCreateTime(zkutil::ZooKeeperPtr & zookeeper, const Strin
    return res;
 }

+static void paranoidCheckForCoveredPartsInZooKeeperOnStart(const StorageReplicatedMergeTree * storage, const Strings & parts_in_zk,
+                                                           MergeTreeDataFormatVersion format_version, Poco::Logger * log)
+{
+#ifdef ABORT_ON_LOGICAL_ERROR
+    constexpr bool paranoid_check_for_covered_parts_default = true;
+#else
+    constexpr bool paranoid_check_for_covered_parts_default = false;
+#endif
+
+    bool paranoid_check_for_covered_parts = Context::getGlobalContextInstance()->getConfigRef().getBool(
+        "replicated_merge_tree_paranoid_check_on_startup", paranoid_check_for_covered_parts_default);
+    if (!paranoid_check_for_covered_parts)
+        return;
+
+    ActiveDataPartSet active_set(format_version);
+    for (const auto & part_name : parts_in_zk)
+        active_set.add(part_name);
+
+    const auto disks = storage->getStoragePolicy()->getDisks();
+    auto path = storage->getRelativeDataPath();
+
+    for (const auto & part_name : parts_in_zk)
+    {
+        String covering_part = active_set.getContainingPart(part_name);
+        if (part_name == covering_part)
+            continue;
+
+        bool found = false;
+        for (const DiskPtr & disk : disks)
+            if (disk->exists(fs::path(path) / part_name))
+                found = true;
+
+        if (!found)
+        {
+            LOG_WARNING(log, "Part {} exists in ZooKeeper and covered by another part in ZooKeeper ({}), but doesn't exist on any disk. "
+                        "It may cause false-positive 'part is lost forever' messages", part_name, covering_part);
+            chassert(false);
+        }
+    }
+}

 void StorageReplicatedMergeTree::checkParts(bool skip_sanity_checks)
 {
    auto zookeeper = getZooKeeper();

    Strings expected_parts_vec = zookeeper->getChildren(fs::path(replica_path) / "parts");
+    paranoidCheckForCoveredPartsInZooKeeperOnStart(this, expected_parts_vec, format_version, log);

    /// Parts in ZK.
    NameSet expected_parts(expected_parts_vec.begin(), expected_parts_vec.end());
@ -6805,6 +6846,31 @@ void StorageReplicatedMergeTree::clearOldPartsAndRemoveFromZKImpl(zkutil::ZooKee
 }


+void StorageReplicatedMergeTree::forcefullyRemoveBrokenOutdatedPartFromZooKeeperBeforeDetaching(const String & part_name)
+{
+    /// An outdated part is broken and we are going to move it do detached/
+    /// But we need to remove it from ZooKeeper as well. Otherwise it will be considered as "lost forever".
+
+    /// Since the part is Outdated, it should be safe to remove it, but it's still dangerous.
+    /// It could became Outdated because it was merged/mutated (so we have a covering part) or because it was dropped.
+    /// But DROP [PART]ITION waits for all Outdated parts to be loaded, so it's not the case.
+
+    auto zookeeper = getZooKeeper();
+    String part_path = replica_path + "/parts/" + part_name;
+    if (!zookeeper->exists(part_path))
+        return;
+
+    auto part = getActiveContainingPart(part_name);
+    if (!part)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Outdated part {} is broken and going to be detached, "
+                        "but there's no active covering part, so we are not sure that it can be safely removed from ZooKeeper "
+                        "(path: {})", part_name, part_path);
+
+    LOG_WARNING(log, "Outdated part {} is broken and going to be detached, removing it from ZooKeeper. The part is covered by {}",
+                part_name, part->name);
+    removePartsFromZooKeeperWithRetries({part_name}, /* infinite retries */ 0);
+}
+
 void StorageReplicatedMergeTree::removePartsFromZooKeeperWithRetries(PartsToRemoveFromZooKeeper & parts, size_t max_retries)
 {
    Strings part_names_to_remove;
@ -7166,6 +7232,7 @@ void StorageReplicatedMergeTree::replacePartitionFrom(
        }

        Coordination::Responses op_results;
+        DataPartsVector parts_holder;

        try
        {
@ -7215,7 +7282,10 @@ void StorageReplicatedMergeTree::replacePartitionFrom(
                auto data_parts_lock = lockParts();
                transaction.commit(&data_parts_lock);
                if (replace)
+                {
+                    parts_holder = getDataPartsVectorInPartitionForInternalUsage(MergeTreeDataPartState::Active, drop_range.partition_id, &data_parts_lock);
                    removePartsInRangeFromWorkingSet(NO_TRANSACTION_RAW, drop_range, data_parts_lock);
+                }
            }

            PartLog::addNewParts(getContext(), PartLog::createPartLogEntries(dst_parts, watch.elapsed(), profile_events_scope.getSnapshot()));
@ -7235,11 +7305,15 @@ void StorageReplicatedMergeTree::replacePartitionFrom(
        for (auto & lock : ephemeral_locks)
            lock.assumeUnlocked();

-        cleanup_thread.wakeup();
-
        lock2.reset();
        lock1.reset();

+        /// We need to pull the DROP_RANGE before cleaning the replaced parts (otherwise CHeckThread may decide that parts are lost)
+        queue.pullLogsToQueue(getZooKeeperAndAssertNotReadonly(), {}, ReplicatedMergeTreeQueue::SYNC);
+        parts_holder.clear();
+        cleanup_thread.wakeup();
+
+
        waitForLogEntryToBeProcessedIfNecessary(entry, query_context);

        return;
@ -7405,6 +7479,8 @@ void StorageReplicatedMergeTree::movePartitionToTable(const StoragePtr & dest_ta

        Coordination::Responses op_results;

+        /// We should hold replaced parts until we actually create DROP_RANGE in ZooKeeper
+        DataPartsVector parts_holder;
        try
        {
            Coordination::Requests ops;
@ -7439,6 +7515,7 @@ void StorageReplicatedMergeTree::movePartitionToTable(const StoragePtr & dest_ta
                else
                    zkutil::KeeperMultiException::check(code, ops, op_results);

+                parts_holder = getDataPartsVectorInPartitionForInternalUsage(MergeTreeDataPartState::Active, drop_range.partition_id, &src_data_parts_lock);
                removePartsInRangeFromWorkingSet(NO_TRANSACTION_RAW, drop_range, src_data_parts_lock);
                transaction.commit(&src_data_parts_lock);
            }
@ -7461,7 +7538,6 @@ void StorageReplicatedMergeTree::movePartitionToTable(const StoragePtr & dest_ta
        for (auto & lock : ephemeral_locks)
            lock.assumeUnlocked();

-        cleanup_thread.wakeup();
        lock2.reset();

        dest_table_storage->waitForLogEntryToBeProcessedIfNecessary(entry, query_context);
@ -7480,6 +7556,12 @@ void StorageReplicatedMergeTree::movePartitionToTable(const StoragePtr & dest_ta
        entry_delete.znode_name = log_znode_path.substr(log_znode_path.find_last_of('/') + 1);

        lock1.reset();
+
+        /// We need to pull the DROP_RANGE before cleaning the replaced parts (otherwise CHeckThread may decide that parts are lost)
+        queue.pullLogsToQueue(getZooKeeperAndAssertNotReadonly(), {}, ReplicatedMergeTreeQueue::SYNC);
+        parts_holder.clear();
+        cleanup_thread.wakeup();
+
        waitForLogEntryToBeProcessedIfNecessary(entry_delete, query_context);

        /// Cleaning possibly stored information about parts from /quorum/last_part node in ZooKeeper.
--- a/src/Storages/StorageReplicatedMergeTree.h
+++ b/src/Storages/StorageReplicatedMergeTree.h
@ -579,6 +579,8 @@ private:
    void removePartsFromZooKeeperWithRetries(const Strings & part_names, size_t max_retries = 5);
    void removePartsFromZooKeeperWithRetries(PartsToRemoveFromZooKeeper & parts, size_t max_retries = 5);

+    void forcefullyRemoveBrokenOutdatedPartFromZooKeeperBeforeDetaching(const String & part_name) override;
+
    /// Removes a part from ZooKeeper and adds a task to the queue to download it. It is supposed to do this with broken parts.
    void removePartAndEnqueueFetch(const String & part_name, bool storage_init);

--- a/src/Storages/StorageS3.cpp
+++ b/src/Storages/StorageS3.cpp
@ -578,14 +578,21 @@ StorageS3Source::StorageS3Source(

 StorageS3Source::ReaderHolder StorageS3Source::createReader()
 {
-    auto [current_key, info] = (*file_iterator)();
-    if (current_key.empty())
-        return {};
+    KeyWithInfo key_with_info;
+    size_t object_size;
+    do
+    {
+        key_with_info = (*file_iterator)();
+        if (key_with_info.key.empty())
+            return {};

-    size_t object_size = info ? info->size : S3::getObjectSize(*client, bucket, current_key, version_id, request_settings);
-    auto compression_method = chooseCompressionMethod(current_key, compression_hint);
+        object_size = key_with_info.info ? key_with_info.info->size : S3::getObjectSize(*client, bucket, key_with_info.key, version_id, request_settings);
+    }
+    while (getContext()->getSettingsRef().s3_skip_empty_files && object_size == 0);

-    auto read_buf = createS3ReadBuffer(current_key, object_size);
+    auto compression_method = chooseCompressionMethod(key_with_info.key, compression_hint);
+
+    auto read_buf = createS3ReadBuffer(key_with_info.key, object_size);
    auto input_format = FormatFactory::instance().getInput(
            format, *read_buf, sample_block, getContext(), max_block_size,
            format_settings, std::nullopt, std::nullopt,
@ -604,7 +611,7 @@ StorageS3Source::ReaderHolder StorageS3Source::createReader()
    auto pipeline = std::make_unique<QueryPipeline>(QueryPipelineBuilder::getPipeline(std::move(builder)));
    auto current_reader = std::make_unique<PullingPipelineExecutor>(*pipeline);

-    return ReaderHolder{fs::path(bucket) / current_key, std::move(read_buf), std::move(pipeline), std::move(current_reader)};
+    return ReaderHolder{fs::path(bucket) / key_with_info.key, std::move(read_buf), std::move(pipeline), std::move(current_reader)};
 }

 std::future<StorageS3Source::ReaderHolder> StorageS3Source::createReaderAsync()
@ -1449,38 +1456,45 @@ ColumnsDescription StorageS3::getTableStructureFromDataImpl(

    ReadBufferIterator read_buffer_iterator = [&, first = true](ColumnsDescription & cached_columns) mutable -> std::unique_ptr<ReadBuffer>
    {
-        auto [key, _] = (*file_iterator)();
-
-        if (key.empty())
+        while (true)
        {
-            if (first)
-                throw Exception(
-                    ErrorCodes::CANNOT_EXTRACT_TABLE_STRUCTURE,
-                    "Cannot extract table structure from {} format file, because there are no files with provided path "
-                    "in S3. You must specify table structure manually", configuration.format);
+            auto key_with_info = (*file_iterator)();

-            return nullptr;
-        }
-
-        /// S3 file iterator could get new keys after new iteration, check them in schema cache.
-        if (ctx->getSettingsRef().schema_inference_use_cache_for_s3 && read_keys.size() > prev_read_keys_size)
-        {
-            columns_from_cache = tryGetColumnsFromCache(read_keys.begin() + prev_read_keys_size, read_keys.end(), configuration, format_settings, ctx);
-            prev_read_keys_size = read_keys.size();
-            if (columns_from_cache)
+            if (key_with_info.key.empty())
            {
-                cached_columns = *columns_from_cache;
+                if (first)
+                    throw Exception(
+                        ErrorCodes::CANNOT_EXTRACT_TABLE_STRUCTURE,
+                        "Cannot extract table structure from {} format file, because there are no files with provided path "
+                        "in S3 or all files are empty. You must specify table structure manually",
+                        configuration.format);
+
                return nullptr;
            }
-        }

-        first = false;
-        int zstd_window_log_max = static_cast<int>(ctx->getSettingsRef().zstd_window_log_max);
-        return wrapReadBufferWithCompressionMethod(
-            std::make_unique<ReadBufferFromS3>(
-                configuration.client, configuration.url.bucket, key, configuration.url.version_id, configuration.request_settings, ctx->getReadSettings()),
-            chooseCompressionMethod(key, configuration.compression_method),
-            zstd_window_log_max);
+            /// S3 file iterator could get new keys after new iteration, check them in schema cache.
+            if (ctx->getSettingsRef().schema_inference_use_cache_for_s3 && read_keys.size() > prev_read_keys_size)
+            {
+                columns_from_cache = tryGetColumnsFromCache(read_keys.begin() + prev_read_keys_size, read_keys.end(), configuration, format_settings, ctx);
+                prev_read_keys_size = read_keys.size();
+                if (columns_from_cache)
+                {
+                    cached_columns = *columns_from_cache;
+                    return nullptr;
+                }
+            }
+
+            if (ctx->getSettingsRef().s3_skip_empty_files && key_with_info.info && key_with_info.info->size == 0)
+                continue;
+
+            int zstd_window_log_max = static_cast<int>(ctx->getSettingsRef().zstd_window_log_max);
+            auto impl = std::make_unique<ReadBufferFromS3>(configuration.client, configuration.url.bucket, key_with_info.key, configuration.url.version_id, configuration.request_settings, ctx->getReadSettings());
+            if (!ctx->getSettingsRef().s3_skip_empty_files || !impl->eof())
+            {
+                first = false;
+                return wrapReadBufferWithCompressionMethod(std::move(impl), chooseCompressionMethod(key_with_info.key, configuration.compression_method), zstd_window_log_max);
+            }
+        }
    };

    ColumnsDescription columns;
--- a/src/Storages/StorageURL.cpp
+++ b/src/Storages/StorageURL.cpp
@ -14,10 +14,8 @@
 #include <Parsers/ASTIdentifier.h>

 #include <IO/ConnectionTimeouts.h>
-#include <IO/ParallelReadBuffer.h>
 #include <IO/WriteBufferFromHTTP.h>
 #include <IO/WriteHelpers.h>
-#include <IO/WithFileSize.h>

 #include <Formats/FormatFactory.h>
 #include <Formats/ReadSchemaUtils.h>
@ -29,7 +27,6 @@
 #include <Common/ThreadStatus.h>
 #include <Common/parseRemoteDescription.h>
 #include <Common/NamedCollections/NamedCollections.h>
-#include <IO/HTTPCommon.h>
 #include <IO/ReadWriteBufferFromHTTP.h>
 #include <IO/HTTPHeaderEntries.h>

@ -48,7 +45,7 @@ namespace ErrorCodes
    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
    extern const int NETWORK_ERROR;
    extern const int BAD_ARGUMENTS;
-    extern const int LOGICAL_ERROR;
+    extern const int CANNOT_EXTRACT_TABLE_STRUCTURE;
 }

 static constexpr auto bad_arguments_error_message = "Storage URL requires 1-4 arguments: "
@ -242,27 +239,36 @@ StorageURLSource::StorageURLSource(
    auto headers = getHeaders(headers_);

    /// Lazy initialization. We should not perform requests in constructor, because we need to do it in query pipeline.
-    initialize = [=, this](const FailoverOptions & uri_options)
+    initialize = [=, this]()
    {
-        if (uri_options.empty())
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Got empty url list");
+        std::vector<String> current_uri_options;
+        std::pair<Poco::URI, std::unique_ptr<ReadWriteBufferFromHTTP>> uri_and_buf;
+        do
+        {
+            current_uri_options = (*uri_iterator)();
+            if (current_uri_options.empty())
+                return false;

-        auto first_option = uri_options.begin();
-        auto [actual_uri, buf] = getFirstAvailableURIAndReadBuffer(
-            first_option,
-            uri_options.end(),
-            context,
-            params,
-            http_method,
-            callback,
-            timeouts,
-            credentials,
-            headers,
-            glob_url,
-            uri_options.size() == 1);
+            auto first_option = current_uri_options.cbegin();
+            uri_and_buf = getFirstAvailableURIAndReadBuffer(
+                first_option,
+                current_uri_options.end(),
+                context,
+                params,
+                http_method,
+                callback,
+                timeouts,
+                credentials,
+                headers,
+                glob_url,
+                current_uri_options.size() == 1);

-        curr_uri = actual_uri;
-        read_buf = std::move(buf);
+            /// If file is empty and engine_url_skip_empty_files=1, skip it and go to the next file.
+        }
+        while (context->getSettingsRef().engine_url_skip_empty_files && uri_and_buf.second->eof());
+
+        curr_uri = uri_and_buf.first;
+        read_buf = std::move(uri_and_buf.second);

        try
        {
@ -294,6 +300,7 @@ StorageURLSource::StorageURLSource(

        pipeline = std::make_unique<QueryPipeline>(QueryPipelineBuilder::getPipeline(std::move(builder)));
        reader = std::make_unique<PullingPipelineExecutor>(*pipeline);
+        return true;
    };
 }

@ -308,14 +315,8 @@ Chunk StorageURLSource::generate()
            break;
        }

-        if (!reader)
-        {
-            auto current_uri = (*uri_iterator)();
-            if (current_uri.empty())
-                return {};
-
-            initialize(current_uri);
-        }
+        if (!reader && !initialize())
+            return {};

        Chunk chunk;
        if (reader->pull(chunk))
@ -350,7 +351,7 @@ Chunk StorageURLSource::generate()
    return {};
 }

-std::tuple<Poco::URI, std::unique_ptr<ReadWriteBufferFromHTTP>> StorageURLSource::getFirstAvailableURIAndReadBuffer(
+std::pair<Poco::URI, std::unique_ptr<ReadWriteBufferFromHTTP>> StorageURLSource::getFirstAvailableURIAndReadBuffer(
    std::vector<String>::const_iterator & option,
    const std::vector<String>::const_iterator & end,
    ContextPtr context,
@ -367,6 +368,7 @@ std::tuple<Poco::URI, std::unique_ptr<ReadWriteBufferFromHTTP>> StorageURLSource
    ReadSettings read_settings = context->getReadSettings();

    size_t options = std::distance(option, end);
+    std::pair<Poco::URI, std::unique_ptr<ReadWriteBufferFromHTTP>> last_skipped_empty_res;
    for (; option != end; ++option)
    {
        bool skip_url_not_found_error = glob_url && read_settings.http_skip_not_found_url_for_globs && option == std::prev(end);
@ -396,6 +398,12 @@ std::tuple<Poco::URI, std::unique_ptr<ReadWriteBufferFromHTTP>> StorageURLSource
                /* use_external_buffer */ false,
                /* skip_url_not_found_error */ skip_url_not_found_error);

+            if (context->getSettingsRef().engine_url_skip_empty_files && res->eof() && option != std::prev(end))
+            {
+                last_skipped_empty_res = {request_uri, std::move(res)};
+                continue;
+            }
+
            return std::make_tuple(request_uri, std::move(res));
        }
        catch (...)
@ -412,6 +420,11 @@ std::tuple<Poco::URI, std::unique_ptr<ReadWriteBufferFromHTTP>> StorageURLSource
        }
    }

+    /// If all options are unreachable except empty ones that we skipped,
+    /// return last empty result. It will be skipped later.
+    if (last_skipped_empty_res.second)
+        return last_skipped_empty_res;
+
    throw Exception(ErrorCodes::NETWORK_ERROR, "All uri ({}) options are unreachable: {}", options, first_exception_message);
 }

@ -593,26 +606,41 @@ ColumnsDescription IStorageURLBase::getTableStructureFromData(
    if (context->getSettingsRef().schema_inference_use_cache_for_url)
        columns_from_cache = tryGetColumnsFromCache(urls_to_check, headers, credentials, format, format_settings, context);

-    ReadBufferIterator read_buffer_iterator = [&, it = urls_to_check.cbegin()](ColumnsDescription &) mutable -> std::unique_ptr<ReadBuffer>
+    ReadBufferIterator read_buffer_iterator = [&, it = urls_to_check.cbegin(), first = true](ColumnsDescription &) mutable -> std::unique_ptr<ReadBuffer>
    {
-        if (it == urls_to_check.cend())
-            return nullptr;
+        std::pair<Poco::URI, std::unique_ptr<ReadWriteBufferFromHTTP>> uri_and_buf;
+        do
+        {
+            if (it == urls_to_check.cend())
+            {
+                if (first)
+                    throw Exception(
+                        ErrorCodes::CANNOT_EXTRACT_TABLE_STRUCTURE,
+                        "Cannot extract table structure from {} format file, because all files are empty. "
+                        "You must specify table structure manually",
+                        format);
+                return nullptr;
+            }

-        auto [_, buf] = StorageURLSource::getFirstAvailableURIAndReadBuffer(
-            it,
-            urls_to_check.cend(),
-            context,
-            {},
-            Poco::Net::HTTPRequest::HTTP_GET,
-            {},
-            getHTTPTimeouts(context),
-            credentials,
-            headers,
-            false,
-            false);
-        ++it;
+            uri_and_buf = StorageURLSource::getFirstAvailableURIAndReadBuffer(
+                it,
+                urls_to_check.cend(),
+                context,
+                {},
+                Poco::Net::HTTPRequest::HTTP_GET,
+                {},
+                getHTTPTimeouts(context),
+                credentials,
+                headers,
+                false,
+                false);
+
+            ++it;
+        } while (context->getSettingsRef().engine_url_skip_empty_files && uri_and_buf.second->eof());
+
+        first = false;
        return wrapReadBufferWithCompressionMethod(
-            std::move(buf),
+            std::move(uri_and_buf.second),
            compression_method,
            static_cast<int>(context->getSettingsRef().zstd_window_log_max));
    };
--- a/src/Storages/StorageURL.h
+++ b/src/Storages/StorageURL.h
@ -183,7 +183,7 @@ public:

    static Block getHeader(Block sample_block, const std::vector<NameAndTypePair> & requested_virtual_columns);

-    static std::tuple<Poco::URI, std::unique_ptr<ReadWriteBufferFromHTTP>> getFirstAvailableURIAndReadBuffer(
+    static std::pair<Poco::URI, std::unique_ptr<ReadWriteBufferFromHTTP>> getFirstAvailableURIAndReadBuffer(
        std::vector<String>::const_iterator & option,
        const std::vector<String>::const_iterator & end,
        ContextPtr context,
@ -197,7 +197,7 @@ public:
        bool delay_initialization);

 private:
-    using InitializeFunc = std::function<void(const FailoverOptions &)>;
+    using InitializeFunc = std::function<bool()>;
    InitializeFunc initialize;

    String name;
--- a/tests/integration/test_alter_moving_garbage/init.py
+++ b/tests/integration/test_alter_moving_garbage/init.py
--- a/tests/integration/test_alter_moving_garbage/configs/config.d/remote_servers.xml
+++ b/tests/integration/test_alter_moving_garbage/configs/config.d/remote_servers.xml
@ -0,0 +1,16 @@
+<clickhouse>
+    <remote_servers>
+        <test_cluster>
+            <shard>
+                <replica>
+                    <host>node1</host>
+                    <port>9000</port>
+                </replica>
+                <replica>
+                    <host>node2</host>
+                    <port>9000</port>
+                </replica>
+            </shard>
+        </test_cluster>
+    </remote_servers>
+</clickhouse>
--- a/tests/integration/test_alter_moving_garbage/configs/config.d/storage_conf.xml
+++ b/tests/integration/test_alter_moving_garbage/configs/config.d/storage_conf.xml
@ -0,0 +1,26 @@
+<clickhouse>
+    <storage_configuration>
+        <disks>
+            <s3>
+                <type>s3</type>
+                <endpoint>http://minio1:9001/root/data/</endpoint>
+                <access_key_id>minio</access_key_id>
+                <secret_access_key>minio123</secret_access_key>
+            </s3>
+        </disks>
+        <policies>
+            <two_disks>
+                <volumes>
+                    <default>
+                        <disk>default</disk>
+                    </default>
+                    <external>
+                        <disk>s3</disk>
+                    </external>
+                </volumes>
+            </two_disks>
+        </policies>
+    </storage_configuration>
+
+    <allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
+</clickhouse>
--- a/tests/integration/test_alter_moving_garbage/configs/config.xml
+++ b/tests/integration/test_alter_moving_garbage/configs/config.xml
@ -0,0 +1,7 @@
+<clickhouse>
+    <tcp_port>9000</tcp_port>
+    <listen_host>127.0.0.1</listen_host>
+    <max_concurrent_queries>500</max_concurrent_queries>
+    <path>./clickhouse/</path>
+    <users_config>users.xml</users_config>
+</clickhouse>
--- a/tests/integration/test_alter_moving_garbage/test.py
+++ b/tests/integration/test_alter_moving_garbage/test.py
@ -0,0 +1,155 @@
+import logging
+import time
+
+import pytest
+import threading
+import random
+
+from helpers.client import QueryRuntimeException
+from helpers.cluster import ClickHouseCluster
+
+# two replicas in remote_servers.xml
+REPLICA_COUNT = 2
+
+
+@pytest.fixture(scope="module")
+def cluster():
+    try:
+        cluster = ClickHouseCluster(__file__)
+        for i in range(1, REPLICA_COUNT + 1):
+            cluster.add_instance(
+                f"node{i}",
+                main_configs=[
+                    "configs/config.d/storage_conf.xml",
+                    "configs/config.d/remote_servers.xml",
+                ],
+                with_minio=True,
+                with_zookeeper=True,
+            )
+
+        logging.info("Starting cluster...")
+        cluster.start()
+        logging.info("Cluster started")
+
+        yield cluster
+    finally:
+        cluster.shutdown()
+
+
+def create_table(node, table_name, replicated, additional_settings):
+    settings = {
+        "storage_policy": "two_disks",
+        "old_parts_lifetime": 1,
+        "index_granularity": 512,
+        "temporary_directories_lifetime": 0,
+        "merge_tree_clear_old_temporary_directories_interval_seconds": 1,
+    }
+    settings.update(additional_settings)
+
+    table_engine = (
+        f"ReplicatedMergeTree('/clickhouse/tables/0/{table_name}', '{node.name}')"
+        if replicated
+        else "MergeTree()"
+    )
+
+    create_table_statement = f"""
+        CREATE TABLE {table_name} (
+            dt Date,
+            id Int64,
+            data String,
+            INDEX min_max (id) TYPE minmax GRANULARITY 3
+        ) ENGINE = {table_engine}
+        PARTITION BY dt
+        ORDER BY (dt, id)
+        SETTINGS {",".join((k+"="+repr(v) for k, v in settings.items()))}"""
+
+    if replicated:
+        node.query_with_retry(create_table_statement)
+    else:
+        node.query(create_table_statement)
+
+
+@pytest.mark.parametrize(
+    "allow_remote_fs_zero_copy_replication,replicated_engine",
+    [(False, False), (False, True), (True, True)],
+)
+def test_create_table(
+    cluster, allow_remote_fs_zero_copy_replication, replicated_engine
+):
+    if replicated_engine:
+        nodes = list(cluster.instances.values())
+    else:
+        nodes = [cluster.instances["node1"]]
+
+    additional_settings = {}
+
+    # Different names for logs readability
+    table_name = "test_table"
+    if allow_remote_fs_zero_copy_replication:
+        table_name = "test_table_zero_copy"
+        additional_settings["allow_remote_fs_zero_copy_replication"] = 1
+    if replicated_engine:
+        table_name = table_name + "_replicated"
+
+    for node in nodes:
+        create_table(node, table_name, replicated_engine, additional_settings)
+
+    for i in range(1, 11):
+        partition = f"2021-01-{i:02d}"
+        random.choice(nodes).query(
+            f"INSERT INTO {table_name} SELECT toDate('{partition}'), number as id, toString(sipHash64(number, {i})) FROM numbers(10_000)"
+        )
+
+    # Run ALTER in parallel with moving parts
+
+    stop_alter = False
+
+    def alter():
+        random.choice(nodes).query(f"ALTER TABLE {table_name} ADD COLUMN col0 String")
+        for d in range(1, 100):
+            if stop_alter:
+                break
+
+            # Some lightweight mutation should change moving part before it is swapped, then we will have to cleanup it.
+            # Messages `Failed to swap {}. Active part doesn't exist` should appear in logs.
+            #
+            # I managed to reproduce issue with DELETE (`ALTER TABLE {table_name} ADD/DROP COLUMN` also works on real s3 instead of minio)
+            # Note: do not delete rows with id % 100 = 0, because they are used in `check_count` to use them in check that data is not corrupted
+            random.choice(nodes).query(f"DELETE FROM {table_name} WHERE id % 100 = {d}")
+
+            time.sleep(0.1)
+
+    alter_thread = threading.Thread(target=alter)
+    alter_thread.start()
+
+    for i in range(1, 11):
+        partition = f"2021-01-{i:02d}"
+        try:
+            random.choice(nodes).query(
+                f"ALTER TABLE {table_name} MOVE PARTITION '{partition}' TO DISK 's3'",
+            )
+        except QueryRuntimeException as e:
+            if "PART_IS_TEMPORARILY_LOCKED" in str(e):
+                continue
+            raise e
+
+        # Function to clear old temporary directories wakes up every 1 second, sleep to make sure it is called
+        time.sleep(0.5)
+
+    stop_alter = True
+    alter_thread.join()
+
+    # Check that no data was lost
+
+    data_digest = None
+    if replicated_engine:
+        # We don't know what data was replicated, so we need to check all replicas and take unique values
+        data_digest = random.choice(nodes).query_with_retry(
+            f"SELECT countDistinct(dt, data) FROM clusterAllReplicas(test_cluster, default.{table_name}) WHERE id % 100 == 0"
+        )
+    else:
+        data_digest = random.choice(nodes).query(
+            f"SELECT countDistinct(dt, data) FROM {table_name} WHERE id % 100 == 0"
+        )
+
+    assert data_digest == "1000\n"
--- a/tests/integration/test_consistant_parts_after_move_partition/configs/remote_servers.xml
+++ b/tests/integration/test_consistant_parts_after_move_partition/configs/remote_servers.xml
@ -16,4 +16,5 @@
            </shard>
        </test_cluster>
    </remote_servers>
+    <allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
 </clickhouse>
--- a/tests/integration/test_consistant_parts_after_move_partition/test.py
+++ b/tests/integration/test_consistant_parts_after_move_partition/test.py
@ -18,7 +18,7 @@ def initialize_database(nodes, shard):
            CREATE TABLE `{database}`.dest (p UInt64, d UInt64)
            ENGINE = ReplicatedMergeTree('/clickhouse/{database}/tables/test_consistent_shard2{shard}/replicated', '{replica}')
            ORDER BY d PARTITION BY p
-            SETTINGS min_replicated_logs_to_keep=3, max_replicated_logs_to_keep=5, cleanup_delay_period=0, cleanup_delay_period_random_add=0;
+            SETTINGS min_replicated_logs_to_keep=3, max_replicated_logs_to_keep=5, cleanup_delay_period=0, cleanup_delay_period_random_add=0, temporary_directories_lifetime=1;
        """.format(
                shard=shard, replica=node.name, database=CLICKHOUSE_DATABASE
            )
--- a/tests/integration/test_encrypted_disk/configs/storage.xml
+++ b/tests/integration/test_encrypted_disk/configs/storage.xml
@ -105,4 +105,5 @@
            </s3_encrypted_cache_policy>
         </policies>
    </storage_configuration>
+    <allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
 </clickhouse>
--- a/tests/integration/test_encrypted_disk/test.py
+++ b/tests/integration/test_encrypted_disk/test.py
@ -96,7 +96,7 @@ def test_part_move(policy, destination_disks):
            data String
        ) ENGINE=MergeTree()
        ORDER BY id
-        SETTINGS storage_policy='{}'
+        SETTINGS storage_policy='{}', temporary_directories_lifetime=1
        """.format(
            policy
        )
--- a/tests/integration/test_lost_part_during_startup/configs/compat.xml
+++ b/tests/integration/test_lost_part_during_startup/configs/compat.xml
@ -0,0 +1,4 @@
+<clickhouse>
+    <replicated_merge_tree_paranoid_check_on_drop_range>0</replicated_merge_tree_paranoid_check_on_drop_range>
+    <replicated_merge_tree_paranoid_check_on_startup>0</replicated_merge_tree_paranoid_check_on_startup>
+</clickhouse>
--- a/tests/integration/test_lost_part_during_startup/test.py
+++ b/tests/integration/test_lost_part_during_startup/test.py
@ -6,7 +6,14 @@ from helpers.cluster import ClickHouseCluster

 cluster = ClickHouseCluster(__file__)
 node1 = cluster.add_instance("node1", with_zookeeper=True, stay_alive=True)
-node2 = cluster.add_instance("node2", with_zookeeper=True, stay_alive=True)
+node2 = cluster.add_instance(
+    "node2",
+    with_zookeeper=True,
+    stay_alive=True,
+    main_configs=[
+        "configs/compat.xml",
+    ],
+)


@pytest.fixture(scope="module")
--- a/tests/integration/test_merge_tree_azure_blob_storage/configs/config.xml
+++ b/tests/integration/test_merge_tree_azure_blob_storage/configs/config.xml
@ -15,4 +15,5 @@
    <max_concurrent_queries>500</max_concurrent_queries>
    <path>./clickhouse/</path>
    <users_config>users.xml</users_config>
+    <allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
 </clickhouse>
--- a/tests/integration/test_merge_tree_azure_blob_storage/test.py
+++ b/tests/integration/test_merge_tree_azure_blob_storage/test.py
@ -66,6 +66,7 @@ def create_table(node, table_name, **additional_settings):
        "storage_policy": "blob_storage_policy",
        "old_parts_lifetime": 1,
        "index_granularity": 512,
+        "temporary_directories_lifetime": 1,
    }
    settings.update(additional_settings)

--- a/tests/integration/test_merge_tree_hdfs/configs/config.d/storage_conf.xml
+++ b/tests/integration/test_merge_tree_hdfs/configs/config.d/storage_conf.xml
@ -29,4 +29,5 @@
    <merge_tree>
        <min_bytes_for_wide_part>0</min_bytes_for_wide_part>
    </merge_tree>
+    <allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
 </clickhouse>
--- a/tests/integration/test_merge_tree_hdfs/test.py
+++ b/tests/integration/test_merge_tree_hdfs/test.py
@ -29,7 +29,8 @@ def create_table(cluster, table_name, additional_settings=None):
        SETTINGS
            storage_policy='hdfs',
            old_parts_lifetime=0,
-            index_granularity=512
+            index_granularity=512,
+            temporary_directories_lifetime=1
        """.format(
        table_name
    )
--- a/tests/integration/test_merge_tree_load_parts/configs/compat.xml
+++ b/tests/integration/test_merge_tree_load_parts/configs/compat.xml
@ -0,0 +1,4 @@
+<clickhouse>
+    <replicated_merge_tree_paranoid_check_on_drop_range>0</replicated_merge_tree_paranoid_check_on_drop_range>
+    <replicated_merge_tree_paranoid_check_on_startup>0</replicated_merge_tree_paranoid_check_on_startup>
+</clickhouse>
--- a/tests/integration/test_merge_tree_load_parts/test.py
+++ b/tests/integration/test_merge_tree_load_parts/test.py
@ -9,7 +9,7 @@ cluster = helpers.cluster.ClickHouseCluster(__file__)

 node1 = cluster.add_instance(
    "node1",
-    main_configs=["configs/fast_background_pool.xml"],
+    main_configs=["configs/fast_background_pool.xml", "configs/compat.xml"],
    with_zookeeper=True,
    stay_alive=True,
 )
--- a/tests/integration/test_merge_tree_s3/configs/config.xml
+++ b/tests/integration/test_merge_tree_s3/configs/config.xml
@ -8,4 +8,5 @@
    </s3>

    <enable_system_unfreeze>true</enable_system_unfreeze>
+    <allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
 </clickhouse>
--- a/tests/integration/test_merge_tree_s3/test.py
+++ b/tests/integration/test_merge_tree_s3/test.py
@ -75,6 +75,7 @@ def create_table(node, table_name, **additional_settings):
        "storage_policy": "s3",
        "old_parts_lifetime": 0,
        "index_granularity": 512,
+        "temporary_directories_lifetime": 1,
    }
    settings.update(additional_settings)

--- a/tests/integration/test_move_partition_to_disk_on_cluster/configs/config.d/storage_configuration.xml
+++ b/tests/integration/test_move_partition_to_disk_on_cluster/configs/config.d/storage_configuration.xml
@ -24,5 +24,6 @@
    </policies>

 </storage_configuration>
+<allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>

 </clickhouse>
--- a/tests/integration/test_move_partition_to_disk_on_cluster/test.py
+++ b/tests/integration/test_move_partition_to_disk_on_cluster/test.py
@ -46,7 +46,7 @@ def test_move_partition_to_disk_on_cluster(start_cluster):
            "(x UInt64) "
            "ENGINE=ReplicatedMergeTree('/clickhouse/tables/test_local_table', '{replica}') "
            "ORDER BY tuple()"
-            "SETTINGS storage_policy = 'jbod_with_external';",
+            "SETTINGS storage_policy = 'jbod_with_external', temporary_directories_lifetime=1;",
        )

    node1.query("INSERT INTO test_local_table VALUES (0)")
--- a/tests/integration/test_multiple_disks/configs/config.d/storage_configuration.xml
+++ b/tests/integration/test_multiple_disks/configs/config.d/storage_configuration.xml
@ -122,5 +122,10 @@
    </policies>

 </storage_configuration>
+<allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
+
+<merge_tree>
+    <temporary_directories_lifetime>1</temporary_directories_lifetime>
+</merge_tree>

 </clickhouse>
--- a/tests/integration/test_rename_column/configs/config.d/storage_configuration.xml
+++ b/tests/integration/test_rename_column/configs/config.d/storage_configuration.xml
@ -24,9 +24,11 @@
        </default_with_external>
    </policies>
 </storage_configuration>
-    
+
 <merge_tree>
    <min_bytes_for_wide_part>0</min_bytes_for_wide_part>
+    <temporary_directories_lifetime>1</temporary_directories_lifetime>
 </merge_tree>
+<allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>

 </clickhouse>
--- a/tests/integration/test_replicated_merge_tree_hdfs_zero_copy/configs/config.d/storage_conf.xml
+++ b/tests/integration/test_replicated_merge_tree_hdfs_zero_copy/configs/config.d/storage_conf.xml
@ -89,4 +89,5 @@
        <cluster>test_cluster</cluster>
        <shard>1</shard>
    </macros>
+    <allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
 </clickhouse>
--- a/tests/integration/test_replicated_merge_tree_hdfs_zero_copy/test.py
+++ b/tests/integration/test_replicated_merge_tree_hdfs_zero_copy/test.py
@ -128,7 +128,7 @@ def test_hdfs_zero_copy_replication_single_move(cluster, storage_policy, init_ob
            CREATE TABLE single_node_move_test (dt DateTime, id Int64)
            ENGINE=ReplicatedMergeTree('/clickhouse/tables/{cluster}/{shard}/single_node_move_test', '{replica}')
            ORDER BY (dt, id)
-            SETTINGS storage_policy='$policy'
+            SETTINGS storage_policy='$policy',temporary_directories_lifetime=1
            """
            ).substitute(policy=storage_policy)
        )
--- a/tests/integration/test_s3_zero_copy_replication/configs/config.d/s3.xml
+++ b/tests/integration/test_s3_zero_copy_replication/configs/config.d/s3.xml
@ -93,4 +93,5 @@
        <cluster>test_cluster</cluster>
    </macros>

+    <allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
 </clickhouse>
--- a/tests/integration/test_s3_zero_copy_replication/test.py
+++ b/tests/integration/test_s3_zero_copy_replication/test.py
@ -163,7 +163,7 @@ def test_s3_zero_copy_on_hybrid_storage(started_cluster):
        CREATE TABLE hybrid_test ON CLUSTER test_cluster (id UInt32, value String)
        ENGINE=ReplicatedMergeTree('/clickhouse/tables/hybrid_test', '{}')
        ORDER BY id
-        SETTINGS storage_policy='hybrid'
+        SETTINGS storage_policy='hybrid',temporary_directories_lifetime=1
        """.format(
            "{replica}"
        )
--- a/tests/integration/test_storage_hdfs/test.py
+++ b/tests/integration/test_storage_hdfs/test.py
@ -833,6 +833,56 @@ def test_hdfsCluster_unset_skip_unavailable_shards(started_cluster):
    )


+def test_skip_empty_files(started_cluster):
+    node = started_cluster.instances["node1"]
+
+    node.query(
+        f"insert into function hdfs('hdfs://hdfs1:9000/skip_empty_files1.parquet', TSVRaw) select * from numbers(0) settings hdfs_truncate_on_insert=1"
+    )
+
+    node.query(
+        f"insert into function hdfs('hdfs://hdfs1:9000/skip_empty_files2.parquet') select * from numbers(1) settings hdfs_truncate_on_insert=1"
+    )
+
+    node.query_and_get_error(
+        f"select * from hdfs('hdfs://hdfs1:9000/skip_empty_files1.parquet') settings hdfs_skip_empty_files=0"
+    )
+
+    node.query_and_get_error(
+        f"select * from hdfs('hdfs://hdfs1:9000/skip_empty_files1.parquet', auto, 'number UINt64') settings hdfs_skip_empty_files=0"
+    )
+
+    node.query_and_get_error(
+        f"select * from hdfs('hdfs://hdfs1:9000/skip_empty_files1.parquet') settings hdfs_skip_empty_files=1"
+    )
+
+    res = node.query(
+        f"select * from hdfs('hdfs://hdfs1:9000/skip_empty_files1.parquet', auto, 'number UInt64') settings hdfs_skip_empty_files=1"
+    )
+
+    assert len(res) == 0
+
+    node.query_and_get_error(
+        f"select * from hdfs('hdfs://hdfs1:9000/skip_empty_files*.parquet') settings hdfs_skip_empty_files=0"
+    )
+
+    node.query_and_get_error(
+        f"select * from hdfs('hdfs://hdfs1:9000/skip_empty_files*.parquet', auto, 'number UInt64') settings hdfs_skip_empty_files=0"
+    )
+
+    res = node.query(
+        f"select * from hdfs('hdfs://hdfs1:9000/skip_empty_files*.parquet') settings hdfs_skip_empty_files=1"
+    )
+
+    assert int(res) == 0
+
+    res = node.query(
+        f"select * from hdfs('hdfs://hdfs1:9000/skip_empty_files*.parquet', auto, 'number UInt64') settings hdfs_skip_empty_files=1"
+    )
+
+    assert int(res) == 0
+
+
 if __name__ == "__main__":
    cluster.start()
    input("Cluster created, press any key to destroy...")
--- a/tests/integration/test_storage_s3/test.py
+++ b/tests/integration/test_storage_s3/test.py
@ -1713,3 +1713,70 @@ def test_s3_list_objects_failure(started_cluster):

        assert ei.value.returncode == 243
        assert "Could not list objects" in ei.value.stderr
+
+
+def test_skip_empty_files(started_cluster):
+    bucket = started_cluster.minio_bucket
+    instance = started_cluster.instances["dummy"]
+
+    instance.query(
+        f"insert into function s3('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files1.parquet', TSVRaw) select * from numbers(0) settings s3_truncate_on_insert=1"
+    )
+
+    instance.query(
+        f"insert into function s3('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files2.parquet') select * from numbers(1) settings s3_truncate_on_insert=1"
+    )
+
+    def test(engine, setting):
+        instance.query_and_get_error(
+            f"select * from {engine}('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files1.parquet') settings {setting}=0"
+        )
+
+        instance.query_and_get_error(
+            f"select * from {engine}('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files1.parquet', auto, 'number UINt64') settings {setting}=0"
+        )
+
+        instance.query_and_get_error(
+            f"select * from {engine}('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files1.parquet') settings {setting}=1"
+        )
+
+        res = instance.query(
+            f"select * from {engine}('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files1.parquet', auto, 'number UInt64') settings {setting}=1"
+        )
+
+        assert len(res) == 0
+
+        instance.query_and_get_error(
+            f"select * from {engine}('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files{{1,2}}.parquet') settings {setting}=0"
+        )
+
+        instance.query_and_get_error(
+            f"select * from {engine}('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files{{1,2}}.parquet', auto, 'number UInt64') settings {setting}=0"
+        )
+
+        res = instance.query(
+            f"select * from {engine}('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files{{1,2}}.parquet') settings {setting}=1"
+        )
+
+        assert int(res) == 0
+
+        res = instance.query(
+            f"select * from {engine}('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files{{1,2}}.parquet', auto, 'number UInt64') settings {setting}=1"
+        )
+
+        assert int(res) == 0
+
+    test("s3", "s3_skip_empty_files")
+    test("url", "engine_url_skip_empty_files")
+
+    res = instance.query(
+        f"select * from url('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files{{1|2}}.parquet') settings engine_url_skip_empty_files=1"
+    )
+
+    assert int(res) == 0
+
+    res = instance.query(
+        f"select * from url('http://{started_cluster.minio_host}:{started_cluster.minio_port}/{bucket}/skip_empty_files{{11|1|22}}.parquet') settings engine_url_skip_empty_files=1"
+    )
+
+    assert len(res.strip()) == 0
--- a/tests/integration/test_ttl_move/configs/config.d/storage_configuration.xml
+++ b/tests/integration/test_ttl_move/configs/config.d/storage_configuration.xml
@ -107,4 +107,5 @@

 </storage_configuration>

+<allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
 </clickhouse>
--- a/tests/integration/test_ttl_move/test.py
+++ b/tests/integration/test_ttl_move/test.py
@ -1549,7 +1549,7 @@ def test_double_move_while_select(started_cluster, name, positive):
            ) ENGINE = MergeTree
            ORDER BY tuple()
            PARTITION BY n
-            SETTINGS storage_policy='small_jbod_with_external'
+            SETTINGS storage_policy='small_jbod_with_external',temporary_directories_lifetime=1
        """.format(
                name=name
            )
--- a/tests/integration/test_ttl_replicated/configs/compat.xml
+++ b/tests/integration/test_ttl_replicated/configs/compat.xml
@ -0,0 +1,4 @@
+<clickhouse>
+    <replicated_merge_tree_paranoid_check_on_drop_range>0</replicated_merge_tree_paranoid_check_on_drop_range>
+    <replicated_merge_tree_paranoid_check_on_startup>0</replicated_merge_tree_paranoid_check_on_startup>
+</clickhouse>
--- a/tests/integration/test_ttl_replicated/test.py
+++ b/tests/integration/test_ttl_replicated/test.py
@ -19,6 +19,9 @@ node4 = cluster.add_instance(
    tag="20.12.4.5",
    stay_alive=True,
    with_installed_binary=True,
+    main_configs=[
+        "configs/compat.xml",
+    ],
 )

 node5 = cluster.add_instance(
@ -28,6 +31,9 @@ node5 = cluster.add_instance(
    tag="20.12.4.5",
    stay_alive=True,
    with_installed_binary=True,
+    main_configs=[
+        "configs/compat.xml",
+    ],
 )
 node6 = cluster.add_instance(
    "node6",
@ -36,6 +42,9 @@ node6 = cluster.add_instance(
    tag="20.12.4.5",
    stay_alive=True,
    with_installed_binary=True,
+    main_configs=[
+        "configs/compat.xml",
+    ],
 )


@ -517,7 +526,7 @@ def test_ttl_compatibility(started_cluster, node_left, node_right, num_run):
                ENGINE = ReplicatedMergeTree('/clickhouse/tables/test/test_ttl_delete_{suff}', '{replica}')
                ORDER BY id PARTITION BY toDayOfMonth(date)
                TTL date + INTERVAL 3 SECOND
-                SETTINGS max_number_of_merges_with_ttl_in_pool=100, max_replicated_merges_with_ttl_in_queue=100, remove_empty_parts=0
+                SETTINGS max_number_of_merges_with_ttl_in_pool=100, max_replicated_merges_with_ttl_in_queue=100
            """.format(
                suff=num_run, replica=node.name
            )
@ -529,7 +538,7 @@ def test_ttl_compatibility(started_cluster, node_left, node_right, num_run):
                ENGINE = ReplicatedMergeTree('/clickhouse/tables/test/test_ttl_group_by_{suff}', '{replica}')
                ORDER BY id PARTITION BY toDayOfMonth(date)
                TTL date + INTERVAL 3 SECOND GROUP BY id SET val = sum(val)
-                SETTINGS max_number_of_merges_with_ttl_in_pool=100, max_replicated_merges_with_ttl_in_queue=100, remove_empty_parts=0
+                SETTINGS max_number_of_merges_with_ttl_in_pool=100, max_replicated_merges_with_ttl_in_queue=100
            """.format(
                suff=num_run, replica=node.name
            )
@ -541,7 +550,7 @@ def test_ttl_compatibility(started_cluster, node_left, node_right, num_run):
                ENGINE = ReplicatedMergeTree('/clickhouse/tables/test/test_ttl_where_{suff}', '{replica}')
                ORDER BY id PARTITION BY toDayOfMonth(date)
                TTL date + INTERVAL 3 SECOND DELETE WHERE id % 2 = 1
-                SETTINGS max_number_of_merges_with_ttl_in_pool=100, max_replicated_merges_with_ttl_in_queue=100, remove_empty_parts=0
+                SETTINGS max_number_of_merges_with_ttl_in_pool=100, max_replicated_merges_with_ttl_in_queue=100
            """.format(
                suff=num_run, replica=node.name
            )
--- a/tests/integration/test_version_update_after_mutation/configs/compat.xml
+++ b/tests/integration/test_version_update_after_mutation/configs/compat.xml
@ -0,0 +1,4 @@
+<clickhouse>
+    <replicated_merge_tree_paranoid_check_on_drop_range>0</replicated_merge_tree_paranoid_check_on_drop_range>
+    <replicated_merge_tree_paranoid_check_on_startup>0</replicated_merge_tree_paranoid_check_on_startup>
+</clickhouse>
--- a/tests/integration/test_version_update_after_mutation/test.py
+++ b/tests/integration/test_version_update_after_mutation/test.py
@ -13,6 +13,9 @@ node1 = cluster.add_instance(
    tag="20.4.9.110",
    with_installed_binary=True,
    stay_alive=True,
+    main_configs=[
+        "configs/compat.xml",
+    ],
 )
 node2 = cluster.add_instance(
    "node2",
@ -21,6 +24,9 @@ node2 = cluster.add_instance(
    tag="20.4.9.110",
    with_installed_binary=True,
    stay_alive=True,
+    main_configs=[
+        "configs/compat.xml",
+    ],
 )
 node3 = cluster.add_instance(
    "node3",
@ -29,6 +35,9 @@ node3 = cluster.add_instance(
    tag="20.4.9.110",
    with_installed_binary=True,
    stay_alive=True,
+    main_configs=[
+        "configs/compat.xml",
+    ],
 )


--- a/tests/integration/test_zero_copy_fetch/configs/storage_conf.xml
+++ b/tests/integration/test_zero_copy_fetch/configs/storage_conf.xml
@ -38,4 +38,5 @@
    <merge_tree>
        <allow_remote_fs_zero_copy_replication>true</allow_remote_fs_zero_copy_replication>
    </merge_tree>
+    <allow_remove_stale_moving_parts>true</allow_remove_stale_moving_parts>
 </clickhouse>
--- a/tests/integration/test_zero_copy_fetch/test.py
+++ b/tests/integration/test_zero_copy_fetch/test.py
@ -45,7 +45,7 @@ CREATE TABLE test1 (EventDate Date, CounterID UInt32)
 ENGINE = ReplicatedMergeTree('/clickhouse-tables/test1', 'r1')
 PARTITION BY toMonday(EventDate)
 ORDER BY (CounterID, EventDate)
-SETTINGS index_granularity = 8192, storage_policy = 's3'"""
+SETTINGS index_granularity = 8192, storage_policy = 's3', temporary_directories_lifetime=1"""
    )

    node1.query(
--- a/tests/queries/0_stateless/02444_async_broken_outdated_part_loading.reference
+++ b/tests/queries/0_stateless/02444_async_broken_outdated_part_loading.reference
@ -0,0 +1,5 @@
+1	1	all_0_1_1
+1	2	all_0_1_1
+0
+2	1	all_0_1_1
+2	2	all_0_1_1
--- a/tests/queries/0_stateless/02444_async_broken_outdated_part_loading.sh
+++ b/tests/queries/0_stateless/02444_async_broken_outdated_part_loading.sh
@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Tags: long, zookeeper
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+$CLICKHOUSE_CLIENT -q "drop table if exists rmt sync;"
+$CLICKHOUSE_CLIENT -q "create table rmt (n int) engine=ReplicatedMergeTree('/test/02444/$CLICKHOUSE_TEST_ZOOKEEPER_PREFIX/rmt', '1') order by n"
+
+$CLICKHOUSE_CLIENT --insert_keeper_fault_injection_probability=0 -q "insert into rmt values (1);"
+$CLICKHOUSE_CLIENT --insert_keeper_fault_injection_probability=0 -q "insert into rmt values (2);"
+
+$CLICKHOUSE_CLIENT -q "system sync replica rmt pull;"
+$CLICKHOUSE_CLIENT --optimize_throw_if_noop=1 -q "optimize table rmt final"
+$CLICKHOUSE_CLIENT -q "system sync replica rmt;"
+$CLICKHOUSE_CLIENT -q "select 1, *, _part from rmt order by n;"
+
+path=$($CLICKHOUSE_CLIENT -q "select path from system.parts where database='$CLICKHOUSE_DATABASE' and table='rmt' and name='all_1_1_0'")
+# ensure that path is absolute before removing
+$CLICKHOUSE_CLIENT -q "select throwIf(substring('$path', 1, 1) != '/', 'Path is relative: $path')" || exit
+rm -f "$path/*.bin"
+
+$CLICKHOUSE_CLIENT -q "detach table rmt sync;"
+$CLICKHOUSE_CLIENT -q "attach table rmt;"
+$CLICKHOUSE_CLIENT -q "select 2, *, _part from rmt order by n;"
+
+$CLICKHOUSE_CLIENT -q "truncate table rmt;"
+
+$CLICKHOUSE_CLIENT -q "detach table rmt sync;"
+$CLICKHOUSE_CLIENT -q "attach table rmt;"
+
+$CLICKHOUSE_CLIENT -q "SELECT table, lost_part_count FROM system.replicas WHERE database=currentDatabase() AND lost_part_count!=0";
+
+$CLICKHOUSE_CLIENT -q "drop table rmt sync;"
--- a/tests/queries/0_stateless/02771_skip_empty_files.reference
+++ b/tests/queries/0_stateless/02771_skip_empty_files.reference
@ -0,0 +1,7 @@
+1
+1
+1
+1
+1
+0
+0
--- a/tests/queries/0_stateless/02771_skip_empty_files.sh
+++ b/tests/queries/0_stateless/02771_skip_empty_files.sh
@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Tags: no-fasttest
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CUR_DIR"/../shell_config.sh
+
+FILE_PREFIX=$CLICKHOUSE_TEST_UNIQUE_NAME
+touch $FILE_PREFIX-1.parquet
+$CLICKHOUSE_LOCAL -q "select * from numbers(1) format Parquet" > $FILE_PREFIX-2.parquet
+$CLICKHOUSE_LOCAL -q "select * from file('$FILE_PREFIX-1.parquet') settings engine_file_skip_empty_files=0" 2>&1 | grep -c "CANNOT_EXTRACT_TABLE_STRUCTURE"
+$CLICKHOUSE_LOCAL -q "select * from file('$FILE_PREFIX-1.parquet', auto, 'number UInt64') settings engine_file_skip_empty_files=0" 2>&1 | grep -c "Exception"
+$CLICKHOUSE_LOCAL -q "select * from file('$FILE_PREFIX-1.parquet') settings engine_file_skip_empty_files=1" 2>&1 | grep -c "Exception"
+$CLICKHOUSE_LOCAL -q "select * from file('$FILE_PREFIX-1.parquet', auto, 'number UInt64') settings engine_file_skip_empty_files=1"
+$CLICKHOUSE_LOCAL -q "select * from file('$FILE_PREFIX-*.parquet') settings engine_file_skip_empty_files=0" 2>&1 | grep -c "Exception"
+$CLICKHOUSE_LOCAL -q "select * from file('$FILE_PREFIX-*.parquet', auto, 'number UInt64') settings engine_file_skip_empty_files=0" 2>&1 | grep -c "Exception"
+$CLICKHOUSE_LOCAL -q "select * from file('$FILE_PREFIX-*.parquet') settings engine_file_skip_empty_files=1"
+$CLICKHOUSE_LOCAL -q "select * from file('$FILE_PREFIX-*.parquet', auto, 'number UInt64') settings engine_file_skip_empty_files=1"
+
+rm $FILE_PREFIX-*
--- a/tests/queries/0_stateless/02785_text_with_whitespace_tab_field_delimiter.reference
+++ b/tests/queries/0_stateless/02785_text_with_whitespace_tab_field_delimiter.reference
@ -0,0 +1,2 @@
+1	a	b
+2	c	d
--- a/tests/queries/0_stateless/02785_text_with_whitespace_tab_field_delimiter.sh
+++ b/tests/queries/0_stateless/02785_text_with_whitespace_tab_field_delimiter.sh
@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+# NOTE: this sh wrapper is required because of shell_config
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+$CLICKHOUSE_CLIENT -q "drop table if exists test_whitespace"
+$CLICKHOUSE_CLIENT -q "drop table if exists test_tab"
+$CLICKHOUSE_CLIENT -q "create table test_whitespace (x UInt32, y String, z String) engine=MergeTree order by x"
+$CLICKHOUSE_CLIENT -q "create table test_tab (x UInt32, y String, z String) engine=MergeTree order by x"
+cat $CURDIR/data_csv/csv_with_space_delimiter.csv | ${CLICKHOUSE_CLIENT} -q "INSERT INTO test_whitespace SETTINGS format_csv_delimiter=' ', input_format_csv_allow_whitespace_or_tab_as_delimiter=true FORMAT CSV"
+cat $CURDIR/data_csv/csv_with_tab_delimiter.csv | ${CLICKHOUSE_CLIENT} -q "INSERT INTO test_tab SETTINGS format_csv_delimiter='\t', input_format_csv_allow_whitespace_or_tab_as_delimiter=true FORMAT CSV"
+$CLICKHOUSE_CLIENT -q "select * from test_whitespace"
+$CLICKHOUSE_CLIENT -q "select * from test_tab"
+$CLICKHOUSE_CLIENT -q "drop table test_whitespace"
+$CLICKHOUSE_CLIENT -q "drop table test_tab"; 
--- a/tests/queries/0_stateless/data_csv/csv_with_space_delimiter.csv
+++ b/tests/queries/0_stateless/data_csv/csv_with_space_delimiter.csv
@ -0,0 +1 @@
+1 a b
--- a/tests/queries/0_stateless/data_csv/csv_with_tab_delimiter.csv
+++ b/tests/queries/0_stateless/data_csv/csv_with_tab_delimiter.csv
@ -0,0 +1 @@
+2	c	d