Remove default constructor of ReadSettings

kssenii · kssenii · commit ba1a23d0ea3f · 2024-07-01T14:54:51.000+02:00
diff --git a/programs/disks/CommandCopy.cpp b/programs/disks/CommandCopy.cpp
@@ -57,7 +57,7 @@ class CommandCopy final : public ICommand
         String relative_path_from = validatePathAndGetAsRelative(path_from);
         String relative_path_to = validatePathAndGetAsRelative(path_to);
 
-        disk_from->copyDirectoryContent(relative_path_from, disk_to, relative_path_to, /* read_settings= */ {}, /* write_settings= */ {}, /* cancellation_hook= */ {});
+        disk_from->copyDirectoryContent(relative_path_from, disk_to, relative_path_to, /* read_settings= */ getReadSettings(), /* write_settings= */ {}, /* cancellation_hook= */ {});
     }
 };
 }
diff --git a/programs/static-files-disk-uploader/static-files-disk-uploader.cpp b/programs/static-files-disk-uploader/static-files-disk-uploader.cpp
@@ -58,7 +58,7 @@ void processFile(const fs::path & file_path, const fs::path & dst_path, bool tes
     }
     else
     {
-        ReadSettings read_settings{};
+        ReadSettings read_settings = getReadSettings();
         read_settings.local_fs_method = LocalFSReadMethod::pread;
         auto src_buf = createReadBufferFromFileBase(file_path, read_settings, fs::file_size(file_path));
         std::shared_ptr<WriteBuffer> dst_buf;
diff --git a/src/Backups/BackupFactory.h b/src/Backups/BackupFactory.h
@@ -42,7 +42,7 @@ class BackupFactory : boost::noncopyable
         bool allow_azure_native_copy = true;
         bool use_same_s3_credentials_for_base_backup = false;
         bool azure_attempt_to_create_container = true;
-        ReadSettings read_settings;
+        ReadSettings read_settings = getReadSettings();
         WriteSettings write_settings;
     };
 
diff --git a/src/Backups/tests/gtest_backup_entries.cpp b/src/Backups/tests/gtest_backup_entries.cpp
@@ -70,22 +70,22 @@ class BackupEntriesTest : public ::testing::Test
 
     static String getChecksum(const BackupEntryPtr & backup_entry)
     {
-        return getHexUIntUppercase(backup_entry->getChecksum({}));
+        return getHexUIntUppercase(backup_entry->getChecksum(getReadSettings()));
     }
 
     static const constexpr std::string_view NO_CHECKSUM = "no checksum";
 
     static String getPartialChecksum(const BackupEntryPtr & backup_entry, size_t prefix_length)
     {
-        auto partial_checksum = backup_entry->getPartialChecksum(prefix_length, {});
+        auto partial_checksum = backup_entry->getPartialChecksum(prefix_length, getReadSettings());
         if (!partial_checksum)
             return String{NO_CHECKSUM};
         return getHexUIntUppercase(*partial_checksum);
     }
 
     static String readAll(const BackupEntryPtr & backup_entry)
     {
-        auto in = backup_entry->getReadBuffer({});
+        auto in = backup_entry->getReadBuffer(getReadSettings());
         String str;
         readStringUntilEOF(str, *in);
         return str;
diff --git a/src/Compression/getCompressionCodecForFile.cpp b/src/Compression/getCompressionCodecForFile.cpp
@@ -15,7 +15,7 @@ using Checksum = CityHash_v1_0_2::uint128;
 
 CompressionCodecPtr getCompressionCodecForFile(const IDataPartStorage & data_part_storage, const String & relative_path)
 {
-    auto read_buffer = data_part_storage.readFile(relative_path, {}, std::nullopt, std::nullopt);
+    auto read_buffer = data_part_storage.readFile(relative_path, getReadSettings(), std::nullopt, std::nullopt);
     read_buffer->ignore(sizeof(Checksum));
 
     UInt8 header_size = ICompressionCodec::getHeaderSize();
diff --git a/src/Coordination/KeeperCommon.cpp b/src/Coordination/KeeperCommon.cpp
@@ -107,7 +107,7 @@ void moveFileBetweenDisks(
             "creating temporary file"))
         return;
 
-    if (!run_with_retries([&] { disk_from->copyFile(from_path, *disk_to, path_to, {}); }, "copying file"))
+    if (!run_with_retries([&] { disk_from->copyFile(from_path, *disk_to, path_to, getReadSettings()); }, "copying file"))
         return;
 
     if (!run_with_retries([&] { disk_to->removeFileIfExists(tmp_file_name); }, "removing temporary file"))
diff --git a/src/Coordination/KeeperSnapshotManagerS3.cpp b/src/Coordination/KeeperSnapshotManagerS3.cpp
@@ -173,7 +173,8 @@ void KeeperSnapshotManagerS3::uploadSnapshotImpl(const SnapshotFileInfo & snapsh
 
         LOG_INFO(log, "Will try to upload snapshot on {} to S3", snapshot_path);
 
-        auto snapshot_file = snapshot_disk->readFile(snapshot_path, getReadSettings());
+        auto read_settings = getReadSettings();
+        auto snapshot_file = snapshot_disk->readFile(snapshot_path, read_settings);
 
         auto snapshot_name = fs::path(snapshot_path).filename().string();
         auto lock_file = fmt::format(".{}_LOCK", snapshot_name);
@@ -208,7 +209,7 @@ void KeeperSnapshotManagerS3::uploadSnapshotImpl(const SnapshotFileInfo & snapsh
             lock_file,
             "",
             request_settings_2,
-            {}
+            read_settings
         };
 
         std::string read_uuid;
diff --git a/src/Coordination/KeeperStateManager.cpp b/src/Coordination/KeeperStateManager.cpp
@@ -339,7 +339,7 @@ void KeeperStateManager::save_state(const nuraft::srv_state & state)
     {
         auto buf = disk->writeFile(copy_lock_file);
         buf->finalize();
-        disk->copyFile(server_state_file_name, *disk, old_path, ReadSettings{});
+        disk->copyFile(server_state_file_name, *disk, old_path, getReadSettings());
         disk->removeFile(copy_lock_file);
         disk->removeFile(old_path);
     }
diff --git a/src/Coordination/Standalone/Context.cpp b/src/Coordination/Standalone/Context.cpp
@@ -387,7 +387,7 @@ ThrottlerPtr Context::getLocalWriteThrottler() const
 
 ReadSettings Context::getReadSettings() const
 {
-    return ReadSettings{};
+    return ReadSettings(*this);
 }
 
 ResourceManagerPtr Context::getResourceManager() const
diff --git a/src/Disks/DiskLocal.cpp b/src/Disks/DiskLocal.cpp
@@ -525,7 +525,7 @@ void DiskLocal::shutdown()
 std::optional<UInt32> DiskLocal::readDiskCheckerMagicNumber() const noexcept
 try
 {
-    ReadSettings read_settings;
+    ReadSettings read_settings = getReadSettings();
     /// Proper disk read checking requires direct io
     read_settings.direct_io_threshold = 1;
     auto buf = readFile(disk_checker_path, read_settings, {}, {});
diff --git a/src/Disks/IO/ReadBufferFromWebServer.h b/src/Disks/IO/ReadBufferFromWebServer.h
@@ -21,7 +21,7 @@ class ReadBufferFromWebServer : public ReadBufferFromFileBase
         const String & url_,
         ContextPtr context_,
         size_t file_size_,
-        const ReadSettings & settings_ = {},
+        const ReadSettings & settings_,
         bool use_external_buffer_ = false,
         size_t read_until_position = 0);
 
diff --git a/src/Disks/ObjectStorages/DiskObjectStorage.cpp b/src/Disks/ObjectStorages/DiskObjectStorage.cpp
@@ -70,7 +70,7 @@ DiskObjectStorage::DiskObjectStorage(
     , send_metadata(config.getBool(config_prefix + ".send_metadata", false))
     , read_resource_name(config.getString(config_prefix + ".read_resource", ""))
     , write_resource_name(config.getString(config_prefix + ".write_resource", ""))
-    , metadata_helper(std::make_unique<DiskObjectStorageRemoteMetadataRestoreHelper>(this, ReadSettings{}, WriteSettings{}))
+    , metadata_helper(std::make_unique<DiskObjectStorageRemoteMetadataRestoreHelper>(this, getReadSettings(), WriteSettings{}))
 {
     data_source_description = DataSourceDescription{
         .type = DataSourceType::ObjectStorage,
@@ -155,7 +155,7 @@ void DiskObjectStorage::copyFile( /// NOLINT
             /// It may use s3-server-side copy
             auto & to_disk_object_storage = dynamic_cast<DiskObjectStorage &>(to_disk);
             auto transaction = createObjectStorageTransactionToAnotherDisk(to_disk_object_storage);
-            transaction->copyFile(from_file_path, to_file_path, /*read_settings*/ {}, /*write_settings*/ {});
+            transaction->copyFile(from_file_path, to_file_path, /*read_settings*/ getReadSettings(), /*write_settings*/ {});
             transaction->commit();
     }
     else
diff --git a/src/Disks/ObjectStorages/DiskObjectStorageRemoteMetadataRestoreHelper.cpp b/src/Disks/ObjectStorages/DiskObjectStorageRemoteMetadataRestoreHelper.cpp
@@ -73,7 +73,7 @@ int DiskObjectStorageRemoteMetadataRestoreHelper::readSchemaVersion(IObjectStora
     if (!object_storage->exists(object))
         return version;
 
-    auto buf = object_storage->readObject(object, ReadSettings{});
+    auto buf = object_storage->readObject(object, getReadSettings());
     readIntText(version, *buf);
 
     return version;
diff --git a/src/Disks/ObjectStorages/MetadataStorageFromDiskTransactionOperations.cpp b/src/Disks/ObjectStorages/MetadataStorageFromDiskTransactionOperations.cpp
@@ -71,7 +71,7 @@ UnlinkFileOperation::UnlinkFileOperation(const std::string & path_, IDisk & disk
 
 void UnlinkFileOperation::execute(std::unique_lock<SharedMutex> &)
 {
-    auto buf = disk.readFile(path, ReadSettings{}, std::nullopt, disk.getFileSize(path));
+    auto buf = disk.readFile(path, getReadSettings(), std::nullopt, disk.getFileSize(path));
     readStringUntilEOF(prev_data, *buf);
     disk.removeFile(path);
 }
diff --git a/src/Disks/ObjectStorages/MetadataStorageFromPlainObjectStorageOperations.cpp b/src/Disks/ObjectStorages/MetadataStorageFromPlainObjectStorageOperations.cpp
@@ -105,7 +105,7 @@ std::unique_ptr<WriteBufferFromFileBase> MetadataStorageFromPlainObjectStorageMo
     if (validate_content)
     {
         std::string data;
-        auto read_buf = object_storage->readObject(object, ReadSettings{});
+        auto read_buf = object_storage->readObject(object, getReadSettings());
         readStringUntilEOF(data, *read_buf);
         if (data != path_from)
             throw Exception(
diff --git a/src/Disks/ObjectStorages/MetadataStorageFromPlainRewritableObjectStorage.cpp b/src/Disks/ObjectStorages/MetadataStorageFromPlainRewritableObjectStorage.cpp
@@ -32,7 +32,7 @@ MetadataStorageFromPlainObjectStorage::PathMap loadPathPrefixMap(const std::stri
 
         StoredObject object{file->relative_path};
 
-        auto read_buf = object_storage->readObject(object, ReadSettings{});
+        auto read_buf = object_storage->readObject(object, getReadSettings());
         String local_path;
         readStringUntilEOF(local_path, *read_buf);
 
diff --git a/src/Disks/tests/gtest_asynchronous_bounded_read_buffer.cpp b/src/Disks/tests/gtest_asynchronous_bounded_read_buffer.cpp
@@ -48,10 +48,11 @@ TEST_F(AsynchronousBoundedReadBufferTest, setReadUntilPosition)
 {
     String file_path = makeTempFile(getAlphabetWithDigits());
     ThreadPoolRemoteFSReader remote_fs_reader(4, 0);
+    auto read_settings = getReadSettings();
 
     for (bool with_prefetch : {false, true})
     {
-        AsynchronousBoundedReadBuffer read_buffer(createReadBufferFromFileBase(file_path, {}), remote_fs_reader, {});
+        AsynchronousBoundedReadBuffer read_buffer(createReadBufferFromFileBase(file_path, read_settings), remote_fs_reader, read_settings);
         read_buffer.setReadUntilPosition(20);
 
         auto try_read = [&](size_t count)
diff --git a/src/Disks/tests/gtest_disk_encrypted.cpp b/src/Disks/tests/gtest_disk_encrypted.cpp
@@ -59,15 +59,15 @@ class DiskEncryptedTest : public ::testing::Test
 
     String getFileContents(const String & file_name, std::optional<size_t> file_size = {})
     {
-        auto buf = encrypted_disk->readFile(file_name, /* settings= */ {}, /* read_hint= */ {}, file_size);
+        auto buf = encrypted_disk->readFile(file_name, /* settings= */ getReadSettings(), /* read_hint= */ {}, file_size);
         String str;
         readStringUntilEOF(str, *buf);
         return str;
     }
 
     static String getBinaryRepresentation(const String & abs_path)
     {
-        auto buf = createReadBufferFromFileBase(abs_path, /* settings= */ {});
+        auto buf = createReadBufferFromFileBase(abs_path, /* settings= */ getReadSettings());
         String str;
         readStringUntilEOF(str, *buf);
         return str;
diff --git a/src/IO/ReadSettings.h b/src/IO/ReadSettings.h
@@ -63,10 +63,16 @@ enum class RemoteFSReadMethod : uint8_t
 class MMappedFileCache;
 class PageCache;
 class Context;
+struct ReadSettings;
 
 struct ReadSettings
 {
+    friend ReadSettings getReadSettings();
+
+private:
     ReadSettings() = default;
+
+public:
     explicit ReadSettings(const Context & context);
 
     /// Method to use reading from local filesystem.
diff --git a/src/IO/ReadWriteBufferFromHTTP.h b/src/IO/ReadWriteBufferFromHTTP.h
@@ -197,7 +197,7 @@ class BuilderRWBufferFromHTTP
     std::string method = Poco::Net::HTTPRequest::HTTP_GET;
     HTTPConnectionGroupType connection_group = HTTPConnectionGroupType::HTTP;
     ProxyConfiguration proxy_config{};
-    ReadSettings read_settings{};
+    ReadSettings read_settings;
     ConnectionTimeouts timeouts{};
     const RemoteHostFilter * remote_host_filter = nullptr;
     size_t buffer_size = DBMS_DEFAULT_BUFFER_SIZE;
@@ -211,6 +211,7 @@ class BuilderRWBufferFromHTTP
 public:
     explicit BuilderRWBufferFromHTTP(Poco::URI uri_)
         : uri(uri_)
+        , read_settings(getReadSettings())
     {}
 
 /// NOLINTBEGIN(bugprone-macro-parentheses)
diff --git a/src/IO/S3/tests/gtest_aws_s3_client.cpp b/src/IO/S3/tests/gtest_aws_s3_client.cpp
@@ -68,7 +68,7 @@ void doReadRequest(std::shared_ptr<const DB::S3::Client> client, const DB::S3::U
     String version_id;
     UInt64 max_single_read_retries = 1;
 
-    DB::ReadSettings read_settings;
+    DB::ReadSettings read_settings = DB::getReadSettings();
     DB::S3::RequestSettings request_settings;
     request_settings.max_single_read_retries = max_single_read_retries;
     DB::ReadBufferFromS3 read_buffer(
diff --git a/src/Interpreters/tests/gtest_filecache.cpp b/src/Interpreters/tests/gtest_filecache.cpp
@@ -1074,7 +1074,7 @@ TEST_F(FileCacheTest, CachedReadBuffer)
     settings.max_elements = 10;
     settings.boundary_alignment = 1;
 
-    ReadSettings read_settings;
+    ReadSettings read_settings = getReadSettings();
     read_settings.enable_filesystem_cache = true;
     read_settings.local_fs_method = LocalFSReadMethod::pread;
 
@@ -1285,7 +1285,7 @@ TEST_F(FileCacheTest, SLRUPolicy)
     }
 
     {
-        ReadSettings read_settings;
+        ReadSettings read_settings = getReadSettings();
         read_settings.enable_filesystem_cache = true;
         read_settings.local_fs_method = LocalFSReadMethod::pread;
 
diff --git a/src/Storages/Cache/RemoteCacheController.cpp b/src/Storages/Cache/RemoteCacheController.cpp
@@ -211,11 +211,8 @@ void RemoteCacheController::close()
 
 std::unique_ptr<ReadBufferFromFileBase> RemoteCacheController::allocFile()
 {
-    ReadSettings settings;
     //settings.local_fs_method = LocalFSReadMethod::read;
-    auto file_buffer = createReadBufferFromFileBase((local_path / "data.bin").string(), settings);
-
-    return file_buffer;
+    return createReadBufferFromFileBase((local_path / "data.bin").string(), getReadSettings());
 }
 
 }
diff --git a/src/Storages/MergeTree/DataPartStorageOnDiskBase.cpp b/src/Storages/MergeTree/DataPartStorageOnDiskBase.cpp
@@ -117,7 +117,7 @@ bool DataPartStorageOnDiskBase::looksLikeBrokenDetachedPartHasTheSameContent(con
 
     if (!original_checksums_content)
     {
-        auto in = storage_from_detached->readFile("checksums.txt", /* settings */ {}, /* read_hint */ {}, /* file_size */ {});
+        auto in = storage_from_detached->readFile("checksums.txt", /* settings */ getReadSettings(), /* read_hint */ {}, /* file_size */ {});
         original_checksums_content.emplace();
         readStringUntilEOF(*original_checksums_content, *in);
     }
@@ -127,7 +127,7 @@ bool DataPartStorageOnDiskBase::looksLikeBrokenDetachedPartHasTheSameContent(con
 
     String detached_checksums_content;
     {
-        auto in = readFile("checksums.txt", /* settings */ {}, /* read_hint */ {}, /* file_size */ {});
+        auto in = readFile("checksums.txt", /* settings */ getReadSettings(), /* read_hint */ {}, /* file_size */ {});
         readStringUntilEOF(detached_checksums_content, *in);
     }
 
@@ -801,7 +801,7 @@ void DataPartStorageOnDiskBase::remove(
                 try
                 {
                     MergeTreeDataPartChecksums tmp_checksums;
-                    auto in = projection_storage->readFile(checksums_name, {}, {}, {});
+                    auto in = projection_storage->readFile(checksums_name, getReadSettings(), {}, {});
                     tmp_checksums.read(*in);
 
                     clearDirectory(fs::path(to) / name, *can_remove_description, tmp_checksums, is_temp, log);
diff --git a/src/Storages/MergeTree/DataPartStorageOnDiskFull.cpp b/src/Storages/MergeTree/DataPartStorageOnDiskFull.cpp
@@ -209,7 +209,7 @@ void DataPartStorageOnDiskFull::copyFileFrom(const IDataPartStorage & source, co
         fs::path(source_on_disk->getRelativePath()) / from,
         *volume->getDisk(),
         fs::path(root_path) / part_dir / to,
-        Context::getGlobalContextInstance()->getReadSettings());
+        getReadSettings());
 }
 
 void DataPartStorageOnDiskFull::createProjection(const std::string & name)
diff --git a/src/Storages/MergeTree/GinIndexStore.cpp b/src/Storages/MergeTree/GinIndexStore.cpp
@@ -190,7 +190,7 @@ UInt32 GinIndexStore::getNextSegmentIDRange(const String & file_name, size_t n)
     /// Read id in file
     UInt32 result = 0;
     {
-        std::unique_ptr<DB::ReadBufferFromFileBase> istr = this->storage->readFile(file_name, {}, std::nullopt, std::nullopt);
+        std::unique_ptr<DB::ReadBufferFromFileBase> istr = this->storage->readFile(file_name, getReadSettings(), std::nullopt, std::nullopt);
 
         /// Skip version
         istr->seek(1, SEEK_SET);
@@ -236,7 +236,7 @@ UInt32 GinIndexStore::getNumOfSegments()
 
     UInt32 result = 0;
     {
-        std::unique_ptr<DB::ReadBufferFromFileBase> istr = this->storage->readFile(segment_id_file_name, {}, std::nullopt, std::nullopt);
+        std::unique_ptr<DB::ReadBufferFromFileBase> istr = this->storage->readFile(segment_id_file_name, getReadSettings(), std::nullopt, std::nullopt);
 
         uint8_t version = 0;
         readBinary(version, *istr);
@@ -361,10 +361,11 @@ void GinIndexStoreDeserializer::initFileStreams()
     String metadata_file_name = store->getName() + GinIndexStore::GIN_SEGMENT_METADATA_FILE_TYPE;
     String dict_file_name = store->getName() + GinIndexStore::GIN_DICTIONARY_FILE_TYPE;
     String postings_file_name = store->getName() + GinIndexStore::GIN_POSTINGS_FILE_TYPE;
+    auto read_settings = getReadSettings();
 
-    metadata_file_stream = store->storage->readFile(metadata_file_name, {}, std::nullopt, std::nullopt);
-    dict_file_stream = store->storage->readFile(dict_file_name, {}, std::nullopt, std::nullopt);
-    postings_file_stream = store->storage->readFile(postings_file_name, {}, std::nullopt, std::nullopt);
+    metadata_file_stream = store->storage->readFile(metadata_file_name, read_settings, std::nullopt, std::nullopt);
+    dict_file_stream = store->storage->readFile(dict_file_name, read_settings, std::nullopt, std::nullopt);
+    postings_file_stream = store->storage->readFile(postings_file_name, read_settings, std::nullopt, std::nullopt);
 }
 void GinIndexStoreDeserializer::readSegments()
 {
diff --git a/src/Storages/MergeTree/MergeTreeDataPartCompact.cpp b/src/Storages/MergeTree/MergeTreeDataPartCompact.cpp
@@ -112,7 +112,7 @@ void MergeTreeDataPartCompact::loadIndexGranularityImpl(
     size_t marks_file_size = data_part_storage_.getFileSize(marks_file_path);
 
     std::unique_ptr<ReadBufferFromFileBase> buffer = data_part_storage_.readFile(
-        marks_file_path, ReadSettings().adjustBufferSize(marks_file_size), marks_file_size, std::nullopt);
+        marks_file_path, getReadSettings().adjustBufferSize(marks_file_size), marks_file_size, std::nullopt);
 
     std::unique_ptr<ReadBuffer> marks_reader;
     bool marks_compressed = index_granularity_info_.mark_type.compressed;
diff --git a/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp b/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp
@@ -502,14 +502,14 @@ void MergeTreeDataPartWriterWide::validateColumnOfFixedSize(const NameAndTypePai
     if (!getDataPartStorage().exists(mrk_path))
         return;
 
-    auto mrk_file_in = getDataPartStorage().readFile(mrk_path, {}, std::nullopt, std::nullopt);
+    auto mrk_file_in = getDataPartStorage().readFile(mrk_path, getReadSettings(), std::nullopt, std::nullopt);
     std::unique_ptr<ReadBuffer> mrk_in;
     if (index_granularity_info.mark_type.compressed)
         mrk_in = std::make_unique<CompressedReadBufferFromFile>(std::move(mrk_file_in));
     else
         mrk_in = std::move(mrk_file_in);
 
-    DB::CompressedReadBufferFromFile bin_in(getDataPartStorage().readFile(bin_path, {}, std::nullopt, std::nullopt));
+    DB::CompressedReadBufferFromFile bin_in(getDataPartStorage().readFile(bin_path, getReadSettings(), std::nullopt, std::nullopt));
     bool must_be_last = false;
     UInt64 offset_in_compressed_file = 0;
     UInt64 offset_in_decompressed_block = 0;
diff --git a/src/Storages/MergeTree/MergeTreeIOSettings.h b/src/Storages/MergeTree/MergeTreeIOSettings.h
@@ -22,7 +22,7 @@ enum class CompactPartsReadMethod : uint8_t
 struct MergeTreeReaderSettings
 {
     /// Common read settings.
-    ReadSettings read_settings;
+    ReadSettings read_settings = getReadSettings();
     /// If save_marks_in_cache is false, then, if marks are not in cache,
     ///  we will load them but won't save in the cache, to avoid evicting other data.
     bool save_marks_in_cache = false;
diff --git a/src/Storages/MergeTree/MergeTreeReadTask.h b/src/Storages/MergeTree/MergeTreeReadTask.h
@@ -81,7 +81,7 @@ struct MergeTreeReadTask : private boost::noncopyable
     {
         UncompressedCache * uncompressed_cache = nullptr;
         MarkCache * mark_cache = nullptr;
-        MergeTreeReaderSettings reader_settings{};
+        MergeTreeReaderSettings reader_settings;
         StorageSnapshotPtr storage_snapshot{};
         IMergeTreeReader::ValueSizeMap value_size_map{};
         ReadBufferFromFileBase::ProfileCallback profile_callback{};
diff --git a/src/Storages/MergeTree/checkDataPart.cpp b/src/Storages/MergeTree/checkDataPart.cpp
diff --git a/src/Storages/StorageKeeperMap.cpp b/src/Storages/StorageKeeperMap.cpp
diff --git a/src/Storages/StorageMemory.cpp b/src/Storages/StorageMemory.cpp

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ class CommandCopy final : public ICommand`
`57`	`57`	`String relative_path_from = validatePathAndGetAsRelative(path_from);`
`58`	`58`	`String relative_path_to = validatePathAndGetAsRelative(path_to);`
`59`	`59`
`60`		`- disk_from->copyDirectoryContent(relative_path_from, disk_to, relative_path_to, /* read_settings= / {}, / write_settings= / {}, / cancellation_hook= */ {});`
	`60`	`+ disk_from->copyDirectoryContent(relative_path_from, disk_to, relative_path_to, /* read_settings= / getReadSettings(), / write_settings= / {}, / cancellation_hook= */ {});`
`61`	`61`	`}`
`62`	`62`	`};`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ void processFile(const fs::path & file_path, const fs::path & dst_path, bool tes`
`58`	`58`	`}`
`59`	`59`	`else`
`60`	`60`	`{`
`61`		`- ReadSettings read_settings{};`
	`61`	`+ ReadSettings read_settings = getReadSettings();`
`62`	`62`	`read_settings.local_fs_method = LocalFSReadMethod::pread;`
`63`	`63`	`auto src_buf = createReadBufferFromFileBase(file_path, read_settings, fs::file_size(file_path));`
`64`	`64`	`std::shared_ptr<WriteBuffer> dst_buf;`
Original file line number	Diff line number	Diff line change
`@@ -70,22 +70,22 @@ class BackupEntriesTest : public ::testing::Test`
`70`	`70`
`71`	`71`	`static String getChecksum(const BackupEntryPtr & backup_entry)`
`72`	`72`	`{`
`73`		`- return getHexUIntUppercase(backup_entry->getChecksum({}));`
	`73`	`+ return getHexUIntUppercase(backup_entry->getChecksum(getReadSettings()));`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`static const constexpr std::string_view NO_CHECKSUM = "no checksum";`
`77`	`77`
`78`	`78`	`static String getPartialChecksum(const BackupEntryPtr & backup_entry, size_t prefix_length)`
`79`	`79`	`{`
`80`		`- auto partial_checksum = backup_entry->getPartialChecksum(prefix_length, {});`
	`80`	`+ auto partial_checksum = backup_entry->getPartialChecksum(prefix_length, getReadSettings());`
`81`	`81`	`if (!partial_checksum)`
`82`	`82`	`return String{NO_CHECKSUM};`
`83`	`83`	`return getHexUIntUppercase(*partial_checksum);`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`static String readAll(const BackupEntryPtr & backup_entry)`
`87`	`87`	`{`
`88`		`- auto in = backup_entry->getReadBuffer({});`
	`88`	`+ auto in = backup_entry->getReadBuffer(getReadSettings());`
`89`	`89`	`String str;`
`90`	`90`	`readStringUntilEOF(str, *in);`
`91`	`91`	`return str;`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ using Checksum = CityHash_v1_0_2::uint128;`
`15`	`15`
`16`	`16`	`CompressionCodecPtr getCompressionCodecForFile(const IDataPartStorage & data_part_storage, const String & relative_path)`
`17`	`17`	`{`
`18`		`- auto read_buffer = data_part_storage.readFile(relative_path, {}, std::nullopt, std::nullopt);`
	`18`	`+ auto read_buffer = data_part_storage.readFile(relative_path, getReadSettings(), std::nullopt, std::nullopt);`
`19`	`19`	`read_buffer->ignore(sizeof(Checksum));`
`20`	`20`
`21`	`21`	`UInt8 header_size = ICompressionCodec::getHeaderSize();`
Original file line number	Diff line number	Diff line change
`@@ -339,7 +339,7 @@ void KeeperStateManager::save_state(const nuraft::srv_state & state)`
`339`	`339`	`{`
`340`	`340`	`auto buf = disk->writeFile(copy_lock_file);`
`341`	`341`	`buf->finalize();`
`342`		`- disk->copyFile(server_state_file_name, *disk, old_path, ReadSettings{});`
	`342`	`+ disk->copyFile(server_state_file_name, *disk, old_path, getReadSettings());`
`343`	`343`	`disk->removeFile(copy_lock_file);`
`344`	`344`	`disk->removeFile(old_path);`
`345`	`345`	`}`
Original file line number	Diff line number	Diff line change
`@@ -387,7 +387,7 @@ ThrottlerPtr Context::getLocalWriteThrottler() const`
`387`	`387`
`388`	`388`	`ReadSettings Context::getReadSettings() const`
`389`	`389`	`{`
`390`		`- return ReadSettings{};`
	`390`	`+ return ReadSettings(*this);`
`391`	`391`	`}`
`392`	`392`
`393`	`393`	`ResourceManagerPtr Context::getResourceManager() const`
Original file line number	Diff line number	Diff line change
`@@ -525,7 +525,7 @@ void DiskLocal::shutdown()`
`525`	`525`	`std::optional<UInt32> DiskLocal::readDiskCheckerMagicNumber() const noexcept`
`526`	`526`	`try`
`527`	`527`	`{`
`528`		`- ReadSettings read_settings;`
	`528`	`+ ReadSettings read_settings = getReadSettings();`
`529`	`529`	`/// Proper disk read checking requires direct io`
`530`	`530`	`read_settings.direct_io_threshold = 1;`
`531`	`531`	`auto buf = readFile(disk_checker_path, read_settings, {}, {});`