text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#pragma once
#include <IO/HTTPHeaderEntries.h>
#include <IO/S3/Client.h>
#include <base/types.h>
#include <Common/Exception.h>
#include <Core/Field.h>
#include <Poco/Util/AbstractConfiguration.h>
#include "config.h"
#if USE_AWS_S3
#include <IO/S3/URI.h>
#include <IO/S3/Credentials.h>
#include <aws/cor... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>1024 * 1024;
inline static constexpr uint64_t DEFAULT_OBJECTS_CHUNK_SIZE_TO_DELETE = 1000;
inline static constexpr bool DEFAULT_ALLOW_NATIVE_COPY = true;
inline static constexpr bool DEFAULT_CHECK_OBJECTS_AFTER_UPLOAD = false;
}
<|fim_prefix|>#pragma once
#include <Core/Types.h>
namespace DB::S3
{
///... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>].changed
? (*this)[S3RequestSetting::max_get_burst].value
: default_max_get_burst;
request_throttler.get_throttler = std::make_shared<Throttler>(
max_get_rps,
max_get_burst,
ProfileEvents::S3GetRequestThrottlerCount,
Profile... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/BaseSettingsFwdMacros.h>
#include <Core/SettingsEnums.h>
#include <Core/SettingsFields.h>
#include <IO/HTTPRequestThrottler.h>
namespace Poco::Util
{
class AbstractConfiguration;
};
namespace DB
{
class NamedCollection;
struct ProxyConfigurationResolver;
struct S3RequestSett... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> const DB::Settings & settings,
const std::string & scheme,
bool validate_settings)
{
auth_settings = S3::S3AuthSettings(config, settings, config_prefix);
request_settings = S3::S3RequestSettings(config, settings, config_prefix, "s3_", validate_settings);
request_settings.proxy_resolv... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <map>
#include <mutex>
#include <optional>
#include <base/types.h>
#include <Interpreters/Context_fwd.h>
#include <Common/IThrottler.h>
#include <Common/MapWithMemoryTracking.h>
#include <IO/S3Common.h>
#include <IO/S3AuthSettings.h>
#include <IO/S3Defines.h>
#include <IO/S3Request... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <IO/SeekableReadBuffer.h>
#include <istream>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_READ_FROM_ISTREAM;
extern const int NOT_IMPLEMENTED;
}
namespace
{
template <typename CustomData>
class SeekableReadBufferWrapper : public Se... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
#include <IO/WithFileSize.h>
#include <Common/VectorWithMemoryTracking.h>
#include <functional>
#include <memory>
#include <optional>
namespace DB
{
class SeekableReadBuffer : public ReadBuffer
{
public:
SeekableReadBuffer(Position ptr, size_t size)
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>am(Session session_, std::streambuf * sb)
: std::iostream(sb)
, session(std::move(session_))
{
}
Session & getSession() { return session; }
const Session & getSession() const { return session; }
private:
/// Poco HTTP session is holder of response stream.
Session... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/SharedThreadPools<|fim_suffix|>ool & getMergeTreePrefixesDeserializationThreadPool()
{
static StaticThreadPool instance("MergeTreePrefixesDeserializationThreadPool", CurrentMetrics::MergeTreeSubcolumnsReaderThreads, CurrentMetrics::MergeTreeSubcolumnsReaderThreadsActive, CurrentMetrics::M... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Common/ThreadPool_fwd.h>
#include <Common/CurrentMetrics.h>
#include <cstdlib>
#include <memory>
#include <mutex>
namespace DB
{
class StaticThreadPool
{
public:
StaticThreadPool(
const String & name_,
CurrentMetrics::Metric threads_m... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_SNAPPY
#include <memory>
#include <fcntl.h>
#include <sys/types.h>
#include <snappy.h>
#include <IO/copyData.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include <IO/SnappyReadBuffer.h>
namespace DB
{
namespace ErrorCodes
{
extern const int SN... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_t seek(off_t off, int whence) override;
off_t getPosition() override;
private:
std::unique_ptr<ReadBuffer> in;
String compress_buffer;
String uncompress_buffer;
};
}
#endif
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_SNAPPY
#include <IO/ReadBuffer.h>
#include <IO/SeekableR... | fim | ClickHouse/ClickHouse | c |
#include "config.h"
#if USE_SNAPPY
#include <cstring>
#include <snappy.h>
#include <Common/ErrorCodes.h>
#include <IO/SnappyWriteBuffer.h>
namespace DB
{
namespace ErrorCodes
{
extern const int SNAPPY_COMPRESS_FAILED;
}
SnappyWriteBuffer::SnappyWriteBuffer(std::unique_ptr<WriteBuffer> out_, size_t buf_size, ch... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_SNAPPY
#include <IO/BufferWithOwnMemory.h>
#include <IO/WriteBuffer.h>
namespace DB
{
/// Performs compression using snappy library and write compressed data to the underlying buffer.
class SnappyWriteBuffer : public BufferWithOwnMemory<WriteBuffer>
{
using ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
}
}
<|fim_prefix|>#include <IO/StdIStreamFromMemory.h>
namespace DB
{
StdIStreamFromMemory::MemoryBuf::MemoryBuf(char * begin_, size_t size_)
: begin(begin_)
, size(size_)
{
this->setg(begin, begin, begin + size);
}
StdIStreamFromMemory::MemoryBuf::int_type StdIStreamFromMemory::MemoryBuf... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <iostream>
namespace DB
{
/// StdIStreamFromMemory is used in WriteBuffer<|fim_suffix|> pos_type seekpos(pos_type sp,
std::ios_base::openmode mode) override;
char * begin = nullptr;
size_t size = 0;
};
MemoryBuf me... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> std::ios_base::cur)
return seekpos(getCurrentPosition() + off, which);
if (dir == std::ios_base::end)
return seekpos(size + off, which);
throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong seek's base {}", static_cast<int>(dir));
}
std::streampos StdStreamBufFromReadBuffer::seekpos... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <streambuf>
namespace DB
{
class ReadBuffer;
class SeekableReadBuffer;
/// `std::streambuf`-compatible wrapper around a ReadBuffer.
class StdStreamBufFromReadBuffer : public std::streambuf
{
public:
using Base = std::streambuf;
explicit StdStream<|fim_s... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/StdStreamFromReadBuffer.h>
#include <IO/ReadBuffer.h>
namespace DB
{
StdIStreamFromReadBuffer::StdIStreamFromReadBuffer(std::unique_ptr<ReadBuffer> buf, size_t size)
: Base(&stream_buf)
, stream_buf(std::move(buf), size)
{
/// ios::failbit isn't specified here because otherwis... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ue_ptr<ReadBuffer> buf, size_t size);
StdIStreamFromReadBuffer(ReadBuffer & buf, size_t size);
StdStreamBufFromReadBuffer * rdbuf() const { return const_cast<StdStreamBufFromReadBuffer *>(&stream_buf); }
private:
StdStreamBufFromReadBuffer stream_buf;
};
/// `std::iostream`-compatible wrapp... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/SwapHelper<|fim_suffix|>wap(b2);
}
}
<|fim_middle|>.h>
namespace DB
{
SwapHelper::SwapHelper(BufferBase & b1_, BufferBase & b2_)
: b1(b1_), b2(b2_)
{
b1.swap(b2);
}
SwapHelper::~SwapHelper()
{
b1.s<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/BufferBase.h>
namespace DB
{
class SwapHelper
{
public:
SwapHel<|fim_suffix|> ~SwapHelper();
private:
BufferBase & b1;
BufferBase & b2;
};
}
<|fim_middle|>per(BufferBase & b1_, BufferBase & b2_);
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>to read from tables).
/// Sometimes it is better to use taskstats::blkio_delay_total, but it is quite expensive to get it.
watch.stop();
ProfileEvents::increment(ProfileEvents::DiskReadElapsedMicroseconds, watch.elapsedMicroseconds());
ProfileEvents::increment(ProfileEvents::AsynchronousR... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>c:
std::future<Result> submit(Request request) override;
Result execute(Request request) override;
void wait() override {}
};
}
<|fim_prefix|>#pragma once
#include <IO/AsynchronousReader.h>
namespace DB
{
/** Implementation of IAsynchronousReader that in fact synchronous.
* The only a... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/TimeoutSetter.h>
#include <Common/Exception.h>
#include <Common/logger_useful.h>
<|fim_suffix|>.
/// Let's not confuse the users of Apple macOS with extraneous error messages.
#if !defined(OS_DARWIN)
tryLogCurrentException("Client", "TimeoutSetter: Can't reset timeouts");
#en... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
}
<|fim_prefix|>#pragma once
#include <Poco/Net/StreamSocket.h>
#include <Poco/Timespan.h>
namespace DB
{
/// Temporarily overrides socket send/receive timeouts and reset them back into destructor (or manually by calling reset method)
/// If "limit_max_timeout" is true, timeouts could be only decreas... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/UncompressedCache.h>
#include <Common/SipHash.h>
namespace DB
{
template class CacheBase<UInt128,<|fim_suffix|>offset)
{
SipHash hash;
hash.update(path_to_file.size());
hash.update(path_to_file.data(), path_to_file.size());
hash.update(offset);
return hash.get128();
}
}
<... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/ProfileEvents.h>
#include <Common/HashTable/Hash.h>
#include <Common/JemallocCacheAllocator.h>
#include <IO/BufferWithOwnMemory.h>
#include <Common/CacheBase.h>
name<|fim_suffix|>dSizeWeightFunction>;
/** Cache of decompressed blocks for implementation of CachedCompressed... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
}
}
<|fim_prefix|>#include <IO/VarInt.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ATTEMP<|fim_middle|>T_TO_READ_AFTER_EOF;
}
void throwReadAfterEOF()
{
throw Exception(ErrorCodes::ATTEMPT_TO_READ_AFTER_EOF, "Attempt to read after eof");<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <base/types.h>
#include <base/defines.h>
#include <IO/ReadBuffer.h>
#include <IO/WriteBuffer.h>
namespace DB
{
/// Variable-Length Quantity (VLQ) Base-128 compression, also known as Variable Byte (VB) or Varint encoding.
[[noreturn]] void throwReadAfterEOF();
inline void writeVarUInt(UInt64 ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> ReadBufferWrapperBase *>(&in))
return getFileNameFromReadBuffer(wrapper->getWrappedReadBuffer());
if (const auto * parallel = dynamic_cast<const ParallelReadBuffer *>(&in))
return getFileNameFromReadBuffer(parallel->getReadBuffer());
if (const auto * peekable = dynamic_cast<const ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>0;
virtual ~WithFileName() = default;
};
String getFileNameFromReadBuffer(const ReadBuffer & in);
String getExceptionEntryWithFileName(const ReadBuffer & in);
}
<|fim_prefix|>#pragma once
#include <base/types.h>
namespace DB
{
class ReadBuffer<|fim_middle|>;
class WithFileName
{
public:
virtu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/WithFileSize.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/CompressedReadBufferWrapper.h>
#include <IO/ReadBufferFromFileDecorator.h>
#include <IO/PeekableReadBuffer.h>
namespace DB
{
namespace ErrorCodes
{
extern const int UNKNOWN_FILE_SIZE;
}
size_t WithFileSize::getFileSize()
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <optional>
namespace DB
{
class ReadBuffer;
class WithFileSize
{
publ<|fim_suffix|>fer & in);
size_t getFileSizeFromReadBuffer(ReadBuffer & in);
std::optional<size_t> tryGetFileSizeFromReadBuffer(ReadBuffer & in);
size_t getDataOffsetMaybeCompressed(const... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>:nextImpl()
{
throw Exception(ErrorCodes::CANNOT_WRITE_AFTER_END_OF_BUFFER, "Cannot write after end of buffer.");
}
}
<|fim_prefix|>#include <IO/WriteBuffer.h>
#include <Common/Exception.h>
#include <Common/LockMemoryExceptionInThread.h>
#include <Common/StackTrace.h>
#include <Common/logger_useful.h... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <algorithm>
#include <atomic>
#include <exception>
#include <memory>
#include <IO/BufferBase.h>
namespace DB
{
/** A simple abstract class for buffered data writing (char sequences) somewhere.
* Unlike std::ostream, it provides access to the internal buffer,
* and also allows you to manu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eBuffer>>;
}
<|fim_prefix|>#pragma once
#include <IO/WriteBuffer.h>
#include <IO/BufferWithOwnMemory.h>
#include <utility>
#include <memory>
namespace DB
{
class WriteBuffer;
/// WriteBuffer that decorates data and delegates it to underlying buffer.
/// It's used for writing compressed and encrypted ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>= continuation + continuation_size;
/// internal buffer points to whole memory segment and working buffer - to free space for writing.
internalBuffer() = Buffer(const_cast<char *>(begin), end);
buffer() = Buffer(continuation, end);
}
/// it is super strange,
/// but a... | fim | ClickHouse/ClickHouse | c |
#include <IO/WriteBufferFromEncryptedFile.h>
#include <Common/logger_useful.h>
#if USE_SSL
namespace DB
{
WriteBufferFromEncryptedFile::WriteBufferFromEncryptedFile(
size_t buffer_size_,
std::unique_ptr<WriteBufferFromFileBase> out_,
const String & key_,
const FileEncryption::Header & header_,
si... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_SSL
#include <Common/Logger.h>
#include <Common/assert_cast.h>
#include <IO/WriteBufferFromFileBase.h>
#<|fim_suffix|>fferFromFileBase> out_,
const String & key_,
const FileEncryption::Header & header_,
size_t old_file_size,
bool u... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> F_NOCACHE, 1) == -1)
ErrnoException::throwFromPath(ErrorCodes::CANNOT_OPEN_FILE, file_name, "Cannot set F_NOCACHE on file {}", file_name);
}
#endif
}
/// Use pre-opened file descriptor.
WriteBufferFromFile::WriteBufferFromFile(
int & fd_,
const std::string & original_file_name,
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <sys/types.h>
#include <Common/CurrentMetrics.h>
#include <Common/IThrottler.h>
#include <IO/WriteBufferFromFileDescriptor.h>
namespace CurrentMetrics
{
extern const Metric OpenFileForWrite;
}
#ifndef O_DIRECT
#define O_DIRECT 00040000
#endif
namespace DB
{
/** Accepts pa... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>xisting_memory, alignment)
{
}
}
<|fim_prefix|>#include <IO/WriteBufferFromFileBase.h>
namespace DB
{
WriteBufferFromFileB<|fim_middle|>ase::WriteBufferFromFileBase(size_t buf_size, char * existing_memory, size_t alignment)
: BufferWithOwnMemory<WriteBuffer>(buf_size, e<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include <IO/WriteBuffer.h>
#include <IO/BufferWithOwnMemory.h>
namespace DB
{
class WriteBufferFromFileBase : publi<|fim_suffix|>id sync() override = 0;
virtual std::string getFileName() const = 0;
};
}
<|fim_middle|>c BufferWithOwnMemory<WriteBuffer>
{
public:
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>l()
{
SwapHelper swap(*this, *impl);
impl->next();
}
}
<|fim_prefix|>#include <IO/WriteBufferFromFileDecorator.h>
#include <IO/WriteBuffer.h>
#include <IO/SwapHelper.h>
namespace DB
{
WriteBufferFromFileDecorator::WriteBufferFromFileDecorator(std::unique_ptr<WriteBuffer> impl_)
: WriteBuff... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
void sync() override;
std::string getFileName() const override;
void preFinalize() override;
const WriteBuffer & getImpl() const { return *impl; }
protected:
void finalizeImpl() override;
void cancelImpl() noexcept override;
std::unique_ptr<WriteBuffer> impl;
private:... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <unistd.h>
#include <cerrno>
#include <sys/stat.h>
#include <Common/Throttler.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/ProfileEvents.h>
#include <Common/CurrentMetrics.h>
#include <Common/Stopwatch.h>
#include <IO/WriteBufferFromFileDescriptor.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/WriteBufferFromFileBase.h>
#include <Common/IThrottler.h>
namespace DB
{
/** Use ready file descriptor. Does not open or close a file.
*/
class WriteBufferFromFileDescriptor : public WriteBufferFromFileBase
{
public:
explicit WriteBufferFromFileDescriptor(
int f... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/WriteBufferFromFileDescriptorDisca<|fim_suffix|>n() + bytes_written, offset() - bytes_written);
if ((-1 == res || 0 == res) && errno != EINTR)
{
/// Never send this profile event to trace log because it may cause another
/// write into the same fd and ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/WriteBufferFromFileDescriptor.h>
namespace DB
{
/** Write to file descriptor but drop the data if write would block or fail.
* To use within signal handler. Motivating example: a signal handler invoked during execution of malloc
* <|fim_suffix|> not block because some mu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ptr;
}
}
<|fim_prefix|>#include <IO/WriteBufferFromHTTP.h>
#include <Common/logger_useful.h>
#include <Common/ProxyConfigurationResolverProvider.h>
#include <Interpreters/Context.h>
namespace ProfileEvents
{
extern const Event WriteBufferFromHTTPRequestsSent;
extern const Event WriteBufferFrom... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ConnectionTimeouts.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteBufferFromOStream.h>
#include <IO/HTTPCommon.h>
#include <IO/HTTPHeaderEntries.<|fim_suffix|>fferFromHTTP & name(decltype(BuilderWriteBufferFromHTTP::member) arg_##member) \
{ \
member = std::move(ar... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/WriteBufferFromOStream.h>
#include <Common/logger_useful.h>
#include <ostream>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_WRITE_TO_OSTREAM;
}
void WriteBu<|fim_suffix|>
return;
ostr->write(working_buffer.begin(), offset());
ostr->flush();
if (!... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>,
char * existing_memory = nullptr,
size_t alignment = 0);
protected:
explicit WriteBufferFromOStream(size_t size = DBMS_DEFAULT_BUFFER_SIZE, char * existing_memory = nullptr, size_t alignment = 0);
void nextImpl() override;
std::ostream * ostr{};
};
}
<|fim_prefix|>#pragma... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> }
catch (const Poco::Net::NetException & e)
{
throw NetException(ErrorCodes::NETWORK_ERROR, "{}, while writing to socket ({} -> {})", e.displayText(),
our_address.toString(), peer_address.toString());
}
catch (const Poco::Time... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Poco/Net/Socket.h>
#include <IO/WriteBuffer.h>
#include <IO/BufferWithOwnMemory.h>
#include <Common/AsyncTaskExecutor.h>
namespace DB
{
using AsyncCallback = std::function<void(int, Poco::Timespan, AsyncEventTimeoutType, const std::string &, uint32_t)>;
/** Works with the ready Poco::Net::So... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/WriteBufferFromPocoSocketChunked.h>
#include <Common/logger_useful.h>
#include <IO/NetUtils.h>
namespace
{
template <typename T>
void setValue(T * typed_ptr, std::type_identity_t<T> val)
{
memcpy(static_cast<void*>(typed_ptr), &val, sizeof(T));
}
}
namespace DB
{
WriteBufferFromPoco... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/logger_useful.h>
#include <IO/WriteBufferFromPocoSocket.h>
namespace DB
{
class WriteBufferFromPocoSocketChunked: public WriteBufferFromPocoSocket
{
public:
explicit WriteBufferFromPocoSocketChunked(Poco::Net::Socket & socket_, size_t buf_size = DBMS_DEFAULT_BUFFER_SI... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>))
{
if (!isEmpty())
{
LOG_INFO(log, "Nothing to abort. {}", getVerboseLogDetails());
}
return;
}
LOG_INFO(log, "Abort multipart upload. {}", getVerboseLogDetails());
S3::AbortMultipartUploadRequest req;
req.SetBucket(bucket);
req.SetKe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_data;
char fake_buffer_when_prefinalized[1] = {};
/// offset() and count() are unstable inside nextImpl
/// For example nextImpl changes position hence offset() and count() is changed
/// This vars are dedicated to store information about sizes when offset() and count() are unstable
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <IO/WriteBufferFromString.h>
namespace DB
{
/// It is safe to make them autofinalizable.
WriteBufferFromString::~WriteBufferFromString()
{
try
{
if (!this->finalized && !this->canceled)
this->finalize();
}
catch<|fim_suffix|>_PRE... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <IO/WriteBufferFromVector.h>
#include <string>
namespace DB
{
/** Writes the data to a string.
* Note: before using the resulting string, destroy this object or call finalize.
*/
class WriteBufferFromString final : public WriteBufferFromVectorImpl<std::string>
{
using Base = WriteBuffe... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <IO/WriteBufferFromVector.h>
#include <Common/StringWithMemoryTracking.h>
namespace DB
{
class WriteBufferFromStringWithMemoryTracking final : public WriteBufferFromVectorImpl<StringWithMemoryTracking>
{
using Base = <|fim_suffix|>Tracking() override;
};
}
<|fim_middle|>Write... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nalize();
}
catch (...)
{
tryLogCurrentException(__PRETTY_FUNCTION__);
}
}
}
<|fim_prefix|>#include <Common/Exception.h>
#include <IO/WriteBufferFromStringWithMemoryTracking.h>
namespace DB
{
/// It is safe to make them autofinalizable.
WriteBufferFromStringWithMemoryTracking::~... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ld_size = vector.size();
/// pos may not be equal to vector.data() + old_size, because WriteBuffer::next() can be used to flush data
size_t pos_offset = pos - reinterpret_cast<Position>(vector.data());
if (pos_offset == old_size)
{
vector.resize(old_size * size_... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Poco/UTF8Encoding.h>
#include <IO/WriteBufferValidUTF8.h>
#include <base/types.h>
#include <base/simd.h>
#ifdef __SSE2__
#include <emmintrin.h>
#endif
#if defined(__aarch64__) && defined(__ARM_NEON)
# include <arm_neon.h>
# pragma clang diagnostic ignored "-Wreserved-identifier"
#e... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
std::string replacement;
};
}
<|fim_prefix|>#pragma once
#include <IO/WriteBuffer.h>
#include <IO/BufferWithOwnMemory.h>
namespace DB
{
/** Writes the data to another buffer, replacing the invalid UTF-8 sequences with the specified sequence.
* If the valid UTF-8 is already written, it works... | fim | ClickHouse/ClickHouse | c |
#include <IO/WriteHelpers.h>
#include <base/DecomposedFloat.h>
#include <base/hex.h>
#include <Common/formatIPv6.h>
#include <Common/NaNUtils.h>
#include <zmij.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
template <typename IteratorSrc, typename IteratorDst>
void formatHex(IteratorSrc ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>writeDateText(LocalDate(x, time_zone), buf); }
inline void writeText(const LocalDate & x, WriteBuffer & buf) { writeDateText(x, buf); }
inline void writeText(const LocalDateTime & x, WriteBuffer & buf) { writeDateTimeText(x, buf); }
inline void writeText(const LocalTime & x, WriteBuffer & buf) { writeTime... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Defines.h>
#include <IO/WriteBuffer.h>
#include <base/itoa.h>
template <typename T> constexpr size_t max_int_width = 20;
template <> inline constexpr size_t max<|fim_suffix|>457584007913129639935
template <> inline constexpr size_t max_int_width<Int256> = 78; /// -578960446... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Settings.h>
#include <IO/WriteSettings.h>
#include <Interpreters/Context.h>
#include <Common/CurrentThread.h>
namespace DB
{
<|fim_suffix|>ings getWriteSettingsForMetadata()
{
WriteSettings write_settings = getWriteSettings();
write_settings.write_through_distributed_cache = false;... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/IThrottler.h>
#include <Common/Scheduler/ResourceLink.h>
#include <IO/DistributedCacheSettings.h>
namespace DB
{
/// Settings to be passed to IDisk::writeFile()
struct WriteSettings
{
/// Bandwidth throttler to use during writing
ThrottlerPtr remote_throttler;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>end() - out->position());
int rc = deflate(&zstr, Z_FULL_FLUSH);
out->position() = out->buffer().end() - zstr.avail_out;
if (rc != Z_OK)
throw Exception(ErrorCodes::ZLIB_DEFLATE_FAILED, "deflate failed: {}", zError(rc));
}
while (zstr.avail_out == 0);
whi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_size = DBMS_DEFAULT_BUFFER_SIZE,
char * existing_memory = nullptr, /// NOLINT(readability-non-const-parameter)
size_t alignment = 0,
bool compress_empty_ = true)
: WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment), compress_em... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>// move in stream on place, where reading stopped
size_t bytes_read = zstr.total_in - old_total_in;
in->position() += bytes_read;
/// change size of working buffer (it's size equal to internal_buffer size without unused uncompressed values)
working_buffer.resize(internal_b... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
#include <IO/CompressedReadBufferWrapper.h>
#include <IO/CompressionMethod.h>
#include <limits>
#include <zlib.h>
namespace DB
{
namespace ErrorCodes
{
}
/// Reads compressed data from ReadBuffer in_ and performs decompression using zlib library.
/// This buff... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> reader->readStrict(result.data(), 3);
/// If we don't have correct block in the end, then we need to add it manually.
/// NOTE: maybe we can have the same bytes in case of data corruption/unfinished write.
/// But in this case file still corrupted and we have to remove it.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/BufferWithOwnMemory.h>
#include <IO/CompressionMethod.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteBufferDecorator.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/ReadBufferFromFileBase.h>
#include <zstd.h>
namespace DB
{
/// Performs stream compression using zstd li... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ingWriteBuffer::flush(ZSTD_EndDirective mode)
{
input.src = reinterpret_cast<unsigned char *>(working_buffer.begin());
input.size = offset();
input.pos = 0;
try
{
size_t out_offset = out->offset();
bool ended = false;
do
{
out->nextIfAtEnd()... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ide;
/// Flush all pending data and write zstd footer to the underlying buffer.
/// After the first call to this function, subsequent calls will have no effect and
/// an attempt to write to this buffer will result in exception.
void finalFlushBefore() override;
void finalFlushAfter()... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> /// move position to the end of read data
in->position() = in->buffer().begin() + input.pos;
working_buffer.resize(output.pos);
/// If end of file is reached, fill eof variable and return true if there is some data in buffer, otherwise return false
if (in->eof())
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>(
std::unique_ptr<ReadBuffer> in_,
size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
char * existing_memory = nullptr,
size_t alignment = 0,
int zstd_window_log_max = 0);
~ZstdInflatingReadBuffer() override;
private:
bool nextImpl() override;
ZSTD_DCtx * dc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <Common/Throttler.h>
#include <IO/ReadBuffer.h>
#include <IO/WriteBuffer.h>
#include <IO/copyData.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ATTEMPT_TO_READ_AFTER_EOF;
extern const int CANNOT_READ_ALL_DATA;
}
namespace
{
void copyDataImpl(R... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nt> & is_cancelled, ThrottlerPtr throttler);
}
<|fim_prefix|>#pragma once
#include <atomic>
#include <functional>
namespace DB
{
class ReadBuffer;
class WriteBuffer;
class IThrottler;
using ThrottlerPtr = std::shared_ptr<IThrottler>;
/// Copies data from ReadBuffer to WriteBuffer, all that is.
void... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <iostream>
#include <memory>
#include <string>
#include <snappy.h>
#include <IO/ReadBufferFromString.h>
#inclu<|fim_suffix|> << buf_size << std::endl;
return 1;
}
}
if (uncompress(256) != output)
{
std::cout << "test hadoop snappy read buffer failed, buf_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> std::string hello;
{
DB::WriteBufferFromString buf(hello);
buf << "Hello";
std::cerr << hello.size() << '\n';
}
std::cerr << hello.size() << '\n';
std::cerr << hello << '\n';
}
{
DB::WriteBufferFromFileDescriptor ... | fim | ClickHouse/ClickHouse | cpp |
#include <IO/ReadBufferFromFileDescriptor.h>
#include <IO/LimitReadBuffer.h>
#include <IO/WriteBufferFromFileDescriptor.h>
#include <IO/copyData.h>
#include <IO/WriteHelpers.h>
#include <iostream>
#include <string>
#include <Examples/clickhouse_examples.h>
int mainEntryExampleLimitReadBuffer(int argc, char ** argv)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>";
ReadBuffer in(src.data(), src.size(), 0);
std::string dst;
{
WriteBufferFromString out(dst);
char x = {};
readChar(x, in);
auto limit_in = LimitReadBuffer(in, {.read_no_more = 1});
copyData(limit_in, out);
... | fim | ClickHouse/ClickHouse | cpp |
#include <iomanip>
#include <iostream>
#include <IO/LZMADeflatingWriteBuffer.h>
#include <IO/LZMAInflatingReadBuffer.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/WriteHelpers.h>
#include <Common/Stopwatch.h>
#include <Examples/clickhouse_examples.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <string>
#include <iostream>
#include <base/types.h>
#include <base/getPageSize.h>
#include <IO/WriteHelpers.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/ReadBufferFromFile.h>
#include <Examples/clickhouse_examples.h>
int mainEntryExampleODirectAndDirtyPages(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#in<|fim_suffix|>ude <IO/WriteBufferFromFileDescriptor.h>
#include <Examples/clickhouse_examples.h>
using namespace DB;
int mainEntryExampleParseDateTimeBestEffort(int, char **)
try
{
const DateLUTImpl & local_time_zone = DateLUT::instance();
const DateLUTImpl & utc_time_zone = DateLUT::instanc... | fim | ClickHouse/ClickHouse | cpp |
#include <iostream>
#include <iomanip>
#include <vector>
#include <pcg_random.hpp>
#include <base/types.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <IO/WriteIntText.h>
#include <IO/WriteBufferFromVector.h>
#include <Common/Stopwatch.h>
#include <Examples/clickhouse_examples.h>
#include <Comm... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <iostream>
#include <iomanip>
#include <IO/ReadHelpers.h>
#include <IO/ReadBufferFromFileDescriptor.h>
#include <Common/Stopwatch.h>
#include <Examples/clickhouse_examples.h>
namespace test
{
template <typename T>
void readIntText(T & x, DB::ReadBuffer & buf)
{
bool negati... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <string>
#include <iostream>
#include <IO/ReadBuffer.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
#include <base/types.h>
#include <Examples/clickhouse_examples.h>
static int readAndPrint(DB::ReadBuffer <|fim_suffix|> in(s);
if (readAndPrint(in))
std:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <IO/ReadSettings.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/copyData.h>
#include <Storages/ObjectStorage/HDFS/ReadBufferFromHDFS.h>
#include <base/types.h>
#include <Common/Config/ConfigProcessor.h>
#include <Poco/Util/MapConfiguration.h>
#include <Examples/clickhouse_examples.h>
using... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>' << c << '\t' << '\'' << d << '\'' << std::endl;
std::cout << i << std::endl;
}
catch (const DB::Exception & e)
{
std::cerr << e.what() << ", " << e.displayText() << std::endl;
return 1;
}
return 0;
}
<|fim_prefix|>#include <string>
#include <iostream>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <string>
#include <iostream>
#include <IO/ReadHelpers.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/ConcatReadBuffer.h>
#include <Examples/clickhouse_examples.h>
usin<|fim_suffix|>) << std::endl;
return 0;
}
catch (const Exception & e)
{
std::cerr << e.what() << ", " << e.disp... | fim | ClickHouse/ClickHouse | cpp |
// NOLINTBEGIN(clang-analyzer-core.UndefinedBinaryOperatorResult,clang-analyzer-optin.core.EnumCastOutOfRange)
// False positives: clang-analyzer traces into fast_float library headers and reports
// UndefinedBinaryOperatorResult in ascii_number.h and EnumCastOutOfRange in float_common.h.
// These cannot be suppressed ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>64>::min();
Int64 x2 = 0;
std::string s;
std::cerr << x1 << std::endl;
{
DB::WriteBufferFromString wb(s);
DB::writeIntText(x1, wb);
}
std::cerr << s << std::endl;
{
DB::ReadBufferFromString rb(s);
D... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.