text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#include <Common/assert_cast.h>
#include <Common/Exception.h>
#include <base/demangle.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
}
void throwBadAssertCast(const std::ty<|fim_suffix|>from, const std::type_info & to)
{
throw DB::Exception(DB::ErrorCodes::LOGICAL_ERR... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> throwBadAssertCast(typeid(from), typeid(To));
#else
return static_cast<To>(from);
#endif
}
<|fim_prefix|>#pragma once
#include <exception>
#include <typeinfo>
#ifdef DEBUG_OR_SANITIZER_BUILD
#include <type_traits>
#include <typeindex>
#include <string>
#endif
[[noreturn]] void throwBadAssertCast... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nameNoReplace(const std::string & old_path, const std::string & new_path)
{
if (!renameat2(old_path, new_path, RENAME_NOREPLACE))
renameNoReplaceFallback(old_path, new_path);
}
void renameExchange(const std::string & old_path, const std::string & new_path)
{
if (!renameat2(old_path, new_p... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>g & new_path);
/// Returns false instead of throwing exception if renameat2 is not supported
bool renameExchangeIfSupported(const std::string & old_path, const std::string & new_path);
}
<|fim_prefix|>#pragma once
#include <string>
namespace DB
{
/// Returns true, if the following functions supported... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <benchmark/benchmark.h>
#include <iomanip>
#include <random>
#include <vector>
#include <unordered_map>
#include <sparsehash/dense_hash_map>
#include <sparsehash/sparse_hash_map>
#include <absl/container/flat_hash_map.h>
#include <Common/Stopwatch.h>
//#define DBMS_HASH_MAP_COUNT_COLLISIONS
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_) : entry(str, len), index(index_) { }
DictEntry entry;
size_t index;
};
NewSortedStringDictionary() : totalLength_(0) { }
// insert a new string into dictionary, return its insertion order
size_t insert(const char * str, size_t len);
// reorder input index buffer f... | fim | ClickHouse/ClickHouse | cpp |
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionHelpers.h>
#include <Storages/StorageGenerateRandom.h>
#include <benchmark/benchmark.h>
using namespace DB;
static void BM_RadixSort_UInt8(benchmark::State & state)
{
pcg64 rng;
UInt64 limit = DEFAULT_BLOCK_SIZE;
auto type = std::make_shar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>lable2(benchmark::State & state)
{
pcg64 rng;
UInt64 limit = DEFAULT_BLOCK_SIZE;
UInt64 max_array_length = 10;
UInt64 max_string_length = 10;
DataTypePtr nullable_float64 = std::make_shared<DataTypeNullable>(std::make_shared<DataTypeFloat64>());
ColumnPtr src_column = fillColumnWi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ctory::instance().getDefaultJSONEachRowOutputFormat(buffer, materialized_block);
output_format->write(materialized_block);
output_format->finalize();
}
void dumpChunkToJSON(const Chunk & chunk, const Block & header, WriteBuffer & buffer)
{
if (chunk.empty())
{
buffer.write("{}", 2... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
<|fim_prefix|>#pragma once
#include <base/types.h>
namespace DB
{
class Block;
class Chunk;
class WriteBuffer;
/// Dump the contents of a Block/Chunk to the provided WriteBuffer in JSONEachR<|fim_middle|>ow format.
/// These functions are intended for debugging purposes.
void dumpBlockToJSON(const Bl... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <mutex>
namespace DB
{
using OnceFlag = std::once_flag;
template <typename Callable, typename ...Args>
void callOnce(OnceFlag & flag, Callable && func, Args&&... args)
{
std::call_once(flag, std::forward<Callable>(func), std::forward<Args>(args)...);
}
}
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/checkSSLRe<|fim_suffix|>
#if USE_SSL
return ret == Poco::Net::SecureStreamSocket::ERR_SSL_WANT_WRITE;
#else
return false;
#endif
}
}
<|fim_middle|>turnCode.h>
#include "config.h"
#if USE_SSL
#include <Poco/Net/SecureStreamSocket.h>
#endif
namespace DB
{
bool checkSSLWantRead([... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <sys/types.h>
namespace DB
{
/// Check if<|fim_suffix|>size_t ret);
/// CHeck if ret is ERR_SSL_WANT_WRITE.
bool checkSSLWantWrite(ssize_t ret);
}
<|fim_middle|> ret is ERR_SSL_WANT_READ.
bool checkSSLWantRead(s<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <base/getThreadId.h>
#include <base/defines.h> /// THREAD_SANITIZER
#include <base/scope_guard.h>
#include <Common/checkStackSize.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/Fiber.h>
#include <sys/resource.h>
#include <pthread.h>
#include <unistd.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
/** If the stack is large enough and is near its size, throw an exception.
* You can call this funct<|fim_suffix|>nctions that may be called recursively
* to prevent possible stack overflows.
*/
void checkStackSize();
<|fim_middle|>ion in "heavy" fu<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>g + 1 < argc && argv[arg] == "--password"sv)
{
++arg;
memset(argv[arg], 0, strlen(argv[arg]));
}
else if (0 == strncmp(argv[arg], "--password=", strlen("--password=")))
{
memset(argv[arg] + strlen("--password="), 0, strlen(argv[arg]) - st... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
/** If there are --password=... or --password ... arguments in command line, replace their values with zero bytes.
* This is needed to prevent password exposure in 'ps' and similar tools.
*/
void clearPasswordFromCommandLine(int argc, char ** argv);
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>// IWYU pragma: export
#pragma GCC diagnostic pop
<|fim_prefix|>#pragma once
/*
Include this file to access libssh api.
*/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreserved-macro-identifier"
#pragma GCC diagnostic ignored "-W<|fim_middle|>reserved-identifier"
#pragma GCC diagnostic i... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/computeMaxTableNameLength.h>
#include <Common/escapeForFileName.h>
#include <Interpreters/Context.h>
#include <filesystem>
#include <unistd.h>
namespace DB
{
size_t computeMaxTableNameLength(const String & database_name, ContextPtr context)
{
namespace fs = std::filesystem;
c... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#p<|fim_suffix|>a once
#include <base/types.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
size_t computeMaxTableNameLength(const String & database_name, ContextPtr context);
}
<|fim_middle|>ragm<|endoftext|> | fim | ClickHouse/ClickHouse | c |
#pragma once
/// These fields are changing only on every release, but we still don't want to have them in the header file,
/// because it will make build cache less efficient.
// NOTE: has nothing common with DBMS_TCP_PROTOCOL_VERSION,
// only DBMS_TCP_PROTOCOL_VERSION should be incremented on protocol changes.
exter... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ot link {} to {}", source_path, destination_path);
}
}
}
<|fim_prefix|>#include <Common/createHardLink.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <cerrno>
#include <unistd.h>
#include <sys/stat.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_S... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>already exists, check that it has the same inode (and throw if they are different).
void createHardLink(const String & source_path, const String & destination_path);
}
<|fim_prefix|>#pragma once
#include <base/types.h>
namespace DB
{
/// Create a hard link `destination_p<|fim_middle|>ath` pointing to ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <base/hex.h>
#include <Common/StringUtils.h>
#include <Common/escapeForFileName.h>
namespace DB
{
std::string escapeForFileName(const std::string & s)
{
std::string res;
const char * pos = s.data();
const char * end = pos + s.size();
wh<|fim_suffix|> res += *pos;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
namespace DB
{
/** <|fim_suffix|>ileName(const std::string & s);
}
<|fim_middle|>Convert a string, so result could be used as a file name.
* In fact it percent-encode all non-word characters, as in URL.
*/
std::string escapeForFileName(const std::string & s);
std::... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>peString.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
namespace DB
{
String escapeString(std::string_view value)
{
WriteBufferFromOwnString buf;
writeEscapedString(value, buf);
return buf.str();
}
}
<|fim_prefix|>#include <<|fim_middle|>Common/esca<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <base/types.h>
namespace DB
{
String escapeString(std::string_view value);
}
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tates_unrolled<2>(keys, values); break;
case 74: res = simple_lookup_table_embedded_states_unrolled<4>(keys, values); break;
case 76: res = simple_lookup_table_embedded_states_unrolled<6>(keys, values); break;
case 78: res = simple_lookup_table_embedded_states_unrolled<8>(keys, val... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>der_relaxed) + 1, std::memory_order_relaxed);
sleepForNanoseconds(100000000);
for (size_t i = 0; i < num_iterations; ++i)
counter1.store(counter1.load(std::memory_order_relaxed) + 1, std::memory_order_relaxed);
});
t1.join();
t2.join();
std::cerr << "Result:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ar **)
{
struct sigaction sa{};
memset(&sa, 0, sizeof(sa));
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdisabled-macro-expansion"
sa.sa_sigaction = signalHandler;
#pragma clang diagnostic pop
sa.sa_flags = SA_SIGINFO;
if (sigemptyset(&sa.sa_mask)
|| sigad... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
TestSet<Generator1>::execute();
std::cout << "Test set 2\n";
TestSet<Generator2>::execute();
std::cout << "Test set 3\n";
TestSet<Generator3>::execute();
}
}
int mainEntryExampleCompactArray(int, char **)
{
runTests();
return 0;
}
<|fim_prefix|>#include <Common/CompactArray... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/COW.h>
#include <iostream>
#include <base/defines.h>
#include <Examples/clickhouse_examples.h>
namespace
{
class IColumn : public COW<IColumn>
{
private:
friend class COW<IColumn>;
virtual MutablePtr clone() const = 0;
public:
IColumn() = default;
IColumn(const IColumn ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>) == 1);
chassert(x.get() != y.get());
x = ColumnComposition::create(0);
print(x, y);
chassert(x->get() == 0 && y->get() == 2);
chassert(x->use_count() == 1 && y->use_count() == 1);
chassert(x.get() != y.get());
{
MutableColumnPtr mut = IColumn::mutate(std::move(y));
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> </aes_128_gcm_siv>
</encryption_codecs>
<zookeeper>
<node>
<host>localhost</host>
<port>2181</port>
</node>
<node>
<host>localhost</host>
<port>2182</port>
</node>
<node>
<host>localhost</h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
while (!read_buffer.eof())
{
readIntText(rows, read_buffer);
readChar(dummy, read_buffer);
for (size_t i = 0; i < rows; ++i)
{
readString(buffer, read_buffer);
readChar(dummy, read_buffer);
writeString("Key ", write_buffer);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> (check = " << check << ")"
<< ", elapsed: " << watch.elapsedSeconds()
<< " (" << static_cast<double>(rows) / watch.elapsedSeconds() << " rows/sec., " << static_cast<double>(bytes) / 1000000.0 / watch.elapsedSeconds() << " MB/sec.)"
<< std::endl;
}
#if USE_SSL
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>storeClient client(protocol);
try
{
transport->open();
Table table;
client.get_table(table, "default", "persons");
table.printTo(std::cout);
vector<Partition> partitions;
client.get_partitions(partitions, "default", "persons", 0);
for (con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Examples/clickhouse_examples.h>
#pragma clang diagnostic ignored "-Wreserved-identifier"
#if defined (OS_LINUX)
# include <sched.h>
#endif
#include <iostream>
#include <iomanip>
#include <pcg_random.hpp>
#include <Poco/Exception.h>
#include <Common/HashTable/Hash.h>
#include <Common/Stopwat... | fim | ClickHouse/ClickHouse | cpp |
#include <iostream>
#include <iomanip>
#include <vector>
#include <unordered_map>
#include <sparsehash/dense_hash_map>
#include <sparsehash/sparse_hash_map>
#include <absl/container/flat_hash_map.h>
#include <Common/Stopwatch.h>
#include <base/types.h>
#include <IO/ReadBufferFromFileDescriptor.h>
#include <Compress... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> }
}
{
IntervalMap<Int64Interval, std::string> tree;
tree.emplace(Int64Interval(0, 5), "value1");
tree.emplace(Int64Interval(10, 15), "value2");
tree.build();
for (const auto & [interval, value] : tree)
{
std::cout << "Interval ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
#endif
(void)argc;
(void)argv;
return 0;
}
<|fim_prefix|>#include <Examples/clickhouse_examples.h>
#if defined(OS_LINUX)
#include <Common/MemoryStatisticsOS.h>
#include <iostream>
#endif
int mainEntryExampleMemoryStatisticsOsPerf([[maybe_unused]] int argc, [[maybe_unused]] char ** argv)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rger, pool);
if (!method || method == 4)
Work<
Map,
AggregateIndependentWithSequentialKeysOptimization<Map>,
MergeSequentialTransposed<Map>
>::execute(data, num_threads, creator, updater, merger, pool);
if (!method || method == 5)
Work<... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> return 0;
}
#endif
<|fim_prefix|>#include <Examples/clickhouse_examples.h>
#if defined(OS_LINUX)
#include <Common/ProcfsMetricsProvider.h>
#include <iostream>
#include <linux/taskstats.h>
#endif
#if defined(OS_LINUX)
int mainEntryExampleProcfsMetricsProviderPerf(int argc, char ** argv)
{
using n... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>it);
}
void NO_INLINE sort23(Key * data, size_t size, size_t limit)
{
RadixSort<RadixSortTraitsWithCustomBits<13>>::executeMSD(data, size, limit);
}
void NO_INLINE sort24(Key * data, size_t size, size_t limit)
{
RadixSort<RadixSortTraitsWithCustomBits<14>>::executeMSD(data, size, limit);
}
void... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>::cerr << DB::getCurrentExceptionMessage(true) << '\n';
throw;
}
<|fim_prefix|>#include <thread>
#include <Common/ShellCommand.h>
#include <Common/Exception.h>
#include <IO/ReadBufferFromFileDescriptor.h>
#include <IO/WriteBufferFromFileDescriptor.h>
#include <IO/copyData.h>
#include <iostream>
#inc... | fim | ClickHouse/ClickHouse | cpp |
#include <vector>
#include <string>
#include <iomanip>
#include <iostream>
#include <Common/SipHash.h>
#include <IO/ReadBufferFromFileDescriptor.h>
#include <IO/ReadHelpers.h>
#include <Common/Stopwatch.h>
#include <Examples/clickhouse_examples.h>
/** Test this way:
*
* clickhouse-client --query="SELECT SearchPh... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <iostream>
#include <Interpreters/AggregationCommon.h>
#include <Common/HashTable/SmallTable.h>
#include <Examples/clickhouse_examples.h>
int mainEntryExampleSmallTable(int, char **)
{
{
using Cont = SmallSet<int, 16>;
Cont cont;
cont.insert(1);
cont.inser... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <vector>
#include <thread>
#include <iostream>
#include <Common/Stopwatch.h>
#include <Examples/clickhouse_examples.h>
int mainEntryExampleStopwatch(int, char **)
{
static constexpr size_t num_threads = 10;
static constexpr size_t num_iterations = 3;
std::vector<std::thread> thread... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e
(void)argc;
(void)argv;
std::cerr << "This test does not make sense for non-ELF objects.\n";
#endif
return 0;
}
<|fim_prefix|>#include <iostream>
#include <dlfcn.h>
#include <Core/Defines.h>
#include <base/demangle.h>
#include <Common/Dwarf.h>
#include <Common/Elf.h>
#include <Common/S... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <iostream>
#include <iomanip>
#include <IO/ReadHelpers.h>
#include <Common/Stopwatch.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/ThreadPool.h>
#include <Common/CurrentMetrics.h>
#include <Examples/clickhouse_examples.h>
namespace CurrentMetrics
{
e... | fim | ClickHouse/ClickHouse | cpp |
#include <iostream>
#include <unicode/unistr.h>
#include <Examples/clickhouse_examples.h>
[[maybe_unused]] static std::string utf8_to_lower(const std::string & input)
{
icu::UnicodeString unicodeInput(input.c_str(), "UTF-8");
unicodeInput.toLower();
std::string output;
unicodeInput.toUTF8String(output)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>0, 1000000000};
return exp10_i32_table[x]; /// NOLINT(clang-analyzer-security.ArrayBound)
}
}
<|fim_prefix|>#pragma once
namespace common
{
constexpr int exp10_i32(int x)
{
if (x < 0)
return 0;
if (x > 9)
return std::numeric_limits<int>::max();
constexpr int exp10_i32_t... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> -1)
{
close(n);
return true;
}
DB::ErrnoException::throwFromPath(DB::ErrorCodes::CANNOT_CREATE_FILE, path, "Cannot create file: {}", path);
}
bool exists(const std::string & path)
{
return faccessat(AT_FDCWD, path.c_str(), F_OK, AT_EACCESS) == 0;
}
bool canRead(const std... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ol exists(const std::string & path);
bool canRead(const std::string & path);
bool canWrite(const std::string & path);
bool canExecute(const std::string & path);
/// st_mtime
time_t getModificationTime(const std::string & path);
Poco::Timestamp getModificationTimestamp(const std::string & path);
void setM... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>size_t end)
{
std::optional<T> opt = findExtremeMax(ptr, start, end);
if (!opt)
return std::nullopt;
T value = *opt;
/// We apply some minimal heuristics for the case the input is sorted
if constexpr (is_floating_point<T>)
{
/// We search for the exact byte represe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>size_t end);
FOR_BASIC_NUMERIC_TYPES(EXTERN_INSTANTIATION)
EXTERN_INSTANTIATION(Decimal32)
EXTERN_INSTANTIATION(Decimal64)
EXTERN_INSTANTIATION(DateTime64)
#undef EXTERN_INSTANTIATION
}
<|fim_prefix|>#pragma once
#include <DataTypes/IDataType.h>
#include <base/defines.h>
#include <base/types.h>
#inclu<... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Common/Exception.h>
#include <Common/PODArray.h>
#include <Common/StringUtils.h>
#include <Common/VectorWithMemoryTracking.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
namespace Format
{
using IndexPositions = PODArra... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/formatIPv6.h>
#include <base/range.h>
#include <array>
#include <algorithm>
#if defined(__SSE4_1__)
#include <x86intrin.h>
#endif
namespace DB
{
/** Further we want to generate constexpr array of strings with sizes from sequence of unsigned ints [0..N)
* in order to use this arrey ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r_dst();
/// last parsed group should be reinterpreted as a decimal value - it's the first octet of IPv4
--groups;
iter -= 2;
UInt16 num = 0;
for (int i = 0; i < 2; ++i)
{
unsigned char first = (iter[i] >> 4) & 0x0fu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
{
DB::WriteBufferFromOwnString out;
formatReadableSizeWithBinarySuffix(value, out, precision);
return out.str();
}
void formatReadableSizeWithDecimalSuffix(double value, DB::WriteBuffer & out, int precision)
{
const char * units[] = {" B", " KB", " MB", " GB", " TB", " PB", " EB", " ZB"... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include <concepts>
#include <fmt/format.h>
namespace DB
{
class WriteBuffer;
}
/// Displays the passed size in by<|fim_suffix|>ion);
}
/// Displays the passed size in bytes as 132.55 GB.
void formatReadableSizeWithDecimalSuffix(double value, DB::WriteBuffer & out, in... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ast<UInt32>(value & 0xffffffffull);
}
constexpr UInt32 upperHalf(UInt64 value)
{
return static_cast<UInt32>(value >> 32ull);
}
inline UInt32 * lowerHalfAddress(void * address)
{
return reinterpret_cast<UInt32 *>(address) + (std::endian::native == std::endian::big);
}
inline UInt32 * upperHalfAd... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>const std::exception &) // NOLINT(bugprone-empty-catch)
{
}
}
#endif
return result;
}
<|fim_prefix|>#include <Common/getCurrentProcessFDCount.h>
#include <Common/ShellCommand.h>
#include <IO/WriteBufferFromString.h>
#include <unistd.h>
#include <fmt/format.h>
#include <IO/ReadHelp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
/// Get current process file descriptor count
/// @return -1 os doesn't support "lsof" command or some error occurs.
<|fim_suffix|>ocessFDCount();
<|fim_middle|>Int64 getCurrentPr<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/getExecutablePath.h>
#include <filesystem>
std::string getExecutablePath()
{
std::error_code ec;
std::file<|fim_suffix|>cal("/proc/self/exe", ec);
if (ec)
return {};
return canonical_path;
}
<|fim_middle|>system::path canonical_path = std::filesystem::canoni<|en... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string<|fim_suffix|> getExecutablePath();
<|fim_middle|>>
/** Get path to the running executable if possible.
* It is possible when:
* - procfs exists;
* - there is a /proc/self/exe file;
* Otherwise return empty string.
*/
std::string<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> = getHashOfLoadedBinary();
const auto checksum = hash.get128();
return getHexUIntUppercase(checksum);
}
#else
SipHash getHashOfLoadedBinary()
{
return {};
}
std::string getHashOfLoadedBinaryHex()
{
return {};
}
#endif
<|fim_prefix|>#include <Common/getHashOfLoadedBinary.h>
#if defin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ine code but also by the data in these segments,
* so the integrity check is going to be incomplete.
*/
SipHash getHashOfLoadedBinary();
std::string getHashOfLoadedBinaryHex();
<|fim_prefix|>#pragma once
#include <string>
#include <Common/SipHash.h>
/** Calculate hash of the executable loaded segmen... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/getMappedArea.h>
#include <Common/Exception.h>
#if defined<|fim_suffix|> skipToNextLineOrEOF(in);
if (begin <= uintptr && uintptr < end)
return {reinterpret_cast<void *>(begin), end - begin};
}
throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot find mapp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <utility>
#include <cstddef>
namespace DB
{
/// Find the address and size of the mapped memory r<|fim_suffix|>);
}
<|fim_middle|>egion pointed by ptr.
/// Throw exception if not found.
std::pair<void *, size_t> getMappedArea(void * ptr<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/getMaxFileDescriptorCount.h>
#include <sys/resource.h>
std::optional<size_t> getMaxFileDescriptorCount()
{
#if defined(OS_LINUX) || defined(OS_DARWIN)
/// We want to calculate it only once.
static auto result = []() -> std::optional<|fim_suffix|>se
return std::nullopt;
#endif... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <optional>
/// Get process max file descriptor count
///<|fim_suffix|>d::optional<size_t> getMaxFileDescriptorCount();
<|fim_middle|> @return std::nullopt if os does not support getrlimit command or some error occurs
st<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> values.emplace_back(key);
}
return values;
}
std::vector<std::string> getMultipleValuesFromConfig(const Poco::Util::AbstractConfiguration & config, const std::string & root, const std::string & name)
{
std::vector<std::string> values;
for (const auto & key : DB::getMultipleKeysFrom... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> root, const std::string & name);
}
<|fim_prefix|>#pragma once
#include <string>
#include <vector>
namespace Poco
{
namespace Util
{
class Abst<|fim_middle|>ractConfiguration;
}
}
namespace DB
{
/// get all internal key names for given key
std::vector<std::string> getMultipleKeysFromConfig(const Poco... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/getNumberOfCPUCoresToUse.h>
#if defined(OS_LINUX)
# include <cmath>
# include <fstream>
#endif
#include <boost/algorithm/string/trim.hpp>
#include <|fim_suffix|> std::ifstream cpu_max_file(current_cgroup / "cpu.max");
if (cpu_max_file.is_open())
{
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
/// Get the number of CPU cores to use. Depending on the machine size we choose
/// between the number of physical and logical cores.
/// Also under cgroups we respect possible cgroups limits.
unsigned getNumberOfCPUCoresToUse();
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>t<char>(distribution(rng));
return res;
}
}
<|fim_prefix|>#include <Common/getRandomASCIIString.h>
#include <Common/thread_local_rng.h>
#include <random>
namespace DB
{
String getRandomASCIIString(si<|fim_middle|>ze_t length)
{
return getRandomASCIIString(length, thread_local_rng);
}
String ge... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma<|fim_suffix|>
#include <pcg_random.hpp>
namespace DB
{
/// Slow random string. Useful for random names and things like this. Not for generating data.
String getRandomASCIIString(size_t length);
String getRandomASCIIString(size_t length, pcg64 & rng);
}
<|fim_middle|> once
#include <Core/Types... | fim | ClickHouse/ClickHouse | c |
#if defined(OS_LINUX)
#include <Common/hasLinuxCapability.h>
#include <syscall.h>
#include <unistd.h>
#include <linux/capability.h>
#include <cstdint>
#include <base/types.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NETLINK_ERROR;
}... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#if defined(OS_LINUX)
#include <<|fim_suffix|>AP_NET_ADMIN.
bool hasLinuxCapability(int cap);
}
#endif
<|fim_middle|>linux/capability.h>
namespace DB
{
/// Check that the current process has Linux capability. Examples: CAP_IPC_LOCK, C<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <base/extended_types.h>
#include <Common/intExp.h>
#include <cstdint>
namespace common
{
constexpr int64_t exp10_i64_table[]
= {1LL,
10LL,
100LL,
1000LL,
10000LL,
100000LL,
1000000LL,
10000000LL,
100000000LL,
1000000000LL,
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>6_table[x];
}
}
/// intExp10 returning the type T.
template <typename T>
T intExp10OfSize(int x)
{
if constexpr (sizeof(T) <= 4)
return static_cast<T>(common::exp10_i32(x));
else if constexpr (sizeof(T) <= 8)
return common::exp10_i64(x);
else if constexpr (sizeof(T) <= 16)
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstdint>
#include <limits>
constexpr uint64_t <|fim_suffix|> 10000000000000000000ULL};
return intExp10_table[x];
}
<|fim_middle|>intExp10(int x)
{
if (x < 0)
return 0;
if (x > 19)
return std::numeric_limits<uint64_t>::max();
constexpr uint64_... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> < 0)
return 0;
if (x > 63)
return std::numeric_limits<uint64_t>::max();
return 1ULL << x;
}
<|fim_prefix|>#pragma once
#include <base/de<|fim_middle|>fines.h>
#include <cstdint>
/// On overflow, the function returns unspecified value.
constexpr NO_SANITIZE_UNDEFINED uint64_t in... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>t step);
#endif
}
<|fim_prefix|>#include <base/defines.h>
#include <Common/iota.h>
namespace DB
{
/// NO_INLINE prevents LTO from inlining these into callers. When inlined, the
/// hot loop's alignment depends on the surrounding code and can land on a
/// 64-byte boundary crossing, causing ~5% regressio... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
{
/// Make sure to add any new type to the extern declaration at the end of the file and instantiate it in iota.cpp
template <typename T>
concept iota_supported_types = (is_any_of<
T,
UInt8,
UInt32,
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tting
* - through which interface we will actually access the specified address.
*/
if (interface_address->length() == address.length()
&& 0 == memcmp(interface_address->addr(), address.addr(), address.length()))
return true;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>selves.
* Please note that this check is not accurate:
* - the address is simply compared to the addresses of the network interfaces;
* - only the first address is taken for each network interface;
* - the routing rules that affect which network interface we go to the specified address... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/isValidUTF8.h>
#include <cstring>
/// inspired by https://github.com/cyb70289/utf8/
/*
MIT License
Copyright (c) 2019 Yibo Cai
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
}
<|fim_prefix|>#pragma once
#include <base/types.h>
namespace DB::UTF8
{
UInt8 isValidU<|fim_middle|>TF8(const UInt8 * data, UInt64 len);
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> - 1;
for (size_t i = 1; i <= n; ++i)
{
size_t old = row[i];
row[i] = std::min(prev + (std::tolower(lhs[j - 1]) != std::tolower(rhs[i - 1])),
std::min(row[i - 1], row[i]) + 1);
prev = old;
}
}
return row[n];
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <base/extended_types.h>
#include <Common/PODArray.h>
#include <Common/iota.h>
#include <span>
#include <algorithm>
#include <type_traits>
namespa<|fim_suffix|> iota(v0.data() + 1, n, size_t(1));
for (size_t j = 1; j <= m; ++j)
{
v0[0] = j... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/likePatternToRegexp.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_PARSE_ESCAPE_SEQUENCE;
}
String likePatternToRegexp(std::string_view pattern)
{
String res;
res.reserve(pattern.size() * 2);
const char * pos = pattern.d... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ttern(std::string_view pattern, char escape_char);
}
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <string_view<|fim_middle|>>
namespace DB
{
/// Transforms the [I]LIKE expression into regexp re2. For example, abc%def -> ^abc.*def$
String likePatternToRegexp(std::string_view pattern);
/... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
constexpr bool is_preformatted_message = !LogTypeInfo::is_static && LogTypeInfo::has_format; \
if constexpr (is_preformatted_message) \
{ ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nst std::string & host, uint16_t port, LoggerPtr log)
{
return makeSocketAddress(host, port, log.get());
}
}
<|fim_prefix|>#include <Common/<|fim_middle|>makeSocketAddress.h>
#include <Common/logger_useful.h>
#include <Poco/Net/NetException.h>
namespace DB
{
Poco::Net::SocketAddress makeSocketAddre... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Poco/Net/SocketAddress.h>
#include <Common/Logger.h>
namespace Poco { class Lo<|fim_suffix|>co::Net::SocketAddress makeSocketAddress(const std::string & host, uint16_t port, Poco::Logger * log);
Poco::Net::SocketAddress makeSocketAddress(const std::string & host, uint16_t port, L... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_JEMALLOC && (defined(OS_LINUX) || defined(OS_FREEBSD))
#include <cerrno>
#include <cstdlib>
#include <cstddef>
#include <jemalloc/jemalloc.h>
#include <Common/memory.h>
#include <base/getPageSize.h>
/// Define standard allocation functions that perform memory tracking
/// ... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Common/re2.h>
namespace DB
{
inline bool maskURIPassword(std::string * uri)
{
return RE2::Replace(uri, R"(([^:]+://[^:]*):([^@]*)@(.*))", "\\1:[HIDDEN]@\\3");
}
}
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>to 15 excessive bytes after end of 'src' region
* and to write any garbage into up to 15 bytes after end of 'dst' region.
*/
inline void memcpySmallAllowReadWriteOverflow15(void * __restrict dst, const void * __restrict src, size_t n)
{
detail::memcpySmallAllowReadWriteOverflow15Impl(reinterpret_... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.