text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#pragma once
#include <IO/IFileBasedSourceReader.h>
#include <Disks/IDisk.h>
#include <Common/Logger.h>
namespace DB
{
class IObjectStorag<|fim_suffix|>::shared_ptr<IObjectStorage>;
/// Reads from any IObjectStorage (S3, Azure, HDFS, etc.).
class ObjectStorageSourceReader : public IFileBasedSourceRead... | fim | ClickHouse/ClickHouse | c |
#include <IO/OffsetMap.h>
#include <Common/Exception.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
void OffsetMap::build(const StoredObjects & objects)
{
segments.clear();
total_size = 0;
for (const auto & obj : objects)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Disks/DiskObjectStorage/ObjectStorages/StoredObject.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
/// Maps logical file offsets to (object, offset-within-object).
/// Used to abstract many storage objects behind a single logical file.
class OffsetMap
{
public:
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <mutex>
#include <unistd.h>
#include <fcntl.h>
#include <Common/ProfileEvents.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <IO/OpenedFile.h>
namespace ProfileEvents
{
extern const Event FileOpen;
}
namespace DB
{
namespace ErrorCodes
{
extern const int... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nt flags_);
~OpenedFile();
/// Close prematurely.
void close();
int getFD() const;
std::string getFileName() const;
private:
std::string file_name;
int flags = 0;
mutable int fd = -1;
mutable std::mutex mutex;
CurrentMetrics::Increment metric_increment{CurrentM... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ileEvents::OpenedFileCacheMicroseconds);
const auto bucket = CityHash_v1_0_2::CityHash64(path.data(), path.length()) % buckets;
impls[bucket].remove(path, flags);
}
static OpenedFileCache & instance()
{
static OpenedFileCache res;
return res;
}
};
using Op... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
#include <IO/WriteBuffer.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
namespace DB
{
/** Implements the ability to write and read data in/from WriteBuffer/ReadBuffer
* with the help of << and >> operators and also manipulators,
* providing a ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <IO/Operators.h>
#include <pcg_random.hpp>
namespace DB
{
namespace ErrorCodes
{
extern const int INCORRECT_DATA;
}
struct PcgSerializer
{
static void serializePcg32(const pcg32_fast & rng, WriteBuffer & buf)
{
writeText(pcg32_fast::multiplier(), buf);
wr... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>fset
{
UInt64 offset;
UInt64 size;
};
using Index = MapWithMemoryTracking<String, FileOffset>;
}
}
<|fim_prefix|>#pragma once
#include <Common/MapWithMemoryTracking.h>
#include <base/types.h>
#include <map>
namespace DB
{
/// Common <|fim_middle|>parts of PackedFilesReader and PackedFilesWrit... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eView doesn't support reading with mmap and direct io methods, because
/// they require special alignment which cannot be achieved while reading archive file.
/// So just disable them.
auto in = disk->readFile(data_file_name, patchSettings(settings), read_hint);
return std::make_unique<Rea... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/PackedFilesIO.h>
#include <IO/ReadSettings.h>
#include <Core/Names.h>
#include <base/types.h>
#include <IO/ReadBuffer.h>
namespace DB
{
class IDisk;
class ReadBufferFromFileBase;
using DiskPtr = std::shared_ptr<IDisk>;
/// Class that allows to read files from archive written ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/UnorderedSetWithMemoryTracking.h>
#include <IO/WriteSettings.h>
#include <IO/WriteHelpers.h>
#include <IO/PackedFilesWriter.h>
#include <IO/WriteBufferFromString.h>
#include <Common/escapeForFileName.h>
namespace DB
{
namespace ErrorCodes
{
extern const int FILE_ALREADY_EXISTS;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/VectorWithMemoryTracking.h>
#include <Common/MapWithMemoryTracking.h>
#include <Common/PODArray.h>
#include <IO/PackedFilesIO.h>
#include <IO/WriteBufferFromVector.h>
#include <IO/WriteBufferFromFileBase.h>
#include <IO/WriteSettings.h>
namespace DB
{
/** Class that allows... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/ParallelReadBuffer.h>
#include <IO/SharedThreadPools.h>
#include <Poco/Logger.h>
#include <Common/logger_useful.h>
namespace DB
{
namespace ErrorCodes
{
extern const int UNEXPECTED_END_OF_FILE;
extern const int CANNOT_SEEK_THROUGH_FILE;
extern const int SEEK_POSITION_OUT_OF_BOUN... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Common/DequeWithMemoryTracking.h>
#include <IO/BufferWithOwnMemory.h>
#include <IO/ReadBuffer.h>
#include <IO/SeekableReadBuffer.h>
#include <Common/threadPoolCallbackRunner.h>
#include <Common/ArenaWithFreeLists.h>
namespace DB
{
/**
* Reads from multiple positions in a ReadBuffer in paralle... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/PeekableReadBuffer.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
PeekableReadBuffer::PeekableReadBuffer(ReadBuffer & sub_buf_, size_t start_size_ /*= 0*/) // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init) - `stack_memory` is scratch space... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
#include <IO/BufferWithOwnMemory.h>
#include <stack>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
/// Also allows to set checkpoint at some position in stream and come back to this position later.
/// When next() is called, saves d... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/PeekableWriteBuffer.h>
namespace DB
{
PeekableWriteBuffer::PeekableWriteBuffer(DB::WriteBuffer & sub_buf_) : BufferWithOwnMemory(0), sub_buf(sub_buf_)
{
Buffer & sub_working = sub_buf.buffer();
BufferBase::set(sub_working.begin() + sub_buf.offset(), sub_working.size() - sub_buf.offs... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <IO/WriteBuffer.h>
#include <IO/BufferWithOwnMemory.h>
#include <stack>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
/// Similar to PeekableReadBuffer.
/// Allows to set checkpoint at some position in stream and come back to this position later.
/// When next() is... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>on
/// would resume there, skipping the bytes in between.
if (position < read_position)
{
const size_t current = read_position - available();
resetWorkingBuffer();
executor->seek(current);
read_position = current;
}
}
void PipelineReadBuffer::setReadUntilEn... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadBufferFromFileBase.h>
#include <Common/Logger.h>
#include <memory>
#include <optional>
namespace DB
{
class ReaderExecutor;
/// Thin `ReadBufferFromFileBase` over a `ReaderExecutor` (experimental
/// `use_reader_executor` path). `nextImpl` points `working_buffer` at the
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/Progress.h>
#include <IO/ReadBuffer.h>
#include <IO/WriteBuffer.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Core/ProtocolDefines.h>
namespace DB
{
namespace
{
UInt64 getApproxTotalRowsToRead(UInt64 read_rows, UInt64 read_bytes, UInt64 total_bytes_to_read)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <atomic>
#include <functional>
#include <base/types.h>
#include <Core/Defines.h>
namespace DB
{
class ReadBuffer;
class WriteBuffer;
/// See Progress.
struct ProgressValues
{
UInt64 read_rows = 0;
UInt64 read_bytes = 0;
UInt64 total_rows_to_read = 0;
UInt64 tota... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rCodes::LOGICAL_ERROR,
"ProtobufZeroCopyInputStreamFromReadBuffer::BackUp() cannot back up {} bytes (max = {} bytes)",
count,
in->offset());
in->position() -= count;
}
bool ProtobufZeroCopyInputStreamFromReadBuffer::Skip(int count)
{
return static_cast<Int64>(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rride;
// Returns the total number of bytes read since this object was created.
int64_t ByteCount() const override;
private:
std::unique_ptr<ReadBuffer> in;
};
}
#endif
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_PROTOBUF
#include <google/protobuf/io/zero_copy_stream.h>
n<|f... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>otobufZeroCopyOutputStreamFromWriteBuffer::ByteCount() const
{
return out->count();
}
void ProtobufZeroCopyOutputStreamFromWriteBuffer::finalize()
{
out->finalize();
}
}
#endif
<|fim_prefix|>#include "config.h"
#if USE_PROTOBUF
#include <Common/Exception.h>
#include <IO/Protobuf/ProtobufZeroC... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> // Backs up a number of bytes, so that the end of the last buffer returned
// by Next() is not actually written.
void BackUp(int count) override;
// Returns the total number of bytes written since this object was created.
int64_t ByteCount() const override;
void finalize();
private... | fim | ClickHouse/ClickHouse | c |
#include <IO/ReadBuffer.h>
#include <IO/ReadBufferWrapperBase.h>
#include <Common/Logger.h>
#include <Common/StackTrace.h>
#include <Common/logger_useful.h>
#include <Common/Exception.h>
#include <Core/LogsLevel.h>
#include <exception>
namespace DB
{
namespace ErrorCodes
{
extern const int ATTEMPT_TO_READ_AFTE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <cstring>
#include <memory>
#include <Common/Priority.h>
#include <IO/BufferBase.h>
#include <Common/Exception.h>
namespace DB
{
static constexpr auto DEFAULT_PREFETCH_PRIORITY = Priority{0};
/** A simple abstract class for buffered data reading (char sequences) from somewhere.... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
#include <IO/ReadBufferFromFileBase.h>
namespace DB
{
/// In case of empty file it does not make any sense to read it.
///
/// Plus regular readers from file has an assert that buffer is not empty, that will fail:
/// - ReadBufferFromFileDescr<|fim_suffix|>false;... | fim | ClickHouse/ClickHouse | c |
#include <IO/ReadBufferFromEncryptedFile.h>
#if USE_SSL
#include <Common/logger_useful.h>
#include <base/demangle.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ARGUMENT_OUT_OF_BOUND;
extern const int LOGICAL_ERROR;
}
ReadBufferFromEncryptedFile::ReadBufferFromEncryptedFile(
const String & fi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_SSL
#include <IO/ReadBufferFromFileBase.h>
#include <IO/FileEncryptionCommon.h>
namespace DB
{
/// Reads data from the underlying read buffer and decrypts it.
class ReadBufferFromEncryptedFile : public ReadBufferFromFileBase
{
public:
ReadBufferFromEncrypt... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ottler_)
, file_name(original_file_name.empty() ? "(fd = " + toString(fd_) + ")" : original_file_name)
{
fd_ = -1;
}
ReadBufferFromFile::~ReadBufferFromFile()
{
if (fd < 0)
return;
[[maybe_unused]] int err = ::close(fd);
chassert(!err || errno == EINTR);
}
void ReadBufferF... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadBufferFromFileDescriptor.h>
#include <IO/OpenedFileCache.h>
#include <Common/CurrentMetrics.h>
namespace CurrentMetrics
{
extern const Metric OpenFileForRead;
}
namespace DB
{
/** Accepts path to file and opens it, or pre-opened file descriptor.
* Closes file by hi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ng_memory, alignment)
, file_size(file_size_)
{
}
ReadBufferFromFileBase::~ReadBufferFromFileBase() = default;
std::optional<size_t> ReadBufferFromFileBase::tryGetFileSize()
{
return file_size;
}
void ReadBufferFromFileBase::setProgressCallback(ContextPtr context)
{
auto file_progress_callb... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/BufferWithOwnMemory.h>
#include <IO/SeekableReadBuffer.h>
#include <IO/WithFileName.h>
#include <Interpreters/Context_fwd.h>
#include <base/time.h>
#include <functional>
#include <utility>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#ifnd... | fim | ClickHouse/ClickHouse | c |
#include <IO/ReadBufferFromFileDecorator.h>
namespace DB
{
ReadBufferFromFileDecorator::ReadBufferFromFileDecorator(std::unique_ptr<SeekableReadBuffer> impl_)
: ReadBufferFromFileDecorator(std::move(impl_), "")
{
}
ReadBufferFromFileDecorator::ReadBufferFromFileDecorator(std::unique_ptr<SeekableReadBuffer> imp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>adBuffer & getWrappedReadBuffer() { return *impl; }
std::optional<size_t> tryGetFileSize() override;
protected:
std::unique_ptr<SeekableReadBuffer> impl;
String file_name;
};
}
<|fim_prefix|>#pragma once
#include <IO/ReadBufferFromFileBase.h>
namespace DB
{
/// Delegates all reads to un... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <cerrno>
#include <ctime>
#include <algorithm>
#include <limits>
#include <optional>
#include <Common/ProfileEvents.h>
#include <Common/Stopwatch.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/CurrentMetrics.h>
#include <Common/Throttler.h>
#include <IO/ReadB... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <IO/ReadBufferFromFileBase.h>
#include <Interpreters/Context_fwd.h>
#include <Common/IThrottler.h>
#include <unistd.h>
namespace DB
{
/** Use ready file descriptor. Does not open or close a file.
*/
class ReadBufferFromFileDescriptor : public ReadBufferFromFileBase
{
protected:
const si... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/ReadBufferFromFileView.h>
#include <cstddef>
namespace DB
{
namespace ErrorCodes
{
extern const int ARGUMENT_OUT_OF_BOUND;
extern const int SEEK_POSITION_OUT_OF_BOUND;
}
ReadBufferFromFileView::ReadBufferFromFileView(
std::unique_ptr<ReadBufferFromFileBase> impl_, const String ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>id executeWithOriginalBuffer(Op && op);
};
}
<|fim_prefix|>#pragma once
#include <IO/ReadBufferFromFileBase.h>
#include <Common/Priority.h>
namespace DB
{
/// Read buffer that allows to read from file view.
/// File view is part of the file (archive) that repsents the other file.
/// For the user this... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>adBufferFromIStream::ReadBufferFromIStream(std::istream & istr_, size_t size)
: BufferWithOwnMemory<ReadBuffer>(size)
, stream_holder(std::make_optional<StreamHolder>(istr_, dynamic_cast<Poco::Net::HTTPBasicStreamBuf &>(*istr_.rdbuf())))
{
}
}
<|fim_prefix|>#include <IO/ReadBufferFromIStream.h>
#i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/BufferWithOwnMemory.h>
#include <IO/ReadBuffer.h>
#include <Poco/Net/HTTPBasicStreamBuf.h>
namespace DB
{
class ReadBufferFromIStream : public BufferWithOwnMemory<ReadBuffer>
{
private:
struct StreamHolder
{
std::istream & istr;
Poco::Net::HTTPBasicSt... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/ReadBufferFromMemory.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_SEEK_THROUGH_FILE;
extern const int SEEK_POSITION_OUT_OF_BOUND;
}
template <typename Derived>
off_t ReadBufferFromMemoryHelper<Derived>::seekImpl(off_t offset, int w... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <IO/SeekableReadBuffer.h>
#include <IO/ReadBufferFromFileBase.h>
namespace DB
{
/// Helper class that implements seek and getPosition method from SeekableReadBuffer.
template <typename Derived>
class ReadBufferFromMemoryHelper
{
public:
off_t seekImpl(off_t offset, int whence);
off_t ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>akeTimeout()
{
handshake_timeout_milliseconds = 0;
handshake_stopwatch.stop();
}
}
<|fim_prefix|>#include <Poco/Net/NetException.h>
#include <base/scope_guard.h>
#include <Common/scope_guard_safe.h>
#include <IO/ReadBufferFromPocoSocket.h>
#include <Common/Exception.h>
#include <Common/NetExcep... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>adBuffer.h>
#include <Common/AsyncTaskExecutor.h>
#include <Common/Stopwatch.h>
#include <Poco/Net/Socket.h>
namespace DB
{
/// Works with the ready Poco::Net::Socket. Blocking operations.
class ReadBufferFromPocoSocketBase : public BufferWithOwnMemory<ReadBuffer>
{
protected:
Poco::Net::Socket & so... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> return false;
data_end = buffer().end();
c_pos = buffer().begin();
}
return processChunkLeft(c_pos);
}
}
<|fim_prefix|>#include <IO/ReadBufferFromPocoSocketChunked.h>
#include <Common/logger_useful.h>
#include <IO/NetUtils.h>
namespace DB::ErrorCodes
{
extern co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e::setAsyncCallback;
explicit ReadBufferFromPocoSocketChunked(Poco::Net::Socket & socket_, size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE);
explicit ReadBufferFromPocoSocketChunked(Poco::Net::Socket & socket_, const ProfileEvents::Event & read_event_, size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE);
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/HTTPCommon.h>
#include <IO/S3Common.h>
#include "config.h"
#if USE_AWS_S3
#include <IO/ReadBufferFromS3.h>
#include <Common/BlobStorageLogWriter.h>
#include <IO/WriteHelpers.h>
#include <IO/S3/getObjectInfo.h>
#include <IO/S3/Requests.h>
#include <Common/Stopwatch.h>
#include <Common/Histo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>he last request. If there were no requests, it will throw exception.
ObjectMetadata getObjectMetadataFromTheLastRequest() const;
size_t getReadUntilPosition() const { return read_until_position; }
std::string getStopReason() const { return stop_reason; }
std::optional<RemoteFileMetadata... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>BufferFromOwnString(S && s_) : String(std::forward<S>(s_)), ReadBufferFromString(*this)
{
}
};
}
<|fim_prefix|>#pragma once
#include <IO/ReadBufferFromMemory.h>
namespace DB
{
/// Allows to read from std::string-like object.
class ReadBufferFromString : public ReadBufferFromMemory
{
public:
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> virtual ~ReadBufferWrapperBase() = default;
};
}
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
namespace DB
{
class ReadBufferWrapperBase
{
public:
virtual const ReadBuffer & getWrappedReadBuffer() cons<|fim_middle|>t = 0;
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>f.position() == ' ' || *buf.position() == 'T'))
{
++buf.position();
if (size != time_broken_down_length)
{
if constexpr (throw_exception)
throw Exception(ErrorCodes::CANNOT_PARSE_DATETIME, "Cannot parse Time {}", std::string_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <cstring>
#include <string>
#include <string_view>
#include <limits>
#include <bit>
#include <span>
#include <type_traits>
#include <Common/FramePointers.h>
#include <Common/formatIPv6.h>
#include <Common/DateLUT.h>
#include <Common/DateLUTImpl.h>
#include <Common/LocalDate.h>
#in... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>);
buf.readStrict(data, size);
return std::string_view(data, size);
}
}
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
#include <<|fim_middle|>IO/ReadHelpers.h>
#include <IO/VarInt.h>
#include <Common/Arena.h>
namespace DB
{
namespace ErrorCodes
{
extern const int TOO_LARGE_STRIN... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstdint>
namespace DB
{
enum class LocalFSReadMethod : uint8_t
{
/**
* Simple synchronous reads with 'read'.
* Can use direct IO after specified size.
* Can use prefetch b<|fim_suffix|>ies and limit the number of concurrent reads.
*/
pread_threadpool,
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>d with,
/// otherwise prefetches don't line up with cache blocks.
size_t async_page_cache_block_size = memory_cache
? memory_cache->page_cache_settings.block_size
: settings.page_cache_settings.block_size;
return std::make_unique<AsynchronousBoundedReadBuffer>(
std::mo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_path; /// Override the full cache key path
std::optional<String> custom_file_version; /// Override the file_version in the cache key
};
struct AsyncPrefetchStage
{
IAsynchronousReader * reader = nullptr;
AsyncReadCountersPtr async_read_counters;
Fi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/ReadSettings.h>
#include <Common/CurrentThread.h>
#include <Interpreters/Context.h>
#include <Core/Settings.h>
namespace
{
constexpr size_t METADATA_FILE_BUFFER_SIZE = 32768;
}
namespace DB<|fim_suffix|>gs::adjustBufferSize(size_t file_size) const
{
ReadSettings res = *this;
res.loca... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nc reads.
bool enable_hdfs_pread = true;
/// Log every blob storage read operation to system.blob_storage_log.
bool enable_blob_storage_log = false;
};
/// Settings controlling reads from the local filesystem.
/// Used by `createReadBufferFromFileBase` to pick a read method and buffer size.
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_request)
return HTTPFileInfo{};
Poco::Net::HTTPResponse response;
try
{
getHeadResponse(response);
}
catch (const HTTPException & e)
{
/// Maybe the web server doesn't support HEAD requests.
/// E.g. webhdfs reports status 400.
/// We shoul... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>hod_,
ProxyConfiguration proxy_config_,
ReadSettings read_settings_,
ConnectionTimeouts timeouts_,
const Poco::Net::HTTPBasicCredentials & credentials_,
const RemoteHostFilter * remote_host_filter_,
size_t buffer_size_,
size_t max_redirects_,
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ncrement(ProfileEvents::ReaderExecutorCachePopulateRequests, value);
ProfileEvents::increment(ProfileEvents::ReaderExecutorModeledCostMicroseconds, 100 * value);
break;
case WorkMicroseconds:
ProfileEvents::increment(ProfileEvents::ReaderExecutorWorkMicroseconds... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/OffsetMap.h>
#include <IO/IFileBasedSourceReader.h>
#include <IO/BufferWithOwnMemory.h>
#include <Common/CurrentMetrics.h>
#include <Common/Logger.h>
#include <Common/Stopwatch.h>
#include <base/types.h>
#include <array>
#include <memory>
#include <optional>
namespace DB
{
c... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> return false;
UInt64 code = 0;
if (!tryParse<UInt64>(code, message.data() + prefix.size(), 3))
return false;
return code == Poco::Net::HTTPResponse::HTTP_NOT_FOUND;
}
bool isExpectedAwsHttpResponseMuted(const std::string_view message)
{
return isWrongSigningRegionMuted(message... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ge);
void Flush() final {}
void vaLog(Aws::Utils::Logging::LogLevel log_level, const char * tag, const char * format_str, va_list args) final;
private:
LoggerPtr default_logger;
bool enable_s3_requests_logging;
UnorderedMapWithMemoryTracking<String, LoggerPtr> tag_loggers;
};
}
#e... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> return;
/// Wait until `next_time_to_retry_after_retryable_error`.
for (;;)
{
UInt64 current_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
UInt64 next_time_ms = next_time_to_retry_after_retryab... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <optional>
#include <base/types.h>
#include "config.h"
namespace DB::S3
{
/// See https://docs.aws.amazon.com/AmazonS3/latest/userguide/specifying-kms-encryption.html
/// Needed by S3Common.h even if USE_AWS_S3 is 0
struct ServerSideEncryptionKMSConfig
{
// If key_id is non-n... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ock to avoid refreshing twice
return credentials;
Reload();
return credentials;
}
void AwsAuthSTSAssumeRoleWebIdentityCredentialsProvider::Reload()
{
LOG_INFO(logger, "Credentials have expired, attempting to renew from STS.");
std::ifstream token_stream(token_file.data());
i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#include <base/types.h>
#include <IO/S3/getAvailabilityZone.h>
#if USE_AWS_S3
# include <aws/core/auth/AWSCredentials.h>
# include <aws/core/utils/threading/ReaderWriterLock.h>
# include <aws/core/http/HttpRequest.h>
# include <aws/core/endpoint/AWSEndpoint.... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Poco/Timespan.h>
#include <Poco/Net/NetException.h>
#include <Common/NetException.h>
#include <Common/config_version.h>
#include "config.h"
#if USE_AWS_S3
#include <IO/S3/PocoHTTPClient.h>
#include <IO/S3/Requests.h>
#include <algorithm>
#include <functional>
#include <Common/logger_useful.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#include <string>
#include <vector>
#if USE_AWS_S3
#include <Common/HistogramMetrics.h>
#include <Common/RemoteHostFilter.h>
#include <Common/ProxyConfiguration.h>
#include <IO/ConnectionTimeouts.h>
#include <IO/HTTPCommon.h>
#include <IO/HTTPHeaderEntries.h>
#include ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#include <Poco/String.h>
#if USE_AWS_S3
#include <IO/S3/PocoHTTPClientFactory.h>
#include <IO/S3/PocoHTTPClient.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/http/HttpRequest.h>
#include <aws/core/http/HttpResponse.h>
#include <aws/core/http/standard/Standa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ient(const Aws::Client::ClientConfiguration & client_configuration) const override;
[[nodiscard]] std::shared_ptr<Aws::Http::HttpRequest>
CreateHttpRequest(const Aws::String & uri, Aws::Http::HttpMethod method, const Aws::IOStreamFactory & streamFactory) const override;
[[nodiscard]] std::shar... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>endif
<|fim_prefix|>#include <IO/S3/ProviderType.h>
#if USE_AWS_S3
#include <string>
namespace DB::S3
{
std::string_view toString(ProviderType provider_type)
{
using enum ProviderType;
switch (provider_type)
{
case AWS:
return "AWS";
case GCS:
retur... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_AWS_S3
#include <string_view>
#include <cstdint>
namespace DB::S3
{
<|fim_suffix|>nes the platform containing the object
/// we are trying to access
/// This information is useful for determining general support for
/// some feature like multipart copy which is... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_AWS_S3
#inc<|fim_suffix|>h>
namespace HistogramMetrics
{
extern Metric & S3ReadRequestDuration;
extern Metric & S3ReadRequestBytes;
}
namespace DB::S3
{
ReadBufferFromGetObjectResult::ReadBufferFromGetObjectResult(Aws::S3::Model::GetObjectResult && result_, size_t ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_AWS_S3
#include <IO/ReadBufferFromIStream.h>
#include <aws/s3/model/GetObjectResult.h>
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectStorage.h>
#include <Common/Stopwatch.h>
namespace DB::S3
{
/// Wrapper for ReadBufferFromIStream to store GetObjectRes... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/S3/Requests.h>
#if USE_AWS_S3
#include <Common/logger_useful.h>
#include <Common/VectorWithMemoryTracking.h>
#include <aws/core/endpoint/EndpointParameter.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <string_view>
#include <fmt/format.h>
namespace DB::S3
{
Aws::Http::HeaderV... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_AWS_S3
#include <IO/S3/URI.h>
#include <IO/S3/ProviderType.h>
#include <aws/core/endpoint/EndpointParameter.h>
#include <aws/s3/model/HeadObjectRequest.h>
#include <aws/s3/model/ListObjectsV2Request.h>
#include <aws/s3/model/ListObjectsRequest.h>
#include <aws/... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/S3/S3Capabilities.h>
#include <Common/logger_useful.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
namespace DB
{
S3Capabilities::S3Capabilities(const S3Capabilities & src)
: S3Capabilities(src.isBatchDeleteSupported(), src.support_proxy)
{
}
std::optional<bool> S3Capabi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/defines.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <mutex>
#include <optional>
#include <string>
#include <IO/WriteBuffer.h>
#include <IO/ReadBuffer.h>
namespace DB
{
/// Supported/unsupported features by different S3 implementations
/// Can be useful only for ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/S3/URI.h>
#if USE_AWS_S3
#include <Interpreters/Context.h>
#include <Common/Macros.h>
#include <Common/Exception.h>
#include <Common/quoteString.h>
#include <Common/re2.h>
#include <IO/Archives/ArchiveUtils.h>
#include <boost/algorithm/string/case_conv.hpp>
#include <Poco/Util/AbstractConfi... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#if USE_AWS_S3
#include <optional>
#include <string>
#include <Poco/URI.h>
#include <Core/SettingsEnums.h>
namespace DB::S3
{
/**
* Represents S3 URI.
*
* The following patterns are allowed:
* s3://bucket/key
* http(s)://endpoint/bucket/key
* http(s)://bucket.<vpce_endpoint_... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ettings,
read_settings,
object_metadata,
schedule,
blob_storage_log,
std::move(fallback_method)};
helper.performCopy();
}
}
#endif
<|fim_prefix|>#include <Common/DequeWithMemoryTracking.h>
#include <IO/S3/copyS3File.h>
#if USE_AWS_S3
#include <Common/Excepti... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>bjectAttributes> & object_metadata = std::nullopt);
}
#endif
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_AWS_S3
#include <IO/S3Settings.h>
#include <Common/threadPoolCallbackRunner.h>
#include <Common/BlobStorageLogWriter.h>
#include <base/types.h>
#include <functional>
#include <memory>
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/S3/deleteFileFromS3.h>
#if USE_AWS_S3
#include <Common/logger_useful.h>
#include <Common/UnorderedSetWithMemoryTracking.h>
#include <IO/S3/Client.h>
#include <IO/S3/Requests.h>
#include <Common/BlobStorageLogWriter.h>
#include <IO/S3/S3Capabilities.h>
#include <IO/S3/getObjectInfo.h>
name... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_AWS_S3
#include <Common/ProfileEvents.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Core/Types.h>
#include <memory>
namespace <|fim_suffix|>ing & bucket,
const String & key,
bool if_exists = false,
BlobStorageLogWriterPtr blob_storage_l... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>THEN_GCP_ZONE);
}
<|fim_prefix|>#pragma once
#include <string>
namespace DB::S3
{
enum class AZFacilities
{
AWS_ZONE_NAME_THEN_GCP_ZONE,
AWS_ZONE_ID,
AWS_ZONE_NAME,
GCP_ZONE,
CLICKHOUSE
};
/// getRunningAvailabilityZone returns the availability zone of the underlying compute resourc... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>error.GetMessage());
}
}
#endif
<|fim_prefix|>#include <optional>
#include <IO/S3/getObjectInfo.h>
#include <IO/Expect404ResponseScope.h>
#if USE_AWS_S3
namespace ProfileEvents
{
extern const Event S3GetObjectTagging;
extern const Event S3HeadObject;
extern const Event DiskS3GetObjectTaggin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_AWS_S3
#include <IO/S3Settings.h>
#include <base/types.h>
#include <IO/S3/Client.h>
namespace DB::S3
{
struct ObjectInfo
{
size_t size = 0;
/// Checks if Content-Length was present in the HEAD response and we can rely on its result
bool is_size_know... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstddef>
#include <memory>
#include <string>
#include <Poco/Net/HTTPRequestHandler.h>
#include <Poco/Net/HTTPRequestHandlerFactory.h>
#include <Poco/Net/HTTPServer.h>
#include <Poco/Net/HTTPServerParams.h>
#include <Poco/Net/HTTPServerRequest.h>
#include <Poco/Net/HTTPServerRespon... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <gtest/gtest.h>
#include "config.h"
#if USE_AWS_S3
#include <sstream>
#include <aws/core/utils/logging/LogLevel.h>
#include <aws/core/utils/memory/stl/AWSStringStream.h>
#include <Poco/AutoPtr.h>
#include <Poco/StreamChannel.h>
#include <Common/logger_useful.h>
#include <IO/Expect404Respon... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <IO/S3/Credentials.h>
#include "config.h"
#if USE_AWS_S3
#include <cstdlib>
#include <memory>
#include <string>
#include <base/scope_guard.h>
#include <boost/algorithm/string/split.hpp>
#include <Poco/Net/HTTPResponse.h>
#include <Poco/URI.h>
#include <aws/core/cl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ASSERT_EQ(uri_with_no_key_and_no_slash.key, "key");
auto uri_with_no_key_and_with_slash = S3::URI("https://s3.region.amazonaws.com/bucket-name/key/key/key/key");
ASSERT_EQ(uri_with_no_key_and_with_slash.bucket, "bucket-name");
ASSERT_EQ(uri_with_no_key_and_with_slash.key, "key/key/key/key");... | fim | ClickHouse/ClickHouse | cpp |
#include <Core/BaseSettings.h>
#include <Core/BaseSettingsFwdMacrosImpl.h>
#include <Core/Settings.h>
#include <IO/S3AuthSettings.h>
#include <IO/S3Defines.h>
#include <IO/S3Common.h>
#include <Common/Exception.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Poco/Util/AbstractConfiguration.h>
na... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/UnorderedSetWithMemoryTracking.h>
#include <Core/BaseSettingsFwdMacros.h>
#include <Core/SettingsEnums.h>
#include <Core/SettingsFields.h>
#include <IO/HTTPHeaderEntries.h>
#include <IO/S3/Client.h>
namespace Poco::Util
{
class AbstractConfiguration;
};
namespace DB
{
stru... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ncryptionKMSConfig getSSEKMSConfig(const std::string & config_elem, const Poco::Util::AbstractConfiguration & config)
{
ServerSideEncryptionKMSConfig sse_kms_config;
if (config.has(config_elem + ".server_side_encryption_kms_key_id"))
sse_kms_config.key_id = config.getString(config_elem + ... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.