text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#include <new>
#include "config.h"
#include <Common/memory.h>
#if defined(OS_DARWIN) && (USE_JEMALLOC)
/// In case of OSX jemalloc register itself as a default zone allocator.
///
/// Sure jemalloc will register itself, since zone_register() declared with
/// constructor attribute (since zone_register i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>memptr, alignment, size)
#define __real_aligned_alloc(alignment, size) ::aligned_alloc(alignment, size)
#define __real_free ::free
#endif
// NOLINTEND
#pragma clang diagnostic pop
<|fim_prefix|>#pragma once
#include "config.h"
#include <cstddef>
#pragma clang diagnostic push
#pragma clang diagnostic... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <cstddef>
#include <base/defines.h>
/// This is a structure which is returned by MemoryTracker.
/// Methods onAlloc/onFree should be called after actual memory allocation if it succeed.
/// For now, it will only collect allocation trace with sample_probability.
struct AllocationTrace
{
Alloca... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/AllocationInterceptors.h>
#include <Common/Allocator.h>
#include <Common/BitHelpers.h>
#include <Common/CurrentMemoryTracker.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/VersionNumber.h>
#include <Common/formatReadable.h>
#include <Common/logger_use... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>faster for about 1-2% and up to 5-7x for some types of queries.
* That is why we don't do manual mmap/mremap/munmap here and completely rely on jemalloc for allocations of any size.
*
* Responsible for allocating / freeing memory. Used, for example, in PODArray, Arena.
* Also used in hash tables.
... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <cstddef>
#include <cstdlib>
#include <type_traits>
#include <Common/AllocationInterceptors.h>
#include <Common/CurrentMemoryTracker.h>
/// Implementation of std::allocator interface that tracks memory with MemoryTracker.
/// NOTE We already plug MemoryTracker into new/delete operators. So, ev... | fim | ClickHouse/ClickHouse | c |
#pragma once
/**
* This file provides forward declarations for Allocator.
*/
template <bool clear_memory_, bool populate = false>
class Allocator;
template <typename Base, size_t N = 64, size_t Alignment = 1>
class AllocatorWithStackMemory;
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> }
friend class ArenaAllocator;
template <size_t> friend class AlignedArenaAllocator;
public:
explicit Arena(size_t initial_size_ = 4096, size_t growth_factor_ = 2, size_t linear_growth_threshold_ = 128 * 1024 * 1024)
: initial_size(initial_size_)
, growth_factor(growth_fa... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Arena.h>
#include <Common/Allocator.h>
namespace DB
{
/// Allocator which proxies all allocations to Arena. Used in aggregate functions.
class ArenaAllocator
{
public:
static void * alloc(size_t size, Arena * arena)
{
return arena->alloc(size);
}
s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>oid *>(place_for_key), reinterpret_cast<const void *>(value.data()), value_size);
return std::string_view{place_for_key, value_size};
}
<|fim_prefix|>#pragma once
#include <string.h>
#<|fim_middle|>include <string>
/** Copy string value into Arena.
* Arena should support method:
* char * alloc(s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>he list to the next
/// item in the list. We poisoned the free block before putting
/// it into the free list, so we have to unpoison it before
/// reading anything.
ASAN_UNPOISON_MEMORY_REGION(free_block_ptr,
std::max... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/AsyncLoader.h>
#include <optional>
#include <base/EnumReflection.h>
#include <base/defines.h>
#include <base/scope_gua<|fim_suffix|>nd(job); info != scheduled_jobs.end())
{
// Requeue job into the new pool queue without allocations
if (UInt64 ready_seqno = info->seco... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>6) The job is no longer considered as scheduled and is instead moved to the finished jobs set. This is just for introspection of the finished jobs.
// 7) The task containing this job is destructed or `remove()` is explicitly called. The job is removed from the finished job set.
// 8) The job is destruc... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>;
class LoadTask;
using LoadTaskPtr = std::shared_ptr<LoadTask>;
using LoadTaskPtrs = std::vector<LoadTaskPtr>;
class LoadJob;
using LoadJobPtr = std::shared_ptr<LoadJob>;
using LoadJobSet = std::unordered_set<LoadJobPtr>;
}
<|fim_prefix|>#pragma once
#include <vector>
#include <memory>
#include <unord... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tion timeout {} ms)", socket_description, timeout.totalMilliseconds());
case AsyncEventTimeoutType::RECEIVE:
return fmt::format("Timeout exceeded while reading from socket ({}, receive timeout {} ms)", socket_description, timeout.totalMilliseconds());
case AsyncEventTimeoutType... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <atomic>
#include <mutex>
#include <base/types.h>
#include <Common/Epoll.h>
#include <Common/Fiber.h>
#include <Common/FiberStack.h>
#include <Poco/Timespan.h>
#if defined(OS_LINUX)
#include <sys/epoll.h>
#endif
namespace DB
{
enum class AsyncEventTimeoutType : uint8_t
{
CON... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/CgroupsMemoryUsageObserver.h>
#include <Common/MemoryStatisticsOS.h>
#include <Common/MemoryWorker.h>
#include <Common/ThreadPool.h>
#include <Common/Stopwatch.h>
#include <Common/SharedMutex.h>
#include <IO/ReadBufferFromFile.h>
#include <condition_variable>
#include <stri... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <mutex>
#include <memory>
#include <base/types.h>
#include <Common/Logger.h>
#include <Common/SharedLockGuard.h>
#include <Common/SharedMutex.h>
namespace DB
{
/** AtomicLogger allows to atomically <|fim_suffix|>er(const std::string & log_name)
: AtomicLogger(::getLogger(... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_MONGODB
#include <Common/Base64.h>
#include <Common/DateLUTImpl.h>
#include <Common/JSONBuilder.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/ReadHelpers.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/Da... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <optional>
#include <base/types.h>
#include <base/defines.h>
namespace DB
{
struct Base32Rfc4648
{
static constexpr char encodeChar(UInt8 c)
{
chassert(c < 32);
if (c < 26)
return 'A' + c;
return '2' + (c - 26);
}
static constexp... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Base58.h>
#include <cstring>
#include <optional>
#if defined(__AVX2__)
# include <immintrin.h>
#endif
/// Firedancer based implementation as per https://github.com/firedancer-io/firedancer/tree/main/src/ballet/base58
/// Copyright (c) Firedancer contributors
/// Licensed under the A... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <functional>
#include <optional>
namespace DB
{
/// The generic (variable-length) Base58 encoder and decoder use a big-integer base conversion
/// whose cost is quadratic in the input length. For large inputs this can run for a very long
/// time, so they... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Base64.h>
#include <Poco/Base64Decoder.h>
#include <Poco/Base64Encoder.h>
#include <Poco/MemoryStream.h>
#include <Poco/StreamCopier.h>
#include <sstream>
namespace DB
{
std::string base64Encode(const std::string & decoded, bool url_encoding, bool no_padding)
{
std::ostringstream ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>::string & encoded, bool url_encoding = false, bool no_padding = false);
}
<|fim_prefix|>#pragma once
#include <string>
namespace DB
{
std::string base64Encode(const std::string & decoded, <|fim_middle|>bool url_encoding = false, bool no_padding = false);
std::string base64Decode(const std<|endoftext... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> ++out;
}
chassert((end - pos) % word_size == 0);
while (end - pos != 0)
{
UInt8 c = 0;
for (UInt8 i = 0; i < 8; ++i)
{
c = static_cast<UInt8>(c << 1);
if (*pos != '0')
c += 1;
++pos;
}
*out... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <algorithm>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <base/defines.h>
/** For zero argument, result is zero.
* For arguments with most significand bit set, result is n.
* For other arguments, returns value, rounded up to power of two.
*/
in... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/BlobStorageLogWriter.h>
#include <base/getThreadId.h>
#include <Common/CurrentThread.h>
#include <Common/ThreadStatus.h>
#include <Common/setThreadName.h>
#include <Interpreters/Context.h>
#include <Common/logger_useful.h>
namespace DB
{
void BlobStorageLogWriter::addEvent(
BlobSt... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>sk_name;
String query_id;
String local_path;
static BlobStorageLogWriterPtr create(const String & disk_name = "");
private:
BlobStorageLogPtr log;
};
}
<|fim_prefix|>#pragma once
#include <Interpreters/BlobStorageLog.h>
namespace DB
{
using BlobStorageLogPtr = std::shared_ptr<BlobSto... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ize_t LIBRARY_BRIDGE_PROTOCOL_VERSION = 1;
// Version of protocol between clickhouse-server and clickhouse-xdbc-bridge. Increment if you change it in a non-compatible way.
static constexpr size_t XDBC_BRIDGE_PROTOCOL_VERSION = 1;
}
<|fim_prefix|>#pragma once
#include <cstddef>
namespace DB
{
// Versi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ze > 0)
return std::make_unique<FixedSizeBufferAllocationPolicy>(settings_);
return std::make_unique<ExpBufferAllocationPolicy>(settings_);
}
}
<|fim_prefix|>#include <Common/BufferAllocationPolicy.h>
#include <base/defines.h>
#include <algorithm>
#include <memory>
namespace DB
{
class Fi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
namespace DB
{
class BufferAllocationPolicy;
using BufferAllocationPolicyPtr = std::unique_ptr<BufferAllocationPolicy>;
/// Buffer number starts with 0
class BufferAllocationPolicy
{
public:
struct Settings
{
size_t strict_size = 0;
siz<|fim_su... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>.
template <typename U>
immutable_ptr(const mutable_ptr<U> &) = delete;
immutable_ptr() = default;
immutable_ptr(std::nullptr_t) {} /// NOLINT
};
using Ptr = immutable_ptr<Derived>;
template <typename... Args>
static MutablePtr create(Args &&... args) { ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>12F) \
OP(AVX512DQ) \
OP(AVX512IFMA) \
OP(AVX512PF) \
OP(AVX512ER) \
OP(AVX512CD) \
OP(AVX512BW) \
OP(AVX512VL) \
OP(AVX512VBMI) \
OP(AVX512VBMI2) \
OP(AVX512VNNI) \
OP(AVX512BITALG) \
OP(AVX512VPOPCNTDQ) \
OP(AVX512BF16) \
OP(AVX512FP16) \
OP(AV... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
#include <Common/ICachePolicy.h>
#include <Common/LRUCachePolicy.h>
#include <Common/SLRUCachePolicy.h>
#include <Common/CurrentMetrics.h>
#include <base/UUID.h>
#include <base/defines.h>
#include <atomic>
#include <memory>
#include <mutex>
#include <optional>... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>or AArch64, where LLVM sets `hardware_destructive_interference_size` to 256,
/// see https://github.com/llvm/llvm-project/commit/bce2cc15133a1458e4ad053085e58c7423c365b4.
/// In reality though, most of the server (not Apple M-series) processors (i.e., Neoverse) have 64-byte cache lines,
/// see https://gi... | fim | ClickHouse/ClickHouse | c |
#include <Common/CalendarTimeInterval.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
CalendarTimeInterval::CalendarTimeInterval(const CalendarTimeInterval::Intervals & intervals)
{
for (auto [kind, val] : intervals)
{
switch (kind.kind)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> to the start of the week (Monday).
///
/// Guarantees:
/// * advance(floor(x)) > x
/// * floor(advance(floor(x))) = advance(floor(x))
std::chrono::sys_seconds floor(std::chrono::system_clock::time_point t) const;
bool operator==(const CalendarTimeInterval & rhs) const;
bool... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>l_fds, static_cast<nfds_t>(dns_state.poll_nfds), static_cast<int>(timeout));
if (number_of_fds_ready < 0)
{
if (errno == EINTR)
continue;
return false;
}
if (number_of_fds_ready == 0)
{
process_possible_timeout(c... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
void process_readable_sockets(std::span<pollfd> readable_sockets, ares_channel channel);
};
}
<|fim_prefix|>#pragma once
#include <Common/DNSPTRResolver.h>
#include <span>
#include <mutex>
#include <ares.h>
#include <poll.h>
using ares_channel = struct ares_channeldata *;
namespace DB... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/CgroupsMemoryUsageObserver.h>
#if defined(OS_LINUX)
#include <Common/setThreadName.h>
#include <Common/logger_useful.h>
#include <Common/formatReadable.h>
#include <IO/ReadBufferFromFileDescriptor.h>
#include <IO/ReadHelpers.h>
#include <base/cgroupsv2.h>
#include <base/getMemoryAmount.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Logger_fwd.h>
#include <Common/ThreadPool.h>
#include <chrono>
#include <mutex>
#include <base/defines.h>
namespace DB
{
/// Periodically reads the the maximum memory available to the process (which can change due to cgroups settings).
/// You can specify a callback to ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/ClickHouseRevision.h>
#include <Common/config_version.h>
namespace ClickHouseRevision
{
<|fim_suffix|>ersionRevision() { return VERSION_REVISION; }
unsigned getVersionInteger() { return VERSION_INTEGER; }
}
<|fim_middle|> unsigned getV<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
}
<|fim_prefix|>#pragma once
namespace ClickHouseRevision
{
unsigned getVersionRevision();
unsigned getVersionIntege<|fim_middle|>r();<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/ClickHouseVersion.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
#include <boost/algorithm/string.hpp>
#include <fmt/ranges.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
ClickHouseVersion::ClickHouseVersion(std::string_view versi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <compare>
#include <vector>
#include <string_view>
namespace DB
{
class ClickHouseVersion
{
public:
explicit ClickHouseVersion(std::string_view version);
std::string toString() const;
<|fim_suffix|>onents;
};
}
<|fim_middle|> std::strong_ordering operator<=>(const Cl... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/defines.h>
#include <Common/Exception.h>
#include <algorithm>
#include <memory>
#include <typeindex>
#include <vector>
#include <string>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
/* This is a collections of objects derived from ItemBase.... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ardinality)
{
low_cardinality_keys.nested_columns.resize(key_columns.size());
low_cardinality_keys.positions.assign(key_columns.size(), nullptr);
low_cardinality_keys.position_sizes.resize(key_columns.size());
for (size_t i = 0; i < key_columns.size(... | fim | ClickHouse/ClickHouse | c |
#include <Common/CacheBase.h>
#include <Common/ColumnsHashing.h>
namespace DB
{
template class CacheBase<
ColumnsHashing::LowCardinalityDictionaryCache::DictionaryKey,
ColumnsHashing::LowCardinalityDictionaryCache::CachedValues,
ColumnsHashing::LowCardinalityDictionaryCache::DictionaryKeyHash>;
}
<|endofte... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/demangle.h>
#include <Common/HashTable/HashTable.h>
#include <Common/HashTable/HashTableKeyHolder.h>
#include <Common/ColumnsHashing/HashMethod.h>
#include <Common/HashTable/Prefetching.h>
#include <Common/ColumnsHashingImpl.h>
#include <Common/Arena.h>
#include <Common/CacheB... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> size_t offset = k % 8;
bitmap[bucket] |= UInt8(1) << offset;
}
}
}
return bitmap;
}
private:
ColumnRawPtrs actual_columns;
ColumnRawPtrs null_maps;
};
/// Case where nullable keys are not supported.
template <typename K... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/HashTable/SmallTable.h>
#include <Common/HashTable/HashSet.h>
#include <Common/HyperLogLogCounter.h>
#include <Core/Defines.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
namespace details
{
enum class ContainerType : uint8_t
{
SMALL =... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
}
private:
/// number of bytes in bitset
static constexpr size_t BITSET_SIZE = (bucket_count * content_width + 7) / 8;
UInt8 bitset[BITSET_SIZE] = { 0 };
};
/** A class for sequentially reading cells from a compact array on a disk.
*/
template <typename BucketIndex, UInt8 content_widt... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <concepts>
#include <variant>
#include <vector>
#include <type_traits>
namespace DB
{
template<typename T, typename ... U>
concept is_any_of = (std::same_as<T, U> || ...);
template <typename... T>
concept OptionalArgument = requires(T &&...)
{
requires(sizeof...(T) == 0 || s... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/ISlotControl.h>
#include <Common/ConcurrencyControl.h>
#include <Common/Exception.h>
#include <Common/ProfileEvents.h>
namespace ProfileEvents
{
extern const Event ConcurrencyControlSlotsGranted;
extern const Event ConcurrencyControlSlotsDelayed;
extern const Event Concurren... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <atomic>
#include <list>
#include <mutex>
#include <optional>
#include <base/types.h>
#include <boost/core/noncopyable.hpp>
#include <boost/intrusive/set.hpp>
#include <Common/CurrentMetrics.h>
#include <Common/ISlotControl.h>
namespace DB
{
/*
* Controls how many threads can be allocated for... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <deque>
#include <condition_variable>
#include <mutex>
#include <optional>
#include <base/MoveOrCopyIfThrow.h>
#include <base/defines.h>
/** A very simple thread-safe queue of limited size.
* If you try to pop an item from an empty queue, the thread is blocked until the queue be... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ng());
}
bool isSameConfiguration(const Poco::Util::AbstractConfiguration & left, const Poco::Util::AbstractConfiguration & right, const String & key)
{
return isSameConfiguration(left, key, right, key);
}
bool isSameConfiguration(const Poco::Util::AbstractConfiguration & left, const String & left_k... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> {
return isSameConfiguration(left, right);
}
inline bool operator!=(const Poco::Util::AbstractConfiguration & left, const Poco::Util::AbstractConfiguration & right)
{
return !isSameConfiguration(left, right);
}
}
<|fim_prefix|>#pragma once
#include <base/types.h>
#inclu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> if (sub_keys.empty() && config.getString(key).empty())
return empty_as;
return config.getBool(key, default_);
}
}
}
<|fim_prefix|>#include <Common/Config/ConfigHelper.h>
#include <Poco/Util/AbstractCo<|fim_middle|>nfiguration.h>
#include <Poco/Util/XMLConfiguration.h>
namespace DB
{
nam... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>bstractConfiguration & config, const std::string & key, bool default_ = false, bool empty_as = true);
}
<|fim_prefix|>#pragma once
#include <Poco/AutoPtr.h>
#include <string>
namespace Poco::Util
{
class AbstractConfiguration;
}
namespace DB::ConfigHelper
{
/// Clones a configuration.
/// NOTE:... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#include <Common/Config/ConfigProcessor.h>
#include <Common/Config/YAMLParser.h>
#include <sys/utsname.h>
#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <functional>
#include <filesystem>
#include <boost/algorithm/string.hpp>
#include <Poco/DOM/T... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ool hasNodeWithNameAndChildNodeWithAttribute(LoadedConfig & loaded_config, const std::string & node_name, const std::string & attribute_name);
#endif
void hideRecursive(Poco::XML::Node * config_root);
XMLDocumentPtr hideElements(XMLDocumentPtr xml_tree);
static void mergeRecursive(XMLDocumen... | fim | ClickHouse/ClickHouse | c |
#include <Common/Config/ConfigReloader.h>
#include <Common/ZooKeeper/ZooKeeperNodeCache.h>
#include <filesystem>
#include <memory>
#include <Common/Config/ConfigProcessor.h>
#include <Common/Exception.h>
#include <Common/logger_useful.h>
#include <Common/setThreadName.h>
namespace fs = std::filesystem;
namespace DB... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Config/ConfigProcessor.h>
<|fim_suffix|>ra_paths;
std::string preprocessed_dir;
FilesChangesTracker files;
std::unique_ptr<zkutil::ZooKeeperNodeCache> zk_node_cache;
bool need_reload_from_zk = false;
Coordination::EventPtr zk_changed_event = std::make_sh... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|><|fim_suffix|>", path, e.what());
}
catch (const YAML::BadFile&)
{
/// yaml-cpp cannot open the file even though it exists
throw Exception(ErrorCodes::CANNOT_OPEN_FILE, "Unable to open YAML configuration file {}", path);
}
Poco::AutoPtr<Poco::XML::Document> xml = new Do... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#include <base/types.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/AutoPtr.h>
#if USE_YAML_CPP
namespace DB
{
/// Real YAML parser: loads yaml file into a YAML::Node
class YAMLParserImpl
{
public:
static Poco::AutoPtr<Poco::XML::Document> parse(const String... | fim | ClickHouse/ClickHouse | c |
#include <Common/Config/getClientConfigPath.h>
#include <Common/XDGBaseDirectories.h>
#include <filesystem>
#include <vector>
namespace fs = std::filesystem;
namespace DB
{
std::optional<std::string> getClientConfigPath(const std::string & home_path)
{
std::string config_path;
std::vector<std::string> nam... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>space DB
{
/// Return path to existing configuration file.
std::optional<std::string> getClientConfigPath(const std::string & home_path);
}
<|fim_prefix|>#pragma once
#include <string>
#include <op<|fim_middle|>tional>
name<|endoftext|> | fim | ClickHouse/ClickHouse | c |
#include <Common/Config/getLocalConfigPath.h>
#include <filesystem>
#include <vector>
namespace fs = std::filesystem;
namespace DB
{
std::optional<std::string> getLocalConfigPath(const std::string & home_path)
{
std::string config_path;
std::vector<std::string> names;
names.emplace_back("./clickhouse-... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>d::string & home_path);
}
<|fim_prefix|>#pragma once<|fim_middle|>
#include <string>
#include <optional>
namespace DB
{
/// Return path to existing configuration file.
std::optional<std::string> getLocalConfigPath(const st<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e(config.getString(prefix + ".history_file"));
if (config.has(prefix + ".history_max_entries"))
res.history_max_entries.emplace(config.getUInt(prefix + ".history_max_entries"));
if (config.has(prefix + ".accept-invalid-certificate"))
res.accept_invalid_certificate.e... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|><std::string> & connection_name);
}
<|fim_prefix|>#pragma once
#include <string>
#include <optional>
#include <base/types.h>
namespace Poco::Util { class AbstractConfiguration; }
namespace DB
{
struct ConnectionsCredentials
{
/// .hostname or fallback to connection
std::optional<std::string> ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once<|fim_suffix|>e_))
{}
CopyableAtomic & operator=(const CopyableAtomic & other)
{
if (&other == this)
return *this;
value = other.value.load();
return *this;
}
template <std::convertible_to<T> U>
CopyableAtomic & operator=(U && value... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <fcntl.h>
#include <sys/file.h>
#include <string>
#include <mutex>
#include <filesystem>
#include <Poco/Exception.h>
#include <IO/ReadBufferFromFileDescriptor.h>
#include <IO/WriteBufferFromFileDescriptor.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#inclu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#if defined(__ELF__) && !defined(OS_FREEBSD) && WITH_COVERAGE_DEPTH
#include <Common/CoverageCollection.h>
#include <|fim_suffix|>dth && r.is_branch && !it->second.is_branch))
it->second = r;
}
}
LOG_INFO(
getLogger("CoverageCollection"),
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#if defined(__ELF__) && !defined(OS_FREEBSD) && WITH_COVERAGE_DEPTH
#include <Interpreters/Context_fwd.h>
#include <base/coverage.h>
#include <cstdint>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>
namespace DB
{
/// Look up each (name_has... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>w_e) <= 0 || !raw_e)
throw Exception(ErrorCodes::OPENSSL_ERROR, "Failed to get RSA exponent: {}", getOpenSSLErrors());
BIGNUM_ptr e(raw_e, &BN_free);
std::vector<unsigned char> result(BN_num_bytes(e.get()));
BN_bn2bin(e.get(), reinterpret_cast<unsigned char *>(result.data()));
ret... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
explicit KeyPair(EVP_PKEY * key_);
explicit operator EVP_PKEY *() const;
KeyPair(const KeyPair &) = delete;
KeyPair & operator=(const KeyPair &) = delete;
KeyPair(KeyPair && other) noexcept;
KeyPair & operator=(KeyPair && other) noexcept;
~KeyPair();
static KeyPair fro... | fim | ClickHouse/ClickHouse | c |
#include <Common/Crypto/OpenSSLInitializer.h>
#include "config.h"
#include <Common/Exception.h>
#include <Common/OpenSSLHelpers.h>
#if USE_SSL
# include <openssl/crypto.h>
# include <openssl/provider.h>
# include <openssl/ssl.h>
#endif
namespace DB
{
#if USE_SSL
std::atomic<bool> DB::OpenSSLInitializer::... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> static std::atomic<bool> cleanup_done;
static OSSL_PROVIDER * legacy_provider;
static OSSL_PROVIDER * default_provider;
#endif
};
}
<|fim_prefix|>#pragma once
#include "config.h"
#include <boost/noncopyable.hpp>
#include <atomic>
#if USE_SSL
# include <openssl/provider.<|fim_middle|>h>... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Crypto/X509Certificate.h>
#include <base/scope_guard.h>
#if USE_SSL
namespace DB
{
namespace ErrorCodes
{
extern const int OPENSSL_ERROR;
extern const int BAD_ARGUMENTS;
}
X509Certificate::X509Certificate(X509 * cert_)
: certificate(cert_)
{
}
X509Certificate::operator X509 *()... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> String toString(X509Certificate::Subjects::Type type_);
bool operator==(const X509Certificate::Subjects & rhs) const;
};
Subjects extractAllSubjects();
private:
X509 * certificate;
};
#endif
}
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
#include <boost/containe... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/CurrentMemoryTracker.h>
#include <Common/CurrentThread.h>
#include <Common/ThreadStatus.h>
#include <Common/Exception.h>
#include <Common/MemoryTracker.h>
#include <Common/MemoryTrackerBlockerInThread.h>
#include <atomic>
#include <limits>
#ifdef MEMORY_TRACKER_DEBUG_CHECKS
thread_loca... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ntMemoryTracker::alloc` path, which always honours
/// the memory limit regardless of size.
///
/// @param value - 0 means disabled, internally use UINT64_MAX max so the hot path is a single comparison
static void setMinAllocationSizeBytesToThrow(UInt64 value);
static UInt64 getMinAllo... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>M(KafkaConsumersInUse, "Number of consumers which are currently used by direct or background reads") \
M(KafkaWrites, "Number of currently running inserts to Kafka") \
M(KafkaAssignedPartitions, "Number of partitions Kafka tables currently assigned to") \
M(FilesystemCacheReadBuffers, "Number ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>fetch_add(new_amount - amount, std::memory_order_relaxed);
amount = new_amount;
}
void sub(Value value = 1)
{
what->fetch_sub(value, std::memory_order_relaxed);
amount -= value;
}
void add(Value value = 1)
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <memory>
#include <Common/CurrentThread.h>
#include <Common/logger_useful.h>
#include <Common/ThreadStatus.h>
#include <Interpreters/ProcessList.h>
#include <Interpreters/Context.h>
#include <base/getThreadId.h>
#include <Poco/Logger.h>
namespace DB
{
thread_local ThreadStatus constinit * cur... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block.h>
#include <Core/LogsLevel.h>
#include <Interpreters/Context_fwd.h>
#include <base/defines.h>
#include <Common/ConcurrentBoundedQueue.h>
#include <Common/IThrottler.h>
#include <Common/Scheduler/ResourceLink.h>
#include <memory>
#include <string_view>
namespace Profi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Curre<|fim_suffix|>get().getClientLogsLevel();
}
}
<|fim_middle|>ntThread.h>
#include <Common/ThreadStatus.h>
#include <Common/CurrentThreadHelpers.h>
namespace DB
{
bool currentThreadHasGroup()
{
return DB::CurrentThread::getGroup() != nullptr;
}
LogsLevel currentThreadLogsLevel()... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/LogsLevel.h>
namespace DB
{
bool currentThreadHas<|fim_suffix|>sLevel();
}
<|fim_middle|>Group();
LogsLevel currentThreadLog<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <string>
#include <unordered_set>
namespace DB
{
struct DNSPTRResolver
{
virtual ~DNSPTRResolver() = default;
virtual std::unordered_set<std::string> resolve(const std::string & ip) = 0;
<|fim_suffix|> std::string & ip) = 0;
};
}
<|fim_middle|> ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>red_ptr<DNSPTRResolver> DNSPTRResolverProvider::get()
{
static auto resolver = std::make_shared<CaresPTRResolver>(
CaresPTRResolver::provider_token {}
);
return resolver;
}
}
<|fim_prefix|>#include <Common/DNSPTRResolverProvider.h>
#include <Common/CaresPTRReso... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
}
<|fim_prefix|>#pragma once
#include <memory>
#include <Common/DNSPTRResolver.h>
namespace DB
{
/*
* Provides a ready-to-use DNSPTRResolver instance.
* It hides 3rd party lib dependencies, handles initialization and lifetime.
* Since `ge<|fim_middle|>t` function is static, it can b... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>cache_max_entries);
}
String DNSResolver::getHostName()
{
if (impl->disable_cache)
return Poco::Net::DNS::hostName();
std::lock_guard lock(impl->drop_mutex);
if (!impl->host_name.has_value())
impl->host_name.emplace(Poco::Net::DNS::hostName());
return *impl->host_name;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Poco/Net/IPAddress.h>
#include <Poco/Net/SocketAddress.h>
#include <memory>
#include <base/types.h>
#include <Core/Names.h>
#include <boost/noncopyable.hpp>
#include <Common/LoggingFormatStringHelpers.h>
namespace Poco { class Logger; }
namespace DB
{
using LoggerPtr = std::shar... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/DateLUT.h>
#include <Interpreters/Context.h>
#include <Common/CurrentThread.h>
#include <Common/ThreadStatus.h>
#include <Common/DateLUTImpl.h>
#include <Common/filesystemHelpers.h>
#include <Core/Settings.h>
#include <Poco/DigestStream.h>
#include <Poco/Exception.h>
#include <Poco/SHA1... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>lut);
UInt32 getDayNumOffsetEpoch();
<|fim_prefix|>#pragma once
#include <base/DayNum.h>
#include <base/defines.h>
#include <base/types.h>
#include <boost/noncopyable.hpp>
#include <atomic>
#include <memory>
#include <mutex>
#include <unordered_map>
class DateLUTImpl;
/// This class provides lazy in... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/DecimalFunctions.h>
#include <Common/DateLUTImpl.h>
#include <Common/Exception.h>
#include <algorithm>
#include <chrono>
#include <cstring>
#include <memory>
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wimplicit-int-conversion"
#include <cctz/civil_time.h>
#include <c... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>onst
{
if constexpr (std::is_same_v<Date, DayNum>)
return toDayNum(LUTIndexWithSaturation(addMonthsIndex(d, delta)));
else
return toDayNum(addMonthsIndex(d, delta));
}
template <typename DateOrTime>
auto NO_SANITIZE_UNDEFINED addQuarters(DateOrTime ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
<|fim_prefix|>#incl<|fim_middle|>ude <Common/DelayWithJitter.h>
#include <Common/thread_local_rng.h>
#include <algorithm>
#include <random>
namespace DB
{
DelayWithJitter::DelayWithJitter(int64_t delay_)
: delay(std::max<int64_t>(0, delay_))
{
}
uint64_t DelayWithJitter::getDelay() const
{
re... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.