text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#pragma once
#include <IO/ReadBufferFromFileBase.h>
#include <IO/AsynchronousReader.h>
#include <Interpreters/FilesystemReadPrefetchesLog.h>
#include <Common/IThrottler.h>
#include <Common/Priority.h>
#include <optional>
#include <unistd.h>
namespace DB
{
/** Use ready file descriptor. Does not open ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <optional>
#include <memory>
#include <future>
#include <boost/noncopyable.hpp>
#include <Common/Stopwatch.h>
#include <Common/Priority.h>
namespace DB
{
class PageCacheCell;
using PageCacheCellPtr = std::shared_ptr<PageCacheCell>;
/** Interface for async... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <IO/WriteBuffer.h>
#include <Common/Exception.h>
namespace DB
{
/// That class is applied in
// HTTPServerResponse. The external interface HTTPResponse forces that.
// AutoFinalizedWriteBuffer could not be inherited due to a restriction on polymorphics call in d-tor.
template <cla... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/AzureBlobStorage/PocoHTTPClient.h>
#include "config.h"
#if USE_AZURE_BLOB_STORAGE
#inclu<|fim_suffix|>
extern const Event DiskAzureReadMicroseconds;
extern const Event DiskAzureReadRequestsCount;
extern const Event DiskAzureReadRequestsErrors;
extern const Event DiskAzureRe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>hrottler.get_throttler; }
ThrottlerPtr putThrottler() const { return request_throttler.put_throttler; }
private:
enum class AzureMetricType : uint8_t
{
Microseconds,
Count,
Errors,
Throttling,
Redirects,
EnumSize,
};
enum class AzureMet... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/AzureBlobStorage/copyAzureBlobStorageFile.h>
#if USE_AZURE_BLOB_STORAGE
#include <Common/ListWithMemoryTracking.h>
#include <Common/PODArray.h>
#include <Common/ProfileEvents.h>
#include <Common/Stopwatch.h>
#include <Common/typeid_cast.h>
#include <Interpreters/Context.h>
#include <IO/Limi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_AZURE_BLOB_STORAGE
#include <Disks/DiskObjectStorage/ObjectStorages/AzureBlobStorage/AzureObject<|fim_suffix|>eLogWriterPtr blob_storage_log = {});
/// Copies data from any seekable source to AzureBlobStorage.
/// The same functionality can be done by using th... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>bleAzureException.h>
namespace DB
{
bool isRetryableAzureException(const Azure::Core::RequestFailedException & e, bool may_be_provisioning_access)
{
/// Always retry transport errors.
if (dynamic_cast<const Azure::Core::Http::TransportException *>(&e))
return true;
/// Azure may be ... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#if USE_AZURE_BLOB_STORAGE
#include <azure/core/http/http.hpp>
namespace DB
{
bool isRetryableAzureException(const Azure::Core::RequestFailedException & e, bool may_be_provisioning_access = false);
}
#endif
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> }
return result;
}
// Fills internal bits_buffer with data from source, reads at most 64 bits
ALWAYS_INLINE size_t fillBitBuffer()
{
const size_t available = source_end - source_current;
const auto bytes_to_read = std::min<size_t>(64 / 8, available);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e
throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method readBigAt() is not implemented for a given implementation");
}
}
<|fim_prefix|>#include <IO/BoundedReadBuffer.h>
#include <IO/SwapHelper.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
BoundedReadBuffer::Bo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ndedReads() const override { return true; }
void setReadUntilPosition(size_t position) override;
void setReadUntilEnd() override;
bool nextImpl() override;
off_t seek(off_t off, int whence) override;
size_t getFileOffsetOfBufferEnd() const override { return file_offset_of_buffer_e... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_BROTLI
# include <brotli/decode.h>
# include <IO/BrotliReadBuffer.h>
# include <IO/WithFileName.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BROTLI_READ_FAILED;
}
class BrotliReadBuffer::BrotliStateWrapper
{
public:
BrotliStateWrapper()
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
}
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
#include <IO/CompressedReadBufferWrapper.h>
namespace DB
{
class BrotliReadBuffer : public CompressedReadBufferWrapper
{
public:
explicit BrotliReadBuffer(
std::unique_ptr<ReadBuffer> in_,
size_t buf_size = DBMS_DEF... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_BROTLI
# include <IO/BrotliWriteBuffer.h>
# include <brotli/encode.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BROTLI_WRITE_<|fim_suffix|>/ Do not try to write next time after exception.
out->position() = out->buffer().begin();
throw;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ass BrotliStateWrapper
{
public:
BrotliStateWrapper();
~BrotliStateWrapper();
BrotliEncoderState * state;
};
std::unique_ptr<BrotliStateWrapper> brotli;
size_t in_available;
const uint8_t * in_data;
size_t out_capacity;
uint8_t * out_data;
prot... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Core/Defines.h>
#include <algorithm>
namespace DB
{
/** Base class for ReadBuffer and WriteBuffer.
* Contains common types, variables, and functions.
*
* ReadBuffer and WriteBuffer are similar to istream and ostream, respectively.
* They have to be used, because using iostreams it is... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ng_memory != nullptr)
{
Base::set(existing_memory ? existing_memory : memory.data(), size);
Base::padded = !existing_memory;
}
void resize(size_t size, bool deallocate_if_empty = false)
{
if (use_existing_memory)
{
throw Exception(
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
return false;
int ret = 0;
do
{
if (!bz->stream.avail_in)
{
in->nextIfAtEnd();
bz->stream.avail_in = static_cast<unsigned>(in->buffer().end() - in->position());
bz->stream.next_in = in->position();
/// If the inner stre... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#<|fim_suffix|>que_ptr<Bzip2StateWrapper> bz;
bool eof_flag;
};
}
<|fim_middle|>include <IO/ReadBuffer.h>
#include <IO/CompressedReadBufferWrapper.h>
namespace DB
{
class Bzip2ReadBuffer : public CompressedReadBufferWrapper
{
public:
explicit Bzip2ReadBuffer(
std::u... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> catch (...)
{
/// Do not try to write next time after exception.
out->position() = out->buffer().begin();
throw;
}
}
void Bzip2WriteBuffer::finalFlushBefore()
{
next();
/// Don't write out if no data was ever compressed
if (!compress_empty && total_in == 0)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ess_empty(compress_empty_)
{
memset(&stream, 0, sizeof(stream));
int ret = BZ2_bzCompressInit(&stream, compression_level, 0, 0);
if (ret != BZ_OK)
throw Exception(
ErrorCodes::BZIP2_STREAM_ENCODER_FAILED,
"bzip2 stream encoder init ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e - offset_in_block, end_offset - current_offset);
const char * data_ptr = cells[i]->data() + offset_in_block;
regions.push_back(CachedRegion{
.handle = std::move(cells[i]),
.data = data_ptr,
.size = usable,
.file_offset = current_offset,
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>>supportsReadAt` may do HTTP/fstat, so don't probe in the ctor.
/// `call_once` also keeps the probe from racing with parallel `readBigAt` calls.
mutable std::once_flag inner_supports_read_at_init;
mutable bool inner_supports_read_at = false;
bool innerSupportsReadAt() const;
/// Ensu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/CascadeWriteBuffer.h>
#include <IO/MemoryReadWriteBuffer.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CURRENT_WRITE_BUFFER_IS_EXHAUSTED;
extern const int CANNOT_WRITE_AFTER_END_OF_BUFFER;
extern const int CANNOT_CREATE_IO_BUFFER;
}
Cas... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/VectorWithMemoryTracking.h>
#include <IO/WriteBuffer.h>
#include <functional>
#include <vector>
namespace DB
{
namespace ErrorCodes
{
}
/* The buffer is similar to ConcatReadBuffer, but writes data
*<|fim_suffix|>ne of underlying WriteBuffers buffers outside, you need ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <IO/BufferWithOwnMemory.h>
#include <IO/ReadBuffer.h>
#include <IO/ReadBufferWrapperBase.h>
namespace DB
{
class CompressedReadBufferWrapper : public BufferWithOwnMemory<ReadBuffer>, public ReadBufferWrapperBase
{
public:
CompressedReadBufferWrapper(
std::unique_ptr<ReadB... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>}
std::unique_ptr<ReadBuffer> wrapReadBufferWithCompressionMethod(
std::unique_ptr<ReadBuffer> nested, CompressionMethod method, int zstd_window_log_max, size_t buf_size, char * existing_memory, size_t alignment)
{
if (method == CompressionMethod::None)
return nested;
return createCom... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <string>
#include <Core/Defines.h>
namespace DB
{
class ReadBuffer;
class WriteBuffer;
/** These are "generally recognizable" compression methods for data import/export.
* Do not mess with more efficient compressi<|fim_suffix|>/// How the compression method is... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rrent)
return true;
if (!working_buffer.empty())
(*current)->position() = position();
return (*current)->poll(timeout_microseconds);
}
protected:
Buffers buffers;
Buffers::iterator current;
bool nextImpl() override
{
if (buffers.end()... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/ConcatReadBufferFromFile.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ARGUMENT_OUT_OF_BOUND;
}
ConcatReadBufferFromFile::BufferInfo::BufferInfo(BufferInfo && src) noexcept
: in(std::exchange(src.in, nullptr)), own_in(std::exchange(src.own... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t size);
void appendBuffer(SeekableReadBuffer & buffer, size_t size);
off_t seek(off_t off, int whence) override;
off_t getPosition() override;
std::optional<size_t> tryGetFileSize() override { return total_size; }
private:
bool nextImpl() override;
void appendBuffer(SeekableRea... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/ServerSettings.h>
#include <Core/Settings.h>
#include <IO/ConnectionTimeouts.h>
#include <Poco/Util/AbstractConfiguration.h>
namespace DB
{
namespace Setting
{
extern const SettingsSeconds connect_timeout;
extern const SettingsSeconds send_timeout;
extern const SettingsSeconds... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_timeout = Poco::Timespan(DBMS_DEFAULT_SEND_TIMEOUT_SEC, 0);
Poco::Timespan receive_timeout = Poco::Timespan(DBMS_DEFAULT_RECEIVE_TIMEOUT_SEC, 0);
Poco::Timespan tcp_keep_alive_timeout = Poco::Timespan(DEFAULT_TCP_KEEP_ALIVE_TIMEOUT, 0);
Poco::Timespan http_keep_alive_timeout = Poco::Timespan... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstdint>
namespace <|fim_suffix|>_ALL,
};
}
<|fim_middle|>DB
{
enum class DistributedCacheLogMode
{
LOG_NOTHING,
LOG_ON_ERROR,
LOG<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstdint>
namespace DB
{
enum class DistributedCachePoolBeh<|fim_suffix|>rOnLimit
{
WAIT,
ALLOCATE_NEW_BYPASSING_POOL,
};
}
<|fim_middle|>aviou<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/DistributedCacheDefines.h>
#include <Core/Types.h>
#includ<|fim_suffix|>_mode = DistributedCacheLogMode::LOG_ON_ERROR;
bool operator ==(const DistributedCacheSettings &) const = default;
void load(const Settings & settings);
void validate() const;
};
}
<|fim_mi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>s<emit_decimal_point>::flags, "inf", "nan", 'e', -6, 21, 6, 1};
return instance;
}
template class DoubleConverter<true>;
template class DoubleConverter<false>;
}
<|fim_prefix|><|fim_middle|>#include <IO/DoubleConverter.h>
namespace DB
{
template <bool emit_decimal_point>
const double_conversion::Do... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>DigitsBeforePoint +
1 + double_conversion::DoubleToStringConverter::kMaxFixedDigitsAfterPoint + 1;
using BufferType = char[MAX_REPRESENTATION_LENGTH];
static const double_conversion::DoubleToStringConverter & instance();
};
}
<|fim_prefix|>#pragma once
#pragma clang diagnostic push
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <IO/SeekableReadBuffer.h>
namespace DB
{
/// Just a stub - reads nothing from nowhere.
class EmptyReadBuffer : public SeekableReadBuffer
{
public:
EmptyReadBuffer() : SeekableReadBuffer(nullptr, 0) {}
off_t seek(off_t, int) override
<|fim_suffix|>tImpl() override { return... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/Expect404ResponseScope.h>
#include <base/defines.h>
namespace DB
{<|fim_suffix|>unt);
--expected_404_scope_count;
}
bool Expect404ResponseScope::is404Expected()
{
return expected_404_scope_count != 0;
}
}
<|fim_middle|>
thread_local size_t expected_404_scope_count = 0;
Expect404... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <thread>
namespace DB
{
// Inside the inner scope
// Remote storage response with PATH_NOT_FOUND error is considered as expected
// No error logs are written, n<|fim_suffix|>ors are incremented
class Expect404ResponseScope
{
public:
Expect404ResponseScope();
~Expect404Resp... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> auto off = blockOffset(offset);
if (off)
{
size_t in_part_size = partBlockSize(size, off);
size_t out_part_size = encryptBlockWithPadding(evp_ctx, &data[in_size], in_part_size, off, out);
in_size += in_part_size;
out_size += out_part_size;
}
if (in_size < ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_SSL
#include <Core/Types.h>
#include <openssl/evp.h>
namespace DB
{
class ReadBuffer;
class WriteBuffer;
namespace FileEncryption
{
/// Encryption algorithm.
/// We chose to use CTR cipther algorithms because they have the following features which are importan... | fim | ClickHouse/ClickHouse | c |
#include <IO/ForkWriteBuffer.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_CREATE_IO_BUFFER;
}
ForkWriteBuffer::ForkWriteBuffer(WriteBufferPtrs && sources_)
: WriteBuffer(nullptr, 0), sources(std::move(sources_))
{
if (sources.empty())
{
throw Exce... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Common/VectorWithMemoryTracking.h>
#include <IO/WriteBuffer.h>
#include <vector>
namespace DB
{
/** ForkWriteBuffer takes a vector of WriteBuffer and writes data to all of them
* If the vector of WriteBufferPts is empty, then it throws an error
* It uses the buffer of the first element as i... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/GCPOAuth.h>
#include <fmt/format.h>
#include <Poco/JSON/Par<|fim_suffix|>D;
}
GCPOAuthToken fetchGCPOAuthToken(
const std::string & client_id,
const std::string & client_secret,
const std::string & refresh_token,
const ConnectionTimeouts & timeouts,
HTTPConnectionGroupTy... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> Session creation is retried up to 5 times.
GCPOAuthToken fetchGCPOAuthToken(
const std::string & client_id,
const std::string & client_secret,
const std::string & refresh_token,
const ConnectionTimeouts & timeouts,
HTTPConnectionGroupType group = HTTPConnectionGroupType::HTTP);
}
<|f... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>(!in)
return false;
if (need_read_chunk_footer)
{
readChunkFooter();
need_read_chunk_footer = false;
}
size_t chunk_size = readChunkHeader();
if (0 == chunk_size)
{
readChunkFooter();
in.reset(); // prevent double-eof situation.
re... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>);
void readChunkFooter();
bool nextImpl() override;
};
}
<|fim_prefix|>#pragma once
#include <IO/BufferWithOwnMemory.h>
#include <IO/ReadBuffer.h>
namespace DB
{
/// Reads data with HTTP Chunked Transfer Encoding.
class HTTPChunkedReadBuffer : public BufferWithOwnMemory<ReadBuffer>
{
public:... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/HTTPCommon.h>
#include <Server/HTTP/HTTPServerResponse.h>
#include <Poco/StreamCopier.h>
#include <Common/Exception.h>
#include "config.h"
#if USE_SSL
# include <Poco/Net/AcceptCertificateHandler.h>
# include <Poco/Net/Context.h>
# include <Poco/Net/HTTPSClientSession.h>
# incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <mutex>
#include <string_view>
#include <Poco/Net/HTTPClientSession.h>
#include <Poco/Net/HTTPRequest.h>
#include <Poco/Net/HTTPResponse.h>
#include <Poco/URI.h>
#include <Poco/URIStreamFactory.h>
#include <Common/HTTPConnectionPool.h>
#include <Common/ProxyConfig... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <string>
#include <vector>
namespace DB
{
struct HTTPHeaderEntry
{
std::string name;
std::string value;
HTTPHeaderEntry(const std::string & name_, const std::string & value_) : name(name_), value(value_) {}
bool operator==(const HTTPHeaderEntry & other) const { re... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> ProfileEvents::increment(disk_sleep_event, sleep_watch.elapsedMicroseconds());
}
}
}
<|fim_prefix|>#include <IO/HTTPRequestThrottler.h>
#include <Common/Stopwatch.h>
namespace DB
{
void HTTPRequestThrottler::throttleImpl(
const ThrottlerPtr & throttler,
ProfileEvents::Even... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Common/ProfileEvents.h>
#include <Common/Throttler.h>
namespace DB
{
/// Helper struct encapsulating HTTP request throttling and profile event update logic.
struct HTTPRequestThrottler
{
/// Throttles for different kinds of HTTP requests
/// NOTE:... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>avail_out, char ** next_out)
{
if (*avail_in == 0)
{
if (buffer_length == 0 && block_length < 0 && compressed_length < 0)
return Status::OK;
return Status::NEEDS_MORE_INPUT;
}
HadoopSnappyDecoder::Status status = readBlockLength(avail_in, next_in);
if (stat... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>UT";
case Status::TOO_LARGE_COMPRESSED_BLOCK:
return "TOO_LARGE_COMPRESSED_BLOCK";
}
}
explicit HadoopSnappyReadBuffer(
std::unique_ptr<ReadBuffer> in_,
size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
char * existing_memory = nullptr,
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <IO/HashingWriteBuffer.h>
#include <IO/ReadBuffer.h>
namespace DB
{
/*
* Calculates the hash from the read data. When reading, the data is read from the nested ReadBuffer.
* Small pieces are copied into its own memory.
*/
class HashingReadBuffer : public IHashingBuffer<ReadBuff... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>emory[block_pos], data, n);
append(&BufferWithOwnMemory<Buffer>::memory[0]);
len -= n;
data += n;
block_pos = 0;
}
while (len >= block_size)
{
append(data);
len -= block_siz... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/WriteBuffer.h>
#include <IO/BufferWithOwnMemory.h>
#include <IO/ReadHelpers.h>
#include <city.h>
constexpr size_t DBMS_DEFAULT_HASHING_BLOCK_SIZE = 2048ULL;
namespace DB
{
template <typename Buffer>
class IHashingBuffer : public BufferWithOwnMemory<Buffer>
{
public:
usin... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Disks/DiskObjectStorage/ObjectStorages/StoredObject.h>
#include <base/types.h>
#include <memory>
namespace DB
{
class ReadBufferFromFileBase;
/// Opens a seekable buffer for reading from a storage object.
class IFileBasedSourceReader
{
public:
virtual ~IFileBasedSourceReader() = default;... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <memory>
#include <IO/ReadBuffer.h>
nam<|fim_suffix|>
return getReadBufferImpl();
}
virtual ~IReadableWriteBuffer() = default;
protected:
/// Creates read buffer from current write buffer.
/// Returned buffer points to the first byte of original buffer.
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>void LZMADeflatingWriteBuffer::nextImpl()
{
if (!offset())
return;
lstr.next_in = reinterpret_cast<unsigned char *>(working_buffer.begin());
lstr.avail_in = offset();
try
{
lzma_action action = LZMA_RUN;
do
{
out->nextIfAtEnd();
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <IO/BufferWithOwnMemory.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteBufferDecorator.h>
#include <lzma.h>
namespace DB
{
/// Performs compression using lzma library and writes compressed data to out_ WriteBuffer.
class LZMADeflatingWriteBuffer : public WriteBufferWithOwnMemoryDecorator
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/LZMAInflatingReadBuffer.h>
#include <IO/WithFileName.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LZMA_STREAM_DECODER_FAILED;
}
LZMAInflatingReadBuffer::LZMAInflatingReadBuffer(std::unique_ptr<ReadBuffer> in_, size_t buf_size, char * existing_memory, size_t alignment)
:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
};
}
<|fim_prefix|>#pragma once
#include <IO/CompressedReadBufferWrapper.h>
#include <IO/ReadBuffer.h>
#include <lzma.h>
namespace DB
{
class LZMAInflatingReadBuffer : public CompressedReadBufferWrapper
{
public:
explicit LZMAInflatingReadBuffer(
std::unique_ptr<ReadBuffer> in_,
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/LimitReadBuffer.h>
#include <Common/Exception.h>
#include <Core/Settings.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LIMIT_EXCEEDED;
extern const int CANNOT_READ_ALL_DATA;
}
bool LimitReadBuffer::nextImpl()
{
chassert(position() >= in->position());
/// Let ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>hint = {};
};
LimitReadBuffer(ReadBuffer & in_, Settings settings);
LimitReadBuffer(std::unique_ptr<ReadBuffer> in_, Settings settings);
~LimitReadBuffer() override;
bool poll(size_t timeout_microseconds) override;
private:
ReadBuffer * in;
std::unique_ptr<ReadBuffer> holde... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/LimitSeekableReadBuffer.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ARGUMENT_OUT_OF_BOUND;
}
LimitSeekableReadBuffer::LimitSeekableReadBuffer(SeekableReadBuffer & in_, UInt64 start_offset_, UInt64 limit_size_)
: LimitSeekableReadBuffer(w... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <IO/SeekableRe<|fim_suffix|>adBuffer
{
public:
LimitSeekableReadBuffer(SeekableReadBuffer & in_, UInt64 start_offset_, UInt64 limit_size_);
LimitSeekableReadBuffer(std::unique_ptr<SeekableReadBuffer> in_, UInt64 start_offset_, UInt64 limit_size_);
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/LocalSourceReader.h>
#include <Disks/IO/createReadBufferFromFileBase.h>
#include <Common/logger_useful.h>
namespace DB
{
std::unique_ptr<ReadBufferFromFileBase> Loca<|fim_suffix|> : std::to_string(object.bytes_size));
/// The file size drives the direct-IO / mmap threshold choice in `cr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>og = getLogger("LocalSourceReader");
};
}
<|fim_prefix|>#pragma once
#include <IO/IFileBasedSourceReader.h>
#include <IO/ReadSettings.h>
#include <Commo<|fim_middle|>n/Logger.h>
namespace DB
{
/// Reads from local filesystem.
class LocalSourceReader : public IFileBasedSourceReader
{
public:
explic... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ksum,
LZ4F_frame,
0 /* unknown content size */,
0 /* no dictID */,
LZ4F_noBlockChecksum},
compression_level, /* compression level; 0 == default */
1, /* autoflush */
0, /* favor decompression speed */
{0, 0, 0}, /* reserved, must be set t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>alignment = 0,
bool compress_empty_ = true)
: WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment) /// NOLINT(bugprone-move-forwarding-reference)
, tmp_memory(buf_size)
, compress_empty(compress_empty_)
{
initialize(compression_level);
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/Lz4InflatingReadBuffer.h>
#include <IO/WithFileName.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LZ4_DECODER_FAILED;
}
Lz4InflatingReadBuffer::Lz4InflatingReadBuffer(std::unique_ptr<ReadBuffer> in_, si<|fim_suffix|>ion());
size_t in_available = in->available();
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/CompressedReadBufferWrapper.h>
#include <IO/CompressionMethod.h>
#include <IO/ReadBuffer.h>
#include <lz4.h>
#include <lz4frame.h>
namespace DB
{
class Lz4InflatingReadBuffer : public CompressedReadBufferWrapper
{
public:
expli<|fim_suffix|><ReadBuffer> in_,
size... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> errno == ENOENT ? ErrorCodes::FILE_DOESNT_EXIST : ErrorCodes::CANNOT_OPEN_FILE, file_name, "Cannot open file {}", file_name);
}
std::string MMapReadBufferFromFile::getFileName() const
{
return file_name;
}
bool MMapReadBufferFromFile::isRegularLocalFile(size_t * out_view_offset)
{
*out_view_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
~MMapReadBufferFromFile() override;
void close();
std::string getFileName() const override;
bool isRegularLocalFile(size_t * out_view_offset) override;
private:
int fd = -1;
std::string file_name;
CurrentMetrics::Increment metric_increment{CurrentMetrics::OpenFileForRead... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <Common/ProfileEvents.h>
#include <Common/formatReadable.h>
#include <Common/Exception.h>
#include <Common/filesystemHelpers.h>
#include <base/getPageSize.h>
#include <IO/WriteHelpers.h>
#include <IO/MMapReadB... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ufferFromFileDescriptor(int fd_, size_t offset_, size_t length_);
/// Map till end of file.
MMapReadBufferFromFileDescriptor(int fd_, size_t offset_);
/// unmap memory before call to destructor
void finish();
off_t getPosition() override;
std::string getFileName() const overrid... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/MMapReadBufferFromFileWithCache.h>
#include <base/getPageSize.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ARGUMENT_OUT_OF_BOUND;
extern const int CANNOT_SEEK_THROUGH_FILE;
}
void MMapReadBufferFromFileWithCache::init()
{
size_t length = mapped->getLength();
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadBufferFromFileBase.h>
#include <IO/MMappedFileCache.h>
#include <IO/MMapReadBufferFromFileDe<|fim_suffix|>le_name, size_t offset, size_t length);
/// Map till end of file.
MMapReadBufferFromFileWithCache(MMappedFileCache & cache, const std::string & file_name, size_... | fim | ClickHouse/ClickHouse | c |
#include <unistd.h>
#include <fcntl.h>
#include <Common/ProfileEvents.h>
#include <Common/formatReadable.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <IO/MMappedFile.h>
namespace ProfileEvents
{
extern const Event FileOpen;
}
namespace DB
{
namespace ErrorCodes
{
extern cons... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>td::string getFileName() const;
private:
std::string file_name;
CurrentMetrics::Increment metric_increment{CurrentMetrics::OpenFileForRead};
void open();
};
}
<|fim_prefix|>#pragma once
#include <Common/CurrentMetrics.h>
#include <IO/MMap<|fim_middle|>pedFileDescriptor.h>
#include <cstdde... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>te(offset);
hash.update(length);
return hash.get128();
}
}
<|fim_prefix|>#include <IO/MMappedFileCache.h>
#includ<|fim_middle|>e <Common/SipHash.h>
namespace DB
{
UInt128 MMappedFileCache::hash(const String & path_to_file, size_t offset, ssize_t length)
{
SipHash hash;
hash.update(path_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Common/HashTable/Hash.h>
#include <Common/CacheBase.h>
#include <Common/ProfileEvents.h>
#include <Common/CurrentMetrics.h>
#include <IO/MMappedFile.h>
namespace ProfileEvents
{
extern const Event MMappedFileCacheHits;
extern const Event MMappedFil... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>h_);
}
MMappedFileDescriptor::MMappedFileDescriptor(int fd_, size_t offset_)
: fd(fd_), offset(offset_)
{
set(fd_, offset_);
}
void MMappedFileDescriptor::set(int fd_, size_t offset_, size_t length_)
{
finish();
fd = fd_;
offset = offset_;
length = length_;
if (!length)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <cstddef>
#include <Common/CurrentMetrics.h>
namespace CurrentMetrics
{
extern const Metric MMappedFiles;
extern const Metric MMappedFileBytes;
}
namespace DB
{
/// MMaps a region in file (or a whole file) into memory. Unmaps in destructor.
/// Does not open or close fil... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/MemoryReadWriteBuffer.h>
#include <boost/noncopyable.hpp>
namespace DB
{
class ReadBufferFromMemoryWriteBuffer : public ReadBuffer, boost::noncopyable, private Allocator<false>
{
public:
explicit ReadBufferFromMemoryWriteBuffer(MemoryWriteBuffer && origin)
: ReadBuffer(nullptr, 0),... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <forward_list>
#include <IO/WriteBuffer.h>
#include <IO/IReadableWriteBuffer.h>
#include <Common/Allocator.h>
#include <Core/Defines.h>
#include <boost/noncopyable.hpp>
namespace DB
{
/// Stores data in memory chunks, size of chunks are exponentially increasing during write
/// W... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <IO/MySQLBinlogEventReadBuffer.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
MySQLBinlogEventReadBuffer::MySQLBinlogEventReadBuffer(ReadBuffer & in_, size_t checksum_signature_length_)
: ReadBuffer(nullptr, 0, 0), in(in_), che... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
namespace DB
{
class MySQLBinlogEventReadBuffer : public ReadBuffer
{
protected:
static const size_t MAX_CHECKSUM_SIGNATURE_LENGTH = 4;
ReadBuffer & in;
size_t checksum_signature_length = 0;
size_t checks<|fim_suffix|>;
};
}
<|fim_middle|>um_... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> return false;
}
in.nextIfAtEnd();
/// Don't return a buffer when no bytes available
if (!in.hasPendingData())
return false;
working_buffer = ReadBuffer::Buffer(in.position(), in.buffer().end());
size_t count = std::min(in.available(), payload_length - offset);
workin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>8_t & sequence_id;
bool has_read_header = false;
// Size of packet which is being read now.
size_t payload_length = 0;
// Offset in packet payload.
size_t offset = 0;
protected:
bool nextImpl() override;
public:
MySQLPacketPayloadReadBuffer(ReadBuffer & in_, uint8_t & sequ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <IO/MySQLPacketPayloadWriteBuffer.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_WRITE_AFTER_END_OF_BUFFER;
}
const size_t MAX_PACKET_LENGTH = (1 << 24) - 1; // 16 mb
MySQLPacketPayloadWriteBuffer::MySQLPacketPayloadWriteBuffer(WriteBuffer &... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/WriteBuffer.h>
namespace DB
{
/** Writing packets.
* https://dev.mysql.com/doc/internals/en/mysql-packet.html
*/
class MySQLPacketPayloadWriteBuffer : public WriteBuffer
{
public:
MySQLPacketPayloadWriteBuffer<|fim_suffix|>size_t payload_length_, uint8_t & sequence_id_)... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> return value;
}
}
<|fim_prefix|>#pragma once
#include <concepts>
#include <bit>
namespace DB
{
template<std::integral T>
constexpr T netToHost(T value) noexcept
{
if constexpr (std::endian::native != std::endian::big)
return std::byteswap(value);
return value;
}
template<std::in<|... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/NullWriteBuffer.h>
namespace DB
{
NullWriteBuffer::NullWriteBuffer()
: WriteBufferFromPointer(data, sizeof(data))
, write_event(ProfileEvents::end())
{
}
NullWriteBuffer::NullWriteBuffer(const ProfileEvents::Event & write_event_)
: WriteBufferFromPointer(data, sizeof(data))
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/WriteBuffer.h>
#include <Common/ProfileEvents.h>
#include <IO/BufferWithOwnMemory.h>
namespace DB
{
/// Simply do nothing, can be used to measure amount of written bytes.
class NullWriteBuffer final : public WriteBufferFromPointer
{
public:
NullWrit<|fim_suffix|>emory(size... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/ObjectStorageSourceReader.h>
#include <IO/ReadBufferFromFileBase.h>
#include<|fim_suffix|>StorageSourceReader(
ObjectStoragePtr storage_,
const ReadSettings & read_settings_)
: storage(std::move(storage_))
, read_settings(read_settings_)
{
}
std::unique_ptr<ReadBufferFromFile... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.