text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#pragma once
#include <BridgeHelper/LibraryBridgeHelper.h>
#include <Common/ExternalModelInfo.h>
#include <DataTypes/IDataType.h>
#include <IO/ReadWriteBufferFromHTTP.h>
#include <Interpreters/Context_fwd.h>
#include <Poco/URI.h>
#include <optional>
namespace DB
{
struct ColumnWithTypeAndName;
using Col... | fim | ClickHouse/ClickHouse | c |
#include <BridgeHelper/ExternalDictionaryLibraryBridgeHelper.h>
#include <Core/Block.h>
#include <Core/Field.h>
#include <Dictionaries/DictionarySourceHelpers.h>
#include <Formats/FormatFactory.h>
#include <Formats/formatBlock.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromOStream.h>
#include <IO/WriteBuff... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>sModified();
bool supportsSelectiveLoad();
QueryPipeline loadAll();
QueryPipeline loadIds(const VectorWithMemoryTracking<uint64_t> & ids);
QueryPipeline loadKeys(const Block & requested_block);
LibraryInitData getLibraryData() const { return library_data; }
protected:
Poco::U... | fim | ClickHouse/ClickHouse | c |
#include <BridgeHelper/IBridgeHelper.h>
#include <csignal>
#include <filesystem>
#include <thread>
#include <IO/ReadHelpers.h>
#include <IO/ReadWriteBufferFromHTTP.h>
#include <Common/VectorWithMemoryTracking.h>
namespace fs = std::filesystem;
namespace DB
{
namespace ErrorCodes
{
extern const int EXTERNAL_SER... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
#include <Common/ShellCommand.h>
#include <Poco/Logger.h>
#include <Poco/Net/HTTPRequest.h>
#include <Poco/URI.h>
#include <Poco/Util/AbstractConfiguration.h>
namespace DB
{
/// Base class for server-side bridge helpers, e.g. xdbc-bridge and library-b... | fim | ClickHouse/ClickHouse | c |
#include <BridgeHelper/LibraryBridgeHelper.h>
#include <Core/ServerSettings.h>
#include <Core/Settings.h>
#include <Common/ShellCommandsHolder.h>
#include <IO/ConnectionTimeouts.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace Setting
{
extern const SettingsSeconds http_receive_timeout;
}
namespace S... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
#include <IO/ReadWriteBufferFromHTTP.h>
#include <Poco/Logger.h>
#include <Poco/Net/HTTPRequest.h>
#include <Poco/URI.h>
#include <BridgeHelper/IBridgeHelper.h>
#include <Common/BridgeProtocolVersion.h>
namespace DB
{
// Common base class to access the... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>setPath(IDENTIFIER_QUOTE_HANDLER);
uri.addQueryParameter("version", std::to_string(XDBC_BRIDGE_PROTOCOL_VERSION));
uri.addQueryParameter("connection_string", getConnectionString());
uri.addQueryParameter("use_connection_pooling", toString(use_connection_pooling));
auto buf... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadHelpers.h>
#include <IO/ReadWriteBufferFromHTTP.h>
#include <Interpreters/Context.h>
#include <Access/Common/AccessType.h>
#include <Parsers/IdentifierQuotingStyle.h>
#include <Poco/Logger.h>
#include <Poco/Net/HTTPRequest.h>
#include <Poco/URI.h>
#include <Poco/Util/Abstrac... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>teps"))
ai_config.max_steps = config.getUInt64("ai.max_steps");
// Load custom system prompt if provided
if (config.has("ai.system_prompt"))
ai_config.system_prompt = config.getString("ai.system_prompt");
// Load custom base URL for OpenAI-compatible APIs
if (config.has("... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>n configuration
static AIClientResult createClient(const AIConfiguration & config);
/// Load AI configuration from Poco configuration
static AIConfiguration loadConfiguration(const Poco::Util::AbstractConfiguration & config);
};
}
<|fim_prefix|>#pragma once
#include <ai/ai.h>
#include <Poco... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>imeout in seconds
size_t timeout_seconds = 30;
/// Custom system prompt (optional)
std::string system_prompt;
/// Maximum steps for multi-step tool calling
size_t max_steps = 5;
/// Enable schema access - allows AI to query database/table information
bool enable_schema_acces... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>sql>
[SQL STATEMENT]
</sql>
EXAMPLES OF USER REQUESTS AND ASSISTANT RESPONSES:
User: "create a table for storing e-commerce orders"
Assistant:
<sql>
CREATE TABLE IF NOT EXISTS orders (
order_id String,
customer_id UInt64,
order_date DateTime,
status Enum('pending' = 1, 'processing' = 2, ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/AI/AIClientFactory.h>
#include <Client/AI/AIPrompts.h>
#include <Client/AI/AISQLGenerator.h>
#include <Client/AI/AIToolExecutionDisplay.h>
#include <base/terminalColors.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
extern const in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>n success, throws exception on error
std::string generateSQL(const std::string & prompt);
/// Check if the generator is available and properly configured
bool isAvailable() const;
/// Get the provider name
std::string getProviderName() const;
private:
AIConfiguration config;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <algorithm>
#include <atomic>
#include <chrono>
#include <string>
#include <thread>
#include <base/terminalColors.h>
#include <ostream>
#include <Common/StringUtils.h>
#include <IO/ReadBufferFromString.h>
namespace DB
{
class AIToolExecutionDisplay
{
public:
explicit AIToolExe... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> }
return ai::JsonValue{{"success", true}, {"result", buf.str()}, {"databases", databases}};
}
catch (const std::exception & e)
{
return ai::JsonValue{{"success", false}, {"error", e.what()}};
}
}
ai::JsonValue
SchemaExplorationTools::listTablesInDatabase(const ai::JsonVa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <functional>
#include <string>
#include <vector>
#include <ai/tools.h>
namespace DB
{
/// Function signature for executing a query and getting results
using QueryExecutor = std::function<std::string(const std::string & query)>;
/// Creates database schema exploration tools for AI... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> AIConfiguration config;
config.provider = "openai";
config.api_key = "";
// When API key is empty, it should check environment variable
// The behavior depends on whether OpenAI SDK can create a client with env vars
try
{
auto result = AIClientFactory::createClient(confi... | fim | ClickHouse/ClickHouse | cpp |
#include <gtest/gtest.h>
#include "config.h"
#if USE_CLIENT_AI
#include <Client/AI/AISQLGenerator.h>
#include <Client/AI/AIConfiguration.h>
#include <Client/AI/AIClientFactory.h>
#include <Client/AI/SchemaExplorationTools.h>
#include <Common/Exception.h>
#include <Poco/Environment.h>
#include <algorithm>
#include <ss... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
/// Protobuf generated files give lots of warnings, disable them
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Weverything"
#endif
#includ<|fim_suffix|>&);
void SQLQueryToString(String & ret, const SQLQuery &);
}
<|fim_midd... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ions(0, 20);
const uint32_t precision = precisions(rg.generator);
std::uniform_int_distribution<uint32_t> scales(UINT32_C(0), precision);
return fmt::format("DECIMAL({},{})", precision, scales(rg.generator));
}
else
{
/// Character t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
static std::unique_ptr<MongoDBIntegration> testAndAddMongoDBIntegration(FuzzConfig & fcc, const ServerCredentials & scc);
void setTableEngineDetails(RandomGenerator &, const SQLTable &, TableEngine * te) override;
bool performTableIntegration(RandomGenerator &, SQLTable &, bool, std::vector... | fim | ClickHouse/ClickHouse | c |
#include <Client/BuzzHouse/Generator/FuzzConfig.h>
#include <ranges>
#include <IO/copyData.h>
#include <Common/Exception.h>
#include <Common/formatReadable.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BUZZHOUSE;
extern const int NETWORK_ERROR;
}
}
namespace BuzzHouse
{
const DB::Strings compressionMeth... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>umber_alters = 4;
uint32_t deterministic_prob = 50;
std::filesystem::path log_path = std::filesystem::temp_directory_path() / "out.sql";
std::filesystem::path client_file_path = "/var/lib/clickhouse/user_files";
std::filesystem::path server_file_path = "/var/lib/clickhouse/user_files";
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/BuzzHouse/Generator/ProbabilityGenerator.h>
#include <Common/ErrorCodes.h>
#include <Common/Exception.h>
#include <algorithm>
#include <random>
#include <base/defines.h>
#include <Common/randomSeed.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BUZZHOUSE;
}
}
namespace Buzz... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>td::vector<double> genBounded();
void applyDrift();
void buildCdf();
void applyEnabledMaskAndRenorm(std::vector<double> & p) const;
void normalizeEnabledInPlace(std::vector<double> & v, const std::vector<bool> & enabled_values) const;
std::pair<double, double> minmaxEnabled(const ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>first_errcode = errcode;
}
}
void QueryOracle::processSecondOracleQueryResult(const int errcode, ExternalIntegrations & ei, const String & oracle_name)
{
if (other_steps_success && can_test_oracle_result)
{
if (can_test_success && ((first_errcode && !errcode) || (!first_errcode && err... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ure_performance)
{
}
void resetOracleValues();
void setIntermediateStepSuccess(bool success);
void processFirstOracleQueryResult(int errcode, ExternalIntegrations & ei);
void processSecondOracleQueryResult(int errcode, ExternalIntegrations & ei, const String & oracle_name);
/... | fim | ClickHouse/ClickHouse | c |
#include <Client/BuzzHouse/Generator/RandomGenerator.h>
#include <fmt/format.h>
namespace BuzzHouse
{
uint64_t RandomGenerator::getSeed() const
{
return seed;
}
uint32_t RandomGenerator::nextSmallNumber()
{
return dist1(generator);
}
uint32_t RandomGenerator::nextMediumNumber()
{
return dist2(generator... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <cstdint>
#include <functional>
#include <initializer_list>
#include <random>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <Core/Types.h>
#include <pcg_random.hpp>
#include <Common/randomSeed.h>
namespace BuzzHouse
{
class RandomGenerator
{
private:
uint64_t ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Client/BuzzHouse/AST/SQLProtoStr.h>
#include <Client/BuzzHouse/Generator/FuzzConfig.h>
#include <Client/BuzzHouse/Generator/RandomGenerator.h>
#include <Client/BuzzHouse/Generator/SQLTypes.h>
#include <cstdint>
#include <functional>
#include <thread>
namespace BuzzHouse
{
extern... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>SV, InOutFormat::INOUT_CSVWithNames, InOutFormat::INOUT_CSVWithNamesAndTypes},
{InOutFormat::INOUT_CustomSeparated, InOutFormat::INOUT_CustomSeparatedWithNames, InOutFormat::INOUT_CustomSeparatedWithNamesAndTypes},
{InOutFormat::INOUT_JSON,
InOutFormat::INOUT_JSONColumns,
InOutFormat::IN... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> bool is_row = true;
String table_key;
/// USING predicate stored at creation time; absent means the policy allows all rows.
std::optional<WhereStatement> where_expr;
/// True when the policy was created with `TO buzzhouse_oracle_role` — eligible for the row policy oracle.
bool targ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/StringUtils.h>
#include <Client/BuzzHouse/Generator/SQLCatalog.h>
#include <Client/BuzzHouse/Generator/SQLFuncs.h>
#include <Client/BuzzHouse/Generator/SQLTypes.h>
#include <Client/BuzzHouse/Generator/StatementGenerator.h>
namespace BuzzHouse
{
String StatementGenerator::getNextAlias(R... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <cstdint>
#include <string>
#include <vector>
#include <Client/BuzzHouse/AST/SQLProtoStr.h>
namespace BuzzHouse
{
class CHTableFunction
{
public:
const uint32_t fnum;
const uint32_t min_args;
const uint32_t max_args;
CHTableF<|fim_suffix|>SQLTableFunc::TFnull, 1, ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/BuzzHouse/Generator/SQLTypes.h>
#include <Client/BuzzHouse/Generator/StatementGenerator.h>
#include <Client/BuzzHouse/Utils/HugeInt.h>
#include <Client/BuzzHouse/Utils/UHugeInt.h>
namespace BuzzHouse
{
static inline String nextFloatingPoint(RandomGenerator & rg, const bool extremes)
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> String PostgreSQLtypeName(RandomGenerator & rg, bool escape) const override;
String SQLitetypeName(RandomGenerator & rg, bool escape) const override;
std::unique_ptr<SQLType> typeDeepCopy() const override;
String appendRandomRawValue(RandomGenerator &, StatementGenerator &) const override;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Client/BuzzHouse/Generator/ExternalIntegrations.h>
#include <Client/BuzzHouse/Generator/ProbabilityGenerator.h>
#include <Client/BuzzHouse/Generator/RandomGenerator.h>
#include <Client/BuzzHouse/Generator/RandomSettings.h>
#include <Client/BuzzHouse/Generator/SQLCatalog.h>
#include... | fim | ClickHouse/ClickHouse | c |
#include <Client/BuzzHouse/Generator/RandomSettings.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BUZZHOUSE;
}
}
namespace BuzzHouse
{
static const auto bytesRangeSetting
= CHSetting(bytesRange, {"0", "1", "2", "4", "8", "32", "1024", "2048", "4096", "16384", "'10M'"}, false);
static const auto byt... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> {
task = std::move(task_queue_.front());
task_queue_.pop();
}
}
/// Execute the task outside the lock
if (task)
{
try
{
task();
}
catch (const std::exception & e)
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <atomic>
#include <condition_variable>
#include <functional>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <Common/logger_useful.h>
namespace BuzzHouse
{
class BackgroundWorker
{
public:
using BackgroundWorkerTask = std::function<void()>;
explicit Ba... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/BuzzHouse/Utils/HugeInt.h>
#include <Client/BuzzHouse/Utils/UHugeInt.h>
#include <base/defines.h>
#include <cmath>
namespace BuzzHouse
{
static void negateInPlace(HugeInt & input)
{
input.lower = std::numeric_limits<uint64_t>::max() - input.lower + 1ull;
input.upper = -1 - inpu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>const HugeInt & rhs) const;
HugeInt operator-(const HugeInt & rhs) const;
HugeInt operator*(const HugeInt & rhs) const;
HugeInt operator/(const HugeInt & rhs) const;
HugeInt operator%(const HugeInt & rhs) const;
HugeInt operator-() const;
/// Bitwise operators
HugeInt operator... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/BuzzHouse/Utils/MD5Impl.h>
#include <Common/Ex<|fim_suffix|>uffer), inputBufferSize) || file.gcount() > 0)
{
ctx.update(reinterpret_cast<const uint8_t *>(inputBuffer), file.gcount());
}
res = ctx.digest();
}
}
<|fim_middle|>ception.h>
#include <fstream>
namespace DB... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>gine ctx;
uint8_t inputBuffer[inputBufferSize];
public:
void hashFile(const String & filePath, Poco::DigestEngine::Digest & res);
};
}
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Poco/MD5Engine.h>
#include <cstdint>
namespace BuzzHouse
{
class
MD5Impl // NOLINT(cppcoregu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#p<|fim_suffix|>ude <limits>
namespace BuzzHouse
{
template <class T>
struct NumericLimits
{
static constexpr T minimum() { return std::numeric_limits<T>::lowest(); }
static constexpr T maximum() { return std::numeric_limits<T>::max(); }
};
}
<|fim_middle|>ragma once
#incl<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/BuzzHouse/Utils/HugeInt.h>
#include <Client/BuzzHouse/Utils/UHugeInt.h>
#include <base/defines.h>
#include <cmath>
namespace BuzzHouse
{
UHugeInt::UHugeInt(uint64_t value)
{
this->lower = value;
this->upper = 0;
}
bool UHugeInt::operator==(const UHugeInt & rhs) const
{
int... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <cstdint>
#include <Client/BuzzHouse/Utils/Nlimits.h>
#include <base/types.h>
namespace BuzzHouse
{
/// Forward declaration to allow conversion between hugeint and uhugeint
struct HugeInt;
struct UHugeInt
{
public:
uint64_t lower;
uint64_t upper;
UHugeInt() = default;
explici... | fim | ClickHouse/ClickHouse | c |
#include <Client/ClientApplicationBase.h>
#include <base/argsToConfig.h>
#include <base/safeExit.h>
#include <Common/clearPasswordFromCommandLine.h>
#include <Common/TerminalSize.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/SignalHandlers.h>
#include <Client/JWTProvider.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Poco/Util/Application.h>
#include <Client/ClientBase.h>
#include <Client/Suggest.h>
#include <Common/NamePrompter.h>
#include <Poco/ConsoleChannel.h>
#include <Poco/SimpleFileChannel.h>
#include <Poco/SplitterChannel.h>
#include <boost/program_options.hpp>
#include <vector>
namespace po = bo... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/ClientApplicationBase.h>
#include <Client/ClientApplicationBaseParser.h>
#include <filesystem>
#include <vector>
#include <string>
#include <utility>
namespace po = boost::program_options;
namespace DB
{
/**
* Program options parsing is very slow in debug builds and it affects .sh ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <unordered_set>
#include <boost/program_options.hpp>
namespace DB
{
/*
* This functor is used to parse command line arguments and replace dashes with underscores,
* allowing options to be specified using either dashes or underscores.
*/
class OptionsAliasParser
{
public:
ex... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include "config.h"
#include <Client/ProgressTable.h>
#include <Client/Suggest.h>
#include <IO/CompressionMethod.h>
#include <IO/WriteBuffer.h>
#include <Common/DNSResolver.h>
#include <Common/InterruptListener.h>
#include <Common/ProgressIndication.h>
#include <Common/QueryFuzzer.h>
#inclu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>x_parser_backtracks]));
try
{
while (!highlight_token_iterator->isEnd())
{
if (highlight_token_iterator->isError())
break;
if (highlight_token_iterator->type == TokenType::OpeningRoundBracket)
{
/// On opening ro... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string_view>
#include <Core/Types.h>
#include "config.h"
#if USE_REPLXX
# include <Client/ReplxxLineReader.h>
#endif
namespace DB
{
class Context;
/// Should we<|fim_suffix|>omments(const char*& pos, const char* end, std::function<void(std::string_view)> comment_callback);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> host_str);
Poco::URI exchange_url = Poco::URI(endpoints->api_host + "/.api/auth/tokenExchange");
if (show_messages)
output_stream << "Authenticating access to " << host_str << "." << std::endl;
auto session = createHTTPSession(exchange_url);
Poco::Net::HTTPRequest request(Poc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#if USE_JWT_CPP && USE_SSL
#include <Client/JWTProvider.h>
#include <Poco/Timestamp.h>
#include <string>
#include <iosfwd>
#include <map>
namespace DB
{
/// JWT Provider for the ClickHouse managed <|fim_suffix|>udience() const override;
struct AuthEndpoints
{
std::string ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <cstddef>
#include <memory>
#include <Poco/Net/NetException.h>
#include <Core/Defines.h>
#include <Core/Settings.h>
#include <Compression/CompressedReadBuffer.h>
#include <Compression/CompressedWriteBuffer.h>
#include <IO/LimitReadBuffer.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Poco/Net/StreamSocket.h>
#include <Common/callOnce.h>
#include <Common/SSHWrapper.h>
#include <Common/SettingsChanges.h>
#include <Client/IServerConnection.h>
#include <Core/Defines.h>
#include <Formats/FormatSettings.h>
#include <IO/ReadBufferFromPocoSocketChunked.h>
#include <... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/ConnectionEstablisher.h>
#include <Common/quoteString.h>
#include <Common/ProfileEvents.h>
#include <Common/FailPoint.h>
#include <Core/ProtocolDefines.h>
#include <Core/Settings.h>
namespace ProfileEvents
{
extern const Event DistributedConnectionTries;
extern const Event Distri... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/AsyncTaskExecutor.h>
#include <Common/Epoll.h>
#include <Common/Fiber.h>
#include <Common/TimerDescriptor.h>
#include <Common/PoolWithFailoverBase.h>
#include <Client/ConnectionPool.h>
namespace DB
{
/// Class for establishing connection to the replica. It supports setting... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/ConnectionParameters.h>
#include <Core/Defines.h>
#include <Core/Protocol.h>
#include <IO/ConnectionTimeouts.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Common/Exception.h>
#include <Common/isLocalAddress.h>
#include <Common/DNSResolver.h>
#include <Client/ClientBaseHelpers... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/strong_typedef.h>
#include <Common/SSHWrapper.h>
#include <Core/Protocol.h>
#include <IO/ConnectionTimeouts.h>
<|fim_suffix|>ng jwt;
#if USE_JWT_CPP && USE_SSL
std::shared_ptr<JWTProvider> jwt_provider;
#endif
Protocol::Secure security = Protocol::Secure::Disable;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ed(timeouts);
return entry;
}
}
<|fim_prefix|>#include <Client/ConnectionPool.h>
#include <Core/Settings.h>
#include <IO/WriteHelpers.h>
#include <boost/functional/hash.hpp>
namespace DB
{
namespace Setting
{
<|fim_middle|> extern const SettingsMilliseconds connection_pool_max_wait_ms;
}
ICon... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/PoolBase.h>
#include <Common/Priority.h>
#include <Client/Connection.h>
#include <IO/ConnectionTimeouts.h>
#include <base/defines.h>
namespace DB
{
struct Settings;
/** Interface for connection pools.
*
* Usage (using the usual `ConnectionPool` example)
* Connection... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>allback_to_stale_replicas, skip_read_only_replicas, try_get_entry, priority_func);
}
ConnectionPoolWithFailover::TryResult
ConnectionPoolWithFailover::tryGetEntry(
const ConnectionPoolPtr & pool,
const ConnectionTimeouts & timeouts,
std::string & fail_message,
const Settin... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Common/PoolWithFailoverBase.h>
#include <Common/GetPriorityForLoadBalancing.h>
#include <Client/ConnectionPool.h>
#include <chrono>
#include <vector>
namespace DB
{
/** Connection pool with fault tolerance.
* Initialized by several other IConnectionPools.
* When a connection is received,... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <memory>
#include <vector>
namespace DB
{
class IConnectionPool;
using ConnectionPoolPtr = std::shared_ptr<IConnectionPool>;
using ConnectionPoolPtrs = std::vector<ConnectionPoolPtr>;
class ConnectionPoolWithFailover;
using ConnectionPoolWithFailoverPtr = std::share<|fim_suffix|>... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> allow value");
common_arguments.push_back(makeArgument(param.first));
}
else
throw Exception(ErrorCodes::BAD_ARGUMENTS, "URI query parameter {} is not supported", param.first);
}
auto user_info = uri.getUserInfo();
if (!use... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include <string_view>
#include <vector>
namespace DB
{
/** Tries to parse ClickHouse connection string.
* if @connection_string starts with 'clickhouse:' then connection string will be parsed
* and converted into a set of arguments for the client.
* Connection string f... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Protocol.h>
#if defined(OS_LINUX)
#include <Client/HedgedConnections.h>
#include <Client/scaleInteractiveDelayByFanout.h>
#include <Common/ProfileEvents.h>
#include <Core/Settings.h>
#include <Core/ProtocolDefines.h>
#include <Interpreters/ClientInfo.h>
#include <Interpreters/Context.h>
n... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>> replica_with_last_received_packet;
Packet last_received_packet;
Epoll epoll;
ContextPtr context;
const Settings & settings;
ThrottlerPtr throttler;
bool sent_query = false;
bool cancelled = false;
ReplicaInfo replica_info;
mutable std::mutex cancel_mutex;
};
}
#e... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
connections.push_back(connection);
else if (state == State::CANNOT_CHOOSE)
{
if (connections.size() >= min_entries)
break;
/// Determine the reason of not enough replicas.
if (!fallback_to_stale_replicas && up_to_date_count ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>TableName> table_to_check_ = nullptr,
GetPriorityForLoadBalancing::Func priority_func = {});
/// Create and return active connections according to pool_mode.
std::vector<Connection *> getManyConnections(PoolMode pool_mode, AsyncCallback async_callback = {});
/// Try to get connection... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Client/Connection.h>
#include <Storages/MergeTree/RequestResponse.h>
namespace DB
{
struct ClusterFunctionReadTaskResponse;
/// Base class for working with multiple replicas (connections)
/// from one shard within a single thread
class IConnections : boost::noncopyable
{
public:
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>on to enable cancellation during query analysis.
virtual void setCancelCallback(std::function<bool()>) {}
};
using ServerConnectionPtr = std::unique_ptr<IServerConnection>;
}
<|fim_prefix|>#pragma once
#include <Common/Throttler.h>
#include <Core/Types.h>
#include <Core/QueryProcessingStage.h>
#inc... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>;
}
}
void InternalTextLogs::flush()
{
wb.next();
}
}
<|fim_prefix|>#include <Client/InternalTextLogs.h>
#include <Core/Block.h>
#include <IO/WriteBuffer.h>
#include <Interpreters/InternalTextLogsQueue.h>
#include <Interpreters/ProfileEventsExt.h>
#include <Common/typeid_cast.h>
#include <Co<|fim... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
namespace DB
{
c<|fim_suffix|>dler::sendProfileEvents() for block columns.
void writeProfileEvents(const Block & block);
void flush();
private:
WriteBuffer & wb;
bool color;
};
}
<|fim_middle|>lass Block;
class WriteBuffer;
/// Prints internal server logs or profile even... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>HTTPSession(token_url);
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_POST, token_url.getPathAndQuery(), Poco::Net::HTTPMessage::HTTP_1_1);
request.setContentType("application/x-www-form-urlencoded");
std::string request_body = "grant_type=refresh_token&client_id=" + oauth_clien... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#if USE_JWT_CPP && USE_SSL
#include <config.h>
#include <Poco/Net/HTTPSClientSession.h>
#include <Poco/Timestamp.h>
#include <Poc<|fim_suffix|>ken State
std::string idp_access_token;
std::string idp_refresh_token;
Poco::Timestamp idp_access_token_expires_at{0};
};
/// Creates ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/LineReader.h>
#include <iostream>
#include <st<|fim_suffix|> (line.empty() ? "" : "\n") + input;
if (!need_next_line)
break;
}
if (!line.empty() && line != prev_line && !line.starts_with(" "))
{
addToHistory(line);
prev_line = line;
}... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e;
virtual InputStatus readOneLine(const String & prompt);
virtual void addToHistory(const String &) {}
std::istream & input_stream;
std::ostream & output_stream;
int in_fd;
};
}
<|fim_prefix|>#pragma once
#include <iostream>
#include <unistd.h>
#include <mutex>
#include <atomic>
#... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>acket_type.value();
switch (next_packet_type.value())
{
case Protocol::Server::Totals:
case Protocol::Server::Extremes:
case Protocol::Server::Log:
case Protocol::Server::Data:
case Protocol::Server::ProfileEvents:
{
if (state->block && !... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Client/Connection.h>
#include <Interpreters/Context_fwd.h>
#include <QueryPipeline/BlockIO.h>
#include <Interpreters/Session.h>
#include <Interpreters/ProfileEventsExt.h>
#include <Common/QueryScope.h>
#include <Common/ThreadStatus.h>
namespace DB
{
class ColumnsDescription;
clas... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/MultiplexedConnections.h>
#include <Client/scaleInteractiveDelayByFanout.h>
#include <Core/Protocol.h>
#include <Core/ProtocolDefines.h>
#include <Core/Settings.h>
#include <Interpreters/Context.h>
#include <IO/ConnectionTimeouts.h>
#include <IO/Operators.h>
#include <Interpreters/Client... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <mutex>
#include <Common/Throttler.h>
#include <Client/Connection.h>
#include <Client/ConnectionPoolWithFailover.h>
#include <IO/ConnectionTimeouts.h>
#include <Client/IConnections.h>
namespace DB
{
/** To retrieve data directly from multiple replicas (connections) from one shard
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lback async_callback, SuspendCallback suspend_callback)
{
while (true)
{
{
AsyncCallbackSetter<Connection> async_setter(receiver.connection, async_callback);
receiver.packet = receiver.connection->receivePacket();
}
suspend_callback();
}
}
}
#e... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#if defined(OS_LINUX)
#include <Client/IConnections.h>
#include <Common/Fiber.h>
#include <Common/Epoll.h>
#include <Common/TimerDescriptor.h>
#include <Common/AsyncTaskExecutor.h>
namespace DB
{
/// Class for nonblocking packet receiving. It runs connection->receivePacket
/// in fiber an... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ress(time_now);
max_progress = std::max(max_progress, res);
return res;
}
double ProgressTable::MetricInfoPerHost::getSummaryAverageProgress(double time_now) const
{
double res = 0.0;
for (const auto & elem : host_to_metric)
res += elem.second.calculateAverageProgress(time_now);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/ProfileEventsExt.h>
#include <base/types.h>
#include <Common/ProfileEvents.h>
#include <Common/Stopwatch.h>
#include <list>
#include <map>
#include <mutex>
#include <ostream>
#include <string_view>
#include <unord<|fim_suffix|> double updateTime() const;
int g... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/ClientBaseHelpers.h>
#include <Client/ReplxxLineReader.h>
#include <base/errnoToString.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/WriteBufferFromString.h>
#include <IO/copyData.h>
#include <algorithm>
#include <cstdlib>
#include <stdexcept>
#include <chrono>
#include <cerrno>
#i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ER> key when multiline is enabled.
static void setLastIsDelimiter(bool flag);
/// Set text to be prepopulated in the next readLine call
void setInitialText(const String & text) override;
private:
InputStatus readOneLine(const String & prompt) override;
void addToHistory(const String &... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/Suggest.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <AggregateFunctions/Combinators/AggregateFunctionCombinatorFactory.h>
#include <Columns/ColumnString.h>
#include <Common/Exception.h>
#include <Common/QueryScope.h>
#include <Common/setThreadName.h>
#include <Co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>td::atomic<int> last_error { -1 };
};
}
<|fim_prefix|>#pragma once
#include <Client/ConnectionParameters.h>
#include <Client/Connection.h>
#include <Client/IServerConnection.h>
#include <Client/LocalConnection.h>
#include <Client/LineReader.h>
#include <Core/ProtocolDefines.h>
#include <IO/ConnectionTi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eystrokeInterceptor::CallbackMap map)
{
constexpr auto intercept_interval_ms = std::chrono::milliseconds(200);
std::unique_lock lock(stop_requested_mutex);
while (!stop_requested)
{
try
{
runImpl(map);
}
catch (...)
{
tryLogCu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rig_termios;
bool stop_requested = false;
std::mutex stop_requested_mutex;
std::condition_variable stop_requested_cv;
};
}
<|fim_prefix|>#pragma once
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <ostream>
#include <thread>
#include <unorder... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> int code = DB::ErrorCodes::getErrorCodeByName(std::string_view(token.begin, token.end));
error_codes.push_back(code);
}
else
throw DB::Exception(
DB::ErrorCodes::CANNOT_PARSE_TEXT,
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <optional>
#include <vector>
#include <fmt/format.h>
#include <fmt/ranges.h>
namespace DB
{
class Exception;
class Lexer;
/// Checks expected server and client error codes.
///
/// The following comment hints are supported:
///
/// - "-- { serverError 60... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Client/TestTags.h>
#include <cstring>
namespace DB
{
size_t getTestTagsLength(const String & multiline_query)
{
const String & text = multiline_query;
size_t pos = 0;
bool first_line = true;
while (true)
{
size_t line_start = pos;
/// Skip spaces.
... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.