text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>ictionaries();
}
<|fim_prefix|>#pragma once
namespace DB
{
vo<|fim_middle|>id registerD<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Settings.h>
#include <Dictionaries/HashedDictionary.h>
#include <Dictionaries/DictionaryFactory.h>
#include <Dictionaries/DictionarySourceHelpers.h>
#include <Dictionaries/ClickHouseDictionarySource.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace Setting
{
extern const Se... | fim | ClickHouse/ClickHouse | cpp |
#include <Dictionaries/RangeHashedDictionary.h>
#include <Core/Settings.h>
#include <Dictionaries/ClickHouseDictionarySource.h>
#include <Dictionaries/DictionarySourceHelpers.h>
#include <Dictionaries/DictionaryFactory.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace Setting
{
extern const SettingsBo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Dictionaries/getDictionaryConfigurationFromAST.h>
#include <Dictionaries/registerDictionaries.h>
#include <Parsers/ASTCreateQuery.h>
#include <Parsers/ParserCreateQuery.h>
#include <Parsers/parseQuery.h>
#include <Poco/Util/XMLConfiguration.h>
#include <Common/tests/gtest_global_context.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> EXPECT_NO_THROW({
ColumnPtr immutable_col = col->getPtr();
auto subcolumn = non_nullable_type->getSubcolumn("name", immutable_col);
EXPECT_NE(subcolumn, nullptr);
});
}
<|fim_prefix|>#include <gtest/gtest.h>
#include <Dictionaries/DictionaryHelpers.h>
#include <Dictionaries... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>000);
SSDCacheComplexKey key {"", 4064, data_to_insert.get()};
ASSERT_TRUE(SSDCacheBlock::canBeWrittenInEmptyBlock(key, block_data_size));
key.size = 4065;
ASSERT_FALSE(SSDCacheBlock::canBeWrittenInEmptyBlock(key, block_data_size));
key.size = 4064;
size_... | fim | ClickHouse/ClickHouse | cpp |
#include <gtest/gtest.h>
#include <sstream>
#include <Columns/ColumnString.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Dictionaries/ExternalQueryBuilder.h>
#include <Parsers/IdentifierQuotingStyle.h>
#include <Poco/AutoPtr.h>
#include <Poco/Util/XMLConfiguration.h>
using namespace DB;
/// Minimal dict... | fim | ClickHouse/ClickHouse | cpp |
#include <gtest/gtest.h>
#include <Common/HashTable/HashMap.h>
#include <Dictionaries/HierarchyDictionariesUtils.h>
using namespace DB;
TEST(HierarchyDictionariesUtils, getHierarchy)
{
{
HashMap<UInt64, UInt64> child_to_parent;
child_to_parent[1] = 0;
child_to_parent[2] = 1;
chil... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tents
*/
class IDirectoryIterator
{
public:
/// Iterate to the next file.
virtual void next() = 0;
/// Return `true` if the iterator points to a valid element.
virtual bool isValid() const = 0;
/// Path to the file that the iterator currently points to.
virtual std::string path(... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskBackup.h>
#include <Common/logger_useful.h>
#include <IO/ReadHelpers.h>
#include <IO/ReadPipeline.h>
#include <IO/WriteHelpers.h>
#include <Backups/BackupFactory.h>
#include <Disks/DiskFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int UNSUPPORTED_METHOD;
}
names... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>constraints) override;
std::optional<UInt64> getTotalSpace() const override;
std::optional<UInt64> getAvailableSpace() const override;
std::optional<UInt64> getUnreservedSpace() const override;
bool existsFile(const String & path) const override;
bool existsDirectory(const String & p... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <variant>
#include <Common/Exception.h>
#include <Common/ZooKeeper/ZooKeeper.h>
#include <Common/ZooKeeper/ZooKeeperWithFaultInjection.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
using NoCommitOptions = std::monostate;
template <typename ZooKee... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ith("key_hex["))
{
String key_path = config_prefix + "." + config_key;
key.plain = unhexKey(config.getString(key_path));
String key_id_path = key_path + "[@id]";
if (config.has(key_id_path))
key_id = config.get... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#if USE_SSL
#include <mutex>
#include <Disks/IDisk.h>
#include <Common/MultiVersion.h>
#include <Disks/FakeDiskTransaction.h>
#include <Disks/DiskEncryptedTransaction.h>
#include <Disks/MetadataStorageWithPathWrapper.h>
namespace DB
{
class ReadBufferFromFileBase;
class WriteBuffe... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskEncryptedTransaction.h>
#if USE_SSL
#include <IO/FileEncryptionCommon.h>
#include <Common/Exception.h>
#include <boost/algorithm/hex.hpp>
#include <IO/ReadBufferFromEncryptedFile.h>
#include <IO/ReadBufferFromFileDecorator.h>
#include <IO/ReadBufferFromString.h>
#include <IO/WriteBuff... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_SSL
#include <Disks/IDiskTransaction.h>
#include <Disks/IDisk.h>
#include <Disks/DiskCommitTransactionOptions.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/WriteBufferFromFile.h>
#include <Common/logger_useful.h>
namespace DB
{
namespace FileEncryption { ... | fim | ClickHouse/ClickHouse | c |
#include <Disks/DiskFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
extern const int UNKNOWN_ELEMENT_IN_CONFIG;
}
DiskFactory & DiskFactory::instance()
{
static DiskFactory factory;
return factory;
}
void DiskFactory::registerDiskType(const String & disk_type, Creator... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
private:
using DiskTypeRegistry = std::unordered_map<String, Creator>;
DiskTypeRegistry registry;
/// Embedded documentation, keyed by disk type.
std::unordered_map<String, Documentation> documentations;
};
}
<|fim_prefix|>#pragma once
#include <Disks/IDisk.h>
#include <Interpreters/Co... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskFromAST.h>
#include <Common/assert_cast.h>
#include <Common/filesystemHelpers.h>
#include <Common/SipHash.h>
#include <Common/Config/ConfigProcessor.h>
#include <Disks/getDiskConfigurationFromAST.h>
#include <Disks/DiskSelector.h>
#include <Parsers/ASTExpressionList.h>
#include <Parser... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include <Interpreters/Context_fwd.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
namespace Di<|fim_suffix|>onst ASTPtr & disk_function, ContextPtr context, bool attach);
}
}
<|fim_middle|>skFromAST
{
void ensureDiskIsNotCustom(const std::string & name, ContextPtr c... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskLocal.h>
#include <Common/IThrottler.h>
#include <Core/Defines.h>
#include <Common/createHardLink.h>
#include <Disks/DiskFactory.h>
#include <Disks/LocalDirectorySyncGuard.h>
#include <Interpreters/Context.h>
#include <Common/filesystemHelpers.h>
#include <Common/quoteString.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskLocalCheckThread.h>
#include <Disks/IDisk.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/ReadBufferFromFileBase.h>
#include <IO/WriteBufferFromFile.h>
#include <Poco/Util/AbstractConfiguration.h>
namespace DB
{
class DiskLocalReservation;
class DiskLocal : public ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskLocalCheckThread.h>
#include <Disks/DiskLocal.h>
#include <Interpreters/Context.h>
#include <Common/logger_useful.h>
#include <Core/BackgroundSchedulePool.h>
#include <Common/formatReadable.h>
#include <Common/CurrentMetrics.h>
namespace CurrentMetrics
{
extern const Metric ReadonlyD... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ask;
size_t retry{};
};
}
<|fim_prefix|>#pragma once
#include <atomic>
#include <Core/BackgroundSchedulePoolTaskHolder.h><|fim_middle|>
#include <Common/Logger_fwd.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
class DiskLocal;
class DiskLocalCheckThread : WithContext
{
public:
friend... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
bool DiskObjectStorage::areBlobPathsRandom() const
{
return metadata_storage->areBlobPathsRandom();
}
void DiskObjectStorage::writeFileUsingBlobWritingFunction(const String & path, WriteMode mode, WriteBlobFunction && write_blob_function)
{
LOG_TEST(log, "Write file: {}", path);
auto transa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectStorage.h>
#include <Disks/DiskObjectStorage/MetadataStorages/IMetadataStorage.h>
#include <Disks/DiskObjectStorage/Replication/ObjectStorageRouter.h>
#include <Disks/DiskObjectStorage/Replication/ClusterConfiguration.h>
#include <Disks... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>StorageConstPtr layer = std::dynamic_pointer_cast<const DiskObjectStorage>(shared_from_this());
while (layer)
{
disk_names.insert(layer->getName());
layer = layer->wrapped_disk;
}
return disk_names;
}
}
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/Cach... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Disks/DiskObjectStorage/Replication/ClusterConfiguration.h>
#include <Disks/DiskObjectStorage/MetadataStorages/IMetadataStorage.h>
#include <Disks/DiskObjectStorage/DiskObjectStorageTransaction.h>
#include <Disks/DiskObjectStorage/DiskObjectStorage.h>
#include <Disks/DiskObjectStorage/IOScheduli... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/DiskObjectStorage.h>
#include <Disks/DiskObjectStorage/MetadataStorages/IMetadataStorage.h>
#include <Disks/DiskObjectStorage/Replication/ObjectStorageRouter.h>
#include <Disks/DiskObjectStorage/Replication/ClusterConfiguration.h>
#include <Disks/IDiskTransa... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>;
}
WriteSettings updateIOSchedulingSettings(const WriteSettings & settings, const std::string & read_resource_name, const std::string & write_resource_name)
{
return updateIOSchedulingSettingsImpl(settings, read_resource_name, write_resource_name);
}
}
<|fim_prefix|>#include <Disks/DiskObjectStorag... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e);
}
<|fim_prefix|>#pragma once
#include <IO/ReadSettings.h>
#include <IO/WriteSettings.h>
#include <string>
namespace DB
{
ReadSettings updateIOSc<|fim_middle|>hedulingSettings(const ReadSettings & settings, const std::string & read_resource_name, const std::string & write_resource_name);
WriteSett... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ath);
}
void MetadataStorageFromCacheObjectStorageTransaction::removeRecursive(const std::string & path, const ShouldRemoveObjectsPredicate & should_remove_objects)
{
underlying->removeRecursive(path, should_remove_objects);
}
void MetadataStorageFromCacheObjectStorageTransaction::createHardLink(con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>mestamp & timestamp) override;
bool supportsChmod() const override;
void chmod(const String & path, mode_t mode) override;
void setReadOnly(const std::string & path) override;
void unlinkFile(const std::string & path, bool if_exists, bool should_remove_objects) override;
void creat... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/DiskObjectStorageMetadata.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int UNKNOWN_FORMAT;
extern const int LOGICAL_ERROR;
}
DiskObjectStora... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/MetadataStorages/IMetadataStorage.h>
#include <Disks/IDisk.h>
#include <Core/Types.h>
namespace DB
{
/// Metadata for DiskObjectStorage
struct DiskObjectStorageMetadata
{
const std::string compatible_key_prefix;
const std::string metadata_file_pat... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <memory>
namespace DB
{
struct IMe<|fim_suffix|>ue_ptr<IMetadataOperation>;
}
<|fim_middle|>tadataOperation
{
virtual void execute() = 0;
virtual void undo() {}
virtual void finalize() {}
virtual ~IMetadataOperation() = default;
};
using MetadataOperationPtr = st... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <memory>
#include <optional>
#include <vector>
#include <unordered_map>
#include <Poco/Timestamp.h>
#include <IO/ReadSettings.h>
#include <IO/WriteSettings.h>
#include <<|fim_suffix|>onst std::string & path) const = 0;
virtual std::optional<StoredObjects> getStorageObjectsIfExi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/InMemoryRemovalQueue.h>
namespace DB
{
void InMemoryRemovalQueue::submitForRemoval(const StoredObjects & blobs)
{
for (const auto & blob : blobs)
{
if (index.contains(blob))
continue;
int64_t slot = next_slot++;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/ObjectStorages/StoredObject.h>
#include <map>
#include <unordered_map>
namespace DB
{
class InMemoryRemovalQueue
{
public:
/// Enqueue blobs that are not already present.
void submitForRemoval(const StoredObjects & blobs);
/// Return up to `m... | fim | ClickHouse/ClickHouse | c |
#include <Disks/DiskObjectStorage/MetadataStorages/IMetadataStorage.h>
#include <Disks/DiskObjectStorage/MetadataStorages/Local/MetadataStorageFromDisk.h>
#include <Disks/DiskObjectStorage/MetadataStorages/Local/MetadataStorageFromDiskTransactionOperations.h>
#include <Disks/DiskObjectStorage/ObjectStorages/StoredObjec... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ath) const override;
std::string readFileToString(const std::string & path) const override;
std::string readInlineDataToString(const std::string & path) const override;
std::unordered_map<String, String> getSerializedMetadata(const std::vector<String> & file_paths) const override;
uint... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/DiskObjectStorageMetadata.h>
#include <Disks/DiskObjectStorage/MetadataStorages/Local/MetadataStorageFromDiskTransactionOperations.h>
#include <Disks/DiskObjectStorage/MetadataStorages/Local/MetadataStorageFromDisk.h>
#include <Disks/DiskObjectStorage/Obj... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>from;
const std::string path_to;
IDisk & disk;
};
struct ReplaceFileOperation final : public IMetadataOperation
{
ReplaceFileOperation(std::string path_from_, std::string path_to_, const std::string & compatible_key_prefix, IDisk & disk_, StoredObjects & objects_to_remove_);
void execute... | fim | ClickHouse/ClickHouse | c |
#include <Disks/DiskObjectStorage/MetadataStorages/MetadataOperationsHolder.h>
#include <Common/Exception.h>
#include <exception>
namespace DB
{
namespace ErrorCodes
{
extern const int FS_METADATA_ERROR;
}
void MetadataOperationsHolder::rollback(size_t until_pos, Exception & rollback_reason) noexcept
{
for (in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tStorage.
*/
class MetadataOperationsHolder
{
void rollback(size_t until_pos, Exception & rollback_reason) noexcept;
public:
void addOperation(MetadataOperationPtr && operation);
void commit();
void finalize() noexcept;
private:
std::vector<MetadataOperationPtr> operations;
Meta... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>(key_generator), persistent_removal_log, metadata_removal_log_compaction_threshold);
});
}
#if CLICKHOUSE_CLOUD
static void registerMetadataStorageFromKeeper(MetadataStorageFactory & factory)
{
factory.registerMetadataStorageType("keeper", [](
const std::string & name,
const Poco:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nst std::string & config_prefix,
const std::string & compatibility_type_hint = "");
static std::string getCompatibilityMetadataTypeHint(
const ClusterConfigurationPtr & cluster,
const ObjectStorageRouterPtr & object_storages);
void clearRegistry();
private:
using Reg... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>:PARTIALLY_ROLLED_BACK:
return "PARTIALLY_ROLLED_BACK";
}
}
}
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataSto<|fim_middle|>rages/MetadataStorageTransactionState.h>
#include <base/defines.h>
namespace DB
{
std::string toString(MetadataStorageTransactionState state)
{
swit... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ss MetadataStorageTransactionState : uint8_t
{
PREPARING,
FAILED,
COMMITTED,
PARTIALLY_ROLLED_BACK,
};
std::string toString(MetadataStorageTransactionState state);
}
<|fim_prefix|>#pragma <|fim_middle|>once
#include <string>
namespace DB
{
enum cla<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> /// Remove leftovers from the ends
auto filtered_path = lexically_normal.string();
std::string_view normalized_path = filtered_path;
while (normalized_path.ends_with('/') || normalized_path.ends_with('.'))
normalized_path.remove_suffix(1);
while (normalized_path.starts_with('/') ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <filesystem>
namespace DB
{
/// Special class to disable implicit conversation from std::string
class NormalizedPath : public std::filesystem::path
{
public:
Norma<|fim_suffix|>rent_path() const;
};
NormalizedPath normalizePath(std::string path);
}
<|fim_middle|>lizedPath pa... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> return res;
if (auto mapped = get())
return object_metadata_cache->getOrSet(hash128, [&] { return mapped; }).first;
return object_metadata_cache->get(hash128);
}
return get();
}
MetadataStorageFromPlainObjectStorageTransaction::MetadataStorageFromPlainObjectSto... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> { return false; }
void unlinkFile(const std::string & path, bool if_exists, bool should_remove_objects) override;
void removeDirectory(const std::string & path) override;
void removeRecursive(const std::string & path, const ShouldRemoveObjectsPredicate & should_remove_objects) override;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/PlainRewritable/InMemoryDirectoryTree.h>
#include <Disks/DiskObjectStorage/MetadataStorages/NormalizedPath.h>
#include <Common/CurrentMetrics.h>
#include <Common/Exception.h>
#include <base/scope_guard.h>
#include <mutex>
#include <filesystem>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/D<|fim_suffix|>nes.h>
#include <unordered_map>
#include <memory>
#include <string>
#include <vector>
#include <mutex>
namespace DB
{
struct FileRemoteInfo
{
size_t bytes_size;
time_t last_modified;
};
struct DirectoryRemoteInfo
{
std::string remote_path;
s... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/PlainRewritable/InMemoryDirectoryTree.h>
#include <Disks/DiskObjectStorage/MetadataStorages/PlainRewritable/MetadataStorageFromPlainRewritableObjectStorage.h>
#include <Disks/DiskObjectStorage/MetadataStorages/PlainRewritable/MetadataStorageFromPlainRewri... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ieiihy/prefix.path, contents: /hello/world/
* /__meta/xelohvynszqqinrvcygwzpdwvsklbxkk/prefix.path, contents: /hello/
* /aaealinyzgdzycgcnpgaapdssrjirnnr/test2.txt
* /gfkoqxvyhaasroiodbeurnftnwieiihy/test1.txt
*/
class MetadataStorageFromPlainRewritableObjectStorage final : public IMetadataStorage... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/PlainRewritable/MetadataStorageFromPlainRewritableObjectStorageOperations.h>
#include <Disks/DiskObjectStorage/MetadataStorages/PlainRewritable/InMemoryDirectoryTree.h>
#include <Disks/DiskObjectStorage/MetadataStorages/PlainRewritable/PlainRewritableLayo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/MetadataStorages/IMetadataOperation.h>
#include <Disks/DiskObjectStorage/MetadataStorages/PlainRewritable/InMemoryDirectoryTree.h>
#include <Disks/DiskObjectStorage/MetadataStorages/Plain/MetadataStorageFromPlainObjectStorage.h>
#include <Disks/DiskObjectSto... | fim | ClickHouse/ClickHouse | c |
#include <Disks/DiskObjectStorage/MetadataStorages/PlainRewritable/PlainRewritableLayout.h>
#include <base/find_symbols.h>
#include <fmt/format.h>
#include <vector>
namespace DB
{
PlainRewritableLayout::PlainRewritableLayout(std::string object_storage_common_key_prefix_)
: object_storage_common_key_prefix(obje... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include <optional>
#include <filesystem>
namespace DB
{
class PlainRewritableLayout
{
public:
constexpr static std::string PREFIX_PATH_FILE_NAME = "prefix.path";
constexpr static std::string METADATA_DIRECTORY_TOKEN = "__meta";
constexpr static std::string RO... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ot Implemented");
}
}
}
}
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/PlainRewritable/PlainRewritableMetrics.h>
#include <Common/Exception.h>
namespace ProfileEvents
{
extern const Event DiskPlainRewritableAzureDirectoryCreated;
extern const Event DiskPlainRewrit... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Disks/DiskType.h>
#include <Common/CurrentMetrics.h>
#include <Common/ProfileEvents.h>
namespace DB
{
struct PlainRewritableMetrics
{
const ProfileEvents::Event directory_created = ProfileEvents::end();
const ProfileEvents::Event directory_removed = ProfileEvents::end();
const Cu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ctoryIterator::name() const
{
if (iter->filename().empty())
return iter->parent_path().filename();
return iter->filename();
}
}
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/StaticDirectoryIterator.h>
namespace DB
{
StaticDirectoryIterator::StaticDirectoryIterator(st... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>de;
std::string name() const override;
private:
std::vector<std::filesystem::path> dir_file_paths;
std::vector<std::filesystem::path>::iterator iter;
};
}
<|fim_prefix|>#pragma once
#include <Disks/DirectoryIterator.h>
#include <vector>
#include <filesystem>
#include <string>
namespace DB... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>fExist(const std::string & path) const
{
auto fs_path = fs::path(object_storage.url) / path;
std::string remote_path = fs_path.parent_path() / (escapeForFileName(fs_path.stem()) + fs_path.extension().string());
remote_path = remote_path.substr(object_storage.url.size());
if (auto file_inf... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/IDisk.h>
#include <Disks/DiskObjectStorage/MetadataStorages/IMetadataStorage.h>
#include <Disks/DiskObjectStorage/MetadataStorages/MetadataStorageTransactionState.h>
#include <Disks/DiskObjectStorage/ObjectStorages/Web/WebObjectStorage.h>
namespace DB
{
class MetadataStorag... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/ObjectStorages/AzureBlobStorage/AzureBlobStorageCommon.h>
#if USE_AZURE_BLOB_STORAGE
#include <azure/identity/managed_identity_credential.hpp>
#include <azure/identity/workload_identity_credential.hpp>
#include <azure/storage/blobs/blob_options.hpp>
#include <azure/stor... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_AZURE_BLOB_STORAGE
#include <azure/storage/blobs.hpp>
#include <azure/core/response.hpp>
#include <azure/storage/blobs/blob_client.hpp>
#include <azure/storage/blobs/blob_options.hpp>
#include <azure/storage/blobs/blob_service_client.hpp>
#endif
#include <Poco/... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rofileEvents::DiskAzureGetProperties);
ObjectMetadata result;
result.size_bytes = properties.BlobSize;
result.etag = properties.ETag.ToString();
if (!properties.Metadata.empty())
{
result.attributes.emplace();
for (const auto & [key, value] : properties.Metadata)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t & object_to,
const ReadSettings & read_settings,
const WriteSettings & write_settings,
std::optional<ObjectAttributes> object_to_attributes = {}) override;
void shutdown() override {}
void startup() override {}
void applyNewSettings(
const Poco::Util::Abstr... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/ObjectStorages/Cached/CachedObjectStorage.h>
#include <IO/BoundedReadBuffer.h>
#include <IO/ReadPipeline.h>
#include <Disks/IO/CachedOnDiskWriteBufferFromFile.h>
#include <Disks/IO/CachedOnDiskReadBufferFromFile.h>
#include <Interpreters/Context.h>
#include <Interpreters... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectStorage.h>
#include <Interpreters/FileCache/FileCacheKey.h>
#include <Interpreters/FileCache/FileCacheSettings.h>
#include "config.h"
namespace Poco
{
class Logger;
}
namespace DB
{
/**
* Wraps another object storage and add a cachi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/ObjectStorages/HDFS/HDFSObjectStorage.h>
#include <IO/copyData.h>
#include <Storages/ObjectStorage/HDFS/WriteBufferFromHDFS.h>
#include <Storages/ObjectStorage/HDFS/HDFSCommon.h>
#include <Disks/IO/ReadBufferFromRemoteFSGather.h>
#include <Storages/ObjectStorage/HDFS/Re... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_HDFS
#include <Disks/IDisk.h>
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectStorage.h>
#include <Storages/ObjectStorage/HDFS/HDFSCommon.h>
#include <Storages/ObjectStorage/HDFS/HDFSErrorWrapper.h>
#include <Common/Logger.h>
#include <memory>
#include <... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/IO/ThreadPoolRemoteFSReader.h>
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectSto<|fim_suffix|>RROR, "Global context not initialized");
return context->getThreadPoolWriter();
}
void IObjectStorage::copyObjectToAnotherObjectStorage( // NOLINT
const StoredObject & object_f... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <string>
#include <map>
#include <optional>
#include <filesystem>
#include <variant>
#include <Poco/Timestamp.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Core/Defines.h>
#include <IO/ReadSettings.h>
#include <IO/WriteSettings.h>
#include <IO/copyData.h>
#include <Core/Types.h>
#in... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#inc<|fim_suffix|>IObjectStorageIterator>;
}
<|fim_middle|>lude <memory>
namespace DB
{
class IObjectStorage;
using ObjectStoragePtr = std::shared_ptr<IObjectStorage>;
class IMetadataStorage;
using MetadataStoragePtr = std::shared_ptr<IMetadataStorage>;
class IObjectStorageIterator;
usin... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/ObjectStorages/Local/LocalObjectStorage.h>
#include <atomic>
#include <filesystem>
#include <Disks/IO/AsynchronousBoundedReadBuffer.h>
#include <Disks/IO/ReadBufferFromRemoteFSGather.h>
#include <Disks/IO/createReadBufferFromFileBase.h>
#include <IO/ReadBufferFromFileDec... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t WriteSettings & write_settings = {}) override;
void removeObjectIfExists(const StoredObject & object) override;
void removeObjectsIfExist(const StoredObjects & objects) override;
ObjectMetadata getObjectMetadata(const std::string & path, bool with_tags) const override;
std::optional<... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>(config.getString(config_prefix + ".endpoint"));
if (!uri.ends_with('/'))
throw Exception(
ErrorCodes::BAD_ARGUMENTS, "URI must end with '/', but '{}' doesn't.", uri);
try
{
Poco::URI poco_uri(uri);
}
catch (const Poco::Except... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>kip_access_check) const;
void clearRegistry();
private:
using Registry = std::unordered_map<String, Creator>;
Registry registry;
};
}
<|fim_prefix|>#pragma once
#include <boost/noncopyable.hpp>
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectStorage.h>
namespace DB
{
class ObjectS... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/ObjectStorages/ObjectStorageIterator.h>
#include <<|fim_suffix|>}
RelativePathWithMetadataPtr ObjectStorageIteratorFromList::current()
{
if (!isValid())
throw Exception(ErrorCodes::LOGICAL_ERROR, "Trying to access invalid iterator");
return *batch_iterat... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tch.
explicit ObjectStorageIteratorFromList(RelativePathsWithMetadata && batch_)
: batch(std::move(batch_))
, batch_iterator(batch.begin()) {}
void next() override
{
if (isValid())
++batch_iterator;
}
void nextBatch() override { batch_iterator = ba... | fim | ClickHouse/ClickHouse | c |
#include <Disks/DiskObjectStorage/ObjectStorages/ObjectStorageIteratorAsync.h>
#include <Common/logger_useful.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
IObjectStorageIteratorAsync::IObjectStorageIteratorAsync(
CurrentMetrics::Metric threads_metric,
CurrentMetrics::Metri... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/ObjectStorages/ObjectStorageIterator.h>
#include <Common/ThreadPool.h>
#include <Common/threadPoolCallbackRunner.h>
#inc<|fim_suffix|>
ThreadPoolCallbackRunnerUnsafe<BatchAndHasNext> list_objects_scheduler;
std::future<BatchAndHasNext> outcome_future... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/ObjectStorages/S3/DiskS3Utils.h>
#if USE_AWS_S3
#include <Common/Macros.h>
#include <Disks/DiskObjectStorage/MetadataStorages/DiskObjectStorageMetadata.h>
#include <Interpreters/Context.h>
#include <IO/S3/URI.h>
namespace DB
{
namespace ErrorCodes
{
extern const int... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#include <Core/Types.h>
#include <Common/ObjectStorageKeyGenerator.h>
#if USE_AWS_S3
namespace Poco::Util { class Abstr<|fim_suffix|>ix);
}
#endif
<|fim_middle|>actConfiguration; }
namespace DB
{
namespace S3 { struct URI; }
ObjectStorageKeyGeneratorPtr getKeyGenerat... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/ObjectStorages/S3/S3ObjectStorage.h>
#include <Common/CurrentThread.h>
#include <Common/setThreadName.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Common/ObjectStorageKey.h>
#if USE_AWS_S3
#include <IO/S3Common.h>
#include <Disks/DiskObjectStorage/ObjectSto... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ect & object,
const ReadSettings & read_settings,
std::optional<size_t> read_hint = {},
bool use_external_buffer = false,
bool restrict_seek = false) const override;
SmallObjectDataWithMetadata readSmallObjectAndGetObjectMetadata( /// NOLINT
const StoredObject ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <memory>
#include <Disks/DiskObjectStorage/ObjectStorages/S3/diskSettings.h>
#if USE_AWS_S3
#include <Common/Exception.h>
#include <Common/StringUtils.h>
#include <Common/logger_useful.<|fim_suffix|>xtern const S3AuthSettingsString google_adc_refresh_token;
}
namespace S3RequestSetting
{
e... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e::IStorageCredentials>()>> refresh_credentials_callback = std::nullopt);
}
#endif
<|fim_prefix|>#pragma once
#i<|fim_middle|>nclude "config.h"
#if USE_AWS_S3
#include <Poco/Util/AbstractConfiguration.h>
#include <Interpreters/Context_fwd.h>
#include <IO/S3Settings.h>
#include <IO/S3/Client.h>
#inclu... | fim | ClickHouse/ClickHouse | c |
#include <Disks/DiskObjectStorage/ObjectStorages/StoredObject.h>
namespace DB
{
size_t getTotalSize(const StoredObjects & objects)
{
size_t size = 0;
for (const auto & object : objects)
size += object.bytes_size;
return size;
}
Strings collectRemotePaths(const StoredObjects & objects)
{
Strin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ect>
{
size_t operator()(const DB::StoredObject & blob) const
{
return std::hash<std::string>{}(blob.remote_path);
}
};
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Core/Types.h>
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectStorage_fwd.h>
#include <function... | fim | ClickHouse/ClickHouse | c |
#include <Disks/DiskObjectStorage/ObjectStorages/Web/WebObjectStorage.h>
#include <Common/logger_useful.h>
#include <Common/escapeForFileName.h>
#include <Core/ServerSettings.h>
#include <IO/ReadWriteBufferFromHTTP.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Interpreters/Context.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/SharedMutex.h>
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectStorage.h>
#include <filesystem>
namespace Poco
{
class Logger;
}
namespace DB
{
class WebObjectStorage : public IObjectStorage, WithContext
{
friend class MetadataStorageFromStaticFilesWebServer... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>S,
"Filesystem cache relative path must lie inside `{}`, but have {}",
cache_path_prefix_if_relative, file_cache_settings[FileCacheSetting::path].value);
}
}
else if (!cache_path_prefix_if_absolute.empty())
{
if (!is_attach && !pathStartsWith(fil... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ing & config_prefix,
ContextPtr context,
const DisksMap & /* map */,
bool, bool) -> DiskPtr
{
const bool skip_access_check = global_skip_access_check || config.getBool(config_prefix + ".skip_access_check", false);
std::unordered_map<Location, ObjectStoragePtr> ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/IMetadataStorage.h>
#include <Disks/DiskObjectStorage/Replication/BlobCopierThread.h>
#include <Disks/DiskObjectStorage/Replication/ObjectStorageRouter.h>
#include <IO/ReadSettings.h>
#include <IO/WriteSettings.h>
#include <Interpreters/Context.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/MetadataSt<|fim_suffix|> void applyNewSettings(const Poco::Util::AbstractConfiguration & config, const std::string & config_prefix);
private:
const std::string disk_name;
const ClusterConfigurationPtr cluster;
const MetadataStoragePtr metadat... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.