text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>iggerAndWait();
waitRound(expected_round);
}
void BlobKillerThread::applyNewSettings(const Poco::Util::AbstractConfiguration & config, const std::string & config_prefix)
{
enabled = config.getBool(config_prefix + ".enabled", true);
reschedule_interval_sec = config.getUInt64(config_prefix + "... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/MetadataStorages/IMetadataStorage.h>
#include <Disks/DiskObjectStorage/Replication/ClusterConfiguration.h>
#include <Disks/DiskObjectStorage/Replication/ObjectStorageRouter.h>
#include <Core/BackgroundSchedulePoolTaskHolder.h>
#include <Common/threadPoolCa... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/Replication/ClusterConfiguration.h>
#include <Disks/DiskObjectStorage/Replication/Location.h>
#include <Disks/DiskObjectStorage/ObjectStorages/StoredObject.h>
#include <Common/Exception.h>
#include <Common/Logger.h>
#include <Common/UniqueLock.h>
#include <Common/logger_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/Replication/Location.h>
#include <Common/SharedMutex.h>
#include <Common/Logger.h>
#include <base/defines.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <unordered_map>
namespace DB
{
struct Locatio<|fim_suffix|>d_ptr<ClusterConfiguration>;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>et<Location>;
}
<|fim_prefix|>#pragma once
#include <string>
#include <vector>
#include <unordered_set>
namespace DB
{
using Location = std::string;
using Locations = std::vector<Location>;
using LocationSet = std::unordere<|fim_middle|>d_s<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/Replication/ObjectStorageRouter.h>
#include <Disks/DiskObjectStorage/ObjectStorages/Cached/CachedObjectStorage.h>
namespace DB
{
ObjectStorageRouter::ObjectStorageRouter(std::unordered_map<Location, ObjectStoragePtr> object_storages_)
: object_storages(std::move(obj... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectSt<|fim_suffix|>ectStorageRouterPtr = std::shared_ptr<ObjectStorageRouter>;
}
<|fim_middle|>orage.h>
#include <Disks/DiskObjectStorage/Replication/Location.h>
namespace DB
{
class ObjectStorageRouter
{
public:
explicit ObjectStor... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>const std::string & disk_name, DiskPtr disk)
{
if (disk->isPlain() && !disk->isReadOnly() && !disk->isWriteOnce())
{
for (const auto & [saved_disk_name, saved_disk] : disks)
{
if (!saved_disk->isPlain() || saved_disk->isReadOnly() || saved_disk->isWriteOnce())
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskFactory.h>
#include <Disks/IDisk.h>
#include <map>
namespace Poco::Util
{
class AbstractConfiguration;
};
namespace DB
{
class DiskSelector;
using DiskSelectorPtr = std::shared_ptr<const DiskSelector>;
/// Parse .xml configuration and store information about disk... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskType.h>
#include <Poco/String.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int UNKNOWN_ELEMENT_IN_CONFIG;
extern const int LOGICAL_ERROR;
}
MetadataStorageType metadataTypeFromString(const String & type)
{
auto check_type = Poco::toL... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r) const;
String name() const;
/// Returns a string with the name and all the fields of the DataSourceDescription
String toString() const;
};
}
<|fim_prefix|>#pragma once
#include <base/defines.h>
#include <base/types.h>
namespace DB
{
enum class DataSourceType : uint8_t
{
Local,
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>th, dst_path);
}
void truncateFile(const std::string & /* src_path */, size_t) override
{
throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Operation `truncateFile` is not implemented");
}
private:
IDisk & disk;
};
}
<|fim_prefix|>#pragma once
#include <Disks/IDiskTransaction.h... | fim | ClickHouse/ClickHouse | c |
#include <Disks/IDisk.h>
#include <Core/ServerUUID.h>
#include <Core/UUID.h>
#include <Disks/FakeDiskTransaction.h>
#include <IO/ReadBufferFromFileBase.h>
#include <IO/ReadPipeline.h>
#include <IO/WriteBufferFromFileBase.h>
#include <IO/WriteHelpers.h>
#include <IO/copyData.h>
#include <Interpreters/Context.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>on(ErrorCodes::NOT_IMPLEMENTED, "Disk does not support chmod"); }
/// Was disk created to be used without storage configuration?
bool isCustomDisk() const { return custom_disk_settings_hash != 0; }
UInt128 getCustomDiskSettings() const { return custom_disk_settings_hash; }
void markDiskAs... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <string>
#include <vector>
#include <boost/noncopyable.hpp>
#include <Disks/IDisk.h>
#include <sys/types.h>
#include <Disks/DiskCommitT<|fim_suffix|>std::string & path, bool /* keep_shared_data */) = 0;
/// Batch request to remove multiple files.
/// May be much faster for ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/IO/AsynchronousBoundedReadBuffer.h>
#include <Common/CurrentThread.h>
#include <Common/Stopwatch.h>
#include <Common/logger_useful.h>
#include <Common/typeid_cast.h>
#include <Common/ThreadStatus.h>
#include <Common/getRandomASCIIString.h>
#include <Common/ElapsedTimeProfileEventIncrement... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <chrono>
#include <utility>
#include <IO/AsynchronousReader.h>
#include <IO/ReadBufferFromFile.h>
#include <Interpreters/FilesystemReadPrefetchesLog.h>
namespace Poco { class Logger; }
namespace DB
{
struct AsyncReadCounters;
using AsyncReadCountersPtr = std::<|fim_suffix|> int w... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>o, offset + size));
return size;
}
size_t CachedOnDiskReadBufferFromFile::readBigAt(
char * to,
size_t n,
size_t range_begin,
const std::function<bool(size_t)> & progress_callback) const
{
ReadInfo current_info(
info.cache_key, info.source_file_path, info.implementation_b... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>fo & info,
bool & implementation_buffer_can_be_reused,
bool skip_cache_on_disk_failure,
LoggerPtr log);
static bool writeCache(
char * data,
size_t size,
size_t offset,
FileSegment & file_segment,
bool skip_on_disk_failure,
Logge... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
completeFileSegment();
file_segments = nullptr;
}
expected_write_offset = position;
ignore_bytes = 0;
}
CachedOnDiskWriteBufferFromFile::CachedOnDiskWriteBufferFromFile(
std::unique_ptr<WriteBuffer> impl_,
FileCachePtr cache_,
const String & source_path_,
co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/WriteBufferFromFileDecorator.h>
#include <IO/WriteSettings.h>
#include <Interpreters/FileCache/FileCache_fwd.h>
#include <Interpreters/FileCache/FileCacheKey.h>
#include <Interpreters/FileCache/FileSegment.h>
#include <Interpreters/FilesystemCacheLog.h>
namespace Poco
{
class L... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/IO/IOUringReader.h>
#include <Common/ErrnoException.h>
#if USE_LIBURING
# include <future>
# include <memory>
# include <base/MemorySanitizer.h>
# include <base/errnoToString.h>
# include <Common/CurrentMetrics.h>
# include <Common/CurrentMemoryTracker.h>
# include <... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_LIBURING
#include <Common/Exception.h>
#include <Common/ThreadPool_fwd.h>
#include <IO/AsynchronousReader.h>
#include <cstddef>
#include <deque>
#include <unordered_map>
#include <liburing.h>
namespace Poco { class Logger; }
namespace DB
{
namespace ErrorCodes... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_AZURE_BLOB_STORAGE
#include <Disks/IO/ReadBufferFromAzureBlobStorage.h>
#include <Common/BlobStorageLogWriter.h>
#include <Common/ElapsedTimeProfileEventIncrement.h>
#include <IO/AzureBlobStorage/isRetryableAzureException.h>
#include <IO/ReadBufferFromString.h>
#include <IO/A... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ze() override;
std::optional<RemoteFileMetadata> getRemoteFileMetadata() const override;
size_t readBigAt(char * to, size_t n, size_t range_begin, const std::function<bool(size_t)> & progress_callback) const override;
bool supportsReadAt() override { return true; }
/// Buffer may issue... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ed(size_t offset, size_t size)
{
if (!current_buf)
initialize();
if (current_buf)
{
/// offset should be adjusted the same way as we do it in initialize()
for (size_t i = 0; i < blobs_to_read.size(); ++i)
{
const auto & blob = blobs_to_read[i];
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>et();
const size_t min_bytes_for_seek;
const StoredObjects blobs_to_read;
const ReadBufferCreator read_buffer_creator;
const String query_id;
const bool use_external_buffer;
size_t read_until_position = 0;
size_t file_offset_of_buffer_end = 0;
StoredObject current_object... | fim | ClickHouse/ClickHouse | c |
#include <Disks/IO/ReadBufferFromWebServer.h>
#include <Core/ServerSettings.h>
#include <Core/Settings.h>
#include <IO/Operators.h>
#include <IO/ReadWriteBufferFromHTTP.h>
#include <IO/WriteBufferFromString.h>
#include <Interpreters/Context.h>
#include <Common/logger_useful.h>
namespace DB
{
namespace Setting
{
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <atomic>
#include <IO/ReadBufferFromFileBase.h>
#include <IO/BufferWithOwnMemory.h>
#include <IO/ReadSettings.h>
#include <Interpreters/Context_fwd.h>
#include <Poco/Net/HTTPBasicCredentials.h>
namespace DB
{
/* Read buffer, which reads via http, but is used as ReadBufferFromFileBase.
* Used ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>t<int64_t>(request.offset), static_cast<int64_t>(request.offset >> 32),
/// This flag forces read from page cache or returning EAGAIN.
RWF_NOWAIT);
}
if (!res)
{
/// The file has ended.
promise.set... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <memory>
#include <IO/AsynchronousReader.h>
#include <Common/ThreadPool_fwd.h>
#include <Common/threadPoolCallbackRunner.h>
namespace DB
{
/** Perform reads from separate thread pool of specified size.
*
* Note: doing reads from thread pool is usually bad idea for the following reasons:
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ThreadPool>(CurrentMetrics::ThreadPoolRemoteFSReaderThreads,
CurrentMetrics::ThreadPoolRemoteFSReaderThreadsActive,
CurrentMetrics::ThreadPoolRemoteFSReaderThreadsScheduled,
pool_size, p... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ead_counters; }
private:
/// Reader is used for reading only by RemoteFSFileDescriptor.
SeekableReadBuffer & reader;
std::shared_ptr<AsyncReadCounters> async_read_counters;
};
}
<|fim_prefix|>#pragma once
#include <IO/AsynchronousReader.h>
#include <IO/SeekableReadBuffer.h>
#include <Common... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>sage;
if (blob_log)
blob_log->addEvent(
BlobStorageLogElement::EventType::MultiPartUploadComplete,
/* bucket */ container_for_logging,
/* remote_path */ blob_path,
/* local_path */ {},
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> ~WriteBufferFromAzureBlobStorage() override;
void nextImpl() override;
void preFinalize() override;
std::string getFileName() const override { return blob_path; }
void sync() override { next(); }
private:
struct PartData;
void writeMultipartUpload();
void writePart(PartDat... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>sCode), e.Message, watch.elapsedMicroseconds());
throw Exception(
ErrorCodes::AZURE_BLOB_STORAGE_ERROR,
"ADLS Gen2 {} failed for `{}`: HTTP {}: {}",
what,
blob_path,
static_cast<int>(e.Statu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include<|fim_suffix|>ettings & write_settings_,
std::shared_ptr<const AzureBlobStorage::RequestSettings> settings_,
const String & container_for_logging_ = {},
BlobStorageLogWriterPtr blob_log_ = {});
~WriteBufferFromAzureDataLakeStorage() override;
void ne... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Holder && tmp_file_)
: WriteBufferFromFile(tmp_file_->getAbsolutePath(), DBMS_DEFAULT_BUFFER_SIZE, O_RDWR | O_TRUNC | O_CREAT, /* throttler= */ {}, 0600)
, tmp_file(std::move(tmp_file_))
{
}
class ReadBufferFromTemporaryWriteBuffer : public ReadBufferFromFile
{
public:
static std::unique_ptr<... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/WriteBuffer<|fim_suffix|>adableWriteBuffer.h>
#include <IO/WriteBufferFromFile.h>
#include <Common/filesystemHelpers.h>
namespace DB
{
class TemporaryFileOnDisk;
using TemporaryFileOnDiskHolder = std::unique_ptr<TemporaryFileOnDisk>;
/// Rereadable WriteBuffer, could be used ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/IO/WriteBufferWithFinalizeCallback.h>
namespace DB
{
WriteBufferWithFinalizeCallback::WriteBufferWithFinali<|fim_suffix|> /// This will call cancelImpl of the underlying buffer.
WriteBufferFromFileDecorator::cancel();
if (create_metadata_callback)
create_metadat... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ame() const override { return remote_path; }
void preFinalize() override;
private:
void finalizeImpl() override;
FinalizeCallback create_metadata_callback;
String remote_path;
const bool create_blob_if_empty = true;
};
}
<|fim_prefix|>#pragma once
#include <IO/WriteBufferFromFile... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> & reader = getThreadPoolReader(FilesystemReaderType::SYNCHRONOUS_LOCAL_FS_READER);
res = std::make_unique<AsynchronousReadBufferFromFileWithDescriptorsCache>(
reader,
settings.priority,
filename,
buffer_size,
actu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>size = {},
int flags_ = -1,
char * existing_memory = nullptr);
}
<|fim_prefix|>#pragma once
#include <memory>
#include <string>
#include <IO/ReadBufferFromFileBase.h>
namespace DB
{
struct ReadSettings;
class PageCache;
using PageCachePtr = std::shared_ptr<PageCache>;
/** Create an object to r... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#in<|fim_suffix|>des.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
extern const int UNSUPPORTED_METHOD;
}
std::unique_ptr<IOUringReader> createIOUringReader()
{
return std::make_unique<IOUringReader>(512);
}
IOUringReader & getIOUringReaderOrThrow(ContextPtr cont... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_LIBURING
#include <Interpreters/Context_fwd.h>
#include <Disks/IO/IOUringReader.h>
#include <memory>
namespace DB
{
std::unique_ptr<IOUringReader> createIOUringReader();
IOUringReader & g<|fim_suffix|>er & getIOUringReaderOrThrow();
}
#endif
<|fim_middle|>et... | fim | ClickHouse/ClickHouse | c |
#include <Common/ErrorCodes.h>
#include <Core/ServerSettings.h>
#include <Disks/IO/getThreadPoolReader.h>
#include <IO/AsynchronousReader.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Poco/Util/Application.h>
#include <IO/SynchronousReader.h>
#include <Disks/IO/ThreadPoolRemoteFSReader.h>
#include <Disks/IO... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma <|fim_suffix|>READER,
ASYNCHRONOUS_REMOTE_FS_READER,
};
IAsynchronousReader & getThreadPoolReader(FilesystemReaderType type);
std::unique_ptr<IAsynchronousReader> createThreadPoolReader(FilesystemReaderType type, const ServerSettings & server_settings);
}
<|fim_middle|>once
#include <memor... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> "No disk {} in policy {}", backQuote(disk_name), backQuote(getName()));
return *index;
}
VolumePtr IStoragePolicy::tryGetVolumeByDiskName(const String & disk_name) const
{
auto index = tryGetVolumeIndexByDiskName(disk_name);
if (!index)
return nullptr;
return getVolume(*index);... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Disks/DiskType.h>
#include <expected>
#include <memory>
#include <optional>
#include <vector>
#include <base/types.h>
#include <Common/LoggingFormatStringHelpers.h>
namespace DB
{
class IStoragePolicy;
using StoragePolicyPtr = std::shared_ptr<const IStoragePolicy>;
class IVolume;
using Volume... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/IVolume.h>
#include <Common/StringUtils.h>
#include <Common/quoteString.h>
#include <memory>
namespace DB
{
namespace ErrorCodes
{
extern const int NO_ELEMENTS_IN_CONFIG;
extern const int EXCESSIVE_ELEMENT_IN_CONFIG;
}
VolumeLoadBalancing parseVolumeLoadBalancing(const String... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>d a new data part be synchronously moved to a volume according to ttl on insert
/// or move this part in background task asynchronously after insert.
bool perform_ttl_move_on_insert = true;
/// Load balancing, one of:
/// - ROUND_ROBIN
/// - LEAST_USED
const VolumeLoadBalancing loa... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/LocalDirectorySyncGuard.h>
#include <Common/ProfileEvents.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Disks/IDisk.h>
#include <Common/Stopwatch.h>
#include <fcntl.h> // O_RDWR
/// OSX does not have O_DIRECTORY
#ifndef O_DIRECTORY
#define O_DIRECTORY O_RDW... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/IDisk.h>
namespace DB
{
class IDisk;
using DiskPtr = std::shared_ptr<IDisk>;
/// Helper class, that receives file descriptor and does fsync for it in destructor.
/// It's used to keep descriptor open, while doing some operations with it, and do fsync at the end.
/// Guaran... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>oredObject & object) override
{
delegate->addBlobToMetadata(wrappedPath(path), object);
}
void setLastModified(const std::string & path, const Poco::Timestamp & timestamp) override
{
delegate->setLastModified(wrappedPath(path), timestamp);
}
bool supportsChmod() c... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>String & path,
const ReadSettings & settings,
std::optional<size_t> read_hint,
ReadPipeline & pipeline) const override { delegate->prepareRead(path, settings, read_hint, pipeline); }
time_t getLastChanged(const String & path) const override { return delegate->getLastChanged(pa... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Disks/IVolume.h>
namespace DB
{
class SingleDiskVolume : public IVolume
{
public:
SingleDiskVolume(const String & name_, DiskPtr disk, size_t max_data_part_size_ = 0): IVolume(name_, {disk}, max_data_part_size_)
{
}
ReservationPtr reserve(UInt64 bytes) override
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>of the old storage policy {}",
backQuote(new_storage_policy->getName()),
backQuote(name));
}
}
bool StoragePolicy::isCompatibleForPartitionOps(const StoragePolicyPtr & other) const
{
if (getName() == other->getName())
return true;
constexpr aut... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>yGetVolumeByName(const String & volume_name) const override;
/// Checks if storage policy can be replaced by another one.
void checkCompatibleWith(const StoragePolicyPtr & new_storage_policy) const override;
/// If the policy allows table partition operations (move, replace) with the other s... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/UUID.h>
#include <Disks/TemporaryFileOnDisk.h>
#include <IO/WriteHelpers.h>
#include <Common/CurrentMetrics.h>
#include <Common/ZooKeeper/ZooKeeperCommon.h>
#include <Common/logger_useful.h>
#include <filesystem>
namespace ProfileEvents
{
extern const Event ExternalProcessingFilesTota... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <memory>
#include <Disks/IDisk.h>
#include <Common/CurrentMetrics.h>
namespace DB
{
using DiskPtr = std::shared_ptr<IDisk>;
/// This class helps with the handling of temporary files or directories.
/// A unique name for the <|fim_suffix|>nDiskHolder = std::... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/VolumeJBOD.h>
#include <Common/StringUtils.h>
#include <Common/formatReadable.h>
#include <Common/quoteString.h>
#include <Common/logger_useful.h>
namespace DB
{
namespace ErrorCodes
{
extern const int EXCESSIVE_ELEMENT_IN_CONFIG;
}
VolumeJBOD::VolumeJBOD(
String name_,
con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <mutex>
#include <optional>
#inc<|fim_suffix|>isks/IVolume.h>
#include <base/defines.h>
#include <base/types.h>
#include <Common/Stopwatch.h>
namespace DB
{
class VolumeJBOD;
using VolumeJBODPtr = std::shared_ptr<VolumeJBOD>;
using VolumesJBOD = std::vector<Vol... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>write,
Append
};
}
<|fim_prefix|>#pragma once
n<|fim_middle|>amespace DB
{
/// Mode of opening a file for write.
enum class WriteMode : uint8_t
{
Re<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eturn std::make_shared<VolumeJBOD>(name, config, config_prefix, disk_selector);
}
throw Exception(ErrorCodes::UNKNOWN_RAID_TYPE, "Unknown RAID type '{}'", raid_type);
}
VolumePtr updateVolumeFromConfig(
VolumePtr volume,
const Poco::Util::AbstractConfiguration & config,
const String &... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>bstractConfiguration & config,
const String & config_prefix,
DiskSelectorPtr disk_selector
);
VolumePtr updateVolumeFromConfig(
VolumePtr volume,
const Poco::Util::AbstractConfiguration & config,
const String & config_prefix,
DiskSelectorPtr & disk_selector
);
}
<|fim_prefix|>#pr... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/getDiskConfigurationFromAST.h>
#include <Common/assert_cast.h>
#include <|fim_suffix|>ession.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTLiteral.h>
#include <Parsers/ASTFunctionWithKeyValueArguments.h>
#include <Storages/checkAndGetLiteralAr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>BASE` queries pass false so the `dynamic_disk_allow_*` restrictions apply.
[[ maybe_unused ]] Poco::AutoPtr<Poco::XML::Document> getDiskConfigurationFromASTImpl(const ASTs & disk_args, ContextPtr context, bool is_loading_from_existing_metadata = false);
/*
* A reverse function.
*/
[[ maybe_unused ]] AS... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/loadLocalDiskConfig.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Interpreter<|fim_suffix|> String & path,
UInt64 & keep_free_space_bytes)
{
path = config.getString(config_prefix + ".path", "");
if (name == "default")
{
if (!pa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core<|fim_suffix|>ing & name,
const Poco::Util::AbstractConfiguration & config,
const String & config_prefix,
ContextPtr context,
String & path,
UInt64 & keep_free_space_bytes);
}
<|fim_middle|>/Types.h>
#include <Interpreters/Context_fwd.h>
namespace Poco::Util... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/registerDisks.h>
#include <Disks/DiskFactory.h>
#incl<|fim_suffix|> auto & factory = DiskFactory::instance();
registerDiskLocal(factory, global_skip_access_check);
#if USE_SSL
registerDiskEncrypted(factory, global_skip_access_check);
#endif
registerDiskCache(factory, glob... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
namespace DB
{
/// @param global<|fim_suffix|>ctive (used
/// for clickhouse-disks)
void registerDisks(bool global_skip_access_check);
void clearDiskRegistry();
}
<|fim_middle|>_skip_access_check - skip access check regardless regardless
/// ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>WithAppend())
return false;
}
return true;
}
}
<|fim_prefix|>#include <Disks/supportWritingWithAppend.h>
#include <Disks/DiskObjectStorage/DiskObjectStorage.h>
namespace DB
{
bool supportWritingWithAppend(const DiskPtr & disk)
{
auto target_disk = disk;
if (auto delegate_dis... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>kPtr & disk);
}
<|fim_prefix|>#pragma once
#include <Dis<|fim_middle|>ks/IDisk.h>
namespace DB
{
bool supportWritingWithAppend(const Dis<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Disks/IO/AsynchronousBoundedReadBuffer.h>
#include <Disks/IO/ThreadPoolRemoteFSReader.h>
#include <Disks/IO/createReadBufferFromFileBase.h>
#include <IO/ReadSettings.h>
#include <IO/WriteBufferFromFile.h>
#include <Poco/TemporaryFile.h>
#include <filesystem>
using nam... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>lobClientOptions options;
options.Retry.MaxRetries = 0;
auto client = std::make_unique<BlobContainerClient>(BlobContainerClient::CreateFromConnectionString(unavailable_url, container, options));
EXPECT_THROW({ client->ListBlobs(); }, Azure::Core::RequestFailedException);
}
#endif
<|fim_prefi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <stdexcept>
#include <IO/CascadeWriteBuffer.h>
#include <IO/MemoryReadWriteBuffer.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteBuffer.h>
#include <IO/ConcatReadBuffer.h>
#include <IO/copyData.h>
#include <Common/typeid_cast.h>
#include <Disks/DiskLocal.h>
#... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>que_ptr<DB::ReadBuffer> in = disk->readFile("test_file", DB::getReadSettings());
readString(data, *in);
}
EXPECT_EQ("test data", data);
EXPECT_EQ(data.size(), disk->getFileSize("test_file"));
}
TEST_F(DiskTest, readFile)
{
{
std::unique_ptr<DB::WriteBuffer> out = disk->w... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskLocal.h>
#include <Disks/IDisk.h>
DB::DiskPtr createDisk(const std::string & path = "tmp/");
v<|fim_suffix|>disk);
<|fim_middle|>oid destroyDisk(DB::DiskPtr & <|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/IMetadataStorage.h>
#include <Disks/DiskObjectStorage/Replication/ClusterConfiguration.h>
#include <Disks/DiskObjectStorage/Replication/ObjectStorageRouter.h>
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectStorage.h>
#include <gtest/gtest.h>
#in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>disk.removeFileIfExists(file_name);
}
#endif
<|fim_prefix|>#include <gtest/gtest.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Disks/tests/gtest_disk.h>
#define RUN_HDFS_TEST 0
#if RUN_HDFS_TEST
#include <Disks/HDFS/DiskHDFS.h>
#include <Poco/Util/XMLConfiguration.h>
const Str... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Disks/DiskFactory.h>
#include <Disks/DiskEncrypted.h>
#include <Disks/registerDisks.h>
#include <Disks/IDiskTransaction.h>
#include <Disks/DiskObjectStorage/DiskObjectStorage.h>
#include <IO/FileEncryptionCommon.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/Write... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <D<|fim_suffix|>error_code ec;
fs::create_symlink(".", root / "loop", ec);
ASSERT_FALSE(ec) << "Failed to create symlink `loop`: " << ec.message();
fs::create_symlink("..", root / "sub" / "back", ec);
ASSERT_FALSE(ec) << "Failed to create symlink `sub/bac... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <cstdlib>
#include <exception>
#include <filesystem>
#include <memory>
#include <mutex>
#include <Core/ServerUUID.h>
#include <Disks/DiskLocal.h>
#include <Disks/DiskObjectStorage/MetadataStorages/Local/MetadataStorageFromDisk.h>
#include <Common/ObjectStorageKeyGenerator... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>taPlainRewritableDiskTest, OperationsNonExisting)
{
auto metadata = getMetadataStorage("OperationsNonExisting");
auto object_storage = getObjectStorage("OperationsNonExisting");
{
auto tx = metadata->createTransaction();
tx->createDirectoryRecursive("A/B/C");
tx->commi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>./././///.//.///c/././././//.//.").string(), "a/b/c");
}
<|fim_prefix|>#include <Disks/DiskObjectStorage/MetadataStorages/NormalizedPath.h>
#include <gtest/gtest.h>
using namespace DB;
TEST(NormalizedPath, Simple)
{
EXPECT_EQ(normalizePath("a/b/c/d").string(), "a/b/c/d");
EXPECT_EQ(normalizePat... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>le", DB::fileName("test_dir/nested_file"));
EXPECT_EQ("", DB::fileName("test_dir/"));
EXPECT_EQ("", DB::fileName(""));
}
<|fim_prefix|>#include <gtest/gtest.h>
#include <Disks/IDisk.h>
TEST(DiskPathTest, parentPath)
{
EXPECT_EQ("", DB::parentPath("test_dir/"));
EXP<|fim_middle|>ECT_EQ("... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
/// Forward declarations for `clickhouse-examples` entry-point functions.
///
/// Each example translation unit defines a `mainEntryExample*` function that
/// is dispatched from `src/Examples/main.cpp`. Listing the prototypes here
/// (and including this header from each example source) ens... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rr << std::endl;
std::cerr << "Available examples:" << std::endl;
for (const auto & example : examples)
std::cerr << " " << example.first << std::endl;
}
}
int main(int argc, char ** argv)
{
std::vector<char *> args(argv, argv + argc);
if (args.empty())
{
printHelp(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> case BSONType::DOUBLE:
return "Double";
case BSONType::STRING:
return "String";
case BSONType::DECIMAL128:
return "Decimal128";
case BSONType::JAVA_SCRIPT_CODE_W_SCOPE:
return "JavaScript code w/ scope";
case BSONType::... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>= 0x01,
STRING = 0x02,
DOCUMENT = 0x03,
ARRAY = 0x04,
BINARY = 0x05,
UNDEFINED = 0x06,
OBJECT_ID = 0x07,
BOOL = 0x08,
DATETIME = 0x09,
NULL_VALUE = 0x0A,
REGEXP = 0x0B,
DB_POINTER = 0x0C,
JAVA_SCRIPT_CODE = 0x0D,
SYMBOL = 0x0E,
JAVA_SCRIPT_CODE_W_SCO... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/IColumn.h>
#include <Core/Defines.h>
#include <DataTypes/IDataType.h>
#include <Formats/BuffersReader.h>
#include <Formats/NativeReader.h>
#include <IO/ReadBufferFromString.h<|fim_suffix|> before;
if (consumed != buffer_size)
throw Exception(
ErrorCod... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block.h>
#include <Formats/FormatSettings.h>
#include <optional>
namespace DB
{
class ReadBuffer;
/** Deserializes a stream of bloc<|fim_suffix|>ttings;
};
}
<|fim_middle|>ks from the Buffers format.
*
* For each block, the following sequence is read:
* 1. Number of... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Formats/BuffersWriter.h>
#include <Formats/NativeWriter.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include <Core/Block.h>
namespace DB
{
BuffersWriter::BuffersWriter(WriteBuffer & ostr_, SharedHeader header_, const FormatSettings & form... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block_fwd.h>
#include <Formats/FormatSettings.h>
namespace DB
{
class Block;
class WriteBuffer;
/** Serializes the stream of blocks in their native binary format (without names, columns and serialization types).
*
* For each block, the following sequence is written:
*... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Formats/CapnProtoSchema.h>
#if USE_CAPNP
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeEnum.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/IDataT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_CAPNP
#include <Formats/FormatSchemaInfo.h>
#include <capnp/schema-parser.h>
#include <capnp/dynamic.h>
namespace DB
{
// Wrapper for classes that could throw in destructor
// https://github.com/capnproto/capnproto/issues/553
template <typename T>
struct Destruc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_CAPNP
#include <Formats/CapnProtoSerializer.h>
#include <Formats/FormatSettings.h>
#include <Formats/CapnProtoSchema.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeEnum.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypeNullable.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#if USE_CAPNP
#include <Columns/IColu<|fim_suffix|> capnp::StructSchema & schema, const FormatSettings::CapnProto & settings);
void writeRow(const Columns & columns, capnp::DynamicStruct::Builder builder, size_t row_num);
void readRow(MutableColumns & columns, capnp::DynamicStruct... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>t(name);
if (result == CaseAwareBlockNameMap::NOT_FOUND)
{
return std::optional<size_t>();
}
return std::optional<size_t>(result);
});
}
void ColumnMapping::addColumns(const Names & column_names, const BlockNameMap & column_indexes_b... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> /// The list of column names in input data. Needed for better exception messages.
std::vector<String> names_of_columns;
void setupByHeader(const Block & header);
void addColumns(
const Names & column_names, const BlockNameMap & column_indexes_by_names, const FormatSettings & setting... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.