text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/OptimizedRegularExpression.h>
TEST(OptimizeRE, analyze)
{
auto test_f = [](const std::string & regexp,
const std::string & required,
std::vector<std::string> expect_alternatives = {},
bool trival... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/OSThreadNiceValue.h>
#if defined(OS_LINUX)
#include <sys/resource.h>
#include <linux/capability.h>
#include <Common/hasLinuxCapability.h>
#include <Common/ErrnoException.h>
using namespace DB;
namespace DB::ErrorCodes
{
extern const int CANNOT_SET_THREAD_PR... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
ASSERT_EQ(need_to_stop, 0);
ASSERT_EQ(stopped_next, false);
}
TEST(OvercommitTracker, UserFreeContinueAndAlloc3)
{
ProcessList process_list;
ProcessListForUser user_process_list(&process_list);
UserOvercommitTrackerForTest user_overcommit_tracker(&process_list, &user_process_list);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/PageCache.h>
#include <thread>
#include <chrono>
/// Test that PageCache::autoResize correctly tracks peak memory usage over the history window.
///
/// Bug: In PageCache.cpp, autoResize() computes `now` in microseconds but divides by
/// history_window.count() w... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>\n\\t\\rᖴᘍ᎐᙮ᗝᾴ\xFFwtf\xAA\xBB\xCC\xDD\"}"sv);
Poco::JSON::Parser parser;
Poco::Dynamic::Var res_json = parser.parse(source_str);
const Poco::JSON::Object::Ptr & object = res_json.extract<Poco::JSON::Object::Ptr>();
std::stringstream destination;
Poco::JSON::String... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>B::buildPocoNonProxyHosts("*"),
".*");
}
TEST(ProxyConfigurationToPocoProxyConfiguration, TestNoProxyHostRegexBuildEmpty)
{
ASSERT_EQ(
DB::buildPocoNonProxyHosts(""),
"");
}
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/proxyConfigurationToPocoProxyConfig.h>
TEST(P... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r2{std::move(arr)};
}
{
Array arr;
arr.push_back(1);
arr.push_back(2);
arr.push_back(3);
Array arr2{std::move(arr)};
ASSERT_TRUE(arr.empty()); // NOLINT
ASSERT_TRUE(arr2.size() == 3);
ASSERT_TRUE(arr2[0] == 1);
ASSERT_TRU... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <memory>
#include <gtest/gtest.h>
#include <Common/PoolBase.h>
#include <Poco/Lo<|fim_suffix|> auto obj_entry = pool.get(-1);
ASSERT_TRUE(!obj_entry.isNull());
ASSERT_EQ(obj_entry->x, 0);
ASSERT_EQ(1, pool.size());
}
ASSERT_EQ(100, pool.last_destroy_value);
}
<|fim... | fim | ClickHouse/ClickHouse | cpp |
#include <gtest/gtest.h>
#include <Common/ProxyConfigurationResolverProvider.h>
#include <Common/RemoteProxyConfigurationResolver.h>
#include <Common/ProxyListConfigurationResolver.h>
#include <Common/EnvironmentProxyConfigurationResolver.h>
#include <Common/tests/gtest_global_context.h>
#include <Common/tests/gtest_h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>SERT_EQ(https_configuration.protocol, ProxyConfiguration::protocolFromString(https_proxy_server.getScheme()));
ASSERT_EQ(https_configuration.no_proxy_hosts, poco_no_proxy_regex);
}
}
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/EnvironmentProxyConfigurationResolver.h>
#include <Common/tes... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/ProxyListConfigurationResolver.h>
#include <Poco/URI.h>
namespace DB
{
namespace
{
auto proxy_server1 = Poco::URI("http://proxy_server1:3128");
auto proxy_server2 = Poco::URI("http://proxy_server2:3128");
std::string no_proxy_hosts = "localhost,,12... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/RemoteProxyConfigurationResolver.h>
#include <Poco/URI.h>
#include <IO/ConnectionTimeouts.h>
#include <base/sleep.h>
namespace
{
struct RemoteProxyHostFetcherMock : public DB::RemoteProxyHostFetcher
{
explicit RemoteProxyHostFetcherMock(const std::string & ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <IO/WriteBufferFromFile.h>
#include <Common/CurrentThread.h>
#include <Common/HostResolvePool.h>
#include <base/defines.h>
#include <gtest/gtest.h>
#include <optional>
#include <chrono>
#include <thread>
using namespace std::literals::chrono_literals;
static auto now()
{
return std::chr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/Exception.h>
#include <Common/RWLock.h>
#include <Common/Stopwatch.h>
#include <Core/Types.h>
#include <base/types.h>
#include <base/phdr_cache.h>
#include <random>
#include <pcg_random.hpp>
#include <thread>
#include <atomic>
#include <iomanip>
using namespace... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Exception.h>
<|fim_suffix|>root', '******') WHERE "
"ssn='000-00-0000' or email='hidden@hidden.test'");
DB::SensitiveDataMasker maskerbad(*empty_xml_config, "");
// gtest has not good way to check exception content, so just do it manually (see https://github.com/google/g... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> ShellCommand::executeDirect(config);
std::string res;
readStringUntilEOF(res, command->out);
command->wait();
EXPECT_EQ(res, "Hello, world!\n");
}
TEST(ShellCommand, ExecuteWithInput)
{
auto command = ShellCommand::execute("cat");
String in_str = "Hello, world!\n";
ReadBuf... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>fer[i] = static_cast<char>(i * 31 + 7);
/// Streaming one byte at a time must equal hashing the whole buffer in one update.
EXPECT_EQ(hashWhole(buffer.data(), size), hashByteByByte(buffer.data(), size))
<< "size=" << size;
}
}
/// Splitting an update at every chunk size d... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <iomanip>
#include <gtest/gtest.h>
#include <Common/CacheBase.h>
#include <Common/CurrentMetrics.h>
/// Use MarkCache* for tests (to avoid introducing one more metric)
namespace CurrentMetrics
{
extern const Metric MarkCacheBytes;
extern const Metric MarkCacheFiles;
}
TEST(SLRUCache, se... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/SpaceSaving.h>
#include <set>
#include <string>
#include <gtest/gtest.h>
#include <base/scope_guard.h>
#include <Common/FailPoint.h>
namespace DB::FailPoints
{
extern const char space_saving_copy_arena_throw[];
}
using namespace DB;
/// Collect the key strings from a topK result int... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>}
}
catch (const Poco::TimeoutException &)
{
got_timeout = true;
}
ASSERT_TRUE(got_timeout) << "Expected Poco::TimeoutException when writing to a non-reading SSL peer";
}
catch (const Poco::Exception & e)
{
/// Connection setup can f... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <base/strong_typedef.h>
#include <set>
#include <unordered_set>
#include <memory>
#include <type_traits>
#include <gtest/gtest.h>
TEST(StrongTypedefSuite, TypedefsOfTheSameType)
{
/// check that strong typedefs of same type differ
STRONG_TYPEDEF(int, Int)
STRONG_TYPEDEF(int, Anothe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <optional>
#include <thread>
#include <vector>
#include <gtest/gtest.h>
#include <Common/ThreadFuzzer.h>
#include <Common/Stopwatch.h>
TEST(ThreadFuzzer, mutex)
{
/// Initialize ThreadFuzzer::started
DB::ThreadFuzzer::instance().setup();
std::mutex mutex;
std::atomic<si<|fim_suf... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nstexpr size_t num_waiting_threads = 4;
ThreadPool waiting_pool(CurrentMetrics::LocalThread, CurrentMetrics::LocalThreadActive, CurrentMetrics::LocalThreadScheduled, num_waiting_threads);
for (size_t i = 0; i < num_waiting_threads; ++i)
waiting_pool.scheduleOrThrowOnError([&pool] { pool.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>0000);
}
<|fim_prefix|>#include <atomic>
#include <Common/Exception.h>
#include <Common/ThreadPool.h>
#include <Common/CurrentMetrics.h>
#include <gtest/gtest.h>
namespace CurrentMetrics
{
extern const Metric LocalThread;
extern const Metric LocalThreadActive;
extern const Metric LocalThre... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ude <Common/CurrentMetrics.h>
#include <gtest/gtest.h>
namespace CurrentMetrics
{
extern const Metric LocalThread;
extern const Metric LocalThreadActive;
extern const Metric LocalThreadScheduled;
}
/// Regression test for https://github.com/ClickHouse/ClickHouse/issues/83273
/// Configuring... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/CurrentMetrics.h>
#include <Common/ThreadPool.h>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <set>
#include <thread>
#include <vector>
#include <gtest/gtest.h>
namespace CurrentMetrics
{
extern const Metric LocalThread;
extern con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <atomic>
#include <Common/ThreadPool.h>
#include <Common/CurrentMetrics.h>
#include <gtest/gtest<|fim_suffix|>late <typename Pool>
int test()
{
Pool pool(CurrentMetrics::LocalThread, CurrentMetrics::LocalThreadActive, CurrentMetrics::LocalThreadScheduled, 10, 2, 10);
std::atomic<int> co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>or (size_t i = 0; i < 1000; ++i)
{
size_t threads = 16;
ThreadPool pool(CurrentMetrics::LocalThread, CurrentMetrics::LocalThreadActive, CurrentMetrics::LocalThreadScheduled, threads);
for (size_t j = 0; j < threads; ++j)
pool.scheduleOrThrowOnError([&] { ++res; });
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <stdexcept>
#include <Common/ThreadPool.h>
#include <Common/CurrentMetrics.h>
#include <base/defines.h>
#include <gtest/gtest.h>
namespace CurrentMetrics
{
extern const Metric LocalThread;
extern const Metric LocalThreadActive;
extern const Metric LocalThreadScheduled;
}
static bo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/ThreadPoolTaskTracker.h>
#include <Common/setThreadName.h>
#include <gtest/gtest.h>
namespace CurrentMetrics
{
extern const Metric LocalThread;
extern const Metric LocalThreadActive;
extern const Metric LocalThreadScheduled;
}
using namespace DB;
namespace
{
LogSeriesLimi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <thread>
#include <condition_variable>
#include <shared_mutex>
#include <barrier>
#include <atomic>
#include <Common/Exception.h>
#include <Common/SharedMutex.h>
#include <Common/Stopwatch.h>
#include <base/demangle.h>
#include <absl/synchronization/mutex.h>
namespac... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <optional>
#include <Interpreters/TemporaryReplaceTableName.h>
TEST(TemporaryReplaceTableName, FromStringValidInput)
{
auto result = DB::TemporaryReplaceTableName::fromString("_tmp_replace_efe23F_wef44wE");
ASSERT_TRUE(result.has_value());
EXPECT_EQ(result->n... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/escapeForFileName.h>
#include <gt<|fim_suffix|>pace DB;
TEST(Common, unescapeForFileName)
{
EXPECT_EQ(unescapeForFileName(escapeForFileName("172.19.0.6")), "172.19.0.6");
EXPECT_EQ(unescapeForFileName(escapeForFileName("abcd.")), "abcd.");
EXPECT_EQ(unescapeForFileName(esca... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/VersionNumber.h>
#include <gtest/gtest.h>
using namespace DB;
TEST(VersionNumber, Version<|fim_suffix|>mber version(1, 2, 3);
EXPECT_NE(VersionNumber(1, 1, 1), version);
EXPECT_EQ(VersionNumber(1, 2, 3), version);
EXPECT_GE(VersionNumber(1, 2, 3), version);
EXPECT_GT(Ver... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/WeightedRandomSampling.h>
#include <gtest/gtest.h>
#include <algorithm>
#include <cstddef>
#include <unordered_map>
#include <vector>
using namespace DB;
namespace
{
const size_t N = 1'000'000;
const std::unordered_map<size_t, double> objects = {
{0, 10},
{1, 5},
{2, 5},
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <cstdint>
#include <limits>
#include <type_traits>
#include <initializer_list>
#include <Core/Types.h>
#include <IO/WriteHelpers.h>
#include <IO/ReadHelpers.h>
#include <base/demangle.h>
static_assert(is_signed_v<Int128>);
static_assert(!is_unsigned_v<Int128>);
static... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_YAML_CPP
#include <Common/tests/gtest_helper_functions.h>
#include <base/scope_guard.h>
#include <Common/Config/YAMLParser.h>
#include <Common/Config/ConfigHelper.h>
#include <Poco/AutoPtr.h>
#include <Poco/DOM/Document.h>
#include <gtest/gtest.h>
using namespace DB;
TEST(... | fim | ClickHouse/ClickHouse | cpp |
#include <Common/setThreadName.h>
#include <Common/CurrentThread.h>
#include <Common/threadPoolCallbackRunner.h>
#include <Common/futex.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
ThreadPoolCallbackRunnerFast::ThreadPoolCallbackRunnerFast() = default;
void ThreadPoolCallbackRunne... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ad_group, thread_name, my_callback = std::move(callback)]() mutable -> Result
{
ThreadGroupSwitcher switcher(thread_group, thread_name);
SCOPE_EXIT_SAFE(
{
/// Release all captured resources before detaching thread group
/// Rele... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <<|fim_suffix|>Seed()};
<|fim_middle|>Common/thread_local_rng.h>
#include <Common/randomSeed.h>
thread_local pcg64 thread_local_rng{random<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <pcg_random.hpp>
/// Fairly good thread-safe random number generator, but probably slow-down thread creation a little.
extern thread_local pcg64 thread_local_rng;
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ian>(pair.second);
}
template <std::endian ToEndian, std::endian FromEndian = std::endian::native, typename T, typename Tag>
inline void transformEndianness(StrongTypedef<T, Tag> & x)
{
transformEndianness<ToEndian, FromEndian>(x.toUnderType());
}
template <std::endian ToEndian, std::endian FromEndi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ned(OS_DARWIN)
# include <fcntl.h>
#endif
#include <fmt/format.h>
namespace DB
{
std::optional<String> tryGetFileNameFromFileDescriptor(int fd)
{
#ifdef OS_LINUX
std::string proc_path = fmt::format("/proc/self/fd/{}", fd);
char file_path[PATH_MAX] = {'\0'};
if (readlink(proc_path.c_str()... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <optional>
#include <base/types.h>
namespace DB
{
/// Supports only Linux/MacOS. On other<|fim_suffix|>rns nullopt.
std::optional<String> tryGetFileNameFromFileDescriptor(int fd);
}
<|fim_middle|> platforms, retu<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
}
void throwBadTypeidCast(const std::type_info & from, const std::type_info & to)
{
throw DB::Exception(DB::ErrorCodes::LOGICAL_ERROR, "Bad cast from type {} to {}",
demangle(from.name()), demangle(to.name()))... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <type_traits>
#inc<|fim_suffix|>ynamic_cast.
*/
template <typename To, typename From>
requires std::is_reference_v<To>
To typeid_cast(From & from) noexcept(false)
{
if ((typeid(From) == typeid(To)) || (typeid(from) == typeid(To)))
return static_cast<To>(from);
thr... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>d);
if (pid_fd < 0)
{
if (errno == ESRCH)
return PollPidResult::RESTART;
return PollPidResult::FAILED;
}
}
else
{
std::string path = "/proc/" + std::to_string(pid);
pid_fd = HANDLE_EINTR(open(path.c_str(), O_DIRE... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <sys/types.h>
namespace DB
{
/*
* Waits for a specific pid with timeout
* Returns `true` if process terminated successfully in specified timeout or `false` otherwise
*/
bool waitForPid(pid_t pid, size_t timeout_in_seconds);
#if defined(OS_LINUX)
int syscall_pidfd_open(pid_t pid);
int syscall_... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Compression/CachedCompressedReadBuffer.h>
#include <IO/WriteHelpers.h>
#include <Compression/LZ4_decompress_faster.h>
#include <utility>
namespace DB
{
namespace ErrorCodes
{
extern const int SEEK_POSITION_OUT_OF_BOUND;
}
void CachedCompressedReadBuffer::initInput()
{
if (!file_in... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <memory>
#include <ctime>
#include <IO/ReadBufferFromFileBase.h>
#include <Compression/CompressedReadBufferBase.h>
#include <IO/UncompressedCache.h>
namespace DB
{
/** A buffer for reading from a compressed file using the cache of decompressed blocks.
* The external cache is passed as an arg... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Compression/CheckingCompressedReadBuffer.h>
namespace DB
{
bool CheckingCompressedReadBuffer::nextImpl()
{
size_t size_decompressed = 0;
size_t size_compressed_without_checksum = 0;
size_t size_compressed = readCompr<|fim_suffix|>e working_buffer.
BufferBase::set(own_compressed... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>, ReadBuffer(nullptr, 0)
{
}
};
}
<|fim_prefix|>#pragma once
#include <Compression/CompressedReadBufferBase.h>
#include <IO/BufferWithOwnMemory.h>
#include <IO/ReadBuffer.h>
namespace DB
{
/** A buffer for reading from a compressed file with just checking checksums of
* the compressed block... | fim | ClickHouse/ClickHouse | c |
#include <Compression/CompressedReadBuffer.h>
namespace DB
{
bool CompressedReadBuffer::nextImpl()
{
size_t size_decompressed = 0;
size_t size_compressed_without_checksum = 0;
size_compressed = readCompressedData(size_decompressed, size_compressed_without_checksum, false);
if (!size_compressed)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>dingData())
return true;
return compressed_in->poll(timeout_microseconds);
}
/// The compressed size of the current block.
size_t getSizeCompressed() const
{
return size_compressed;
}
};
}
<|fim_prefix|>#pragma once
#include <memory>
#include <Compression... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ompressed_without_checksum = codec->readCompressedBlockSize(compressed_buffer);
size_decompressed = codec->readDecompressedBlockSize(compressed_buffer);
/// This is for clang static analyzer.
chassert(size_decompressed > 0);
if (size_compressed_without_checksum > DBMS_MAX_COMPRESSED_SIZE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ple, may be used when
* compressed data is generated by client, that cannot calculate checksums, and fill checksums with zeros instead.
*/
void disableChecksumming()
{
disable_checksum = true;
}
/// Some compressed read buffer can do useful seek operation
virtual ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>essed_file == file_in.getPosition() - size_compressed &&
offset_in_decompressed_block <= working_buffer.size())
{
pos = working_buffer.begin() + offset_in_decompressed_block;
}
else /// Our seek outside working buffer, so perform "lazy seek"
{
/// Actually seek comp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> independent readBig implementation, so we have to take
/// nextimpl_working_buffer_offset into account there as well.
///
/* size_t nextimpl_working_buffer_offset; */
bool nextImpl() override;
void prefetch(Priority priority) override;
public:
explicit CompressedReadBufferFromF... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> UInt32 compressed_size = codec->compress(working_buffer.begin(), decompressed_size, out_compressed_ptr);
CityHash_v1_0_2::uint128 checksum = CityHash_v1_0_2::CityHash128(out_compressed_ptr, compressed_size);
writeBinaryLittleEndian(checksum.low64, out);
writeBinaryLittleEndian(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Com<|fim_suffix|>s()
{
nextIfAtEnd();
return out.count();
}
/// How many uncompressed bytes were written to the buffer
size_t getUncompressedBytes()
{
return count();
}
/// How many bytes are in the buffer (not yet compressed)
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/UnorderedMapWithMemoryTracking.h>
#include <Compression/CompressionFactory.h>
#include <Compression/CompressionInfo.h>
#include <Compression/ICompressionCodec.h>
#include <Compression/registerCompressionCodecs.h>
#include <DataTypes/IDataType.h>
#include <IO/WriteHelpers.h>
#include <Par... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Compression/ICompressionCodec.h>
#include <Compression/CompressionInfo.h>
#include <Compression/CompressionFactory.h>
#include <Compression/registerCompressionCodecs.h>
#include <DataTypes/IDataType.h>
#include <base/unaligned.h>
#include <Parsers/IAST.h>
#include <Parsers/ASTLiteral.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
#pragma clang diagnostic ignored "-Wreserved-identifier"
#include <Common/SipHash.h>
#include <Compression/ICompressionCodec.h>
#include <Compression/CompressionInfo.h>
#include <Compression/CompressionFactory.h>
#include <Compression/registerCompressionCodecs.h>
#include <DataTypes/IDataType.h>
#include <base/unalign... | fim | ClickHouse/ClickHouse | cpp |
#include <string_view>
#include <base/MemorySanitizer.h>
#include <Compression/CompressionCodecEncrypted.h>
#include <Compression/CompressionFactory.h>
#include <Compression/registerCompressionCodecs.h>
#include <IO/VarInt.h>
#include <Parsers/IAST.h>
#include <base/types.h>
#include <Common/Exception.h>
#include <Comm... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string_view>
#include <base/types.h>
#include <Common/UnorderedMapWithMemoryTracking.h>
#include <Compression/ICompressionCodec.h>
#include <Poco/Util/LayeredConfiguration.h>
#include <Common/MultiVersion.h>
namespace DB
{
/// Now we have two algorithms.
enum EncryptionMethod
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>d data. File has incorrect level");
auto destination = std::as_writable_bytes(std::span(dest, uncompressed_size));
auto src = compressed_data.subspan(HEADER_SIZE);
switch (compressed_float_width)
{
case sizeof(Float64):
return FPCOperation<UInt64>(destination, compress... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_to_skip + decompressDataForType<UInt64>(&source[2 + bytes_to_skip], source_size_no_header, &dest[bytes_to_skip], output_size);
case 16:
return bytes_to_skip + decompressDataForType<UInt128>(&source[2 + bytes_to_skip], source_size_no_header, &dest[bytes_to_skip], output_size);
case 32:
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma clang diagnostic ignored "-Wreserved-identifier"
#include <Common/SipHash.h>
#include <Compression/ICompressionCodec.h>
#include <Compression/CompressionInfo.h>
#include <Compression/CompressionFactory.h>
#include <Compression/registerCompressionCodecs.h>
#include <DataTypes/IDataType.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ar * source, UInt32 source_size, char * dest) const
{
auto success = LZ4_compress_HC(source, dest, source_size, LZ4_COMPRESSBOUND(source_size), level);
if (!success)
throw Exception(ErrorCodes::CANNOT_COMPRESS, "Cannot compress with LZ4 codec");
return success;
}
void registerCodecL... | fim | ClickHouse/ClickHouse | cpp |
#include <Compression/CompressionCodecMultiple.h>
#include <Compression/CompressionInfo.h>
#include <Compression/registerCompressionCodecs.h>
#include <Common/PODArray.h>
#include <Compression/CompressionFactory.h>
#include <IO/WriteHelpers.h>
#include <IO/WriteBufferFromString.h>
namespace DB
{
CompressionCodecMult... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Compression/ICompressionCodec.h>
namespace DB
{
class CompressionCodecMultiple final : public ICompressionCodec
{
public:
CompressionCodecMultiple() = default; /// Need for CompressionFactory to register codec by method byte.
explicit CompressionCodecMultiple(Codecs codecs_);
ui... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>emcpy(dest, source, uncompressed_size);
return uncompressed_size;
}
void registerCodecNone(CompressionCodecFactory & factory)
{
factory.registerSimpleCompressionCodec("NONE", static_cast<char>(CompressionMethodByte::NONE), [&] ()
{
return std::make_shared<CompressionCodecNone>();
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ide { return "No compression. Can be used on columns that can not be compressed anyway."; }
};
}
<|fim_prefix|>#pragma once
#include <IO/WriteBuffer.h>
#include <Compression/ICompressionCodec.h>
#include <IO/BufferWithOwnMemory.h>
<|fim_middle|>
namespace DB
{
class CompressionCodecNone final : public... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <cstring>
#include <Common/TargetSpecific.h>
#include <Common/SipHash.h>
#include <Compression/ICompressionCodec.h>
#include <Compression/CompressionFactory.h>
#include <Compression/registerCompressionCodecs.h>
#include <DataTypes/IDataType.h>
#include <base/unaligned.h>
#include <Parsers/IAST.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>uments) -> CompressionCodecPtr {
int level = CompressionCodecZSTD::ZSTD_DEFAULT_LEVEL;
if (arguments && !arguments->children.empty())
{
if (arguments->children.size() > 2)
throw Exception(ErrorCodes::ILLEGAL_SYNTAX_FOR_CODEC_TYPE, "ZSTD codec must have 1... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Compression/ICompressionCodec.h>
namespace DB
{
class CompressionCodecZSTD : public ICompressionCodec
{
public:
static constexpr auto ZSTD_DEFAULT_LEVEL = 1;
static constexpr auto ZSTD_DEFAULT_LOG_WINDOW = 24;
explicit CompressionCodecZSTD(int level_);
Compressio... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e codec family code '{}' is not unique",
std::to_string(*byte_code));
}
void CompressionCodecFactory::registerCompressionCodec(const String & family_name, std::optional<uint8_t> byte_code, Creator creator)
{
registerCompressionCodecWithType(family_name, byte_code, [family_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Common/IFactoryWithAliases.h>
#include <Common/UnorderedMapWithMemoryTracking.h>
#include <Parsers/IAST_fwd.h>
#include <Columns/IColumn_fwd.h>
#include <functional>
#include <memory>
#include <optional>
#include <boost/noncopyable.hpp>
namespace DB
{
st... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>/**
* This file contains a part of CompressionCodecFactory methods definitions and
* is needed only because they have dependencies on DataTypes.
* They are not useful for fuzzers, so we leave them in other translation unit.
*/
#include <Compression/CompressionFactory.h>
#include <Compression/ICompre... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <cstdint>
/** Common defines for compression */
constexpr uint64_t DBMS_MAX_COMPRESSED_SIZE = 0x40000000ULL; /// 1GB
/** one byte for method, 4 bytes for compressed size, 4 bytes for uncompressed size */
constexpr uint8_t COMPRESSED_BLOCK_HEADER_SIZE = 9;
namespace DB
{
/** ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>2 * __restrict, UInt32 * __restrict, UInt8, UInt32);
template void bitPack<DEFAULT_VALUES>(const UInt64 * __restrict, UInt64 * __restrict, UInt8, UInt64);
template void bitUnpack<DEFAULT_VALUES>(const UInt16 * __restrict, UInt16 * __restrict, UInt8, UInt16);
template void bitUnpack<DEFAULT_VALUES>(const ... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
/**
* This file implements a FFOR algorithm inspired by the FastLanes project:
* https://github.com/cwida/FastLanes
*
* Original work by Azim Afroozeh and the CWI Database Architectures Group, licensed under the MIT License.
*
* This implementation uses template-based C++ generator approach and adap... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Compression/ICompressionCodec.h>
#include <Parsers/ASTFunction.h>
#include <base/unaligned.h>
#include <Common/Exception.h>
#include <Common/CurrentMetrics.h>
#include <Common/SipHash.h>
#include <Parser<|fim_suffix|>d_block_size = unalignedLoadLittleEndian<UInt32>(&source[5]);
if (decompr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Parsers/IAST_fwd.h>
#include <boost/noncopyable.hpp>
#include <Compression/CompressionInfo.h>
#include <Common/VectorWithMemoryTracking.h>
#include <base/types.h>
#include <memory>
class SipHash;
namespace DB
{
extern "C" int LLVMFuzzerTestOneInput(const uint8_t * data, size_t ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Compression/LZ4_decompress_faster.h>
#include <base/defines.h>
#include <base/MemorySanitizer.h>
#include <base/types.h>
#include <base/unaligned.h>
#include <Common/Stopwatch.h>
#include <cstring>
#ifdef __SSSE3__
#include <tmmintrin.h>
#endif
#if defined(__aarch64__) && defined(__ARM_NEON)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> - 1;
return std::normal_distribution<>(mean(), sigma())(stat_rng);
}
};
/// Number of different algorithms to select from.
static constexpr size_t NUM_ELEMENTS = 3;
/// Cold invocations may be affected by additional memory latencies. Don't take first invocations into... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <city.h>
#include <base/types.h>
#include <base/defines.h>
#include <IO/WriteHelpers.h>
#include <Common/setThreadName.h>
#include <Common/scope_guard_safe.h>
#include <Common/CurrentThread.h>
#include <Common/CurrentMetrics.h>
#include <Common/ThreadGroupSwitcher.h>
#include <Compression/Para... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ol.h>
namespace DB
{
/** Uses multi-buffering for parallel compression.
* When the buffer is filled, it will be compressed in the background,
* and a new buffer is created for the next input data.
*/
class ParallelCompressedWriteBuffer final : public WriteBuffer
{
public:
explicit ParallelCom... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> & e)
{
std::cerr << e.what() << ", " << e.displayText() << std::endl;
return 1;
}
return 0;
}
<|fim_prefix|>#include <iostream>
#include <iomanip>
#include <Common/Stopwatch.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/ReadBufferFromFile.h>
#include <Compression/Compr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t>(argv[2]);
ssize_t variant = argc < 4 ? -1 : parse<ssize_t>(argv[3]);
DB::VectorWithMemoryTracking<UInt64> runs;
for (size_t i = 0; i < times; i++)
{
MMapReadBufferFromFile in(argv[1], 0);
FasterCompressedReadBuffer decompressing_in(in, variant);
Stopwatch watc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> return true;
static SharedContextHolder shared_context = Context::createShared();
context = Context::createGlobal(shared_context.get());
context->makeGlobalContext();
MainThreadStatus::getInstance();
return 0;
}
extern "C" int LLVMFuzzerTestOneInput(const uint8_t * data, size_t s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Arena.h>
#include <Common/CurrentThread.h>
#include <Common/ThreadStatus.h>
#include <Common/Exception.h>
#include <Common/MemoryTracker.h>
#include <Compression/CompressedReadBuffer.h>
#include <IO/ReadBufferFromMemory.h>
#include <Interpreters/Context.h>
namespace DB
{
CompressionC... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <string>
#include <Common/Arena.h>
#include <Common/CurrentThread.h>
#include <Common/ThreadStatus.h>
#include <Common/Exception.h>
#include <Common/MemoryTracker.h>
#include <Compression/CompressedReadBuffer.h>
#include <Compression/ICompressionCodec.h>
#include <IO/BufferWithOwnMemory.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ytes stream and increase counter
/// returns false if some errors occuried
bool next(ssize_t count=1);
/// Create a key from data
ssize_t generateKey(std::string name, bool multiple=false);
const uint8_t * data;
size_t start_size;
size_t keys_size;
AutoPtr<Poco::XML::Do... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Arena.h>
#include <Common/CurrentThread.h>
#include <Common/Exception.h>
#include <Common/MemoryTracker.h>
#include <Common/ThreadStatus.h>
#include <Compression/CompressedReadBuffer.h>
#include <Compression/ICompressionCodec.h>
#include <IO/BufferWithOwnMemory.h>
#include <IO/ReadBufferF... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Arena.h>
#include <Common/CurrentThread.h>
#include <Common/ThreadStatus.h>
#include <Common/Exception.h>
#include <Common/MemoryTracker.h>
#include <Compression/CompressedReadBuffer.h>
#include <Compression/ICompressionCodec.h>
#include <Compression/LZ4_decompress_faster.h>
#include <IO/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>return getCompressionCodecForFile(*read_buffer, size_compressed, size_decompressed, false);
}
}
<|fim_prefix|>#include <Compression/getCompressionCodecForFile.h>
#include <Compression/CompressionInfo.h>
#include <Compression/CompressionFactory.h>
#include <Compression/CompressionCodecMultiple.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Compression/ICompressionCodec.h>
#include <Disks/IDisk.h>
#include <Storages/MergeTree/IDataPartStorage.h>
namespace DB
{
/// Return compression codec with default parameters for file compressed in
/// clickhouse fashion (with checksums, headers for each block, etc). This
/// method should be ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ubleDelta(CompressionCodecFactory & factory);
void registerCodecGorilla(CompressionCodecFactory & factory);
void registerCodecEncrypted(CompressionCodecFactory & factory);
void registerCodecFPC(CompressionCodecFactory & factory);
void registerCodecGCD(CompressionCodecFactory & factory);
void registerCodec... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <Common/filesystemHelpers.h>
#include <Compression/CompressedReadBufferFromFile.h>
#include <Compression/CompressedWriteBuffer.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/WriteBufferFromFile.h>
#include <gtest/gtest.h>
#include <memory>
namespace DB::Error... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.