text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#include <optional>
#include <Interpreters/Context.h>
#include <Common/TerminalSize.h>
#include <DisksApp.h>
#include <ICommand.h>
namespace DB
{
class CommandSwitchDisk final : public ICommand
{
public:
explicit CommandSwitchDisk() : ICommand("CommandSwitchDisk")
{
command_name = "switc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Interpreters/Context.h>
#include <Common/TerminalSize.h>
#include <DisksApp.h>
#include <DisksClient.h>
#include <ICommand.h>
#include <Common/logger_useful.h>
namespace DB
{
class CommandTouch final : public ICommand
{
public:
explicit CommandTouch() : ICommand("CommandTouch")
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>[&]() -> std::unique_ptr<ReadBufferFromFileBase>
{
if (!path_from.has_value())
return std::make_unique<ReadBufferFromFileDescriptor>(STDIN_FILENO);
String relative_path_from = disk.getRelativeFromRoot(path_from.value());
auto res = disk.getDisk(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e
command_string += "(";
command_string += alias_name;
}
}
command_string += (need_comma ? ")" : "");
return command_string;
}
void DisksApp::initializeHistoryFile()
{
String home_path;
const char * home_path_cstr = getenv("HOME"); // NOLINT(concurr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
void runInteractive();
void runInteractiveReplxx();
void runInteractiveTestMode();
String getDefaultConfigFileName();
std::vector<String> getCommandsToComplete(const String & command_prefix) const;
// Fields responsible for the REPL work
String history_file;
UInt32 hist... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>t->getPath(), 0, this->context, this->config, config_prefix);
},
std::nullopt});
}
if (!has_local_disk)
{
/// We mount the local disk at the root of the file system so it can be used as a local filesystem within the Disks app. Please note that the initi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> void addDisk(String disk_name, std::optional<String> path);
bool isDiskInitialized(const String & disk_name) const { return initialized_disks.contains(disk_name); }
private:
String current_disk;
std::unordered_map<String, DiskWithPath> disks_with_paths;
DisksMap initialized_disks;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <ICommand.h>
#include <DisksClient.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
CommandLineOptions ICommand::processCommandLineArguments(const Strings & arguments)
{
CommandLineOptions options;
auto parser = po::command_line_parser(arguments);
par... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <config.h>
#include <optional>
#include <Disks/DiskSelector.h>
#include <Disks/IDisk.h>
#include <boost/any/bad_any_cast.hpp>
#include <boost/program_options.hpp>
#include <Poco/Util/Application.h>
#include <Common/Exception.h>
#include <Common/Config/ConfigProcessor.h>
#include... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#i<|fim_suffix|>ICommand;
using CommandPtr = std::shared_ptr<ICommand>;
}
<|fim_middle|>nclude <memory>
namespace DB
{
class <|endoftext|> | fim | ClickHouse/ClickHouse | c |
#include <Utils.h>
std::vector<std::string> splitOnUnquotedSemicolons(const std::string & input)
{
std::vector<std::string> results;
std::string current;
bool in_single_quote = false;
bool in_double_quote = false;
bool escaped = false; // Tracks whether the *previous* character was a backslash (esc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <stri<|fim_suffix|>
#include <vector>
std::vector<std::string> splitOnUnquotedSemicolons(const std::string & input);
<|fim_middle|>ng><|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>, char ** argv);
<|fim_prefix|>int mainEntryClickHous<|fim_middle|>eDisks(int argc<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
/// clickhouse docker-init — Docker entrypoint for distroless ClickHouse images.
/// Replaces entrypoint.sh in shell-free environments (no bash, no coreutils).
///
/// Usage:
/// clickhouse docker-init [--keeper] [-- <extra-server-args>...]
///
/// Environment variables (same as entrypoint.sh):
/// CLICKHOUSE_CONFI... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <filesystem>
#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <queue>
#include <boost/program_options.hpp>
#include <boost/algorithm/string.hpp>
#include <Poco/Logger.h>
#include <Poco/ConsoleChannel.h>
#include <Poco/FormattingChannel.h>
#include <Poco/PatternF... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rgc, char ** argv);
<|fim_prefix|>int ma<|fim_middle|>inEntryClickHouseExtractFromConfig(int a<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <functional>
#include <iostream>
#include <string_view>
#include <Client/ClientBaseHelpers.h>
#include <boost/program_options.hpp>
#include <Core/Settings.h>
#include <IO/ReadBufferFromFileDescriptor.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromFileDescriptor.h>
#include <IO/WriteB... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>);
<|fim_prefix|>int mainEntryClickHo<|fim_middle|>useFormat(int argc, char ** argv<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>har ** argv);
<|fim_prefix|>int mainEntryClickHouseGitImport(int a<|fim_middle|>rgc, c<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nks_changed UInt32,
commit_hash String,
author LowCardinality(String),
time DateTime,
commit_message String,
commit_files_added UInt32,
commit_files_deleted UInt32,
commit_files_renamed UInt32,
commit_files_modified UInt32,
commit_lines_added UInt32,
commit_lines_d... | fim | ClickHouse/ClickHouse | cpp |
#include <iostream>
#include <filesystem>
#include <boost/program_options.hpp>
#include <Common/filesystemHelpers.h>
#include <csignal>
#include <sys/stat.h>
#if defined(OS_LINUX)
#include <syscall.h>
#include <linux/capability.h>
#endif
#if defined(OS_DARWIN)
#include <mach-o/dyld.h>
#endif
#include <C... | fim | ClickHouse/ClickHouse | cpp |
#include <Keeper.h>
#include <Common/ClickHouseRevision.h>
#include <Common/ZooKeeper/ZooKeeperNodeCache.h>
#include <Common/formatReadable.h>
#include <Common/getMultipleKeysFromConfig.h>
#include <Common/DNSResolver.h>
#include <Interpreters/DNSCacheUpdater.h>
#include <Coordination/Defines.h>
#include <Common/Confi... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Server/IServer.h>
#include <Daemon/BaseDaemon.h>
namespace Poco
{
namespace Net
{
class ServerSocket;
}
}
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
/// standalone clickhouse-keeper server (replacement for ZooKeeper). Uses the same
/// con... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eckHarmfulEnvironmentVariables(argv_);
#endif
/// This is used for testing. For example,
/// clickhouse-local should be able to run a simple query without throw/catch.
if (getenv("CLICKHOUSE_TERMINATE_ON_ANY_EXCEPTION")) // NOLINT(concurrency-mt-unsafe)
DB::terminate_on_any_exception ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Generator.h>
#include <fmt/ranges.h>
#include <random>
#include <filesystem>
#include <Common/Exception.h>
#include <Common/ZooKeeper/ZooKeeperCommon.h>
#include <Common/Config/ConfigProcessor.h>
#include <Poco/Util/AbstractConfiguration.h>
using namespace Coordination;
using namespace zkutil;... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/ZooKeeper/KeeperException.h>
#include <Common/ZooKeeper/ZooKeeper.h>
#include <Common/ZooKeeper/ZooKeeperImpl.h>
#include <Common/ZooKeeper/ZooKeeperCommon.h>
#include <optional>
#include <pcg-random/pcg_random.hpp>
#include <Poco/Util/AbstractConfiguration.h>
#include <Commo... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>DB::getCurrentExceptionCode();
}
}
<|fim_prefix|>#include <iostream>
#include <boost/program_options.hpp>
#include <Runner.h>
#include <Common/Exception.h>
#include <Common/TerminalSiz<|fim_middle|>e.h>
#include <Core/Types.h>
#include <boost/program_options/variables_map.hpp>
namespace
{
template <... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>row_iterator();
for (size_t i = 0; i < requests_size; ++i)
{
auto subrequest_from_log = getNextRequest(/*for_multi=*/true);
if (!subrequest_from_log)
throw DB::Exception(DB::ErrorCodes::BAD_ARGUMENTS, "Failed ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/ZooKeeper/ZooKeeperArgs.h>
#include <Common/ZooKeeper/ZooKee<|fim_suffix|>erations limits.
std::atomic<size_t> requests_started = 0;
std::atomic<bool> shutdown = false;
double warmup_seconds = 0;
std::atomic<bool> warmup_complete = false;
std::shared_ptr... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Stats.h>
#include <base/defines.h>
#include <iostream>
#include <rapidjson/document.h>
#include <rapidjson/writer.h>
#include <rapidjson/stringbuffer.h>
void Stats::StatsCollector::add(uint64_t microseconds, size_t requests_inc, size_t bytes_inc)
{
requests += requests_inc;
requests_by... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <atomic>
#include <mutex>
#include <AggregateFunctions/ReservoirSampler.h>
#include <Common/Stopwatch.h>
struct Stats
{
using Sampler = ReservoirSampler<double>;
/// All StatsCollector access is protected by Stats::mutex
struct StatsCollector
{
size_t requests = 0;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>r ** argv);
<|fim_prefix|>extern int mainEntryClickHou<|fim_middle|>seKeeperBench(int argc, cha<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> if (config().has("tls-cert-file") || config().has("tls-key-file") || config().has("tls-ca-file") || config().has("accept-invalid-certificate"))
{
Poco::Net::Context::VerificationMode verification_mode = Poco::Net::Context::VERIFY_RELAXED;
if (config().has("accept-invalid-certificate"... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>imum number of entries in the history file.
LineReader::Suggest suggest;
};
}
<|fim_prefix|>#pragma once
#include <Client/LineReader.h>
#include <Poco/Util/Application.h>
#include <Common/ZooKeeper/KeeperClientCLI/KeeperClient.h>
#include <iostream>
namespace DB
{
class KeeperClient: public Poco... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <iostream>
#include <boost/program_options.hpp>
#include <Coordination/CoordinationSettings.h>
#include <Coordination/KeeperSnapshotManager.h>
#include <Coordination/KeeperStorage.h>
#include <Coordination/ZooKeeperDataReader.h>
#include <Coordination/KeeperContext.h>
#include <Common/TerminalSi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>** argv);
<|fim_prefix|>int mainEntryCl<|fim_middle|>ickHouseKeeperConverter(int argc, char <|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>// NOLINTBEGIN(clang-analyzer-optin.core.EnumCastOutOfRange)
#include <Poco/ConsoleChannel.h>
#include <Poco/Logger.h>
#include <Coordination/CoordinationSettings.h>
#include <Coordination/KeeperStateMachine.h>
#include <Coordination/KeeperStorage.h>
#include <Common/ZooKeeper/ZooKeeperCommon.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>extern int mainEntryClickH<|fim_suffix|>aDumper(int argc, char ** argv);
<|fim_middle|>ouseKeeperDat<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <iostream>
#include <unordered_map>
#include <Columns/IColumn.h>
#include <Coordination/Changelog.h>
#include <Coordination/CoordinationSettings.h>
#include <Coordination/KeeperCommon.h>
#include <Coordination/KeeperLogStore.h>
#include <Coordination/KeeperStateMachine.h>
#include <Coordination/K... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>extern int mainE<|fim_suffix|>rUtils(int argc, char ** argv);
<|fim_middle|>ntryClickHouseKeepe<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ase(server_default_database);
}
if (getClientConfiguration().has("path"))
{
attachInformationSchema(global_context, *createMemoryDatabaseIfNotExists(global_context, DatabaseCatalog::INFORMATION_SCHEMA));
attachInformationSchema(global_context, *createMemoryDatabaseIfNotExists(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
}
<|fim_prefix|>#pragma once
#include <Client/ClientApplicationBase.h>
#include <Client/LocalConnection.h>
#include <Core/ServerSettings.h>
#include <Interpreters/Context_fwd.h>
#include <Loggers/Loggers.h>
#include <Common/MemoryWorker.h>
#include <Common/StatusFile.h>
#include <filesystem>
#includ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>int mainEntryClickHouseLo<|fim_suffix|>r ** argv);
<|fim_middle|>cal(int argc, cha<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> {
signalSafeWrite("[fuzzer] pthread_kill failed with error ");
/// Signal-safe integer-to-string for small error codes.
char err_buf[16];
int pos = 14;
err_buf[15] = '\0';
err_buf[14] = '\n';
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <base/phdr_cache.h>
#include <base/scope_guard.h>
#include <base/defines.h>
#include <base/sanitizer_options.h>
#include <Common/EnvironmentChecks.h>
#include <Common/Exception.h>
#include <Common/StringUtils.h>
#include <Common/getHashOfLoadedBinary.h>
#include <Common/Crypto/OpenSSLInitializer... | fim | ClickHouse/ClickHouse | cpp |
#include <Columns/IColumn.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnFixedString.h>
#include <Common/DateLUTImpl.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypesNumber.h>
#include <D... | fim | ClickHouse/ClickHouse | cpp |
int mainEntryClickHouseObfuscator(int argc, char ** argv);
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>icit shutdown. Done first to close the signal-delivery
/// window between exec and the rest of the setup.
sigset_t full_mask;
::sigfillset(&full_mask); // NOLINT(concurrency-mt-unsafe)
::sigprocmask(SIG_SETMASK, &full_mask, nullptr); // NOLINT(concurrency-mt-unsafe)
/// Ask the kernel... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>int mainEntryClickHouseOomCa<|fim_suffix|> argc, char ** argv);
<|fim_middle|>nary(int<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>value.second.value);
}
}
if (!key_vals.empty())
BaseDaemon::instance().writeToGraphite(key_vals, config_name);
}
}
<|fim_prefix|>#include <MetricsTransmitter.h>
#include <Common/AsynchronousMetrics.h>
#include <Common/CurrentMetrics.h>
#include <Common/Exception.h>
#include <Co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>td::optional<ThreadFromGlobalPool> thread;
static constexpr auto profile_events_path_prefix = "ClickHouse.ProfileEvents.";
static constexpr auto profile_events_cumulative_path_prefix = "ClickHouse.ProfileEventsCumulative.";
static constexpr auto current_metrics_path_prefix = "ClickHouse.Metri... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>er> & servers,
const ServerType & server_type) const;
};
}
<|fim_prefix|>#pragma once
#include <Core/ServerSettings.h>
#include <Server/IServer.h>
#include <Daemon/BaseDaemon.h>
#include <Server/HTTP/HTTPContext.h>
#include <Server/TCPProtocolStackFactory.h>
#include <Server/ServerType.h>
#incl... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>int mainEntry<|fim_suffix|>ouseServer(int argc, char ** argv);
<|fim_middle|>ClickH<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> }
else if (strncmp((*argv)[i], "-port=", 6) == 0)
{
char * p_end = nullptr;
port = strtol((*argv)[i] + 6, &p_end, 10);
}
}
}
}
args.push_back(nullptr);
main_app = std::async(st... | fim | ClickHouse/ClickHouse | cpp |
/**
* Skipped minification because the original files appears to be already minified.
* Original file: /npm/@xterm/addon-fit@0.10.0/lib/addon-fit.js
*
* Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files
*/
!function(e,t){"object"==typeof export... | fim | ClickHouse/ClickHouse | javascript |
<|fim_suffix|>()<>]/;function i(e,t){const n=window.open();if(n){try{n.opener=null}catch{}n.location.href=t}else console.warn("Opening link blocked as opener could not be cleared")}e.WebLinksAddon=class{constructor(e=i,t={}){this._handler=e,this._options=t}activate(e){this._terminal=e;const n=this._options,o=n.urlRegex... | fim | ClickHouse/ClickHouse | javascript |
<|fim_suffix|>h),h++),delete u[c]}else for(t=s[c],e=0;e<h;e++)m=m<<1|1&t,v==o-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;0==--l&&(l=Math.pow(2,h),h++)}for(t=2,e=0;e<h;e++)m=m<<1|1&t,v==o-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;for(;;){if(m<<=1,v==o-1){d.push(n(m));break}v++}return d.join("")},decompress:function(r){return null==r?"... | fim | ClickHouse/ClickHouse | javascript |
<|fim_suffix|>t,l){e in ei&&ei[e].forEach((e=>{e.call(null,k,t,l)}))}(u.plugins||[]).forEach((e=>{for(let t in e.hooks)ei[t]=(ei[t]||[]).concat(e.hooks[t])}));const li=Fe({key:null,setSeries:!1,filters:{pub:_e,sub:_e},scales:[ve,re[1]?re[1].scale:null],match:[ke,ke],values:[null,null]},il.sync);il.sync=li;const ni=li.k... | fim | ClickHouse/ClickHouse | javascript |
<|fim_prefix|>int mainEntryClickHouseS<|fim_suffix|>Uploader(int argc, char ** argv);
<|fim_middle|>taticFilesDisk<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Exception.h>
#include <Common/TerminalSize.h>
#include <Common/re2.h>
#include <IO/ReadHelpers.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/ReadSettings.h>
#include <IO/WriteHelpers.h>
#include <IO/WriteBufferFromHTTP.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/copyData.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>int mainEntryClickHouseSU(int argc, cha<|fim_suffix|>rgv);
<|fim_middle|>r ** a<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>d;
if (!user_name.empty())
{
if (0 != initgroups(user_name.c_str(), group_for_initgroups))
throw ErrnoException(ErrorCodes::SYSTEM_ERROR, "Cannot do 'initgroups' for user ({})", user_name);
}
else
{
/// No passwd entry for th... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
("address,a", boost::program_options::value<std::string>()->required(),
"addresses of ZooKeeper instances, comma separated. Example: example01e.clickhouse.com:2181")... | fim | ClickHouse/ClickHouse | cpp |
extern int mainEntryClickHouseZooKeeperDumpTree(int argc, char ** argv);
<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>:createWithoutKillingPreviousSessions(options.at("address").as<std::string>());
DB::ReadBufferFromFileDescriptor in(STDIN_FILENO);
std::list<std::future<Coordination::RemoveResponse>> futures;
std::cerr << "Requested: ";
while (!in.eof())
{
std::string path;
DB::readE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>extern in<|fim_suffix|>RemoveByList(int argc, char ** argv);
<|fim_middle|>t mainEntryClickHouseZooKeeper<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>use std::cell::Cell;
use std::error::Error;
use std::fs;
use std::path::{Path, PathBuf};
use std::time::Duration;
use blake3::Hasher;
use log::trace;
use tokio::time::Instant;
use crate::traits::compiler::Compiler;
use crate::traits::compiler::CompilerMeta;
pub struct ClangLike {
compiler_path: Pat... | fim | ClickHouse/ClickHouse | rust |
<|fim_prefix|>pub mod <|fim_suffix|>od rustc;
<|fim_middle|>clang;
pub m<|endoftext|> | fim | ClickHouse/ClickHouse | rust |
<|fim_prefix|>use blake3::Hasher;
use log::trace;
use std::cell::Cell;
use std::error::Error;
use std::fs::{self};
use std::io::Cursor;
use std::path::{Path, PathBuf};
use std::time::Duration;
use tokio::time::Instant;
use crate::{
compilers::clang::ClangLike,
traits::compiler::{Compiler, CompilerMeta},
};
pu... | fim | ClickHouse/ClickHouse | rust |
<|fim_suffix|> (_, true) => {
trace!(
"Config file not found at {}, trying env vars",
config_path.display()
);
Config {
hostname: std::env::var("CH_HOSTNAME").unwrap(),
user: std::env::var("C... | fim | ClickHouse/ClickHouse | rust |
use std::fs::OpenOptions;
use std::ptr;
use std::sync::atomic::{AtomicUsize, Ordering};
use memmap2::{MmapMut, MmapOptions};
#[repr(C)]
struct CacheStats {
version: u8,
cache_hits_local: AtomicUsize,
cache_hits_remote: AtomicUsize,
cache_miss: AtomicUsize,
uncacheable: AtomicUsize,
invocatio... | fim | ClickHouse/ClickHouse | rust |
<|fim_prefix|>use std::error::Error;
use crate::config::Config;
use crate::traits::disk::Disk;
pub struct ClickHouseDisk {
client: clickhouse::Client,
source_table: String,
target_table: String,
}
#[derive(Debug, clickhouse::Row, serde::Serialize, serde::Deserialize)]
struct CacheLine {
#[serde(with... | fim | ClickHouse/ClickHouse | rust |
<|fim_prefix|>use log::trace;
use std::error::Error;
use std::fs;
use xdg::BaseDirectories;
use crate::config::Config;
use crate::traits::disk::Disk;
pub struct LocalDisk {
local_path: BaseDirectories,
}
impl Disk fo<|fim_suffix|> );
}
}
<|fim_middle|>r LocalDisk {
fn from_config(_config: &Config)... | fim | ClickHouse/ClickHouse | rust |
<|fim_prefix|>pu<|fim_suffix|>
<|fim_middle|>b mod clickhouse;
pub mod local;<|endoftext|> | fim | ClickHouse/ClickHouse | rust |
<|fim_suffix|> did_load_from_clickhouse = true;
bytes
}
Err(e) => {
trace!("Got error from CH: {:?}", e);
stats.increment_miss();
compiler.compile().expect("Unable to compile")
}
... | fim | ClickHouse/ClickHouse | rust |
<|fim_suffix|>f) -> String;
fn version(&self) -> String;
fn compile(&self) -> Result<Vec<u8>, Box<dyn Error>>;
fn apply_cache(&self, source: &Vec<u8>) -> Result<(), Box<dyn Error>>;
fn get_args(&self) -> Vec<String>;
fn get_compile_duration(&self) -> u128;
}
<|fim_prefix|>use std::{error::Error, p... | fim | ClickHouse/ClickHouse | rust |
<|fim_suffix|>hash: &str, data: &Vec<u8>) -> Result<(), Box<dyn Error>>;
}
<|fim_prefix|>use crate::config::Config<|fim_middle|>;
use std::error::Error;
pub trait Disk {
fn from_config(config: &Config) -> Self;
async fn read(&self, hash: &str) -> Result<Vec<u8>, Box<dyn Error>>;
async fn write(&self, <|en... | fim | ClickHouse/ClickHouse | rust |
<|fim_prefix|>p<|fim_suffix|>disk;
<|fim_middle|>ub mod compiler;
pub mod <|endoftext|> | fim | ClickHouse/ClickHouse | rust |
#pragma once
#include <cstdint>
extern "C" {
/// Transpiles SQL from a source dialect to ClickHouse SQL.
/// @param query is a pointer to the beginning of the SQL query.
/// @param query_size is the size of the SQL query.
/// @param source_dialect is a pointer to the beginning of the dialect name string (e.g. "sqlit... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_ptr() as *const u8;
let query_size = query_cstr.to_bytes().len() as u64;
let dialect_cstr = CString::new(dialect).unwrap();
let dialect_ptr = dialect_cstr.as_ptr() as *const u8;
let dialect_size = dialect_cstr.to_bytes().len() as u64;
let mut out: *mut u8 = std::... | fim | ClickHouse/ClickHouse | rust |
<|fim_suffix|>eviously.
void prql_free_pointer(uint8_t * ptr_to_free);
} // extern "C"
<|fim_prefix|>#pragma once
#include <cstdint>
extern "C" {
/// Converts a PRQL query to an SQL query.
/// @param query is a pointer to the beginning of the PRQL query.
/// @param size is the size of the PRQL query.
/// @param out... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ts(query, size.try_into().unwrap()).to_vec();
let Ok(query_str) = String::from_utf8(query_vec) else {
set_output(
"The PRQL query must be UTF-8 encoded!".to_string(),
out,
out_size,
);
return 1;
};
let opts = Options {
format... | fim | ClickHouse/ClickHouse | rust |
fn main() {
let mut build = cxx_build::bridge("src/lib.rs");
build.file("src/check_abi.cpp");
build.compile("skim");
}
<|endoftext|> | fim | ClickHouse/ClickHouse | rust |
<|fim_suffix|>or<::std::string> const &words);
<|fim_prefix|>/// This header was compiled with:
///
/// $ cxxbridge rust/skim/src/lib.rs --header
///
/// For more info [1].
///
/// [1]: https://cxx.rs/build/other.html
#pragma once
#include <array>
#include <cstdint>
#include <string>
#include <vector>
namespace... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <<|fim_suffix|>overflow.
static_assert(sizeof(std::exception) > sizeof(void *),
"std::exception is too small - STD_EXCEPTION_HAS_STACK_TRACE=1 is missing from CXXFLAGS");
<|fim_middle|>exception>
/// ClickHouse patches std::exception with an embedded stack trace.
/// The CXX bridge code must... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>use cxx::{CxxString, CxxVector};
use skim::prelude::*;
use std::panic;
use term::terminfo::TermInfo;
#[cxx::bridge]
mod ffi {
extern "Rust" {
fn skim(prefix: &CxxString, words: &CxxVector<CxxString>) -> Result<String>;
}
}
struct Item {
text_no_newlines: String,
orig_text: String... | fim | ClickHouse/ClickHouse | rust |
<|fim_prefix|>
pub use wa<|fim_suffix|>c_api;
pub use wasmtime_c_api::wasmtime;
<|fim_middle|>smtime_<|endoftext|> | fim | ClickHouse/ClickHouse | rust |
<|fim_suffix|> }
return res;
}
void restoreAccessEntitiesFromBackup(
IAccessStorage & destination_access_storage,
const AccessEntitiesToRestore & entities_to_restore,
const RestoreSettings & restore_settings)
{
if (entities_to_restore.new_entities.empty())
return; /// Nothing to restore.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Access() const;
/// Generates random IDs for access entities we're restoring to insert them into an access storage;
/// and finds IDs of existing access entities which are used as dependencies.
void generateRandomIDsAndResolveDependencies(const AccessControl & access_control);
/// Return... | fim | ClickHouse/ClickHouse | c |
#include <Access/AccessChangesNotifier.h>
#include <Common/Exception.h>
#include <boost/range/algorithm/copy.hpp>
namespace DB
{
AccessChangesNotifier::AccessChangesNotifier() : handlers(std::make_shared<Handlers>())
{
}
AccessChangesNotifier::~AccessChangesNotifier() = default;
void AccessChangesNotifier::onEntit... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ty has been changed.
void onEntityUpdated(const UUID & id, const AccessEntityPtr & changed_entity);
/// Called by access storages after an access entity has been removed.
void onEntityRemoved(const UUID & id, AccessEntityType type);
/// Sends notifications to subscribers about changes in... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>onfigurations
setTableEnginesRequireGrant(config_.getBool("access_control_improvements.table_engines_require_grant", false));
setEnableReadWriteGrants(config_.getBool("access_control_improvements.enable_read_write_grants", false));
setThrowOnUnmatchedRowPolicies(config_.getBool("access_control... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <Access/MultipleAccessStorage.h>
#include <Access/Common/AuthenticationType.h>
#include <Common/SettingsChanges.h>
#include <base/scope_guard.h>
#include <boost/container/flat_set.hpp>
namespace Poco
{
namespace Net
{
class IPAddress;
}<|fim_... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/AccessEntityIO.h>
#include <Access/IAccessEntity.h>
#include <Access/IAccessStorage.h>
#include <Access/Quota.h>
#include <Access/Role.h>
#include <Access/RowPolicy.h>
#include <Access/SettingsProfile.h>
#include <Access/User.h>
#include <Core/Defines.h>
#include <IO/WriteHelpers.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <memory>
namespace DB
{
s<|fim_suffix|>AccessEntity;
using AccessEntityPtr = std::shared_ptr<const IAccessEntity>;
String serializeAccessEntity(const IAccessEntity & entity);
AccessEntityPtr deserializeAccessEntity(const String & definition, const String ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> /// GRANT SELECT ON db.tb* |
/// | -> GRANT SELECT ON db.*
/// GRANT SELECT ON db.* |
if (it->wildcard_grant && canMergeChild(*it))
{
it->wildcard_grant = false;
it->optimizeChildren();
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ntOption(const AccessRightsElements & elements);
void grantWildcardWithGrantOption(const AccessFlags & flags);
void grantWildcardWithGrantOption(const AccessFlags & flags, std::string_view database);
void grantWildcardWithGrantOption(const AccessFlags & flags, std::string_view database, std::... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/Authentication.h>
#include <Access/AuthenticationData.h>
#include <Access/Credentials.h>
#include <Access/ExternalAuthenticators.h>
#include <Access/LDAPClient.h>
#include <Access/GSSAcceptor.h>
#include <Common/Base64.h>
#include <Common/Crypto/X509Certificate.h>
#include <Common/Excepti... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>override { throw *this; } /// NOLINT(cert-err60-cpp)
private:
const String realm;
};
};
template <typename CredentialsType>
Authentication::Require<CredentialsType>::Require(const String & realm_)
: Exception("Credentials required", ErrorCodes::BAD_ARGUMENTS)
, realm(realm_)
{
}... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>o & key : getSSHKeys())
node->children.push_back(make_intrusive<ASTPublicSSHKey>(key.getBase64(), key.getKeyType()));
break;
#else
throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, "SSH is disabled, because ClickHouse is built without libssh");
#endif
}
... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.