text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#include <Compression/CompressionFactory.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/IDataType.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/WriteHelpers.h>
#include <Parsers/ExpressionElementParsers.h>
#include <Parsers/IParser.h>
#include <Parsers/TokenIterator.h>
#include <Com... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>(UInt64) * 8 + 1));
}
<|fim_prefix|>#include <Compression/FFOR.h>
#include <random>
#include <gtest/gtest.h>
using namespace DB;
namespace
{
template <typename T, UInt16 values>
using InputGeneratorFn = std::function<T(T * in, UInt8 bits)>;
template <typename T>
T calculateMaxValue(T min, UInt8 bits... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>auto acls = num_to_acl[acl_id];
num_to_acl.erase(acl_id);
acl_to_num.erase(acls);
usage_counter.erase(acl_id);
}
}
}
<|fim_prefix|>#include <Coordination/ACLMap.h>
#include <Common/SipHash.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
size_t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>st Coordination::ACLs & acls);
/// Convert number to ACL vector. If number is unknown for map
/// than throws LOGICAL ERROR
Coordination::ACLs convertNumber(ACLId acls_id) const;
/// Mapping from numbers to ACLs vectors. Used during serialization.
const NumToACLMap & getMapping() cons... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <libnuraft/ptr.hxx>
#include <Common/ThreadPool_fwd.h>
#include <Common/ConcurrentBoundedQueue.h>
#include <Common/SharedMutex.h>
#include <atomic>
#include <map>
#include <optional>
#include <variant>
#include <unordered_map>
#include <unordered_set>
#include <future>
#include <ve... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>r::operator!=(const ConstIterator & other) const
{
return !(*this == other);
}
// --- CompactChildrenSet implementation ---
CompactChildrenSet::~CompactChildrenSet()
{
if (isSet())
delete asSet();
}
CompactChildrenSet::CompactChildrenSet(const CompactChildrenSet & other)
{
if (other... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <absl/container/flat_hash_set.h>
#include <base/StringViewHash.h>
#include <cstddef>
#include <string_view>
namespace DB
{
using ChildrenSet = absl::flat_hash_set<std::string_view, StringViewHash>;
/// A compact representation of a set of children for Keeper nodes.
/// Uses a ta... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>cp_port_secure=", buf);
write_int(tcp_port_secure);
}
writeText("four_letter_word_allow_list=", buf);
writeText(four_letter_word_allow_list, buf);
buf.write('\n');
}
KeeperConfigurationPtr
KeeperConfiguration::loadFromConfig(const Poco::Util::AbstractConfiguration & config, bool ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ttingsFields.h>
#include <IO/WriteBufferFromString.h>
namespace Poco
{
namespace Util
{
class AbstractConfiguration;
}
}
namespace DB
{
struct CoordinationSettingsImpl;
/// List of available types supported in CoordinationSettings object
#define COORDINATION_SETTINGS_SUPPORTED_TYPES(CLASS_NAME, M) \
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#define KE<|fim_suffix|>H "/var/lib/clickhouse-keeper/"
<|fim_middle|>EPER_DEFAULT_PAT<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>:toCode(token); commands.contains(code))
allow_list.push_back(code);
else
LOG_WARNING(log, "Find invalid keeper 4lw command {} when initializing, ignore it.", token);
}
}
String RuokCommand::run()
{
return "imok";
}
namespace
{
using StringBuffer = DB::WriteBuffe... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#include <atomic>
#include <memory>
#include <unordered_map>
#include <vector>
#include <base/types.h>
#include <boost/noncopyable.hpp>
namespace DB
{
class KeeperDispatcher;
struct IFourLetterCommand;
using FourLetterCommandPtr = std::shared_ptr<DB::IFourLetterCommand>;
/// Just ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>oc(buf_size);
pack.get(buf_local);
nuraft::ptr<nuraft::log_entry> le = nuraft::log_entry::deserialize(*buf_local);
{
std::lock_guard l(logs_lock);
logs[cur_idx] = le;
}
}
{
std::lock_guard l(logs_lock);
auto entry = logs.upp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <atomic>
#include <map>
#include <mutex>
#include <Core/Types.h>
#include <base/defines.h>
#include <libnuraft/log_store.hxx>
namespace DB
{
class InMemoryLogStore : public nuraft::log_store
{
public:
InMemoryLogStore();
uint64_t start_index() const override;
uint64_... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <base/types.h>
#include <Common/Exception.h>
#include <optional>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
/// Keeper server related information for different 4lw commands
struct Keeper4LWInfo
{
bool is_leader;
bool is_observer;
bool is_follower;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>athsWatched"] = { paths_watched, "The number of different paths watched by the clients of ClickHouse Keeper." };
auto keeper_log_info = keeper_dispatcher.getKeeperLogInfo();
new_values["KeeperLastLogIdx"] = { keeper_log_info.last_log_idx, "Index of the last log stored in ClickHouse Keeper." };
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#in<|fim_suffix|> new_values);
class KeeperAsynchronousMetrics : public AsynchronousMetrics
{
public:
KeeperAsynchronousMetrics(
ContextPtr context_,
unsigned update_period_seconds,
const ProtocolServerMetricsFunc & protocol_server_metrics_func_,
bool upd... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ttings = keeper_context->getFixedCoordinationSettings();
auto max_retries_on_init = coordination_settings[CoordinationSetting::disk_move_retries_during_init].value;
auto retries_sleep = std::chrono::milliseconds(coordination_settings[CoordinationSetting::disk_move_retries_wait_ms]);
auto run_w... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>read) and
/// finishSession (from dead session cleaner) may invoke copies of the same callback
/// concurrently for the same session.
/// Returns true if the response was retained in some kind of queue and KeeperDispatcher::onResponseDeallocated will be called for it later.
/// It is valid to always retur... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>latency.store(0, std::memory_order_relaxed);
}
void KeeperConnectionStats::resetRequestCounters()
{
packets_received.store(0, std::memory_order_relaxed);
packets_sent.store(0, std::memory_order_relaxed);
}
}
<|fim_prefix|>#include <atomic>
#include <Coordination/KeeperConnectionStats.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nd,
/// otherwise maybe microsecond is better
std::atomic_uint64_t total_latency;
std::atomic_uint64_t max_latency;
std::atomic_uint64_t min_latency;
/// last operation latency
std::atomic_uint64_t last_latency;
std::atomic_uint64_t count;
};
}
<|fim_prefix|>#pragma once
#i... | fim | ClickHouse/ClickHouse | c |
#include <Common/DimensionalMetrics.h>
#include <Common/HistogramMetrics.h>
#include <Common/ProfileEvents.h>
#include <Common/CurrentMetrics.h>
/// Events which are useful for Keeper.
/// New events should be added manually.
#define APPLY_FOR_KEEPER_PROFILE_EVENTS(M) \
M(FileOpen) \
M(Seek) \
M(ReadBuffer... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
namespace DB
{
/// left for backwards compatibility
enum class KeeperApiVersion : uint8_t
{
ZOOKEEPER_COMPATIBLE = 0,
<|fim_suffix|>_system_path + "/availability_zone";
}
<|fim_middle|> WITH_FILTERED_LIST,
WITH_MULTI_READ,
WITH_CHECK_NOT_EXISTS,
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <atomic>
#include <chrono>
#include <Coordination/KeeperContext.h>
#include <Coordination/CoordinationSettings.h>
#include <Coordination/KeeperSnapshotManager.h>
#include <Coordination/Defines.h>
#include <Disks/DiskLocal.h>
#include <Interpreters/Context.h>
#include <IO/S3/Credentials.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/ZooKeeper/KeeperFeatureFlags.h>
#include <Common/ZooKeeper/ZooKeeperConstants.h>
#include <Common/CacheLine.h>
#include <Common/SharedMutex.h>
#include <IO/WriteBufferFromString.h>
#include <base/defines.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <atomic>
#inc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Coordination/KeeperDispatcher.h>
#if USE_NURAFT
#include <Common/ProfiledLocks.h>
#include <libnuraft/async.hxx>
#include <Poco/Path.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <base/hex.h>
#include <Common/OpenTelemetryTraceContext.h>
#include <Common/OpenTelemetryTracingContex... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>D(int64_t session_timeout_ms);
/// Register session and subscribe for responses with callback.
/// The callback must be safe for concurrent invocation — see ZooKeeperResponseCallback.
void registerSession(int64_t session_id, ZooKeeperResponseCallback callback);
/// Call if we don't need ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> ProfiledSharedLock lock(changelog_lock, ProfileEvents::KeeperChangelogLockWaitMicroseconds);
changelog.getKeeperLogInfo(log_info);
}
std::vector<KeeperChangelogStatus> KeeperLogStore::getChangelogsStatus() const
{
ProfiledSharedLock lock(changelog_lock, ProfileEvents::KeeperChangelogLockWaitMic... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <libnuraft/log_store.hxx>
#include <Core/Types.h>
#include <Common/SharedMutex.h>
#include <Coordination/Changelog.h>
#include <Coordination/KeeperContext.h>
#include <Coordination/Keeper4LWInfo.h>
#include <base/defines.h>
namespace DB
{
/// Wrapper around Changelog class. Implements RAFT log s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> ThreadGroupSwitcher switcher(thread_group, ThreadName::KEEPER_READ);
threadFunction();
});
}
catch (...)
{
tryLogCurrentException("KeeperReadThreadPool", "Failed to create thread", LogsLevel::fatal);
std::abort();
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>n;
ExecuteRequestsFunction execute_requests;
void threadFunction();
};
}
<|fim_prefix|>#pragma once
#include <atomic>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <thread>
#include <Common/CacheLine.h>
#include <Common/ThreadPool.h>
#include <Coordination/Coord... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> ClusterUpdateActions out;
for (std::string_view leaving_server : leaving_arr)
{
int32_t id = 0;
if (!tryParse(id, leaving_server))
return {};
if (remove_ids.contains(id))
continue;
if (auto ptr = cfg->get_server(id))
out.em... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s leavingToClusterUpdates(const ClusterConfigPtr & cfg, std::string_view leaving);
String serializeClusterConfig(const ClusterConfigPtr & cfg, const ClusterUpdateActions & updates = {});
}
<|fim_prefix|>#pragma <|fim_middle|>once
#include <Coordination/KeeperSnapshotManager.h>
#include <Coordination/RaftS... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Coordination/KeeperRequestDispatcher.h>
#if USE_NURAFT
#include <Coordination/CoordinationSettings.h>
#include <Common/setThreadName.h>
#include <Common/CurrentMetrics.h>
#include <Common/ProfileEvents.h>
#include <Common/HistogramMetrics.h>
#include <Common/MemoryTracker.h>
#include <Common/M... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_NURAFT
#include <Common/CacheLine.h>
#include <Common/NonblockingBoundedQueue.h>
#include <Coordination/KeeperServer.h>
#include <Interpreters/OpenTelemetrySpanLog.h>
extern template class NonblockingBoundedQueue<DB::KeeperRequestForSession>;
extern template cl... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Coordination/KeeperRequestDispatcherOld.h>
#if USE_NURAFT
#include <Common/ProfiledLocks.h>
#include <libnuraft/async.hxx>
#include <Poco/Path.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <base/hex.h>
#include <Common/OpenTelemetryTraceContext.h>
#include <Common/OpenTelemetryTra... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_NURAFT
#include <Interpreters/OpenTelemetrySpanLog.h>
#include <Common/ThreadPool.h>
#include <Common/ConcurrentBoundedQueue.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <functional>
#include <unordered_set>
#include <Coordination/KeeperServer.h>
#in... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> {
LOG_TRACE(log, "Logs not preprocessed, ProcessReq callback: waiting for preprocessing");
keeper_context->waitLocalLogsPreprocessedOrShutdown();
}
else
{
LOG_TRACE(log, "Logs not preprocessed, Pro... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Common/Stopwatch.h>
#include <Coordination/InMemoryLogStore.h>
#include <Coordination/KeeperStateMachine.h>
#include <Coordination/KeeperStateManager.h>
#include <libnuraft/raft_params.hxx>
#include <libnuraft/raft_server.hxx>
#include <Poco/Util/AbstractConfiguration.h>
#include <Coordination/K... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <filesystem>
#include <memory>
#include <Compression/CompressedReadBuffer.h>
#include <Compression/CompressedWriteBuffer.h>
#include <Coordination/CoordinationSettings.h>
#include <Coordination/KeeperCommon.h>
#include <Coordination/KeeperConstants.h>
#include <Coordination/KeeperContext.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>};
using SnapshotFileInfoPtr = std::shared_ptr<SnapshotFileInfo>;
#if USE_ROCKSDB
using KeeperStorageSnapshotPtr = std::variant<std::shared_ptr<KeeperStorageSnapshot<KeeperMemoryStorage>>, std::shared_ptr<KeeperStorageSnapshot<KeeperRocksStorage>>>;
#else
using KeeperStorageSnapshotPtr = std::variant<st... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Coordination/KeeperSnapshotManagerS3.h>
#if USE_AWS_S3
#include <Core/UUID.h>
#include <Common/Exception.h>
#include <Common/setThreadName.h>
#include <Disks/IDisk.h>
#include <IO/S3/getObjectInfo.h>
#include <IO/S3/Credentials.h>
#include <IO/WriteBufferFromS3.h>
#include <IO/ReadBufferFrom... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#include <Poco/Util/AbstractConfiguration.h>
#include <Common/MultiVersion.h>
#include <Common/Macros.h>
#include <Coordination/KeeperSnapshotManager.h>
#if USE_AWS_S3
#include <Common/ConcurrentBoundedQueue.h>
#include <Common/ThreadPool.h>
#endif
namespace DB
{
#i... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>of XID
auto buffer_position = buffer.getPosition();
buffer.seek(length - sizeof(uint32_t), SEEK_CUR);
if (request_end_position)
*request_end_position = buffer.getPosition();
using enum ZooKeeperLogSerializationVersion;
ZooKeeperLogSerializationVersion version = INITIAL;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ContextPtr keeper_context;
KeeperSnapshotManagerS3 * snapshot_manager_s3;
virtual KeeperResponseForSession processReconfiguration(const KeeperRequestForSession & request_for_session)
= 0;
};
/// ClickHouse Keeper state machine. Wrapper for KeeperStorage.
/// Responsible for entries comm... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Coordination/KeeperStateManager.h>
#include <filesystem>
#include <Coordination/Defines.h>
#include <Common/DNSResolver.h>
#include <Common/Exception.h>
#include <Common/SipHash.h>
#include <Common/isLocalAddress.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <IO/ReadBuffe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>figFromLogStore() const;
// TODO (myrrc) This should be removed once "reconfig" is stabilized
ClusterUpdateActions getRaftConfigurationDiff(const Poco::Util::AbstractConfiguration & config, const CoordinationSettings & coordination_settings) const;
std::optional<AuthenticationData> getAuthen... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ncommittedStateForSnapshot copyUncommittedStateAfter(int64_t last_log_idx) const;
/// Like `copyUncommittedStateAfter`, but removes the returned transactions
/// and deltas from this storage instead of copying them.
UncommittedStateForSnapshot detachUncommittedStateAfter(int64_t last_log_idx)... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ocksDBContainer<KeeperRocksNode>>;
#endif
}
<|fim_prefix|>#pragma once
#include "config.h"
namespace DB
{
struct KeeperMemNode;
struct KeeperRocksNode;
template<typename TContainer>
class KeeperStorage;
template <class V>
class SnapshotableHashTable;
template <class V>
struct RocksDBContainer;
usi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>static_cast<LogsLevel>(level_);
LOG_IMPL(log, db_level, LEVELS.at(db_level), fmt::runtime(msg));
}
void set_level(int level_) override
{
level_ = std::min(LEVEL_MAX, std::max(LEVEL_MIN, level_));
level = static_cast<LogsLevel>(level_);
log->setLevel(static_cast... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>")
return std::nullopt;
out.learner = parts[2] == "learner";
if (with_server_type)
return out;
const std::string_view priority = parts[3];
if (!tryParse(out.priority, priority))
return std::nullopt;
if (out.priority < 0)
return std::nullopt;
return... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/defines.h>
#include <base/types.h>
#include <fmt/format.h>
#include <libnuraft/srv_config.hxx>
#include <optional>
#include <variant>
#include <vector>
namespace DB
{
// default- and copy-constructible version of nuraft::srv_config
struct RaftServerConfig
{
int id{};
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rFromMemory.h>
#include <libnuraft/nuraft.hxx>
namespace DB
{
class ReadBufferFromNuraftBuffer : public ReadBufferFromMemory
{
public:
explicit ReadBufferFromNuraftBuffer(nuraft::ptr<nuraft::buffer> buffer)
: ReadBufferFromMemory(buffer->data_begin(), buffer->size())
{}
explicit Rea... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Coordination/KeeperContext.h>
#include <Disks/DiskLocal.h>
#include <IO/WriteBufferFromString.h>
#include <IO/ReadBufferFromString.h>
#include <rocksdb/convenience.h>
#include <rocksdb/options.h>
#include <rocksdb/status.h>
#include <rocksdb/table.h>
#include <rocksdb/snapshot.h>
#... | fim | ClickHouse/ClickHouse | c |
#include <Coordination/SessionExpiryQueue.h>
#include <Common/logger_useful.h>
namespace DB
{
bool SessionExpiryQueue::remove(int64_t session_id)
{
std::lock_guard lock(mutex);
auto session_it = session_to_expiration_time.find(session_id);
if (session_it == session_to_expiration_time.end())
return... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>64_t> session_to_expiration_time;
/// Expire time -> session expire near this time
std::map<int64_t, std::unordered_set<int64_t>> expiry_to_sessions;
int64_t expiration_interval;
mutable std::mutex mutex;
static int64_t getNowMilliseconds()
{
using namespace std::chrono... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/HashTable/HashMap.h>
#include <Common/ArenaUtils.h>
#include <list>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
template<typename V>
struct ListNode
{
std::string_view key;
V value;
struct
{
uint64_t active_in_map : 1;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Coordination/SummingStateMachine.h>
#include <cstring>
namespace DB
{
static constexpr int MAX_SNAPSHOTS = 3;
static int64_t deserializeValue(nuraft::buffer & buffer)
{
nuraft::buffer_serializer bs(buffer);
int64_t result = 0;
memcpy(&result, bs.get_raw(buffer.size()), sizeof(resu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>umbers.
std::map<uint64_t, nuraft::ptr<SingleValueSnapshotContext>> snapshots;
// Mutex for `snapshots_`.
std::mutex snapshots_lock;
};
}
<|fim_prefix|>#pragma once
#include <libnuraft/nuraft.hxx>
#include <Core/Types.h>
#include <atomic>
#include <map>
#include <mutex>
namespace DB
{
//... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Coordination/WriteBufferFromNuraftBuffer.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_WRITE_AFTER_END_OF_BUFFER;
}
void WriteBufferFromNuraftBuffer::nextImpl()
{
if (finalized)
throw Exception(ErrorCodes::CANNOT_WRITE_AFTER_END... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>~WriteBufferFromNuraftBuffer() override;
private:
void finalizeImpl() final;
void nextImpl() override;
nuraft::ptr<nuraft::buffer> buffer;
static constexpr size_t initial_size = 32;
static constexpr size_t size_multiplier = 2;
};
}
<|fim_prefix|>#pragma once
#include <IO/WriteBuf... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>result->path, in);
Coordination::read(result->data, in);
Coordination::read(result->acls, in);
Coordination::read(result->is_ephemeral, in);
Coordination::read(result->parent_cversion, in);
result->restored_from_zookeeper_log = true;
return result;
}
Coordination::ZooKeeperReques... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include <memory>
namespace Poco
{
class Logger;
}
using LoggerPtr = std::shared_ptr<Poco::Logger>;
namespace DB
{
template<<|fim_suffix|> std::string & snapshot_path, LoggerPtr log);
template<typename Storage>
void deserializeKeeperStorageFromSnapshotsDir(Storage & sto... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/Exception.h>
#include <Coordination/CompactChildrenSet.h>
#include <string_view>
using namespace DB;
/// We need stable string data that outlives insert/erase operations,
/// similar to how SnapshotableHashTable's GlobalArena works in production.
static constexp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_NURAFT
#include <Coordination/tests/gtest_coordination_common.h>
#include <Coordination/InMemoryLogStore.h>
#include <Coordination/SummingStateMachine.h>
#include <Coordination/KeeperContext.h>
#include <Coordination/KeeperConstants.h>
#include <Coordination/KeeperStorage.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include "config.h"
#if USE_NURAFT
#include <Coordination/tests/gtest_coordination_common.h>
#include <Coordination/KeeperLogStore.h>
#include <Common/ZooKeeper/ZooKeeperCommon.h>
#include <thread>
template<typename TestType>
class CoordinationChangelogTest : public ::testing::Test
{
public:
stat... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Coordination/tests/gtest_coordination_common.h>
#if USE_NURAFT
#include <Coordination/WriteBufferFromNuraftBuffer.h>
#include <Coordination/KeeperStateMachine.h>
#include <Coordination/KeeperStorage.h>
LogEntryPtr getLogEntry(const std::string & s, size_t term)
{
DB::WriteBufferFromNuraft... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_NURAFT
#include <filesystem>
#include <Coordination/ACLMap.h>
#include <Coordination/CoordinationSettings.h>
#include <Coordination/KeeperContext.h>
#include <Coordination/KeeperStorage_fwd.h>
#include <Coordination/KeeperCommon.h>
#include <Common/ZooKeeper/Z... | fim | ClickHouse/ClickHouse | c |
#include "config.h"
#if USE_NURAFT
#include <Coordination/tests/gtest_coordination_common.h>
#include <Coordination/KeeperSnapshotManager.h>
#include <Coordination/KeeperStateMachine.h>
#include <Coordination/SnapshotableHashTable.h>
#include <Coordination/KeeperStorage.h>
#include <Common/SipHash.h>
#include <Commo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/ZooKeeper/IKeeper.h>
#include "config.h"
#if USE_NURAFT
#include <Coordination/tests/gtest_coordination_common.h>
#include <Coordination/KeeperStorage.h>
#include <Common/ZooKeeper/Types.h>
#include <Common/ZooKeeper/ZooKeeperCommon.h>
#include <unordered_set>
TYPED_TEST(CoordinationT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <cmath>
#include <limits>
#include <base/DecomposedFloat.h>
#include <Core/Defines.h>
#include <Core/Types.h>
#include <base/extended_types.h>
#include <Common/NaNUtils.h>
/** Preceptually-correct number comparisons.
* Example: Int8(-1) != UInt8(255)
*/
namespace accurate
{
usi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_task_types.push_back(task_type);
}
running_tasks.erase(task_ptr);
}
tasks_cond_var.notify_one();
}
void BackgroundSchedulePool::scheduleDelayedTask(TaskInfo & task, size_t ms, std::lock_guard<std::mutex> & /* task_schedule_mutex_lock */) TSA_REQUIRES(task.schedule_mutex)
{
P... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <atomic>
#include <condition_variable>
#include <functional>
#include <map>
#include <mutex>
#include <unordered_set>
#include <vector>
#include <Interpreters/StorageID.h>
#include <base/defines.h>
#include <boost/noncopyable.hpp>
#include <Poco/Notification.h>
#include <Poco/NotificationQueue.h>... | fim | ClickHouse/ClickHouse | c |
#include <Core/BackgroundSchedulePoolTaskHolder.h>
#include <Core/BackgroundSchedulePool.h>
#include <base/defines.h>
namespace DB
{
///
/// BackgroundSchedulePoolTaskHolder
///
BackgroundSchedulePoolTaskHolder::BackgroundSchedulePoolTaskHolder() = default;
BackgroundSchedulePoolTaskHolder::BackgroundSchedulePoolTask... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <mutex>
namespace DB
{
class BackgroundSchedulePoolTaskInfo;
using BackgroundSchedulePoolTaskInfoPtr = std::shared_ptr<BackgroundSchedulePoolTaskInfo>;
class BackgroundSchedulePoolTaskHolder
{
public:
BackgroundSchedulePoolTaskHolder();
explicit Backgro... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/BaseSettings.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Common/logger_useful.h>
#include <fmt/ranges.h>
namespace DB
{
namespace ErrorCodes
{
extern const int INCORRECT_DATA;
extern const int UNKNOWN_SETTING;
}
void BaseSettingsHelpers::writeString(std... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/SettingIndex.h>
#include <Core/SettingsFields.h>
#include <Core/SettingsTierType.h>
#include <Core/SettingsWriteFormat.h>
#include <IO/Operators.h>
#include <Common/FieldVisitorToString.h>
#include <Common/SettingsChanges.h>
#include <string_view>
#include <type_traits>
#incl... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/SettingIndex.h>
/// Forward-declares CLASS_NAME so it can be used as a template tag in SettingIndex,
/// even though the full struct definition comes later in the header.
/// The repeated forward declaration is harmless in C++ and avoids requiring
/// each header to manually ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
/// `t.offset` is relative to `Traits::Data`; delegate to `BaseSettings::operator[]` which
/// performs the derived-to-base conversion on a real Impl pointer (rather than reinterpreting
/// raw bytes from `impl.get()` directly, which would skip the Impl->Data subobject offset).
#define IMPLE... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> it != settings_to_aliases.end())
for (const auto alias : it->second)
addProgramOption(cmd_settings, options, alias, field);
}
}
}
<|fim_prefix|>#pragma once
#include <Core/Types_fwd.h>
#include <boost/program_options.hpp>
namespace DB
{
template <typename T>
void add... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>, data[i].name });
return res;
}
Block Block::cloneWithColumns(const Columns & columns) const
{
Block res;
size_t num_columns = data.size();
if (num_columns != columns.size())
{
auto dump_columns = std::views::transform([](const auto & col) { return col->dumpStructure(); }... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>esired);
void assertCompatibleHeader(const Block & actual, const Block & desired, std::string_view context_description);
/// Calculate difference in structure of blocks and write description into output strings. NOTE It doesn't compare values of constant columns.
void getBlocksDifference(const Block & lh... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <base/types.h>
#include <Common/Exception.h>
#include <IO/ReadBuffer.h>
#include <IO/WriteBuffer.h>
#include <IO/VarInt.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Core/BlockInfo.h>
namespace DB
{
namespace ErrorCodes
{
extern const int UNKNOWN_BLOCK_INFO_FIELD;
}... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/ProtocolDefines.h>
#include <base/types.h>
#include <vector>
namespace DB
{
class ReadBuffer;
class WriteBuffer;
/** More information about the block.
*/
struct BlockInfo
{
/** is_overflows:
* After running GROUP BY ... WITH TOTALS with the max_rows_to_group_by... | fim | ClickHouse/ClickHouse | c |
#include <Core/BlockMissingValues.h>
#include <Common/PODArray.h>
namespace DB
{
void BlockMissingValues::init(size_t num_columns)
{
rows_mask_by_column_id.resize(num_columns);
}
void BlockMissingValues::setBit(size_t column_idx, size_t row_idx)
{
RowsBitMask & mask = rows_mask_by_column_id[column_idx];
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <vector>
#include <boost/dynamic_bitset.hpp>
#include <Processors/Chunk.h>
#include <Common/PODArray_fwd.h>
namespace DB
{
/// Block extension to support delayed defaults.
/// AddingDefaultsTransform uses it to replace missing values with column defaults.
class BlockMissingValues
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>);
BlockNameMap res(index_by_name.size());
res.set_empty_key(std::string_view{});
for (const auto & [name, index] : index_by_name)
res[name] = index;
return res;
}
}
<|fim_prefix|>#include <Core<|fim_middle|>/BlockNameMap.h>
#include <Core/Block.h>
namespace DB
{
BlockNameMap g... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/StringViewHas<|fim_suffix|>st Block & block);
}
<|fim_middle|>h.h>
#include <sparsehash/dense_hash_map>
namespace DB
{
class Block;
using BlockNameMap = ::google::dense_hash_map<std::string_view, size_t, StringViewHash>;
BlockNameMap getNamesToIndexesMap(con<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <list>
#include <memory>
#include <vector>
namespace DB
{
class Block;
using BlockPtr = std::shared_ptr<Block>;
using ConstBlockPtr = <|fim_suffix|>tr<const Block>;
using SharedHeaders = std::vector<SharedHeader>;
}
<|fim_middle|>std::shared_ptr<const Block>;
using Blocks = std:... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>as an exact match
auto idx = map.get(key);
if (idx != CaseAwareBlockNameMap::NOT_FOUND)
{
return idx;
}
// Check if the key has a match ignoring case
return i_map.get(key);
}
bool stringCompare(std::string_view left, std::string_view ri... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> expected size of the map
void setSize(size_t size);
/// Constructs the map from the given block
void initFromBlock(const Block & block);
/// Compares two strings, using the same method as the one used internally
bool equal(std::string_view left, std::string_view right) const;
privat... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <unordered_set>
#include <vector>
namespace DB
{
using ColumnNumbers = std::vector<s<|fim_suffix|> std::unordered_set<size_t>;
using ColumnNumbersList = std::vector<ColumnNumbers>;
using ColumnNumbersSetList = std::vector<ColumnNumbersSet>;
}
<|fim_middle|>ize_t>;
using ColumnNu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/IColumn.h>
#include <Core/ColumnsWithTypeAndName.h>
#include <DataTypes/IDataType.h>
#include <IO/Op<|fim_suffix|>)
out << ' ' << type->getName();
else
out << " nullptr";
}
void ColumnWithTypeAndName::dumpStructure(WriteBuffer & out) const
{
dumpNameAndType(out);... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/IColumn_fwd.h>
#include <base/types.h>
#include <memory>
namespace DB
{
class IDataType;
using DataTypePtr = std::shared_ptr<const IDataType>;
class WriteBuffer;
/** Column data along with its data type and name.
* Column data could be nullptr - to represent just 'he... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Name.h>
#include <vector>
namespace DB
{
using ColumnsWithTypeAndName = VectorWithMemoryTracking<ColumnWithTypeAndName>;
}
<|fim_prefix|>#pragma once
<|fim_middle|>
#include <Core/ColumnWithTypeAnd<|endoftext|> | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <base/defines.h>
#include <base/types.h>
#include <Common/NaNUtils.h>
namespace DB
{
/** Stuff for comparing numbers.
* Integer values are compared as usual.
* Floating-point numbers are compared this way that NaNs always end up at the end
* (if you don't do this, the sort would not wor... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/ColumnConst.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <Common/TargetSpecific.h>
#include <Core/ColumnsWithTypeAndName.h>
#include <Core/DecimalF<|fim_suffix|> overflow |= (static_cast<B>(y) != b);
if constexpr (is_unsign... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/DecimalFunctions.h>
#include <Common/ErrnoException.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_CLOCK_GETTIME;
}
namespace DecimalUtils
{
DateTime64 getCurrentDateTime6<|fim_suffix|>visor / 2) / divisor;
}
else if (scale == 9)
{
time += spe... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ier on known scale.
*/
template <typename DecimalType>
inline DecimalComponents<DecimalType> splitWithScaleMultiplier(
const DecimalType & decimal,
typename DecimalType::NativeType scale_multiplier)
{
using T = typename DecimalType::NativeType;
const auto whole = decimal.value / s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>gs, const std::string & insert_deduplication_token, LoggerPtr logger)
{
bool has_user_token = !insert_deduplication_token.empty();
switch (settings[Setting::deduplicate_insert_select].value)
{
case DeduplicateInsertSelectMode::FORCE_ENABLE:
{
if (!select_query_sort... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.