text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#pragma once
#include <memory>
#include <string>
namespace Poco
{
class Logger;
}
using LoggerPtr = std::shared_ptr<Poco::Logger>;
namespace DB
{
struct Settings;
class Context;
using Contex<|fim_suffix|> void overrideDeduplicationSetting(bool is_on, ContextMutablePtr context);
}
<|fim_... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/defines.h>
#include <base/unit.h>
namespace DB
{
static constexpr auto DBMS_DEFAULT_PORT = 9000;
static constexpr auto DBMS_DEFAULT_SECURE_PORT = 9440;
static constexpr auto DBMS_DEFAULT_CONNECT_TIMEOUT_SEC = 10;
static constexpr auto DBMS_DEFAULT_SEND_TIMEOUT_SEC = 300;
st... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>L_VERSION_WITH_TEMPORATY_DATA = 5;
static constexpr auto PROTOCOL_VERSION_WITH_READ_RANGE_ID = 6;
static constexpr auto PROTOCOL_VERSION_WITH_CREDENTIALS_REFRESH = 7;
static constexpr auto PROTOCOL_VERSION_WITH_CACHE_STATS_DATA_PACKET = 8;
static constexpr auto PROTOCOL_VERSION_WITH_STORAGE_INFO_IN_CACHE_... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/ExternalResultDescription.h>
#include <Columns/ColumnConst.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeTime.h>
#include <DataTypes/DataTypeTime64.h>
#include <DataTypes/DataTypeNullable.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <vector>
#include <Core/Block.h>
namespace DB
{
/** Common part for implementation of MySQLSource, MongoDBSource and others.
*/
struct ExternalResultDescription
{
enum struct ValueType
{
vtUInt8,
vtUInt16,
vtUInt32,
vtUInt64,
vtInt... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eader
Poco::Net::NameValueCollection content;
std::string label;
Poco::Net::MessageHeader::splitParameters(header.get("Content-Disposition"), label, content);
/// Get parameters
name = content.get("name", "_data");
format = params.get(name + "_format", "TabSeparated");
if (pa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Client/Connection.h>
#include <Core/Block.h>
#include <Interpreters/Context_fwd.h>
#include <IO/ReadBuffer.h>
#include <Server/HTTP/HTMLForm.h>
#include <iosfwd>
#include <memory>
#include <string>
#include <vector>
namespace Poco::Net
{
class NameValueCollection;
class MessageH... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nary(type, buf);
writeBinary(key, buf);
Field::dispatch([&buf] (const auto & val) { FieldVisitorWriteBinary()(val, buf); }, value);
}
}
void writeText(const Object & x, WriteBuffer & buf)
{
writeFieldText(Field(x), buf);
}
void writeBinary(const CustomType & x, WriteBuffer & buf)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <map>
#include <vector>
#include <base/AlignedUnion.h>
#include <Core/Types.h>
#include <base/DayNum.h>
#include <base/IPv4andIPv6.h>
#include <Common/AllocatorWithMemoryTracking.h>
#include <fmt/format.h>
namespace DB
{
constexpr Null NEGATIVE_INFINITY{Null::Value::NegativeInfi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>, DateTimeInputFormat) \
M(CLASS_NAME, DateTimeOutputFormat) \
M(CLASS_NAME, DateTimeOverflowBehavior) \
M(CLASS_NAME, Double) \
M(CLASS_NAME, EscapingRule) \
M(CLASS_NAME, Float) \
M(CLASS_NAME, IdentifierQuotingRule) \
M(CLASS_NAME, IdentifierQuotingStyle) \
M(CLASS_NAME,... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
/// This header exists so we can share it between multiple setting objects that include format settings
#include <Core/SettingsObsoleteMacros.h>
#include <Core/SettingsFields.h>
#include <Core/Defines.h>
// clang-format off
#if defined(__CLION_IDE__)
/// CLion freezes for a minute every ti... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lvedFunctionPtr = std::shared_ptr<const IResolvedFunction>;
}
<|fim_prefix|>#pragma once
#include <memory>
#include <vector>
namespace DB
{
class IDataType;
using DataTypePtr = std::shared_ptr<const IDataType>;
using DataTypes = std::vector<DataTypePtr>;
struct Array;
/* Generic class for all functi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Block.h>
#include <IO/Operators.h>
#include <Common/JSONBuilder.h>
#include <Core/InterpolateDescription.h>
#include <Interpreters/convertFieldToType.h>
#include <Core/SettingsEnums.h>
#include <Common/IntervalKind.h>
#include <Parsers/ASTOrderByElement.h>
#include <Parsers/ASTInterpolateEl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <unordered_map>
#include <memory>
#include <string>
#include <Parsers/IAST_fwd.h>
#include <Interpreters/ActionsDAG.h>
namespace DB
{
using Aliases = std::unordered_map<String, ASTPtr>;
/// Interpolate description
struct InterpolateDescription
{
explicit InterpolateDesc<|fim... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>har * toString(ASOFJoinInequality asof_join_inequality)
{
switch (asof_join_inequality)
{
case ASOFJoinInequality::None: return "NONE";
case ASOFJoinInequality::Less: return "LESS";
case ASOFJoinInequality::Greater: return "GREATER";
case ASOFJoinInequality::LessOrE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string_view>
namespace DB
{
class ReadBuffer;
class WriteBuffer;
/// Join method.
enum class JoinKind : uint8_t
{
Inner = 0, /// Leave only rows that was JOINed.
Left, /// If in "right" table there is no corresponding rows, use default values instead.
Right,
Full... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstdint>
namespace DB
{
<|fim_suffix|>name prefix and local hostname prefix
NEAREST_HOSTNAME,
/// just like NEAREST_HOSTNAME, but it count distinguished characters in a levenshtein distance manner
HOSTNAME_LEVENSHTEIN_DISTANCE,
// replicas with the same number of e... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <cstdint>
namespace DB
{
enum class LogsLevel : uint8_t
{
none = 0, /// Disable
fatal,
error,
warning,
information,
debug,
trace,
test,
};
}
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_t
{
SIMPLE,
STOCHASTIC_SIMPLE,
TRIVIAL,
MANUAL,
};
}
<|fim_prefix|>#pragma once
#include <cstdint>
namespace DB
{
enum<|fim_middle|> class MergeSelectorAlgorithm : uint8<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nt8_t
{
CONSTANT = 0,
SQRT = 1,
LINEAR = 2,
};
}
<|fim_prefix|>#pragma once
#include <cstdint>
namespace DB
{
enum class MergeTreeSerializationInfoVersion : uint8_t
{
BASIC = 0,
WITH_TYPES = 1,
};
enum class<|fim_middle|> MergeTreeStringSerializationVersion : uint8_t
{
SINGLE... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>td::is_unsigned_v<StorageType> && std::is_integral_v<StorageType>);
}
MultiEnum(const MultiEnum & other) = default;
MultiEnum & operator=(const MultiEnum & other) = default;
bool isSet(EnumType value) const
{
return bitset & toBitFlag(value);
}
void set(EnumType valu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/Credentials.h>
#include <Core/MySQL/Authentication.h>
#include <Core/MySQL/PacketsConnection.h>
#include <Interpreters/Session.h>
#include <Common/logger_useful.h>
#include <Poco/RandomStream.h>
#include <Poco/SHA1Engine.h>
#include <base/scope_guard.h>
#include <base/defines.h>
usin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>thenticate(
const String & user_name, Session & session, std::optional<String> auth_response,
std::shared_ptr<PacketEndpoint> packet_endpoint, bool is_secure_connection, const Poco::Net::SocketAddress & address) override;
private:
KeyPair & private_key;
LoggerPtr log;
String s... | fim | ClickHouse/ClickHouse | c |
#include <Common/Exception.h>
#include <Core/MySQL/IMySQLReadPacket.h>
#include <IO/MySQLPacketPayloadReadBuffer.h>
#include <IO/LimitReadBuffer.h>
namespace DB
{
namespace ErrorCodes
{
extern const int UNKNOWN_PACKET_FROM_CLIENT;
}
namespace MySQLProtocol
{
void IMySQLReadPacket::readPayload(ReadBuffer & in, u... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
namespace DB
{
namespace MySQLProtocol
{
class IMySQLReadPacket
{
public:
IMySQLReadPacket() = default;
virtual ~IMySQLReadPacket() = default;
IMyS<|fim_suffix|>yloadImpl(ReadBuffer & buf) = 0;
};
class LimitedReadPacket : public IMySQLReadPacket
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>odedString(const String & s, WriteBuffer & buffer)
{
writeLengthEncodedNumber(s.size(), buffer);
buffer.write(s.data(), s.size());
}
void writeNulTerminatedString(const String & s, WriteBuffer & buffer)
{
buffer.write(s.data(), s.size());
buffer.write(0);
}
}
}
<|fim_prefix|>#include <C... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <IO/WriteBuffer.h>
namespace DB
{
namespace MySQLProtocol
{
class IMySQLWritePacket
{
public:
IMySQLWritePacket(<|fim_suffix|>WriteBuffer & buffer);
}
}
<|fim_middle|>) = default;
virtual ~IMySQLWritePacket() = default;
IMySQLWritePacket(IM... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/MySQL/MySQLUtils.h>
#include <Common/assert_cast.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnsDateTime.h>
#include <Core/DecimalFunctions.h>
#include <DataTypes/IDataType.h>
#include <cmath>
namespace DB
{
namespace MySQLProtocol
{
namespace MySQLUtils
{
Decima<|fim_su... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> fractional part as if it was scale 6 for MySQL compatibility purposes
DecimalUtils::DecimalComponents<DateTime64> getNormalizedDateTime64Components(DataTypePtr data_type, ColumnPtr col, size_t row_num);
}
}
}
<|fim_prefix|>#pragma once
#include <Core/DecimalFunctions.h>
#include <DataTypes/IDataType.h>
... | fim | ClickHouse/ClickHouse | c |
#include <Core/MySQL/PacketEndpoint.h>
#include <IO/ReadBufferFromPocoSocket.h>
#include <Common/typeid_cast.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
namespace MySQLProtocol
{
PacketEndpoint::PacketEndpoint(WriteBuffer & out_, uint8_t & sequence_id_)
: sequence_id(sequence_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>vePacket(IMySQLReadPacket & packet, UInt64 millisecond = 0);
/// Sets sequence-id to 0. Must be called before each command phase.
void resetSequenceId();
template<class T>
void sendPacket(const T & packet, bool flush = true)
{
static_assert(std::is_base_of<IMySQLWritePacket, ... | fim | ClickHouse/ClickHouse | c |
#include <Core/MySQL/PacketsConnection.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Core/MySQL/PacketsGeneric.h>
namespace DB
{
namespace MySQLProtocol
{
using namespace Generic;
namespace ConnectionPhase
{
static const size_t SCRAMBLE_LENGTH = 20;
static const size_t AUTH_PLUGIN_DATA_PART... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>) const override;
void readPayloadImpl(ReadBuffer & payload) override;
void writePayloadImpl(WriteBuffer & buffer) const override;
public:
Handshake();
Handshake(
uint32_t capability_flags_, uint32_t connection_id_,
String server_version_, String auth_plugin_name_, Stri... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/MySQL/PacketsGeneric.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace MySQLProtocol
{
namespace Generic
{
static const size_t MYSQL_ERRMSG_SIZE = 512;
void SSLRequest::readPayloadImpl(ReadBuffer & buf)
{
buf.readStrict(reinterpret_cast<char *>(&c... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Core/MySQL/IMySQLReadPacket.h>
#include <Core/MySQL/IMySQLWritePacket.h>
namespace DB
{
namespace MySQLProtocol
{
namespace Generic
{
const size_t MAX_PACKET_LENGTH = (1 << 24) - 1; // 16 mb
enum StatusFlags
{
SERVER_SESSION_STATE_CHANGED = 0x4000
};
enum Capability
{
CLIENT_CONNEC... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ement_id_, uint16_t num_columns_, uint16_t num_params_, uint16_t warnings_count_)
: statement_id(statement_id_), num_columns(num_columns_), num_params(num_params_), warnings_count(warnings_count_)
{
}
}
}
}
<|fim_prefix|>#include <Core/MySQL/PacketsPreparedStatements.h>
#include <IO/WriteHelpers.h>
#i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/MySQL/IMySQLWritePacket.h>
namespace DB
{
namespace MySQLProtocol
{
namespace<|fim_suffix|>& buffer) const override;
public:
PreparedStatementResponseOK(uint32_t statement_id_, uint16_t num_columns_, uint16_t num_params_, uint16_t warnings_count_);
};
}
}
}
<|fim_middle|... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> break;
}
}
}
}
}
}
<|fim_prefix|>#include <Core/MySQL/PacketsProtocolBinary.h>
#include <base/DayNum.h>
#include <base/types.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnVector.h>
#include <Columns/IColumn.h>
#include <Common/LocalDate.h>
#include <Common/LocalD... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s & columns_, size_t row_num_);
};
}
}
}
<|fim_prefix|>#pragma once
#include <vector>
#include <Columns/IColumn_fwd.h>
#include <Core/DecimalFunctions.h>
#include <Core/MySQL/IMySQLReadPacket.h>
#include <Core/MySQL/IMySQLWritePacket.h>
#include <DataTypes/IDataType.h>
namespace DB
{
namespace MySQLProt... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/MySQL/PacketsProtocolText.h>
#include <Core/MySQL/MySQLUtils.h>
#include <Columns/ColumnNullable.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include <Common/assert_cast.h>
#include <Core/MySQL/IMySQLWritePacket.h>
#include <DataTypes/D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Columns/IColumn_fwd.h>
#include <DataTypes/IDataType.h>
#include <Core/MySQL/IMySQLReadPacket.h>
#include <Core/MySQL/IMySQLWritePacket.h>
namespace DB
{
namespace MySQLProtocol
{
namespace ProtocolText
{
enum CharacterSet
{
utf8_general_ci = 33,
binary = 63
};
// htt... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>("", 0);
const UInt64 position = 4;
buffer.write(reinterpret_cast<const char *>(&position), 8);
UInt32 gtid_size = static_cast<UInt32>(gtid_datas.size());
buffer.write(reinterpret_cast<const char *>(>id_size), 4);
buffer.write(gtid_datas.data(), gtid_datas.size());
}
}
}
}
<|fim_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/MySQLPacketPayloadReadBuffer.h>
#include <IO/MySQLPacketPayloadWriteBuffer.h>
#include <Core/MySQL/PacketEndpoint.h>
/// Implementation of MySQL wire protocol.
/// Works only on little-endian architecture.
namespace DB
{
namespace MySQLProtocol
{
namespace Replication
{
///... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>.update(column_name);
return hash.get64();
}
}
<|fim_prefix|>#include <Core/Names.h>
#include <Co<|fim_middle|>mmon/SipHash.h>
namespace DB
{
size_t NamesHash::operator()(const Names & column_names) const
{
SipHash hash;
for (const auto & column_name : column_names)
hash<|endoftext... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <vector>
#include <string>
#include <set>
#include <unordered_set>
#include <unordered_map>
namespace DB
{
using Names = s<|fim_suffix|>NameToNameVector = std::vector<std::pair<std::string, std::string>>;
using NameToIndexMap = std::unordered_map<std::string, size_t>;
using Name... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>asPair> { using type = String; };
}
<|fim_prefix|>#pragma once
#include <map>
#include <list>
#include <optional>
#include <string>
#include <set>
#include <initializer_list>
#include <DataTypes/IDataType.h>
#include <Core/Names.h>
namespace DB
{
class NameAndAliasPair
{
public:
NameAndAliasPair(c... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>());
for (const NameAndTypePair & column : *this)
res.insert(column.name);
return res;
}
std::unordered_map<std::string, DataTypePtr> NamesAndTypesList::getNameToTypeMap() const
{
std::unordered_map<std::string, DataTypePtr> res;
res.reserve(size());
for (const NameAndTypePair... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>name;
else if constexpr (I == 1)
return name_and_type.type;
}
/// auto & [name, type] = name_and_type
template <int I>
std::tuple_element_t<I, NameAndTypePair> & get(NameAndTypePair & name_and_type)
{
if constexpr (I == 0)
return name_and_type.name;
else if constexpr (I == 1)
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma o<|fim_suffix|>E = 3,
SAMPLING_KEY = 4,
};
}
<|fim_middle|>nce
#include <base/types.h>
namespace DB
{
/// Deprecated. Used only to define a type for the obsolete setting.
enum class ParallelReplicasCustomKeyFilterType : UInt8
{
DEFAULT,
RANGE,
};
enum class ParallelReplicasMode :... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> if (ret.back().intersectsRange(cur))
ret.back() = *ret.back().unionWith(cur);
else
ret.push_back(cur);
}
return ret;
}
Ranges PlainRanges::makePlainFromUnordered(Ranges ranges_)
{
if (ranges_.size() <= 1)
return ranges_;
std::sort(ranges_.begin(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>return PlainRanges({Range::createWholeUniverseWithoutNull()}); }
};
}
<|fim_prefix|>#pragma once
#include <Core/Range.h>
namespace DB
{
/** A plain ranges is a series of ranges who
* 1. have no intersection in any two of the ranges
* 2. ordered by left side
* 3. does not contain blank... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/PostgreSQL/Connection.h>
#if USE_LIBPQXX
#include <Common/logger_useful.h>
namespace postgres
{
Connection::Connection(const ConnectionInfo & connection_info_, bool replication_, size_t num_tries_)
: connection_info(connection_info_), replication(replication_), num_tries(num_tries_)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ction();
void tryUpdateConnection();
bool isConnected() const { return connection != nullptr && connection->is_open(); }
const ConnectionInfo & getConnectionInfo() { return connection_info; }
String getInfoForLog() const { return connection_info.host_port; }
private:
pqxx::Connec... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include "config.h"
#if USE_LIBPQXX
#include <pqxx/pqxx>
#include <Core/Types.h>
#include <base/BorrowedObjectPool.h>
#include <Core/PostgreSQL/Connection.h>
namespace postgres
{
using Pool = BorrowedObjectPool<ConnectionPtr>;
using PoolPtr = std::shared_ptr<Pool>;
class ConnectionHolder
{
public:
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/PostgreSQL/PoolWithFailover.h>
#include <memory>
#if USE_LIBPQXX
#include <Core/PostgreSQL/Utils.h>
#include <Common/ReplicasReconnector.h>
#include <Common/parseRemoteDescription.h>
#include <Common/Exception.h>
#include <Common/quoteString.h>
#include <Common/logger_useful.h>
#include <... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#include <memory>
#if USE_LIBPQXX
#include <Core/PostgreSQL/ConnectionHolder.h>
#include <mutex>
#include <Poco/Util/AbstractConfiguration.h>
#include <Storages/StoragePostgreSQL.h>
static constexpr inline auto POSTGRESQL_POOL_DEFAULT_SIZE = 16;
static constexpr inline auto POSTGR... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/PostgreSQL/Utils.h>
#if USE_LIBPQXX
#include <IO/Operators.h>
#include <IO/WriteHelpers.h>
namespace postgres
{
ConnectionInfo formatConnectionString(String dbname, String host, UInt16 port, St<|fim_suffix|>tring & postgres_database_name, const String & postgres_table_name)
{
/// Lo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_LIBPQXX
#include <pqxx/pqxx>
#include <Core/Types.h>
#include <Co<|fim_suffix|>>
namespace pqxx
{
using ReadTransaction = pqxx::read_transaction;
using ReplicationTransaction = pqxx::transaction<isolation_level::repeatable_read, write_policy::read_only>... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> which(nested);
std::function<Field(std::string & fields)> parser;
if (which.isUInt8())
parser = [](std::string & field) -> Field
{
if (field == "t")
return UInt8(1);
else if (field == "f")
return UInt8(0);
return... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> std::function<Field(std::string & field)> pqxx_parser;
};
void insertPostgreSQLValue(
IColumn & column, std::string_view value,
ExternalResultDescription::ValueType type, DataTypePtr data_type,
const std::unordered_map<size_t, PostgreSQLArrayInfo> & array_info, size_t idx);
v... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>se TypeIndex::Float32:
return {ColumnType::FLOAT4, 4};
case TypeIndex::Float64:
return {ColumnType::FLOAT8, 8};
case TypeIndex::FixedString:
case TypeIndex::String:
return {ColumnType::VARCHAR, -1};
case TypeIndex::Date:
ret... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> name (C string)
// + object ID of the table (Int32 and always zero) + attribute number of the column (Int16 and always zero)
// + type object id (Int32) + data type size (Int16)
// + type modifier (Int32 and always -1) + format code (Int16)
return static_cast<Int32>((name.... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Protocol.h>
#include <base/EnumReflection.h>
namespace DB::Protocol
{
namespace Server
{
std::string_view toStr<|fim_suffix|>w toString(UInt64 packet)
{
return magic_enum::enum_name(Enum(packet));
}
}
}
<|fim_middle|>ing(UInt64 packet)
{
return magic_enum::enum_name(Enum(packet... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>values
/// - ProfileInfo - serialized BlockStreamProfileInfo structure.
///
/// If a query returns data, the server sends an empty header block containing
/// the description of resulting columns before executing the query.
/// Using this block the client can initialize the output formatter and display th... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
namespace DB
{
/// In the names below, "REVISION" and "PROTOCOL_VERSION" are synonyms.
static constexpr auto DBMS_MIN_REVISION_WITH_CLIENT_INFO = 54032;
static constexpr auto DBMS_MIN_REVISION_WITH_SERVER_TIMEZONE = 54058;
static constexpr auto DBMS_MIN_REVISION_WITH_QUOTA_KEY_IN_CLIENT_IN... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> beginning and at the end
auto pos = maybe_qualified_name.find('.');
if (pos == 0 || pos == (maybe_qualified_name.size() - 1))
return {};
QualifiedTableName name;
if (pos == std::string::npos)
{
name.table = maybe_qualified_name;
}
else if (maybe_qualified_name... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <optional>
#include <string>
#include <tuple>
#include <vector>
namespace DB
{
//TODO replace with StorageID
struct QualifiedTableName
{
std::string database;
std::string table;
bool ope<|fim_suffix|>g> getParts() const
{
if (data... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>h DataTypeEnum8
enum QueryLogElementType : int8_t
{
QUERY_START = 1,
QUERY_FINISH = 2,
EXCEPTION_BEFORE_START = 3,
EXCEPTION_WHILE_PROCESSING = 4,
};
}
<|fim_prefix|>#pragma once
#include <cstdint>
name<|fim_middle|>space DB
{
// Make it signed for compatibility wit<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/QueryProcessingStage.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
namespace QueryProcessingStage
{
Enum fromString(const std::string & stage_string)
{
Enum stage = {};
if (stage_string == "complete"... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
namespace DB
{
/// Up to what stage the SELECT query is executed or needs to be executed.
namespace QueryProcessingStage
{
/// Numbers matter - the later stage has a larger number.
///
/// It is part of Protocol ABI, add values only to the end.
/// ... | fim | ClickHouse/ClickHouse | c |
#include <Columns/IColumn.h>
#include <Core/Range.h>
#include <IO/Operators.h>
#include <IO/WriteBufferFromString.h>
#include <Common/FieldVisitorToString.h>
#include <Common/FieldAccurateComparison.h>
namespace DB
{
FieldRef::FieldRef(ColumnsWithTypeAndName * columns_, size_t row_idx_, size_t column_idx_)
: Fie... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Core/ColumnsWithTypeAndName.h>
#include <Core/Field.h>
/** Range between fields, used for index analysis
* (various arithmetic on intervals of various forms).
*/
namespace DB
{
/** A field, that can be stored in two representations:
* - A standalone field.
* - A field with reference t... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
};
}
<|fim_prefix|>#prag<|fim_middle|>ma once
#include <cstdint>
namespace DB
{
enum class SchemaInferenceMode : uint8_t
{
DEFAULT,
UNION,<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> only what was last loaded from the config.
/// This function returns the live value (as a string) for such settings, or `std::nullopt` when the setting
/// has no live-value override and the configured value in `*this` is authoritative.
std::optional<String> tryGetLiveValueAsString(ContextPtr... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/ServerUUID.h>
#include <Core/UUID.h>
#include <Interpreters/Context.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Common/logger_useful.h>
#include <Common/ErrnoException.h>
namespace DB
{
namesp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/UUID.h>
#include <Common/Logger.h>
#include <filesystem>
namespace fs = std::filesystem;
namespace DB
{
class ServerUUID
{
inline static UUID server_uuid = UUIDHelpers::Nil;
public:
/// Returns persistent UUID of current clickhouse-server or clickhouse-keeper insta... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|><ASTFunction> & func)
: value{func}
{
}
SettingFieldASTFunction::SettingFieldASTFunction(const String & str)
: value{parseASTFunction(str)}
{
}
SettingFieldASTFunction::SettingFieldASTFunction(const Field & f)
: SettingFieldASTFunction{f.safeGet<String>()}
{
}
SettingFieldASTFunction & Sett... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>unction & operator =(const boost::intrusive_ptr<ASTFunction> & func) { value = func; changed = true; return *this; }
SettingFieldASTFunction & operator =(const String & str);
SettingFieldASTFunction & operator =(const Field & f);
bool isChanged() const { return changed; }
void setChanged(... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstddef>
/// Typed index for accessing a setting field within a settings Data struct.
/// Stores the byte offset of the field, enabling type-safe access via operator[].
/// The Owner tag prevents cross-class index misuse at compile time:
/// e.g. SettingIn<|fim_suffix|>erent type ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/BaseSettingsFwdMacros.h>
#include <Core/Field.h>
#include <Core/SettingsEnums.h>
#include <Core/SettingsFields.h>
#include <Core/SettingsTierType.h>
#include <Core/SettingsWriteFormat.h>
#include <base/types.h>
#include <Common/SettingsChanges.h>
#include <string_view>
#inclu... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Core/Field.h>
#include <Common/ClickHouseVersion.h>
#include <map>
#include <vector>
namespace DB
{
namespace SettingsChangesHistory
{
struct SettingChange
{
String name;
Field previous_value;
Field new_value;
String reason;
};
using SettingsC... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/Common/SQLSecurityDefs.h>
#include <Core/SettingsEnums.h>
#include <base/EnumReflection.h>
#include <Common/Exception.h>
#include <Formats/FormatSettings.h>
#include <boost/range/adaptor/map.hpp>
namespace DB
{
namespace ErrorCodes
{
extern const int UNKNOWN_LOAD_BALANCING;
ex... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>enum class TransactionsWaitCSNMode : uint8_t
{
ASYNC,
WAIT,
WAIT_UNKNOWN,
};
DECLARE_SETTING_ENUM(TransactionsWaitCSNMode)
DECLARE_SETTING_ENUM_WITH_RENAME(CapnProtoEnumComparingMode, FormatSettings::CapnProtoEnumComparingMode)
DECLARE_SETTING_ENUM_WITH_RENAME(EscapingRule, FormatSettings::... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>er & out) const
{
/// Note that this returns an UInt64 (for both seconds and milliseconds units) for compatibility reasons as the value
/// for seconds used to be a integer (now a Float64)
/// This method is only used to communicate with clients or servers older than DBMS_MIN_REVISION_WITH_SET... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Field.h>
#include <Core/MultiEnum.h>
#include <base/types.h>
#include <Poco/Timespan.h>
#include <Poco/URI.h>
#include <string_view>
namespace DB
{
class ReadBuffer;
class WriteBuffer;
/** Type-erased operation table for setting fields.
* One static instance per concrete... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
// clang-format off
#define MAKE_OBSOLETE(M, TYPE, NAME, DEFAULT) \
<|fim_suffix|>"Obsolete setting, does nothing.", SettingsTierType::OBSOLETE)
/// NOTE: ServerSettings::loadSettingsFromConfig() should be updated to include this settings
#define MAKE_DEPRECATED_BY_SERVER_CONFIG(M, TYPE, NA... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Defines.h>
#include <Core/Settings.h>
#include <Core/SettingsQuirks.h>
#include <Poco/Environment.h>
#include <Poco/Platform.h>
#include <Common/VersionNumber.h>
#include <Common/getNumberOfCPUCoresToUse.h>
#include <Common/logger_useful.h>
namespace
{
/// Detect does epoll_wait with nes... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Logger.h>
namespace DB
{
struct Settings;
/// Update some settings defaults to avoid some known issues.
void<|fim_suffix|>values. Alters the value to a reasonable one if not
void doSettingsSanityCheckClamp(Settings & settings, LoggerPtr log);
}
<|fim_middle|> applySetting... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/SettingsTierType.h>
#include <DataTypes/DataTypeEnum.h>
namespace DB
{
std::shared_ptr<DataTypeEnum8> <|fim_suffix|>ttingsTierType::BETA)}
});
}
}
<|fim_middle|>getSettingsTierEnum()
{
return std::make_shared<DataTypeEnum8>(
DataTypeEnum8::Values
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>000,
OBSOLETE = 0b0100,
EXPERIMENTAL = 0b1000,
BETA = 0b1100
};
std::shared_ptr<DataTypeEnum8> getSettingsTierEnum();
}
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <cstdint>
#include <memory>
namespace DB
{
template <typename Type>
class DataTypeEnum;
using DataTypeEnum8 ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstdint>
enum class SettingsWriteFormat : uint8_t
{
BINARY = <|fim_suffix|>behaviour.
STRINGS_WITH_FLAGS = 1, /// All settings are serialized as strings. Before each value the flag `is_important` is serialized.
DEFAULT = STRINGS_WITH_FLAGS,
};
<|fim_middle|>0, /// Part... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> DISABLE, // Disable short-circuit function evaluation.
};
}
<|fim_prefix|>#pragma once
#include <cstdint>
namespace DB
{
enum class ShortCircuitFunctionEvaluation : uint8_t
{
ENABLE, // Use short-circuit function evaluation for functions that are suitable for it.
FORCE_ENABLE, // Use short-... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lumnSortCursor<ColumnType>>();
return true;
});
}
if (!result)
initializeQueues<SimpleSortCursor>();
}
else
{
initializeQueues<SortCursor>();
}
}
DataTypes SortQueueVariants::extractSortDescriptionTypesFromHeader(con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>for (size_t i = 0; i < size; ++i)
{
if (cursors[i].empty())
continue;
queue.emplace_back(&cursors[i]);
}
std::make_heap(queue.begin(), queue.end());
if constexpr (strategy == SortingQueueStrategy::Batch)
{
if (!... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ared<CompiledSortDescriptionFunctionHolder>(std::move(compiled_sort_description), std::move(jit_owner));
});
compiled_sort_description_holder = std::static_pointer_cast<CompiledSortDescriptionFunctionHolder>(compiled_function_cache_entry);
}
else
{
LOG_TRACE(getLogger(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r> & b)
{
if (unlikely(a && b))
return *a == *b;
return a == b;
}
bool operator==(const SortColumnDescription & other) const
{
return column_name == other.column_name && direction == other.direction && nulls_direction == other.nulls_direction
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Streaming/CursorTree_fwd.h>
#include <Core/Streaming/CursorTree.h>
#include <Common/Exception.h>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/split.hpp>
#include <variant>
#include <vector>
namespace DB
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ode of cursor tree, which represents logical entry of cursor.
/// Example: partition/shard etc.
class CursorTreeNode
{
using Data = std::map<String, std::variant<Int64, CursorTreeNodePtr>>;
public:
bool hasSubtree(const String & key) const;
const CursorTreeNodePtr & getSubtree(const String & ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ree);
}
<|fim_prefix|>#pragma once
#include <Core/Field.h>
#include <memory>
namespace DB
{
class CursorTreeNode;
using CursorTreeNodePtr = std::shared_ptr<CursorTreeNode>;
Map cursorTreeToMap(const CursorTreeNodePtr & ptr)<|fim_middle|>;
CursorTreeNodePtr buildCursorTree(const Map & collapsed_t<|en... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>t);
auto flat2 = cursorTreeToMap(root);
ASSERT_EQ(flat2.size(), flat.size());
}
TEST(CursorTree, ThrowsOnMissingKey)
{
auto root = std::make_shared<CursorTreeNode>();
ASSERT_ANY_THROW((void)root->getValue("missing"));
ASSERT_ANY_THROW((void)root->getSubtree("missing"));
}
TEST(Curso... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.