text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> const;
uint64_t getDelayWithJitter(int64_t min_deviation, int64_t max_deviation) const;
private:
uint64_t delay = 0;
};
}
<|fim_prefix|>#pragma once
#include <cstdint>
namespace DB
{
class DelayWithJitter
{
public:
e<|fim_middle|>xplicit DelayWithJitter(int64_t delay_);
uint64_t get... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
/// To prevent this, we provide these `-WithMemoryTracking` aliases to standard containers that use the
/// `AllocatorWithMemoryTracking`, which tracks memory using throwing methods of the `MemoryTracker`.
template <typename T>
using DequeWithMemoryTracking = std::deque<T, AllocatorWithMemoryTracking<T>... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/DimensionalMetrics.h>
#include <Common/SipHash.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteHelpers.h>
#include <IO/Operators.h>
#include <mutex>
#include <shared_mutex>
namespace DimensionalMetrics
{
MetricFamily & MergeFailures = Factory::instance().registerMetric(
"me... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>belValues label_values);
template <typename Func>
void forEachMetric(Func && func) const
{
std::shared_lock lock(mutex);
for (const auto & [label_values, metric] : metrics)
{
func(label_values, *metric);
}
}
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>algorithm::trim_copy(query) + "\n";
res += "```\n\n";
res += "```response title=""Response""\n";
res += boost::algorithm::trim_copy(result) + "\n";
res += "```";
res += "\n\n";
}
return res;
}
String Documentation::introducedInAsString() const
{
if (int... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> * that are not available in the current build (e.g. disabled by a compile-time option), so it should
* not be interpreted as a guarantee that every referenced component is registered in this server.
*
* The description should be represented in Markdown (or just plaintext).
*
* Documentation do... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ilogueBegin_ = true;
return CONTINUE;
case DW_LNS_set_isa:
if (version_ == 2)
{
break; // not supported in version 2
}
isa_ = readULEB(program);
return CONTINUE;
defa... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#if (defined(__ELF__) && !defined(OS_FREEBSD)) || defined(OS_DARWIN)
/*
* Copyright 2012-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* htt... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/DynamicDelay.h>
#include <Common/DelayWithJitter.h>
#include <algorithm>
namespace DB
{
namespace
{
double <|fim_suffix|>>(delay);
}
uint64_t DynamicDelay::getCurrentDelayWithJitter(int64_t min_deviation, int64_t max_deviation) const
{
return DelayWithJitter(static_cast<int64_t>(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> = 0;
double factor_up = 1;
double factor_lower = 1;
};
}
<|fim_prefix|>#pragma o<|fim_middle|>nce
#include <cstdint>
namespace DB
{
/// Maintains dynamically changing delay, convenient to use in periodic tasks.
/// Not thread safe.
class DynamicDelay
{
public:
void setConfiguration(double... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> return watch.elapsedMicroseconds();
else if constexpr (unit == Time::Milliseconds)
return watch.elapsedMilliseconds();
else if constexpr (unit == Time::Seconds)
return watch.elapsedSeconds();
}
~ProfileEventTimeIncrement()
{
watch.stop();
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Elf.h>
#include <Common/Exception.h>
#include <base/unaligned.h>
#include <cstring>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_PARSE_ELF;
}
Elf::Elf(const std::string & path_)
{
in.emplace(path_, 0);
init(in->buffer().begin(), in->buffer().size(), path... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ize; }
size_t size() const { return elf_size; }
/// Obtain build id from SHT_NOTE of section headers (fallback to PT_NOTES section of program headers).
/// Return empty string if does not exist.
/// The string is returned in binary. Note that "readelf -n ./clickhouse-server" prints it in ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>he it will search in PATH, like shell will do.
///
/// Also note, that this (search in PATH) because there is no easy and
/// portable way to get absolute path of argv[0].
/// - on linux there is /proc/self/exec and AT_EXECFN
/// - but on other OSes there is no such... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>(char ** argv);
#endif
<|fim_prefix|>#pragma once
#if !defined(USE_MUSL)
void checkHarmfulEnvir<|fim_middle|>onmentVariables<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>()
{
return std::getenv(NO_PROXY_ENVIRONMENT_VARIABLE); // NOLINT(concurrency-mt-unsafe)
}
ProxyConfiguration buildProxyConfiguration(
ProxyConfiguration::Protocol request_protocol,
const Poco::URI & uri,
const std::string & no_proxy_hosts_string,
bool ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/ProxyConfigurationResolver.h>
namespace DB
{
/*
* Grabs proxy configuration from environment variables (http_proxy and https_proxy).
* */
class EnvironmentProxyConfigurationResolver : <|fim_suffix|>ing_for_https_requests_over_http_proxy_ = false);
ProxyConfiguration... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#if defined(OS_LINUX)
#include <Common/Epoll.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/Stopwatch.h>
#include <base/defines.h>
#include <unistd.h>
namespace DB
{
namespace ErrorCodes
{
extern const int EPOLL_ERROR;
extern const int LOGICAL_ERROR;
}
Epo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma on<|fim_suffix|>nts_out, this function returns an amount of
/// ready events. The timeout argument specifies the number of milliseconds to wait for ready
/// events. Timeout of -1 causes epoll_wait() to block indefinitely, while specifying a timeout
/// equal to zero will return immedi... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <base/types.h>
#include <list>
#include <memory>
#include <unordered_map>
namespace DB
{
/// Tracks equivalence classes of values with transitive merging.
/// When two values are added as equivalent, they are placed in the same class.
/// Merging is transitive: if A==B and B==C, then A, B, C ar... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e, FormatStringHelper<Args...> fmt, Args &&... args)
: Exception(fmt.format(std::forward<Args>(args)...), code), saved_errno(errno)
{
addMessage(", {}", errnoToString(saved_errno));
}
template <typename... Args>
ErrnoException(int code, int with_errno, FormatStringHelper<A... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/CurrentThread.h>
#include <Common/ErrorCodes.h>
#include <Common/Exception.h>
#include <chrono>
/** Previously, these constants were located in one enum.
* But in this case there is a problem: when you add a new constant, you need to recompile
* all translation units that use at leas... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <cstddef>
#include <mutex>
#include <string_view>
#include <vector>
#include <base/defines.h>
#include <base/types.h>
/** Allows to count number of simultaneously happening error codes.
* See also Exception.cpp for incrementing part.
*/
namespace DB
{
namespace ErrorCodes
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Poco/ErrorHandler.h>
#include <Common/Exception.h>
#include <Common/logger_useful.h>
/** ErrorHandler for Poco::Thread,
* that in case of unhandled exception,
* logs exception message and terminates the process.
*/
class KillingErrorHandler : public Poco::ErrorHandler
{
p... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> [&]{ return events_happened > events_waited; }))
{
++events_waited;
return true;
}
return false;
}
};
<|fim_prefix|>#pragma once
#include <cstdint>
#include <mutex>
#include <condition_variable>
/** Allow to subscribe for multiple events and wait for... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>
#if defined(OS_LINUX)
#include <Common/EventFD.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <base/defines.h>
#include <sys/eventfd.h>
#include <unistd.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_PIPE;
extern const int CANNOT_READ_FROM_SOCKET... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>struct EventFD
{
};
}
#endif
<|fim_prefix|>#pragma once
#if defined(OS_LINUX)
#include <cstdint>
namespace DB
{
struct EventFD
{
EventFD();
~EventFD();
/// Both read() and write() are blocking.
/// TODO: add non-blocking flag to ctor.
uint64_t rea<|fim_middle|>d() const;
bo... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/EventNotifier.h>
#include <Common/Exception.h>
#include <boost/functional/hash.hpp>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
std::unique_ptr<EventNotifier> EventNotifier::event_notifier;
EventNotifier & EventNotifier::init()
{
if (event_notifier... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <vector>
#include <mutex>
#include <functional>
#include <set>
#include <map>
#include <memory>
#include <utility>
#include <base/types.h>
#include <Common/HashTable/Hash.h>
namespace DB
{
class EventNotifier
{
public:
struct Handler
{
Handler(
EventN... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/defines.h>
#include <Common/ExponentiallySmoothedCounter.h>
namespace DB
{
/// Event count measurement with exponential smoothing intended for computing time derivatives
class EventRateMeter
{
public:
explicit EventRateMeter(double now, double period_, size_t heating_ ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <base/MemorySanitizer.h>
#include <IO/Operators.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <base/demangle.h>
#include <Core/LogsLevel.h>
#include <Common/AtomicLogger.h>
#include <Common/ErrorCodes.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>xceptionErrorCode(std::exception_ptr e);
/// Returns string containing extra diagnostic info for specific exceptions (like "no space left on device" and "memory limit exceeded")
std::string getExtraExceptionInfo(const std::exception & e);
/// An execution status of any piece of code, contains return cod... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/LogsLevel.h>
#include <Common/Exception.h>
#include <Common/ExceptionExt.h>
#include <Common/LockMemoryExceptionInThread.h>
namespace DB
{
void tryLogCurrentException(LogFrequencyLimiterImpl && logger, const std::string & start_of_message, LogsLevel level)
{
/<|fim_suffix|>of_message,... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ve(logger), message); break;
}
}
else
{
switch (level)
{
case LogsLevel::none: break;
case LogsLevel::test: LOG_TEST(std::move(logger), "{}: {}", start_of_message, message.text); break;
case LogsLev... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cmath>
#include <limits>
namespace DB
{
/** https://en.wikipedia.org/wiki/Exponential_smoothing
*
* Exponentially smoothed average over time is weighted average with weight proportional to negative exponent of the time passed.
* For example, the last value is taken with we... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>us>());
for (const auto & [value, str] : magic_enum::enum_entries<ExternalLoaderStatus>())
out.emplace_back(std::string{str}, static_cast<Int8>(value));
return out;
}
}
<|fim_prefix|>#include <Common/ExternalLoaderStatus.h>
#include <base/EnumReflection.h>
namespace DB
{
std::vector<... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <vector>
#include <base/types.h>
namespace DB
{
enum class ExternalLoaderStatus : int8_t
{
NOT_LOADED, /// Object hasn't been tried to load. This is an initial state.
LOADED, /// Object has been loaded successfully.
FAILED, /// Object has been failed to load.
LOADING, /// Object ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> std::time_t
std::chrono::milliseconds loading_duration{}; /// serialized as UInt64
};
using ExternalModelInfos = std::vector<ExternalModelInfo>;
}
<|fim_prefix|>#pragma once
#include <vector>
#include <base/types.h>
namespace DB
{
/// Details about external machine learning model, used by clickh... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <Common/FailPoint.h>
#include <boost/core/noncopyable.hpp>
#include <condition_variable>
#include <mutex>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
extern const int SUPPORT_IS_DISABLED;
};
#if USE_LIBFIU
static struct InitFiu
{
In... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ilpoint remains enabled after resume, so the next hit will block again.
Pauseable = 3,
};
/// Snapshot of a single failpoint's registration and runtime state.
/// Returned by getFailPoints() for introspection (e.g., the system.fail_points table).
struct FailPointInfo
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
struct RoutineImpl
{
struct SuspendCallback
{
Impl & impl;
void operator()()
{
impl = std::move(impl).resume();
}
};
explicit RoutineImpl(Fn && fn_) : fn(std::move(fn_))
{
}
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>K_DEREGISTER(sctx.valgrind_stack_id);
#endif
void * data = static_cast< char * >(sctx.sp) - sctx.size;
if constexpr (guardPagesEnabled())
memoryGuardRemove(data, page_size);
::free(data);
}
<|fim_prefix|>#include <base/defines.h>
#include <base/MemorySanitizer.h>
#include <Common/for... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> void deallocate(boost::context::stack_context & sctx) const;
private:
const size_t stack_size;
const size_t page_size;
};
<|fim_prefix|>#pragma once
#include <boost/context/stack_context.hpp>
/// This is an implementation of allocator for fibe<|fim_middle|>r stack.
/// The reference implement... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/FieldAccurateComparison.h>
#include <Core/Field.h>
#include <Core/AccurateComparison.h>
#include <Core/DecimalFunctions.h>
#include <Core/CompareHelper.h>
#include <base/demangle.h>
#include <Common/FieldVisitors.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
names... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
bool accurateLess(const Field & left, const Field & right);
bool accurateLessOrEqual(const Field & left, const Field & right);
}
<|fim_prefix|>#pragma once
namespace DB
{
class Field;
bool accurateEqua<|fim_middle|>ls(const Field & left, const Field & right);<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>x::Int256:
return decodeBigInteger<Int256>(buf);
case FieldBinaryTypeIndex::UInt256:
return decodeBigInteger<UInt256>(buf);
case FieldBinaryTypeIndex::Float64:
return decodeValueLittleEndian<Float64>(buf);
case FieldBinaryTypeIndex::Decimal32:
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Field.h>
namespace DB
{
/**
Binary encoding for Fields:
|--------------------------|-----------------------------------------------------------------------------------------------------------------------------<|fim_suffix|>` ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>16>;
template class FieldVisitorConvertToNumber<Float32>;
template class FieldVisitorConvertToNumber<Float64>;
}
<|fim_prefix|>#include <Common/FieldVisitorConvertToNumber.h>
namespace DB
{
/// Explicit template instantiations.
template class FieldVisitorConvertToNumber<Int8>;
template class FieldVisit... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>56>;
extern template class FieldVisitorConvertToNumber<UInt256>;
//extern template class FieldVisitorConvertToNumber<BFloat16>;
extern template class FieldVisitorConvertToNumber<Float32>;
extern template class FieldVisitorConvertToNumber<Float64>;
}
<|fim_prefix|>#pragma once
#include <Common/Exception.... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/FieldVisitorDump.h>
#include <IO/WriteHelpers.h>
#include <IO/Operators.h>
namespace DB
{
template <typename T>
static inline String formatQuotedWithPrefix(T x, const char * prefix)
{
WriteBufferFromOwnString wb;
writeCString(prefix, wb);
writeQuoted(x, wb);
return wb.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Decimal256> & x) const;
String operator() (const AggregateFunctionStateData & x) const;
String operator() (const CustomType & x) const;
String operator() (const bool & x) const;
};
}
<|fim_prefix|>#pragma once
#include <Common/FieldVisitors.h>
namespace DB
{
/** Print readable and unique t... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/FieldVisitorHash.h>
#include <Common/SipHash.h>
namespace DB
{
FieldVisitorHash::FieldVisitorHash(SipHash & hash_) : hash(hash_) {}
void FieldVisitorHash::operator() (const Null &) const
{
UInt8 type = Field::Types::Null;
hash.update(type);
}
void FieldVisitorHash::operator(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/FieldVisitors.h>
class SipHash;
namespace DB
{
/** Updates SipHash by type and value of Field */
class FieldVisitorHash : public St<|fim_suffix|>erator() (const Array & x) const;
void operator() (const Tuple & x) const;
void operator() (const Map & x) const;
v... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>orCodes::LOGICAL_ERROR, "Cannot scale Bools"); }
}
<|fim_prefix|>#include <Common/FieldVisitorScale.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
FieldVisitorScale::FieldVisitorScale(Int64 rhs_) : rhs(rhs_) {}
void FieldVisitorScale::operator() (Int64 & x) const { x *... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> = DecimalField<Decimal32>(x.getValue() * Decimal32(static_cast<int32_t>(rhs)), x.getScale()); }
template <typename T>
requires is_big_int_v<T>
void operator() (T & x) const { x *= rhs; }
};
}
<|fim_prefix|>#pragma once
#include <Common/FieldVisitors.h>
#include <Common/FieldVisitorConvertT... | fim | ClickHouse/ClickHouse | c |
#include <Common/FieldVisitorSum.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
FieldVisitorSum::FieldVisitorSum(const Field & rhs_) : rhs(rhs_) {}
// We can add all ints as unsigned regardless of their actual signedness.
bool FieldVisitorSum::operator() (Int64 & x) const { return t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/FieldVisitors.h>
#include <Common/FieldVisitorConvertToNumber.h>
namespace DB
{
/** Implements `+=` operation.
* Returns false if the result is zero.
*/
class FieldVisitorSum : public StaticVisitor<bool>
{
private:
const Field & rhs;
public:
explicit FieldVisit... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rToCastedLiteral::operator() (const DecimalField<Decimal128> & x) const
{
return FieldVisitorToString()(x) + "::Decimal128(" + std::to_string(x.getScale()) + ")";
}
String FieldVisitorToCastedLiteral::operator() (const DecimalField<Decimal256> & x) const
{
return FieldVisitorToString()(x) + "::De... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/FieldVisitors.h>
namespace DB
{
/// Similar to FieldVisitorToString, but in ambiguous cases appends an explicit SQL-like
/// ::Type suffix to the printed value, so that parsing the result back produces a Field
/// of the exact same type as the original.
///
/// For exampl... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nst { return formatAsString(x); }
String FieldVisitorToJSONElement::operator() (const Int256 & x) const { return formatAsString(x); }
String FieldVisitorToJSONElement::operator() (const UUID & x) const { return formatAsString(x); }
String FieldVisitorToJSONElement::operator() (const IPv4 & x) const { retu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/FieldVisitors.h>
namespace DB
{
/** Prints Field as JSON element */
class FieldVisitorToJSONElement : public StaticVisitor<String><|fim_suffix|>x) const;
String operator() (const UInt128 & x) const;
String operator() (const UInt256 & x) const;
String operator()... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>OwnString wb;
wb << '{';
for (auto it = object.begin(); it != object.end(); ++it)
{
if (it != object.begin())
wb << ", ";
writeDoubleQuoted(it->first, wb);
wb << ": " << applyVisitor(FieldVisitorToJSONElement(), it->second);
}
wb << '}';
retur... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/FieldVisitors.h>
namespace DB
{
/** Prints Field as literal in SQL query */
class FieldVisitorToString : public StaticVisitor<String>
{
public:
String operator() (const Null & x) const;
String operator() (const UInt64 & x) const;
String operator() (const U<|fim... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nst size_t size = x.size();
writeBinary(size, buf);
for (const auto & [key, value] : x)
{
const UInt8 type = value.getType();
writeBinary(type, buf);
writeBinary(key, buf);
Field::dispatch([&buf] (const auto & val) { FieldVisitorWriteBinary()(val, buf); }, valu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> operator() (const DecimalField<Decimal64> & x, WriteBuffer & buf) const;
void operator() (const DecimalField<Decimal128> & x, WriteBuffer & buf) const;
void operator() (const DecimalField<Decimal256> & x, WriteBuffer & buf) const;
void operator() (const AggregateFunctionStateData & x, WriteBu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>on-const values.
template <typename Visitor, typename F>
auto applyVisitor(Visitor && visitor, F && field)
{
return Field::dispatch(std::forward<Visitor>(visitor),
std::forward<F>(field));
}
template <typename Visitor, typename F1, typename F2>
auto applyVisitor(Visitor && visitor, F1 && fiel... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/FileChecker.h>
#include <Common/escapeForFileName.h>
#include <Common/logger_useful.h>
#include <Common/ErrorCodes.h>
#include <Disks/IDisk.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Storages/CheckResults.h>
#include <Common/Logger.h>
#include <map>
#include <base/types.h>
#include <memory>
#include <mutex>
namespace Poco { class Logger; }
namespace DB
{
class IDisk;
using DiskPtr = std::shared_ptr<IDisk>;
class WriteBuffer;
/// Stores the sizes of all colu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/FileRenamer.h>
#include <Common/DateLUT.h>
#include <Common/Exception.h>
#include <Common/re2.h>
#include <chrono>
#include <filesystem>
#include <map>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/replace.hpp>
namespace fs = std::filesystem;
namespace DB
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include<|fim_suffix|> * Example:
* Pattern - "processed_%f_%t%e"
* Original filename - "sample.csv"
* New filename - "processed_sample_1683405960646224.csv"
*/
class FileRenamer
{
public:
FileRenamer();
explicit FileRenamer(const... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Poco/Timestamp.h>
#inclu<|fim_suffix|>filesystem>
#include <Common/filesystemHelpers.h>
class FileUpdatesTracker
{
private:
std::string path;
Poco::Timestamp known_time;
public:
explicit FileUpdatesTracker(const std::string & path_)
: path(path_)
, kn... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstdint>
#include <bit>
inline float convertFloat16ToFloat32(uint16_t float16_value)
{
uint32_t old_sign = (float16_value & 0b10000000'00000000);
uint32_t old_exponent = (float16_value & 0b01111100'00000000) >> 10;
uint32_t old_mantissa = float16_value & 0b00000011'11... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <array>
/* NOTE: It cannot be larger right now, since otherwise it
* will not fit into minimal PIPE_BUF (512) in TraceCollec<|fim_suffix|>ers = std::array<void *, FRAMEPOINTER_CAPACITY>;
<|fim_middle|>tor.
*/
static constexpr size_t FRAMEPOINTER_CAPACITY = 45;
using FramePoint<|... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> = getLogger("EmotionalDict");
LOG_TRACE(log, "Loading embedded emotional dictionary");
std::string_view resource(reinterpret_cast<const char *>(resource_tonality_ru_zst), std::size(resource_tonality_ru_zst));
if (resource.empty())
throw Exception(ErrorCodes::FILE_DOESNT_EXIST, "There... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_NLP
#include <Common/logger_useful.h>
#include <string_view>
#include <unordered_map>
#include <Common/Arena.h>
#include <Common/HashTable/HashMap.h>
#include <Common/StringUtils.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/ReadBufferFromString.h>
#inclu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> {Category::Array, "Arrays"},
{Category::Bit, "Bit"},
{Category::Bitmap, "Bitmap"},
{Category::Comparison, "Comparison"},
{Category::Conditional, "Conditional"},
{Category::DateAndTime, "Dates and Times"},
{Category::Decimal, "Decimal"},
{Cate... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>he quantile level. 0.5 is the median.", {"Float*"}}
ReturnedValue returned_value {}; /// E.g. {"Starting position in bytes and counting from 1, if the substring was found.", {"(U)Int*"}}
Examples examples {}; ///
IntroducedIn introduced_in {VERSION_UNKNOWN}... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ng)
{
case LoadBalancing::NEAREST_HOSTNAME:
return true;
case LoadBalancing::HOSTNAME_LEVENSHTEIN_DISTANCE:
return true;
case LoadBalancing::IN_ORDER:
return false;
case LoadBalancing::RANDOM:
return false;
case Lo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>dBalancing & operator=(const GetPriorityForLoadBalancing & other)
{
if (this != &other)
{
hostname_prefix_distance = other.hostname_prefix_distance;
hostname_levenshtein_distance = other.hostname_levenshtein_distance;
load_balancing = other.load_bala... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ig.protocol);
s.update(k.proxy_config.tunneling);
s.update(k.proxy_config.original_request_protocol);
return s.get64();
}
};
static IExtendedPool::Ptr
createConnectionPool(ConnectionGroup::Ptr group, std::string host, UInt16 port, bool secure, ProxyConfiguration proxy_configur... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ConnectionTimeouts.h>
#include <Common/ProfileEvents.h>
#include <Common/CurrentMetrics.h>
#include <Common/ProxyConfiguration.h>
#include <Common/logger_useful.h>
#include <base/defines.h>
#include <Poco/Timespan.h>
#include <Poco/Net/HTTPClientSession.h>
#include <cstdint>... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> "see <http_forbid_headers>", entry.name);
for (const auto & header_regex : forbidden_headers_regexp)
if (re2::RE2::FullMatch(normalized_name, header_regex))
throw Exception(ErrorCodes::BAD_ARGUMENTS, "HTTP header \"{}\" is forbidden in configuration f... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>uration & config);
void checkAndNormalizeHeaders(HTTPHeaderEntries & entries) const;
private:
std::unordered_set<std::string> forbidden_headers;
std::vector<std::string> forbidden_headers_regexp;
mutable std::mutex mutex;
};
}
<|fim_prefix|>#pragma o<|fim_middle|>nce
#include <IO/HTTPH... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/HashTable/HashMap.h>
#include <Common/HashTable/ClearableHashSet.h>
template <typename Key, typename Mapped, typename Hash>
struct ClearableHashMapCell : public ClearableHashTableCell<Key, HashMapCell<Key, Mapped, Hash, ClearableHashSetState>>
{
using Base = ClearableH... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <type_traits>
#include <Common/HashTable/HashSet.h>
/** A hash table that allows you to clear the table in O(1).
* Even simpler than HashSet: Key and Mapped must be POD-types.
*
* Instead of this class, you could just use the pair (version, key) in the HashSet as the key
*... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/HashTable/ClearableHashSet.h>
#include <Common/HashTable/FixedHashTable.h>
template <typename Key>
struct FixedClearableHashTableCell
{
using State = ClearableHashSetState;
using value_type = Key;
using mapped_type = VoidMapped;
UInt32 version;
FixedC... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>HashTableAllocator>
using FixedImplicitZeroHashMap = FixedHashMap<
Key,
Mapped,
FixedHashMapImplicitZeroCell<Key, Mapped>,
FixedHashTableStoredSize<FixedHashMapImplicitZeroCell<Key, Mapped>>,
Allocator>;
template <typename Key, typename Mapped, typename Allocator = HashTableAllocator>... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|><|fim_prefix|>#pragma once
#<|fim_middle|>include <Common/HashTable/FixedHashTable.h>
template <typename Key, typename Allocator = HashTableAllocator>
class FixedHashSet : public FixedHashTable<Key, FixedHashTableCell<Key>, FixedHashTableStoredSize<FixedHashTableCell<Key>>, Allocator>
{
public:
usin... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> min = NUM_CELLS - 1;
size_t max = 0;
protected:
friend class const_iterator;
friend class iterator;
friend class Reader;
using Self = FixedHashTable;
Cell * buf; /// A piece of memory for all elements.
void alloc() { buf = reinterpret_cast<Cell *>(Allocator::alloc(NUM_CELL... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>(key >> 11) | (key << 53));
key = key + (key << 6);
key = key ^ ((key >> 22) | (key << 42));
return static_cast<UInt32>(key);
}
/// For containers.
template <typename T, UInt64 salt = 0>
struct IntHash32
{
size_t operator() (const T & key) const
{
if constexpr (is_big_int_v<... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/HashTable/Hash.h>
#include <Common/HashTable/HashTable.h>
#include <Common/HashTable/HashTableAllocator.h>
#include <Common/HashTable/Prefetching.h>
/** NOTE HashMap could only be used for memmoveable (position independent) types.
* Example: std::string is not position i... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ash<Key, Hash>, Hash, Grower, Allocator>;
template <
typename Key,
typename Hash = DefaultHash<Key>,
typename Grower = TwoLevelHashTableGrower<>,
typename Allocator = HashTableAllocator>
using TwoLevelHashSetWithSavedHash = TwoLevelHashSetTable<Key, HashSetCellWithSavedHash<Key, Hash>, Ha... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>:operator()(x); }
HashTable()
{
if (Cell::need_zero_value_storage)
this->zeroValue()->setZero();
alloc(grower);
}
explicit HashTable(const Grower & grower_)
: grower(grower_)
{
if (Cell::need_zero_value_storage)
this->zeroValue... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tor, initial_bytes>;
<|fim_prefix|>#pragma once
#include <Common/Allocator.h>
/**
* We are going to use the entire memory we allocated when resizing a hash
* table,<|fim_middle|> so it makes sense to pre-fault the pages so that page faults don't
* interrupt the resize loop. Set the allocator para... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>S_INLINE keyHolderDiscardKey(DB::ArenaKeyHolder &)
{
}
namespace DB
{
/** SerializedKeyHolder is a key holder for a std::string_view key that is already
* serialized to an Arena. The key must be the last allocation in this Arena,
* and is discarded by rolling back the allocation.
*/
struct Seriali... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lements<HashTable<Ts...>> : std::true_type
{
};
template <typename... Ts>
struct HasConstructorOfNumberOfElements<TwoLevelHashTable<Ts...>> : std::true_type
{
};
template <template <typename> typename Method, typename Base>
struct HasConstructorOfNumberOfElements<Method<Base>> : HasConstructorOfNumberOf... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>r>
using PackedHashMap = HashMapTable<Key, PackedHashMapCell<Key, Mapped, Hash, HashTableNoState>, Hash, Grower, Allocator>;
<|fim_prefix|>#pragma once
/// Packed versions HashMap, please keep in sync with HashMap.h
#include <Common/HashTable/HashMap.h>
/// A pair that does not initialize the elements,... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>clamp<size_t>(look_ahead, min_look_ahead_value, max_look_ahead_value);
}
static constexpr size_t getInitialLookAheadValue() { return min_look_ahead_value; }
static constexpr size_t iterationsToMeasure() { return iterations_to_measure; }
private:
static constexpr size_t iterations_to_mea... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/HashTable/HashMap.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NO_AVAILABLE_DATA;
extern const int INCORRECT_DATA;
extern const int TOO_LARGE_AR<|fim_suffix|>
if (size > capacity)
throw DB::Ex... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/HashTable/HashMap.h>
#include <Common/HashTable/HashTableAllocator.h>
#include <Common/HashTable/StringHashTable.h>
template <typename Key, typename TMapped>
struct StringHashMapCell : public HashMapCell<Key, TMapped, StringHashTableHash, HashTableNoState>
{
using Base ... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.