text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>s_and_checksums) override;
Strings getReplicatedPartNames(const String & table_zk_path, const String & replica_name) const override;
void addReplicatedMutations(
const String & table_zk_path,
const String & table_name_for_logs,
const String & replica_name,
const s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>name));
return res;
}
}
<|fim_prefix|>#include <Backups/BackupCoordinationReplicatedAccess.h>
#include <filesystem>
namespace fs = std::filesystem;
namespace DB
{
BackupCoordinationReplicatedAccess::BackupCoordinationReplicatedAccess() = default;
BackupCoordinationReplicatedAccess::~BackupCoord... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <map>
#include <set>
namespace DB
{
enum class AccessEntityType : uint8_t;
/// This class is used by hosts to coordinate the access entities of ReplicatedAccessStorage they're writing to a backup.
/// It's designed to make all hosts save the same access en... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupCoordinationReplicatedSQLObjects.h>
namespace DB
{
BackupCoordinationReplicatedSQLObjects::BackupCoordinationReplicatedSQLObjects() = default;
BackupCoordinationReplicatedSQLObjects::~BackupCoordinationReplicatedSQLObjects() = default;
void BackupCoordinationReplicatedSQLObject... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ype = std::pair<String, UserDefinedSQLObjectType>;
struct DirPathsAndHost
{
std::unordered_set<String> dir_paths;
String host_to_store;
};
std::map<ZkPathAndObjectType, DirPathsAndHost> dir_paths_by_zk_path;
};
}
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#inclu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ns_for_table_replica.table_name_for_logs;
const auto & replica_name = mutations_for_table_replica.replica_name;
const auto & mutations = mutations_for_table_replica.mutations;
if (prepared)
throw Exception(ErrorCodes::LOGICAL_ERROR, "addMutations() must not be called after preparing")... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
<|fim_prefix|>#pragma once
#include <Backups/IBackupCoordination.h>
#include <map>
#include <memory>
#include <unordered_map>
#include <unordered_set>
namespace DB
{
/// Replicas used this class to coordinate how they're writing replicated tables to a backup.
/// "BACKUP ON CLUSTER" can be executed o... | fim | ClickHouse/ClickHouse | c |
#include <Backups/BackupCoordinationStage.h>
#include <fmt/format.h>
namespace DB
{
String BackupCoordinationStage::formatGatheringMetadata(int attempt_no)
{
return fmt::format("{} ({})", GATHERING_METADATA, attempt_no);
}
}
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
namespace DB
{
namespace BackupCoordinationStage
{
/// Finding all tables and databases which we're going to put to the backup and collecting their metadata.
constexpr const char * GATHERING_METADATA = "gathering metadata";
String formatGatheringMetada... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupCoordinationStageSync.h>
#include <base/chrono_io.h>
#include <Common/ZooKeeper/Common.h>
#include <Common/Exception.h>
#include <Common/ZooKeeper/KeeperException.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromString.h>
#include <IO... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/BackupConcurrencyCheck.h>
#include <Backups/WithRetries.h>
#include <Common/threadPoolCallbackRunner.h>
namespace DB
{
/// Used to coordinate hosts so all hosts would come to a specific stage at around the same time.
class BackupCoordinationStageSync
{
public:
/// Em... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> BackupDataFileNameGeneratorType,
ErrorCodes::BAD_ARGUMENTS,
{{"", BackupDataFileNameGeneratorType::FirstFileName}, {"checksum", BackupDataFileNameGeneratorType::Checksum}})
}
<|fim_prefix|>#include <Backups/BackupDataFileNam<|fim_middle|>eGeneratorType.h>
#include <Common/Exception.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ING_ENUM(BackupDataFileNameGeneratorType)
}
<|fim_prefix|>#pragma once
#include <Core/SettingsEnums.h>
namespace DB
{
/// Defines how backup da<|fim_middle|>ta file names are generated.
/// - `FirstFileName`: use the original file name from BackupFileInfo.
/// - `Checksum`: derive the name from the fi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>orage,
const std::unordered_set<StorageID, StorageID::DatabaseAndTableNameHash, StorageID::DatabaseAndTableNameEqual> & rmv_replace_target_ids) const
{
if (backup_settings.structure_only)
return false;
if (!backup_settings.backup_data_from_refreshable_materialized_view_targets
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <filesystem>
#include <queue>
#include <Backups/BackupSettings.h>
#include <Core/QualifiedTableName.h>
#include <Databases/DDLRenamingVisitor.h>
#include <Interpreters/StorageID.h>
#include <Parsers/ASTBackupQuery.h>
#include <Storages/IStorage_fwd.h>
#include <Storages/TableLockHol... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> : tmp_file(std::move(tmp_file_))
, file_path(tmp_file->describeFilePath())
, size(tmp_file->getStat().compressed_size)
{
}
BackupEntryFromAppendOnlyFile::~BackupEntryFromAppendOnlyFile() = default;
std::unique_ptr<SeekableReadBuffer> BackupEntryFromAppendOnlyFile::getReadBuffer(const ReadSet... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/BackupEntryWithChecksumCalculation.h>
namespace DB
{
class TemporaryDataBuffer;
using TemporaryDataBufferPtr = std::unique_ptr<TemporaryDataBuffer>;
/// Represents a file prepared to be included in a backup, assuming that until this backup entry is destroyed
/// the fil... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ze() const
{
if (copy_encrypted)
return passed_file_size ? disk->getEncryptedFileSize(*passed_file_size) : disk->getEncryptedFileSize(file_path);
if (passed_file_size)
return *passed_file_size;
return disk->getFileSize(file_path);
}
}
<|fim_prefix|>#include <Backups/BackupEn... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/BackupEntryWithChecksumCalculation.h>
#include <base/defines<|fim_suffix|>ata_source_description;
const bool copy_encrypted;
const std::optional<UInt64> passed_file_size;
const std::optional<UInt128> passed_checksum;
const bool allow_checksum_from_remote_pat... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>pEntryFromMemory(String data_) : data(std::move(data_))
{
}
std::unique_ptr<SeekableReadBuffer> BackupEntryFromMemory::getReadBuffer(const ReadSettings &) const
{
return std::make_unique<ReadBufferFromString>(data);
}
}
<|fim_prefix|>#include <Backups/BackupEntryFromMemory.h>
#include <IO/ReadBuffer... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/BackupEntryWithChecksumCalculation.h>
namespace DB
{
/// Represents small preloaded data to be included in a backup.
class BackupEntryFromMemory : public BackupEntryWithChecksumCalculation
{
public:
/// The constructor is allowed to not set `checksum_`, in that case ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eadSettings & read_settings_)
: file_path(file_path_)
, data_source_description(DiskLocal::getLocalDataSourceDescription(file_path_))
, data(readFile(file_path_, read_settings_))
{
}
BackupEntryFromSmallFile::BackupEntryFromSmallFile(const DiskPtr & disk_, const String & file_path_, const Rea... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>FilePath() const override { return file_path; }
bool isPartialChecksumAllowed() const override { return true; }
private:
const DiskPtr disk;
const String file_path;
const DataSourceDescription data_source_description;
const bool copy_encrypted = false;
const String data;
};
}
<|... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nst ReadSettings & /*read_settings*/) const
{
throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Checksum not implemented for reference backup entries");
}
std::unique_ptr<SeekableReadBuffer> BackupEntryReference::getReadBuffer(const ReadSettings & /*read_settings*/) const
{
throw Exception(ErrorCodes... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/IBackupEntry.h>
namespace DB
{
/// Represents a reference to another backup entry.
class BackupEntryReference : public IBackupEntry
{
public:
explicit BackupEntryReference(std::string reference_target_);
UInt64 getSize() const override;
UInt128 getChecksum(co... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Seed(reinterpret_cast<const char *>(&bytes_count), sizeof(bytes_count), {hash.items[0], hash.items[1]});
}
offset = next_offset;
++index;
}
if ((limit_ == size) && !isPartialChecksumAllowed() && (index != stored_objects->size()))
{
//... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>cksums for method FromRemotePath.
std::pair<std::optional<UInt128>, std::optional<UInt128>> calculateChecksumFromRemotePath(
UInt64 limit, std::optional<UInt64> second_limit) const;
mutable std::optional<UInt128> calculated_checksum TSA_GUARDED_BY(mutex);
};
}
<|fim_prefix|>#pragma once
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e() const override { return entry->isFromImmutableFile(); }
bool isFromRemoteFile() const override { return entry->isFromRemoteFile(); }
String getEndpointURI() const override { return entry->getEndpointURI(); }
String getNamespace() const override { return entry->getNamespace(); }
String ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> registerBackupEngines(*this);
}
}
<|fim_prefix|>#include <Backups/BackupFactory.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BACKUP_ENGINE_NOT_FOUND;
extern const int LOGICAL_ERROR;
}
BackupFactory::CreateParams BackupFactory::CreateParams::getCrea... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <optional>
#include <unordered_map>
#include <Backups/BackupDataFileNameGeneratorType.h>
#include <Backups/BackupInfo.h>
#include <Backups/IBackup.h>
#include <Core/Types.h>
#include <IO/ReadSettings.h>
#include <IO/WriteSettings.h>
#include <Parsers/IAST_fwd.h>
#i... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupFileInfo.h>
#include <Backups/IBackup.h>
#include <Backups/IBackupEntry.h>
#include <Common/CurrentThread.h>
#include <Common/ZooKeeper/ZooKeeperCommon.h>
#include <Common/logger_useful.h>
#include <Common/scope_guard_safe.h>
#include <Common/setThreadName.h>
#include <Common/Threa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ed for plain backups.
Strings data_file_copies;
/// if this file uses lightwegith backup, we only store object key in the metafile.
String object_key;
struct LessByFileName
{
bool operator()(const BackupFileInfo & lhs, const BackupFileInfo & rhs) const { return (lhs.file_name... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Disk(
const String & path_in_backup, DiskPtr src_disk, const String & src_path, bool copy_encrypted, UInt64 start_pos, UInt64 length)
= 0;
virtual void copyFile(const String & destination, const String & source, size_t size) = 0;
/// Removes a file written to the backup, if it st... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tion,
settings,
read_settings,
std::optional<ObjectAttributes>(),
threadPoolCallbackRunnerUnsafe<void>(getBackupsIOThreadPool().get(), ThreadName::AZURE_BACKUP_WRITER));
}
void BackupWriterAzureBlobStorage::copyDataToFile(
const String & path_in_backup,
const CreateRea... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>DataSourceDescription data_source_description;
std::shared_ptr<const AzureBlobStorage::ContainerClient> client;
AzureBlobStorage::ConnectionParams connection_params;
String blob_path;
std::unique_ptr<AzureObjectStorage> object_storage;
std::shared_ptr<const AzureBlobStorage::RequestSet... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupIO_Default.h>
#include <Disks/IDisk.h>
#include <IO/ReadBufferFromFileBase.h>
#include <IO/WriteBufferFromFileBase.h>
#include <IO/copyData.h>
#include <Common/logger_useful.h>
namespace DB
{
BackupReaderDefault::BackupReaderDefault(const ReadSettings & read_settings_, const Wr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/BackupIO.h>
#include <Common/Logger.h>
#include <IO/ReadSettings.h>
#include <IO/WriteSettings.h>
namespace DB
{
class IDisk;
using DiskPtr = std::shared_ptr<IDisk>;
class ReadBuffer;
class SeekableReadBuffer;
class WriteBuffer;
enum class WriteMode : uint8_t;
/// Repres... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupIO_Disk.h>
#include <Common/checkStackSize.h>
#include <Common/logger_useful.h>
#include <Disks/IDisk.h>
#include <IO/ReadBufferFromFileBase.h>
#include <IO/WriteBufferFromFileBase.h>
namespace DB
{
BackupReaderDisk::BackupReaderDisk(const DiskPtr & disk_, const String & root_pa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>stem::path root_path;
const DataSourceDescription data_source_description;
};
class BackupWriterDisk : public BackupWriterDefault
{
public:
BackupWriterDisk(const DiskPtr & disk_, const String & root_path_, const ReadSettings & read_settings_, const WriteSettings & write_settings_);
~BackupWr... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>, fs::copy_options::overwrite_existing);
}
}
<|fim_prefix|>#include <Backups/BackupIO_File.h>
#include <Common/checkStackSize.h>
#include <Disks/DiskLocal.h>
#include <Disks/IO/createReadBufferFromFileBase.h>
#include <IO/WriteBufferFromFile.h>
#include <Common/logger_useful.h>
namespace fs = std::file... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>destination, const String & source, size_t size) override;
void removeFile(const String & file_name) override;
void removeEmptyDirectories() override;
private:
std::unique_ptr<ReadBuffer> readFile(const String & file_name, size_t expected_file_size) override;
void removeEmptyDirectoriesI... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> file_name)
{
return backup_in_memory->getFileSize(file_name);
}
std::unique_ptr<WriteBuffer> BackupWriterMemory::writeFile(const String & file_name)
{
return backup_in_memory->writeFile(file_name);
}
void BackupWriterMemory::copyFile(const String & destination, const String & source, size_t)
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ize_t) override;
void removeFile(const String & file_name) override;
void removeEmptyDirectories() override;
private:
/// This readFile() is used only to implement BackupWriterDefault::fileContentsEqual().
std::unique_ptr<ReadBuffer> readFile(const String & file_name, size_t) override;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupIO_Null.h>
#include <Backups/BackupFactory.h>
#include <Backups/BackupImp<|fim_suffix|>::unique_ptr<WriteBuffer> BackupWriterNull::writeFile(const String & /* file_name */)
{
return std::make_unique<NullWriteBuffer>();
}
void BackupWriterNull::copyDataToFile(const String & /*... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s(const String & file_name) override;
UInt64 getFileSize(const String & file_name) override;
bool fileContentsEqual(const String & file_name, const String & expected_file_contents, String & actual_file_contents) override;
private:
std::unique_ptr<ReadBuffer> readFile(const String & file_name,... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ncrypted, start_pos, length);
}
void BackupWriterS3::copyFile(const String & destination, const String & source, size_t size)
{
LOG_TRACE(log, "Copying file inside backup from {} to {}", source, destination);
const auto source_key = fs::path(s3_uri.key) / source;
copyS3File(
client,
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#if USE_AWS_S3
#include <Backups/BackupIO_Default.h>
#include <Disks/DiskType.h>
#include <Disks/IDisk.h>
#include <IO/S3Common.h>
#include <IO/S3Settings.h>
#include <Interpreters/Context_fwd.h>
#include <Common/BlobStorageLogWriter.h>
#include <IO/S3/S3Capabilities.h>
#include <fun... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupImpl.h>
#include <Backups/BackupFactory.h>
#include <Backups/BackupFileInfo.h>
#include <Backups/BackupIO.h>
#include <Backups/IBackupEntry.h>
#include <Backups/BackupIO_S3.h>
#include <Backups/getBackupDataFileName.h>
#include <Common/CurrentThread.h>
#include <Common/ProfileEvent... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#include <Backups/BackupFactory.h>
#include <Backups/IBackup.h>
#include <Backups/IBackupCoordination.h>
#include <Backups/BackupInfo.h>
#include <Common/Logger_fwd.h>
#include <map>
#include <mutex>
namespace DB
{
class IBackupCoordination;
class IBackupReader;
class I... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>es::BACKUP_ENTRY_NOT_FOUND, "Backup entry {} not found in backup {}", file_name, backup_name);
files.erase(it);
}
std::unique_ptr<ReadBufferFromFileBase> BackupInMemory::readFile(const String & file_name) const
{
String file_contents;
{
std::lock_guard lock{mutex};
auto it =... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/defines.h>
#include <base/types.h>
#include <memory>
#include <mutex>
#include <unordered_map>
namespace DB
{
class BackupsInMemoryHolder;
class ReadBufferFromFileBase;
class WriteBuffer;
/// Keeps a backup stored in memory (good for testing; they will be cleared when the ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupInfo.h>
#include <Access/ContextAccess.h>
#include <Common/NamedCollections/NamedCollections.h>
#include <Common/NamedCollections/NamedCollectionsFactory.h>
#include <Interpreters/Context.h>
#include <Parsers/ASTExpressionList.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> named collection is used).
NamedCollectionPtr getNamedCollection(ContextPtr context) const;
};
}
<|fim_prefix|>#pragma once
#include <Common/NamedCollections/NamedCollections_fwd.h>
#include <Core/Field.h>
#include <Interpreters/Context_fwd.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
/// Info... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>initializing;
extern const SettingsUInt64 backup_restore_keeper_retry_initial_backoff_ms;
extern const SettingsUInt64 backup_restore_keeper_retry_max_backoff_ms;
extern const SettingsUInt64 backup_restore_keeper_value_max_size;
}
BackupKeeperSettings::BackupKeeperSettings(const ContextPtr & c... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
#include <chrono>
namespace DB
{
/// Settings for [Zoo]Keeper-related works during BACKUP or RESTORE.
struct BackupKeeperSettings
{
explicit BackupKeeperSettings(const ContextPtr & context);
/// Maximum number of retries in the middle of a BA... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>);
std::move(task)();
},
thread_pool,
thread_name_);
std::lock_guard lock{mutex};
futures.push_back(std::move(future));
}
void BackupMetadataFinder::checkIsQueryCancelled() const
{
if (process_list_element)
process_list_element->checkTimeLimit();
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/RestoreSettings.h>
#include <Databases/DDLRenamingVisitor.h>
#include <Databases/TablesDependencyGraph.h>
#include <Interpreters/Context_fwd.h>
#include <Parsers/ASTBackupQuery.h>
#include <Storages/IStorage_fwd.h>
#include <Storages/TableLockHolder.h>
#include <Common/Thre... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Backups/BackupStatus.h>
#include <Common/ProfileEvents.h>
#include <exception>
namespace DB
{
using BackupOperationID = String;
/// Information about executing a BACKUP or RESTORE operation
struct BackupOperationInfo
{
/// Operation ID, can be either passed via SETTINGS id=... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupInfo.h>
#include <Backups/BackupSettings.h>
#include <Core/SettingsFields.h>
#include <Parsers/ASTBackupQuery.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTSetQuery.h>
#include <Parsers/ASTLiteral.h>
#include <Backups/SettingsFieldOptionalUUID.h>
namespace DB
{
namesp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>how backup data file names are generated.
/// - `FirstFileName`: use the original file name from BackupFileInfo.
/// - `Checksum`: derive the name from the file checksum.
/// Example: for a 128-bit checksum = `abcd1234ef567890abcd1234ef567890`
/// and `data_file_name_prefix_length = 3`, th... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>apshotLockStatus::SNAPSHOT_LOCKED));
res.emplace_back(magic_enum::enum_name(SnapshotLockStatus::SNAPSHOT_UNLOCKING), static_cast<Int8>(SnapshotLockStatus::SNAPSHOT_UNLOCKING));
return res;
}();
return values;
}
}
<|fim_prefix|>#include <Backups/BackupStatus.h>
#include <Common/Exc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ir string representation,
/// which is used to create DataTypeEnum8 to store those statuses.
const std::vector<std::pair<String, Int8>> & getBackupStatusEnumValues();
enum class SnapshotLockStatus : uint8_t
{
SNAPSHOT_LOCKED,
SNAPSHOT_UNLOCKING,
};
const std::vector<std::pair<String, Int8>> & ge... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>hSecretsOneLine() == query2->formatWithSecretsOneLine())
return true;
}
return false;
}
bool compareRestoredDatabaseDef(const IAST & restored_database_create_query, const IAST & create_query_from_backup, const ContextPtr & global_context)
{
return compareRestoredTableDef(restored... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Parsers/ASTBackupQuery.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
class IBackup;
class AccessRightsElements;
class DDLRenamingMap;
struct QualifiedTableName;
namespace BackupUtils
{
/// Initializes a DDLRenamingMap from a BACKUP or RESTORE query.
DDLRenamingMap makeRenamingMap(c... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> found", backup_name);
backups.erase(it);
}
}
<|fim_prefix|>#include <Backups/BackupsInMemoryHolder.h>
#include <Backups/BackupInMemory.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BACKUP_NOT_FOUND;
extern const<|fim_middle|> int BACKUP_ALREADY_E... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/defines.h>
#include <base/types.h>
#include <memory>
#include <mutex>
#include <unordered_map>
namespace DB
{
class BackupInMemory;
/// Holds all backups stored in memory during the curre<|fim_suffix|>ring & backup_name);
std::shared_ptr<const BackupInMemory> getBackup(... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>r,
size_t only_shard_num, size_t only_replica_num, ContextMutablePtr context, const AccessRightsElements & access_to_check,
const ZooKeeperRetriesInfo & retries_info) const
{
chassert(cluster);
DDLQueryOnClusterParams params;
params.cluster = cluster;
params.only_shard_num = only_... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#include <Backups/BackupOperationInfo.h>
#include <Common/Logger_fwd.h>
#include <Common/ThreadPool_fwd.h>
#include <Interpreters/Context_fwd.h>
#include <Core/UUID.h>
#include <Parsers/IAST_fwd.h>
#include <mutex>
#include <unordered_map>
namespace Poco::Util { class AbstractConfig... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> }
void visitCreateQuery(ASTCreateQuery & create, const DDLAdjustingForBackupVisitor::Data & data)
{
if (create.storage)
visitStorage(*create.storage, data);
}
}
bool DDLAdjustingForBackupVisitor::needChildVisit(const ASTPtr &, const ASTPtr &)
{
return false;
}
vo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/InDepthNodeVisitor.h>
#include <Parsers/IAST_fwd.h>
#include <memory>
namespace DB
{
class Context;
using ContextPtr = std::shared_ptr<const Context>;
/// Changes a create query to a form which is appropriate or suitable for saving in a backup.
void adjustCreateQuer... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ng & file_name) const = 0;
/// Returns the checksum of the entry's data.
/// This function does the same as `read(file_name)->getCheckum()` but faster.
virtual UInt128 getFileChecksum(const String & file_name) const = 0;
/// Returns both the size and checksum in one call.
virtual Siz... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ing & table_zk_path, const String & table_name_for_logs, const String & replica_name,
const std::vector<PartNameAndChecksum> & part_names_and_checksums) = 0;
/// Returns the names of the parts which a specified replica of a replicated table should put to the ba... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/IBackupEntriesLazyBatch.h>
#include <Common/Exception.h>
#include <IO/SeekableReadBuffer.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
class IBackupEntriesLazyBatch::BackupEntryFromBatch : public IBackupEntry
{
public:
BackupEntryFromBatch(const ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/IBackupEntry.h>
#include <mutex>
namespace DB
{
/// Helper class designed to generate multiple backup entries from one source.
class IBackupEntriesLazyBatch : public std::enable_shared_from_this<IBackupEntriesLazyBatch>
{
public:
BackupEntries getBackupEntries();
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <memory>
#include <optional>
#include <vector>
#include <Disks/DiskType.h>
#include <Disks/IDisk.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
class SeekableReadBuffer;
/// A backup entry represents some data which shoul... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <exception>
#include <Core/Types.h>
namespace DB
{
enum class UserDefinedSQLObjectType : uint8_t;
class ASTCreateQuery;
struct ZooKeeperRetriesInfo;
/// Replicas use this class to coordinate what they're reading from a backup while executing RESTORE ON CLUSTER.
/// There are two ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/RestoreCoordinationLocal.h>
#include <Parsers/ASTCreateQuery.h>
#include <Common/ZooKeeper/ZooKeeperRetries.h>
#include <Common/logger_use<|fim_suffix|>:acquireInsertingDataIntoReplicatedTable(const String & table_zk_path)
{
std::lock_guard lock{mutex};
return acquired_data_in_r... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> std::unordered_set<String /* table_zk_path */> acquired_data_in_replicated_tables TSA_GUARDED_BY(mutex);
std::unordered_map<String, CreateQueryUUIDs> create_query_uuids TSA_GUARDED_BY(mutex);
std::unordered_set<String /* root_zk_path */> acquired_data_in_keeper_map_tables TSA_GUARDED_BY(mutex);
... | fim | ClickHouse/ClickHouse | c |
#include <Backups/BackupCoordinationOnCluster.h>
#include <Backups/BackupCoordinationStage.h>
#include <Backups/BackupCoordinationStageSync.h>
#include <Backups/RestoreCoordinationOnCluster.h>
#include <Parsers/ASTCreateQuery.h>
#include <Parsers/CreateQueryUUIDs.h>
#include <Functions/UserDefined/UserDefinedSQLObject... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/IRestoreCoordination.h>
#include <Backups/BackupCoordinationCleaner.h>
#include <Backups/BackupCoordinationStageSync.h>
#include <Backups/WithRetries.h>
namespace DB
{
/// Implementation of the IRestoreCoordination interface performing coordination via ZooKeeper. It's ne... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupInfo.h>
#include <Backups/BackupSettings.h>
#include <Backups/RestoreSettings.h>
#include <Core/SettingsFields.h>
#include <Parsers/ASTBackupQuery.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTSetQuery.h>
#include <boost/algorithm/string/predicate.hpp>
#include <Common/F... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/BackupInfo.h>
#include <Common/SettingsChanges.h>
#include <optional>
namespace DB
{
class ASTBackupQuery;
/// How the RESTORE command will handle table/database existence.
enum class RestoreTableCreationMode : uint8_t
{
/// RESTORE TABLE always tries to create a tab... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>"RESTORE ASYNC" query which could have already finished (the restore process is working in the background).
/// TODO: Get rid of using `query_context` in class RestorerFromBackup.
create_query_context->setProgressCallback(nullptr);
/// Execute CREATE TABLE query (we call IDatabase... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/BackupMetadataFinder.h>
#include <Backups/RestoreSettings.h>
#include <Interpreters/Context_fwd.h>
#include <Parsers/ASTBackupQuery.h>
#include <Storages/IStorage_fwd.h>
#include <Common/ThreadPool_fwd.h>
#include <Common/ZooKeeper/ZooKeeperRetries.h>
#include <filesystem>... | fim | ClickHouse/ClickHouse | c |
#include <Backups/SettingsFieldOptionalString.h>
#include <Common/ErrorCodes.h>
#include <Common/Exception.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_PARSE_BACKUP_SETTINGS;
}
SettingFieldOptionalString::operator Field() const { return Field(value.value_or("")); ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ieldOptionalString(const Field & field);
explicit operator Field() const;
};
}
<|fim_prefix|>#pragma once
#include <optional>
#include <Core/SettingsFields.h>
namespace DB
{
struct SettingFieldOptionalString
{
std::optional<String> value;
explicit S<|fim_middle|>ettingFieldOptionalString... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/SettingsFieldOptionalUInt64.h>
#include <Common/ErrorCodes.h>
#include <IO/WriteHelpers.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/convertFieldToType.h>
namespace DB
{
namespa<|fim_suffix|> ErrorCodes
{
extern const int CANNOT_PARSE_BACKUP_SETTINGS;
}
Settin... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <optional>
#include <Core/SettingsFields.h>
namespace DB
{
struct SettingFieldOptionalUInt64
{
std::optional<UInt64> value;
explicit SettingFieldOptionalUInt64(const std::optional<UInt64> & value_) : value(value_) {}
explicit SettingFieldOptionalUInt64(const Field & field);
e... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>n const int CANNOT_PARSE_BACKUP_SETTINGS;
}
SettingFieldOptionalUUID::operator Field() const { return Field(value ? toString(*value) : ""); }
SettingFieldOptionalUUID::SettingFieldOptionalUUID(const Field & field)
{
if (field.getType() == Field::Types::Null)
{
value = std::nullopt;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>}
explicit SettingFieldOptionalUUID(const Field & field);
explicit operator Field() const;
};
}
<|fim_prefix|>#pragma once
#include <<|fim_middle|>optional>
#include <Core/SettingsFields.h>
namespace DB
{
struct SettingFieldOptionalUUID
{
std::optional<UUID> value;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/WithRetries.h>
#include <mutex>
namespace DB
{
WithRetries::WithRetries(
LoggerPtr log_, zkutil::GetZooKeeper get_zookeeper_, const BackupKeeperSettings & settings_, QueryStatusPtr process_list_element_, RenewerCallback callback_)
: log(log_)
, get_zookeeper(get_zookeeper... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Backups/BackupKeeperSettings.h>
#include <Common/ZooKeeper/Common.h>
#include <Common/ZooKeeper/ZooKeeperRetries.h>
#include <Common/ZooKeeper/ZooKeeperWithFaultInjection.h>
namespace DB
{
/// In backups every request to [Zoo]Keeper should be retryable
/// and this tiny class encapsulates all... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ength)
{
switch (data_file_name_generator)
{
case BackupDataFileNameGeneratorType::FirstFileName:
return file_info.file_name;
case BackupDataFileNameGeneratorType::Checksum: {
if (file_info.checksum == 0)
throw DB::Exception(DB::ErrorCodes::L... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>.file_name`.
*
* @throws DB::Exception If checksum is zero for `Checksum` type.
*/
std::string getBackupDataFileName(const BackupFileInfo & file_info, BackupDataFileNameGeneratorType generator, size_t prefix_length);
}
<|fim_prefix|>#pragma once
#include <Backups/BackupDataFileNameGeneratorType.h>
#in... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#include <Backups/BackupFactory.h>
#include <Core/Settings.h>
#include <Common/Exception.h>
#if USE_AZURE_BLOB_STORAGE
#include <Backups/BackupIO_AzureBlobStorage.h>
#include <Backups/BackupImpl.h>
#include <Backups/BackupInfo.h>
#include <Common/NamedCollections/NamedCollections.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
}
}
<|fim_prefix|>#include "config.h"
#include <Backups/BackupFactory.h>
#include <Core/Settings.h>
#include <Common/Exception.h>
#if USE_AWS_S3
#include <Backups/BackupIO_S3.h>
#include <Backups/BackupImpl.h>
#include <Backups/BackupInfo.h>
#include <Common/NamedCollections/NamedCollections.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
#include <filesystem>
#include <Backups/BackupFactory.h>
#include <Backups/BackupIO_Disk.h>
#include <Backups/BackupIO_File.h>
#include <Backups/BackupImpl.h>
#include <Core/Settings.h>
#include <Disks/IDisk.h>
#include <IO/Archives/hasRegisteredArchiveFileExtension.h>
#include <Interpreters/Context.h>
#include <Poco/U... | fim | ClickHouse/ClickHouse | cpp |
#include <gtest/gtest.h>
#include <Backups/BackupFileInfo.h>
#include <Backups/BackupSettings.h>
#include <Backups/getBackupDataFileName.h>
#include <Poco/Util/MapConfiguration.h>
#include <Common/Exception.h>
#include <Common/SipHash.h>
using ConfigurationPtr = Poco::AutoPtr<Poco::Util::AbstractConfiguration>;
usin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>OME_TEXT_CHECKSUM);
EXPECT_EQ(readAll(entry), "Some text");
entry = std::make_shared<BackupEntryFromAppendOnlyFile>(local_disk, "a.txt");
EXPECT_EQ(entry->getSize(), 9);
EXPECT_EQ(getPartialChecksum(entry, 1), S_CHECKSUM);
EXPECT_EQ(getChecksum(entry), SOME_TEXT_CHECKSUM);
EXPECT_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <BridgeHelper/CatBoostLibraryBridgeHelper.h>
#include <Columns/ColumnsNumber.h>
#include <Common/escapeForFileName.h>
#include <Core/Block.h>
#include <DataTypes/DataTypesNumber.h>
#include <Formats/NativeReader.h>
#include <Formats/NativeWriter.h>
#include <IO/ReadBufferFromString.h>
#include <... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.