text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Common/BitHelpers.h>
#include <base/defines.h>
#include <array>
#include <set>
/** Functions to analyze the Morton space-filling curve on ranges.
* There are two operations:
*
* 1. Inverting the Morton curve on a range.
* Given a range of values of... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nst T> && value)
: current_version(std::move(value))
{
}
/// There is no copy constructor because only one MultiVersion should own the same object.
MultiVersion(MultiVersion && src) { *this = std::move(src); } /// NOLINT
MultiVersion & operator=(MultiVersion && src) /// NOLIN... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>above the
/// upper bound, leading to undefined behavior in subsequent `static_cast<T>(x)`. See issue #103817.
///
/// Bool is special-cased: `numeric_limits<bool>` is exactly representable in `Float64`, and
/// `DecomposedFloat::compare<bool>` is ill-formed (`make_unsigned_t<bool>` is for... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/WriteHelpers.h>
#include <Common/NamePrompter.h>
namespace DB
{
String getHintsErrorMessageSuffix(const std::vector<String> & hints)
{<|fim_suffix|>endHintsMessage(String & message, const std::vector<String> & hints)
{
message += getHintsErrorMessageSuffix(hints);
}
}
<|fim_middle|>
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <base/types.h>
#include <Common/levenshteinDistance.h>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <memory>
#include <queue>
#include <utility>
namespace DB
{
template <size_t MaxNumHints>
class NamePrompter
{
public:
using DistanceIndex = std::pair<size_t, size_t>;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <base/EnumReflection.h>
#include <Poco/Util/XMLConfiguration.h>
#include <Common/Exception.h>
#include <Common/FieldVisitorToString.h>
#include <Common/NamedCollections/NamedCollectionConfiguration.h>
#include <Common/SettingsChanges.h>
namespace DB
{
namespace ErrorCodes
{
extern const in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>erate_paths,
std::set<std::string, std::less<>> & result,
ssize_t depth);
std::optional<bool> isOverridable(const Poco::Util::AbstractConfiguration & config, const std::string & path);
}
}
<|fim_prefix|>#pragma once
#include <queue>
#include <set>
#include <Poco/Util/AbstractConfiguration.h>
na... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/NamedCollections/NamedCollections.h>
#include <Interpreters/Context.h>
#include <IO/WriteBufferFromString.h>
#include <IO/Operators.h>
#include <Common/NamedCollections/NamedCollectionConfiguration.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Common/FieldVisitorToString.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/NamedCollections/NamedCollections_fwd.h>
#include <Parsers/ASTCreateNamedCollectionQuery.h>
#include <Parsers/ASTAlterNamedCollectionQuery.h>
#include <mutex>
namespace Poco { namespace Util { class AbstractConfiguration; } }
namespace DB
{
/**
* Class to represent arb... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Settings.h>
#include <base/sleep.h>
#include <Common/FieldVisitorToString.h>
#include <Common/NamedCollections/NamedCollectionConfiguration.h>
#include <Common/NamedCollections/NamedCollectionsFactory.h>
#include <Common/NamedCollections/NamedCollectionsMetadataStorage.h>
#include <Common/Z... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/NamedCollections/NamedCollections.h>
#include <Common/NamedCollections/NamedCollectionsMetadataStorage.h>
#include <Common/logger_useful.h>
#include <Core/BackgroundSchedulePoolTaskHolder.h>
#include <Interpreters/StorageID.h>
#include <boost/noncopyable.hpp>
#include <<|fim... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <filesystem>
#include <Core/Settings.h>
#include <IO/FileEncryptionCommon.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include <Interpr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Parsers/ASTCreateNamedCollectionQuery.h>
#include <Parsers/ASTAlterNamedCollectionQuery.h>
#include <Parsers/ASTDropNamedCollectionQuery.h>
#include <Common/NamedCollections/NamedCollecti<|fim_suffix|>ce = false);
};
}
<|fim_middle|>ons.h>
#include <Interpreters/Context_fwd.h>
na... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ection;
using NamedCollectionPtr = std::shared_ptr<const NamedCollection>;
using MutableNamedCollectionPtr = std::shared_ptr<NamedCollection>;
using NamedCollectionsMap = std::map<std::string, MutableNamedCollectionPtr>;
}
<|fim_prefix|>#pragma once
#i<|fim_middle|>nclude <memory>
#include <map>
namespa... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>60-cpp)
private:
const char * name() const noexcept override { return "DB::NetException"; }
const char * className() const noexcept override { return "DB::NetException"; }
};
}
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
namespace DB
{
class NetException : public Exception
{
pub... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>acity must be at least 2 to make `pos + 1` different from `pos + capacity`.)
min_capacity = std::max<size_t>(2, roundUpToPowerOfTwoOrZero(min_capacity));
chassert(isPowerOf2(min_capacity));
mask = min_capacity - 1;
slots = std::vector<Slot>(min_capacity);
for (size_... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/OOMCanary/OOMCanary.h>
#if defined(OS_LINUX)
#include <Common/Epoll.h>
#include <Common/OOMCanaryExitCodes.h>
#include <Common/logger_useful.h>
#include <Common/waitForPid.h>
#include <Common/CurrentThread.h>
#include <Common/ThreadStatus.h>
#include <Common/Exception.h>
#include <Commo... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#if defined(OS_LINUX)
#include <Interpreters/Context_fwd.h> // ContextMutablePtr
#include <Common/EventFD.h>
#include <Common/Logger.h>
#include <Common/ThreadPool.h>
#include <base/strong_typedef.h>
#include <cstdint>
#include <optional>
namespace DB
{
/// OOM Canary: a sacrificial child process tha... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
namespace DB::OO<|fim_suffix|>PERMANENT = 2;
}
<|fim_middle|>MCanaryExitCodes
{
constexpr int TRANSIENT = 1;
constexpr int <|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#includ<|fim_suffix|> set(original_value, thread_id);
}
catch (...)
{
tryLogCurrentException(__PRETTY_FUNCTION__);
}
};
#else
return [](){};
#endif
}
}
<|fim_middle|>e <Common/ErrnoExcept... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>// Set the nice value of a thread (0 = current thread), returns a guard that resets it to 0.
/// Linux-only, negative values require CAP_SYS_NICE, otherwise no-op.
static scope_guard scoped(Int32 value, UInt32 thread_id = 0);
};
}
<|fim_prefix|>#pragma once
#include <base/scope_guard.... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> {
std::lock_guard lock{parent->mutex};
parent->stack.emplace(owning_ptr);
}
};
public:
using Pointer = std::unique_ptr<T, Deleter>;
/// Extracts and returns a pointer from the stack if it's not empty,
/// creates a new one by calling provided f() ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/ObjectStorageKey.h>
#include <Common/Exception.h>
#include <filesystem>
namespace fs = std::filesystem;
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
const String & ObjectStorageKey::getPrefix() const
{
if (!is_relative)
throw DB::Exception(DB::... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <memory>
namespace DB
{
struct ObjectStorageKey
{
ObjectStorageKey() = default;
bool hasPrefix() const { return is_relative; }
const String & getPrefix() const;
const String & getSuffix() const;
const String ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/ObjectStorageKeyGenerator.h>
#include <Common/MatchGenerator.h>
#include <Common/re2.h>
#include <fmt/format.h>
#include <filesystem>
namespace
{
class GeneratorWithTemplate : public DB::IObjectStorageKeyGenerator
{
public:
explicit GeneratorWithTemplate(std::string key_template_)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>torageKey generate() const = 0;
};
using ObjectStorageKeyGeneratorPtr = std::shared_ptr<IObjectStorageKeyGenerator>;
ObjectStorageKeyGeneratorPtr createObjectStorageKeyGeneratorByPrefix(String key_prefix);
ObjectStorageKeyGeneratorPtr createObjectStorageKeyGeneratorByTemplate(String key_template);
}
<|... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#if USE_SSL
#include <Common/OpenSSLHelpers.h>
#include <Common/Base64.h>
#include <Common/Exception.h>
#include <Common/Crypto/KeyPair.h>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/sha.h>
#include <openssl/kdf.h>
#include <openssl/core_names.h>
#include <op... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#include <Commo<|fim_suffix|>e key.
std::string generateCSR(std::vector<std::string>, EVP_PKEY * pkey);
/// Returns concatenation of error strings for all errors that OpenSSL has recorded, emptying the error queue.
String getOpenSSLErrors();
}
#endif
<|fim_middle|>n/Ex... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eption
{
/// Ignore exception raised by value_supplier
return false;
}
}
bool Span::addAttribute(const Exception & e) noexcept
{
if (!this->isTraceEnabled())
return false;
return addAttributeImpl("clickhouse.exception", getExceptionMessage(e, false))
&& ad... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/OpenTelemetryTracingContext.h>
#include <base/types.h>
#include <IO/WriteHelpers.h>
#include <chrono>
#include <exception>
#include <string_view>
#include <variant>
namespace DB
{
class Exception;
struct Settings;
class OpenTelemetrySpanLog;
class WriteBuffer;
class Read... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Core/UUID.h>
namespace DB
{
class WriteBuffer;
class ReadBuffer;
namespace OpenTelemetry
{
/// See https://www.w3.org/TR/trace-context/ for trace_flags definition
enum TraceFlags : UInt8
{
TRACE_FLAG_NONE = 0,
TRACE_FLAG_SAMPLED = 1,
TRACE_FLAG_KEEPER_SPANS = 2,
};
/// The runti... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> throw DB::Exception(DB::ErrorCodes::CANNOT_COMPILE_REGEXP, "OptimizedRegularExpression: too many subpatterns in regexp: {}", regexp_);
}
}
if (!required_substring.empty())
{
if (is_case_insensitive)
case_insensitive_substring_searcher = std::make_unique<A... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>earcher> case_sensitive_substring_searcher;
std::unique_ptr<ASCIICaseInsensitiveStringSearcher> case_insensitive_substring_searcher;
std::unique_ptr<re2::RE2> re2;
unsigned number_of_subpatterns;
};
}
<|fim_prefix|>#pragma once
#include <memory>
#include <string>
#include <vector>
#include <C... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>acker::needToStopQuery.
auto & queries = user_process_list->queries;
for (auto const & query : queries)
{
if (query.second->isKilled())
continue;
auto * memory_tracker = query.second->getMemoryTracker();
if (!memory_tracker)
continue;
a... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Core/Types.h>
#include <boost/core/noncopyable.hpp>
#include <Poco/Logger.h>
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <unordered_map>
#include <Common/SharedMutex.h>
// This struct is used for the comparison of query memory ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/PODArray.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_MPROTECT;
extern const int CANNOT_ALLOCATE_MEMORY;
}
namespace PODArrayDetails
{
#ifndef NDEBUG
void protectMemoryRegion(void * addr, siz... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/getPageSize.h>
#include <boost/noncopyable.hpp>
#include <Common/Allocator.h>
#include <Common/BitHelpers.h>
#include <Common/PODArray_fwd.h>
#include <Common/memcpySmall.h>
#include <algorithm>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <numeric>
#ifn... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eof(T))>
using PODArrayWithStackMemory = PODArray<T, rounded_bytes,
AllocatorWithStackMemory<Allocator<false>, rounded_bytes, alignof(T)>>;
}
<|fim_prefix|>#pragma once
/**
* This file contains some using-declarations that define various kinds of
* PODArray.
*/
#include <Core/Defines.h>
#inclu... | fim | ClickHouse/ClickHouse | c |
#include <Common/PageCache.h>
#include <sys/mman.h>
#include <Common/Allocator.h>
#include <Common/JemallocCacheAllocator.h>
#include <Common/MemoryTracker.h>
#include <Common/MemoryTrackerBlockerInThread.h>
#include <Common/formatReadable.h>
#include <Common/ProfileEvents.h>
#include <Common/SipHash.h>
#include <Comm... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <IO/BufferWithOwnMemory.h>
#include <Common/CacheBase.h>
#include <Common/CacheLine.h>
#include <Common/HashTable/Hash.h>
#include <Common/SipHash.h>
#include <Common/thread_local_rng.h>
/// "Userspace page cache"
/// A cache for contents of remote files.
/// Intended mainly for caching data ret... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/PipeFDs.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/formatReadable.h>
#include <Common/FailPoint.h>
#include <Common/logger_useful.h>
#include <base/errnoToString.h>
#include <unistd.h>
#include <fcntl.h>
#include <algorithm>
namespace DB
{
na... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ipeFDs();
};
/** Struct which opens new pipe on creation and closes it on destruction.
* Use `fds_rw` field to access pipe's file descriptors.
*/
struct PipeFDs : public LazyPipeFDs
{
PipeFDs();
};
}
<|fim_prefix|>#pragma once
namespace DB
{
/** Struct containing a pipe with lazy init<|fim_mi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>) = default; /// For deferred initialization.
/** The `Entry` object protects the resource from being used by another thread.
* The following methods are forbidden for `rvalue`, so you can not write a similar to
*
* auto q = pool.get()->query("SELECT .."); // Oops... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Common/Priority.h>
namespace DB
{
/// Indices and priorities of `AsyncLoader` pools.
/// The most important difference from regular ThreadPools is priorities of pools:
/// * Pools that have different priorities do NOT run jobs simultaneously (with small exception due to dynamic prioritizatio... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>t = 0;
size_t failed_pools_count = 0;
/// At exit update shared error counts with error counts occurred during this call.
SCOPE_EXIT(
{
updateSharedErrorCounts(shuffled_pools);
});
std::string fail_messages;
bool finished = false;
while (!finished)
{
f... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <array>
#include <limits>
#include <numeric>
#include <base/defines.h>
#include <base/extended_types.h>
#include <base/types.h>
#include <Common/Concepts.h>
#include <Common/HashTable/Hash.h>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/integer.hpp>
#... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <algorithm>
#include <cmath>
#include <limits>
#include <optional>
#include <vector>
#include <base/defines.h>
#include <base/types.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
/// The following query will hit many edge... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/types.h>
/// Common type for priority<|fim_suffix|>er than `Int64` is used just to avoid implicit conversion errors and to default-initialize
struct Priority
{
using Value = Int64;
Value value = 0; /// Note that lower value means higher priority.
constexpr operato... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/ProcfsMetricsProvider.h>
#if defined(OS_LINUX)
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/ReadHelpers.h>
#include <base/find_symbols.h>
#include <base/defines.h>
#include <Common/logger_useful.h>
#include <sys/typ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
private:
void readParseAndSetThreadCPUStat(::taskstats & out_stats, char *, size_t) const;
void readParseAndSetThreadBlkIOStat(::taskstats & out_stats, char *, size_t) const;
void readParseAndSetThreadIOStat(::taskstats & out_stats, char *, size_t) const;
int thread_schedstat_fd = -1;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ent counter_event)
{
return Timer(*this, timer_event, counter_event, resolution);
}
static const Event num_counters;
};
enum class ValueType : uint8_t
{
Number,
Bytes,
Milliseconds,
Microseconds,
Nanoseconds,
};
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>::Counters::Snapshot>(performance_counters_scope->getPartiallyAtomicSnapshot());
}
ProfileEventsScope::~ProfileEventsScope()
{
/// Restore previous performance counters
CurrentThread::get().attachProfileCountersScope(previous_counters_scope);
}
}
<|fim_prefix|>#include <Common/CurrentThread.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/ProfileEvents.h>
#include <boost/noncopyable.hpp>
namespace DB
{
/// Use specific performance counters for current thread in the current scope.
class ProfileEventsS<|fim_suffix|>vents::Counters * performance_counters_scope_);
std::shared_ptr<ProfileEvents::Counters::... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/SharedMutex.h>
#include <Common/ProfileEvents.h>
#include <Common/Stopwatch.h>
#include <base/defines.h>
#include <boost/noncopyable.hpp>
#include <mutex>
#include <shared_mutex>
namespace DB
{
/// RAII lock guard that measures wait-time on contention only for std::mute... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>dth_of_progress_bar - bar_width_in_terminal, ' ');
}
else
{
/// Render profiling_msg at right after the progress bar.
message << "\033[0;32m" << bar << "\033[0m"
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/Progress.h>
#include <Interpreters/Context_fwd.h>
#include <base/types.h>
#include <Common/Stopwatch.h>
#include <Common/EventRateMeter.h>
#include <iostream>
#include <mutex>
#include <unistd.h>
#include<|fim_suffix|>allback methrod in:
/// - context (used in clickhouse... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <string>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
struct ProxyConfiguration
{
enum class Protocol : uint8_t
{
HTTP,
HTTPS
};
static auto protocolFromString(const std::string & str)
... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Common/ProxyConfiguration.h>
namespace DB
{
struct ProxyConfigurationResolver
{
using Protocol = ProxyConfiguration::Protocol;
explicit ProxyConfigurationResolver(Protocol request_protocol_, bool disable_tunneling_for_https_requests_over_http_proxy_ = false)
: request_protocol... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nfiguration::Protocol request_protocol,
const String & config_prefix,
const Poco::Util::AbstractConfiguration & configuration)
{
auto uris = extractURIList(config_prefix, configuration);
return uris.empty()
? nullptr
: std::make_shared<ProxyList... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Common/ProxyConfigurationResolver.h>
namespace DB
{
class ProxyConfigurationResolverProvider
{
public:
using Protocol = ProxyConfiguration::Protocol;
/*
* Tries to use global context to call the ... | fim | ClickHouse/ClickHouse | c |
#include <Common/ProxyListConfigurationResolver.h>
#include <Common/StringUtils.h>
#include <Poco/URI.h>
namespace DB
{
ProxyListConfigurationResolver::ProxyListConfigurationResolver(
std::vector<Poco::URI> proxies_,
Protocol request_protocol_,
const std::string & no_proxy_hosts_,
bool disable_tunnel... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <atomic>
#include <base/types.h>
#include <Common/ProxyConfigurationResolver.h>
#include <Poc<|fim_suffix|>lver(
std::vector<Poco::URI> proxies_,
Protocol request_protocol_,
const std::string & no_proxy_hosts_,
bool disable_tunneling_for_https_reques... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ation(ASTIndexDeclaration & index);
void fuzzProjectionDeclaration(ASTProjectionDeclaration & projection);
void fuzzProjectionWithSettings(ASTProjectionDeclaration & projection);
void fuzzTableName(ASTTableExpression & table);
void fuzzTableFunctionName(ASTPtr & table_function);
ASTPtr... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>apture. Symbolization happens later in a normal thread context.
#if !defined(THREAD_SANITIZER)
if (!hasPHDRCache())
throw Exception(ErrorCodes::NOT_IMPLEMENTED, "QueryProfiler cannot be used without PHDR cache in this build");
#endif
/// `sigaction` is `#define sigaction __sigaction` on s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>hread's current stack trace
* 3. write collected stack trace to trace_pipe for TraceCollector
*
* Destructor tries to unset timer and restore previous signal handler.
* Note that signal handler implementation is defined by template parameter. See QueryProfilerReal and QueryProfilerCPU.
*/
#if ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>->makeQueryContext();
auto group = ThreadGroup::createForFlushAsyncInsertQueue(query_context, parent);
CurrentThread::attachToGroup(group);
return QueryScope(true);
}
QueryScope::~QueryScope()
{
if (!initialized)
return;
try
{
if (log_peak_memory_usage_in_destruc... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Interpreters/Context_fwd.h>
#include <functional>
#include <memory>
namespace DB
{
class ThreadGroup;
using ThreadGroupPtr = std::shared_ptr<ThreadGroup>;
/// Initializes query with current thread as master thread in constructor, and detaches it in destructor.
/// Formerly nested as CurrentT... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>MemoryTracking<T>>;
}
<|fim_prefix|>#pragma once
#include <Common/DequeWithMemoryTracking.h>
#include <queue>
namespace DB
{
/// We do track memory allocations from standard containers by default, but we do it through
/// non-throwing methods of the `MemoryTracker` (see `trackMemory` in src/Common/me... | fim | ClickHouse/ClickHouse | c |
#include <Common/RWLock.h>
#include <Common/Stopwatch.h>
#include <Common/Exception.h>
#include <Common/CurrentMetrics.h>
#include <Common/ProfileEvents.h>
#include <IO/Operators.h>
#include <IO/WriteBufferFromString.h>
namespace ProfileEvents
{
extern const Event RWLockAcquiredReadLocks;
extern const Event R... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>in a background thread).
LockHolder getLock(Type type, const String & query_id,
const std::chrono::milliseconds & lock_timeout_ms = std::chrono::milliseconds(0), bool throw_in_fast_path = true);
/// Use as query_id to acquire a lock outside the query context.
inline sta... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ss * HISTOGRAM_SIZE + pos]];
++histograms[pass * HISTOGRAM_SIZE + pos];
dest = element;
/// On the last pass, we do the reverse transformation.
if (!Traits::Transform::transform_is_simple && pass == NUM_PASSES - 1)
Traits... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Poco/URI.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Common/RemoteHostFilter.h>
#include <Common/StringUtils.h>
#include <Common/Exception.h>
#include <Common/re2.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int UNACCEPTABLE_URL;
}
void R... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <atomic>
#include <string>
#include <vector>
#include <mutex>
#include <unordered_set>
#include <base/defines.h>
namespace Poco { class URI; }
namespace Poco { namespace Util { class AbstractConfiguration; } }
namespace DB
{
class RemoteHostFilter
{
/**
* This class checks if UR... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/RemoteProxyConfigurationResolver.h>
#include <string_view>
#include <utility>
#include <IO/HTTPCommon.h>
#include <Poco/StreamCopier.h>
#include <Poco/Net/HTTPRequest.h>
#include <Poco/Net/HTTPResponse.h>
#include <Common/logger_useful.h>
namespace DB
{
namespace ErrorCodes
{
exter... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>HostFetcher> fetcher;
std::mutex cache_mutex;
bool cache_valid = false;
std::chrono::time_point<std::chrono::system_clock> cache_timestamp;
ProxyConfiguration cached_config;
};
}
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <mutex>
#include <Common/ProxyConfigurationRes... | fim | ClickHouse/ClickHouse | c |
#include <Core/BackgroundSchedulePool.h>
#include <Core/ServerSettings.h>
#include <Common/ReplicasReconnector.h>
#include <Common/logger_useful.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_INITIALIZED;
extern const int LOGICAL_ERROR;
}
namespace ServerSett... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/BackgroundSchedulePoolTaskHolder.h>
#include <Interpreters/Context_fwd<|fim_suffix|>r = nullptr;
ReconnectorsList reconnectors;
std::mutex mutex;
std::atomic_bool emergency_stop{false};
BackgroundSchedulePoolTaskHolder task_handle;
LoggerPtr log = nullptr;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/ICachePolicy.h>
#include <Common/CurrentMetrics.h>
#include <list>
#include <unordered_map>
namespace DB
{
/// Cache policy SLRU evicts entries which were used only once and are not used for a long time,
/// this policy protects entries which were used more then once from... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SSHWrapper.h>
# if USE_SSH
# include <stdexcept>
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wreserved-macro-identifier"
# pragma clang diagnostic ignored "-Wreserved-identifier"
# include <libssh/libssh.h>
# pragma clang diagnostic pop
namesp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
#include <string_view>
#include <base/types.h>
#<|fim_suffix|>_deallocation_);
friend class SSHKeyFactory;
explicit SSHKey(ssh_key key_) : key(key_) { }
private:
ssh_key key = nullptr;
bool needs_deallocation = true;
};
class SSHKeyFactory... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> // Preemption. If we run more thread than we have slots, the last thread should wait for the next slot to be granted.
// We only preempt the last running thread to avoid running many threads with low utilization (e.g spread 2 CPU among 10 threads).
// It is better to run less th... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <boost/core/noncopyable.hpp>
#include <boost/dynamic_bitset.hpp>
#include <boost/dynamic_bitset/dynamic_bitset.hpp>
#include <Common/Scheduler/ResourceLink.h>
#include <Common/Scheduler/ResourceRequest.h>
#include <<|fim_suffix|>umption to report
Resourc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <mutex>
#include <base/scope_guard.h>
#include <Common/Scheduler/CPUSlotsAllocation.h>
#include <Common/Scheduler/ISchedulerQueue.h>
#include <Common/Exception.h>
#include <Common/ProfileEvents.h>
#include <Common/CurrentThread.h>
namespace ProfileEvents
{
extern const Event ConcurrencyCon... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <boost/core/noncopyable.hpp>
#include <Common/Scheduler/ResourceLink.h>
#include <Common/Scheduler/ResourceRequest.h>
#include <Common/CurrentMetrics.h>
#include <Common/ProfileEvents.h>
#include <Common/ISlotControl.h>
#include <atomic>
#include <condition... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <string_view>
namespace DB
{
/// Describes what resource request c<|fim_suffix|>CostUnit::CPUNanosecond: return "CPUNanosecond";
case CostUnit::QuerySlot: return "QuerySlot";
}
}
}
<|fim_middle|>ost means.
/// One resource could not mix different cost units.
enum clas... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Scheduler/ResourceLink.h>
#include <Common/Scheduler/WorkloadSettings.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <boost/noncopyable.hpp>
#include <memory>
#include <functional>
namespace DB
{
class ISchedulerNode;
using SchedulerNodePtr = std::shared_ptr<I... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Scheduler/ISchedulerNode.h>
namespace DB
{
/*
* Constraint defined on the set of requests in consumption state.
* It allows to track two events:
* - dequeueRequest(): resource consumption begins
* - finishRequest(): resource consumption <|fim_suffix|>est` is finished... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ctivations are stored in a separate queue for performance reasons (mostly to avoid any allocations)
std::deque<Event> events;
boost::intrusive::list<ISchedulerNode> activations;
std::vector<Postponed> postponed;
EventId last_event_id = 0;
std::atomic<TimePoint> manual_time{TimePoint(... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Scheduler/ISchedulerNode.h>
#include <Common/Scheduler/ResourceBudget.h>
#include <Common/Scheduler/ResourceRequest.h>
#include <memory>
namespace DB
{
/*
* Queue for pending requests for specific resource, leaf of hierarchy.
* Note that every queue has budget associat... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Scheduler/Nodes/ClassifiersConfig.h>
namespace DB
{
ClassifierDescription::ClassifierDescription(const Poco::Util::A<|fim_suffix|>ys);
for (const auto & key : keys)
classifiers.emplace(std::piecewise_construct,
std::forward_as_tuple(key),
std::forwar... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> String & classifier_name);
private:
std::unordered_map<String, ClassifierDescription> classifiers; // by classifier_name
};
}
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <unordered_map>
namespace DB
{
/// Mapping of resource name into ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> throw Exception(ErrorCodes::RESOURCE_ACCESS_DENIED, "Access denied to resource '{}'", resource_name);
else
return ResourceLink{}; // unlimited access
}
WorkloadSettings CustomResourceManager::Classifier::getWorkloadSettings(const String & resource_name) const
{
UNUSED(resource_name);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Scheduler/IResourceManager.h>
#include <Common/Scheduler/SchedulerRoot.h>
#include <Common/Scheduler/Nodes/ClassifiersConfig.h>
#include <mutex>
namespace DB
{
/*
* Implementation of `IResourceManager` supporting arbitrary hierarchy of scheduler nodes.
* Scheduling hier... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>.registerMethod<FairPolicy>("fair");
}
}
<|fim_prefix|>#include <Common/Scheduler/Nodes/FairPolicy.h>
#include <Common/Scheduler/Nodes/SchedulerNodeFactory.h>
#include <Common/Scheduler/Nodes/registerSchedulerNodes.h>
<|fim_middle|>
namespace DB
{
void registerFairPolicy(SchedulerNodeFactory & factory)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Scheduler/ISchedulerNode.h>
#include <Common/Stopwatch.h>
#include <algorithm>
#include <optional>
#include <unordered_map>
#include <vector>
namespace DB
{
namespace ErrorCodes
{
extern const int INVALID_SCHEDULER_NODE;
}
/*
* Scheduler node that implements weigh... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Scheduler/Nodes/FifoQueue.h>
#include <Common/Scheduler/Nodes/SchedulerNodeFactory.h>
#include <Common/Scheduler/Nodes/registerSchedulerNodes.<|fim_suffix|>actory & factory)
{
factory.registerMethod<FifoQueue>("fifo");
}
}
<|fim_middle|>h>
namespace DB
{
void registerFifoQueue(Sch... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> bool is_not_usable = false;
};
}
<|fim_prefix|>#pragma once
#include <Common/Stopwatch.h>
#include <Common/Scheduler/ISchedulerQueue.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <boost/intrusive/list.hpp>
#include <mutex>
#include <vector>
namespace DB
{
namespace ErrorCodes
{
e... | fim | ClickHouse/ClickHouse | c |
#include <Common/Scheduler/Nodes/PriorityPolicy.h>
#include <Common/Scheduler/Nodes/SchedulerNodeFactory.h>
#include <Common/Scheduler/Nodes/registerSchedulerNodes.h>
namespace DB
{
void registerPriorityPolicy(SchedulerNodeFactory & factory)
{
factory.registerMethod<PriorityPolicy>("priority");
}
}
<|endoftext|... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Scheduler/ISchedulerNode.h>
#include <algorithm>
#include <unordered_map>
#include <vector>
namespace DB
{
namespace ErrorCodes
{
extern const int INVALID_SCHEDULER_NODE;
}
/*
* Scheduler node that implements priority scheduling policy.
* Requests are scheduled in... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/ErrorCodes.h>
#include <Common/Exception.h>
#include <Common/Scheduler/ISchedulerNode.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <boost/noncopyable.hpp>
#include <memory>
#include <mutex>
#include <unordered_map>
namespace DB
{
namespace ErrorCodes
{
... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.