text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>}
<|fim_prefix|>#pragma once
#include <base/types.h>
<|fim_middle|>#include <Parsers/IAST_fwd.h>
#include <unordered_map>
namespace DB
{
using Aliases = std::unordered_map<String, ASTPtr>;
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ApplyWithAliasVisitor.h>
#include <Interpreters/misc.h>
#include <Parsers/ASTSelectQuery.h>
#include <Parsers/ASTSelectWithUnionQuery.h>
#include <Common/checkStackSize.h>
namespace DB
{
void ApplyWithAliasVisitor::visit(ASTPtr & ast, const Data & data)
{
checkStackSize();
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ta & data);
};
}
<|fim_prefix|>#pragma once
#include <map>
#include <base/types.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
/// Propagate every WITH alias expression to its descendant subqueries, with correct scoping visibility.
class ApplyWithAliasVisitor
{
public:
struct Data
{
s... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ApplyWithGlobalVisitor.h>
#include <Parsers/ASTSelectQuery.h>
#include <Parsers/ASTSelectWithUnionQuery.h>
#include <Parsers/ASTSelectIntersectExceptQuery.h>
#include <Parsers/ASTWithAlias.h>
#include <Common/checkStackSize.h>
namespace DB
{
void ApplyWithGlobalVisitor::visit(AST... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>balVisitor
{
public:
static void visit(ASTPtr & ast);
private:
static void visit(ASTSelectWithUnionQuery & selects, const std::map<String, ASTPtr> & exprs, const ASTPtr & with_expression_list);
static void visit(ASTSelectQuery & select, const std::map<String, ASTPtr> & exprs, const ASTPtr & w... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lone();
table.subquery->as<ASTSubquery &>().cte_name = table_id.table_name;
if (!old_alias.empty())
table.subquery->setAlias(old_alias);
table.children.emplace_back(table.subquery);
}
}
}
}
void ApplyWithSubqueryV... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> void visit(ASTTableExpression & table, const Data & data);
void visit(ASTFunction & func, const Data & data);
const bool use_analyzer;
};
}
<|fim_prefix|>#pragma once
#include <map>
#include <Interpreters/Context_fwd.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class ASTFunction;
class... | fim | ClickHouse/ClickHouse | c |
#include <unordered_set>
#include <Common/typeid_cast.h>
#include <Parsers/ASTLiteral.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTSubquery.h>
#include <Parsers/ASTTablesInSelectQuery.h>
#include <Interpreters/ArithmeticOperationsInAgrFuncOptimize.h>
#include <Poco/String.h>
namespace DB
{
namespace Err... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Parsers/IAST_fwd.h>
#include <Interpreters<|fim_suffix|>/// [min|max|avg]([multiply|divide|plus|minus]) -> [multiply|divide|plus|minus]([min|max|avg])
/// TODO: groupBitAnd, groupBitOr, groupBitXor
/// TODO: better constant detection: f(const) is not detected as const.
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#incl<|fim_suffix|>umns;
bool is_left = false;
};
}
<|fim_middle|>ude <Core/Names.h>
namespace DB
{
struct ArrayJoin
{
Names col<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/typeid_cast.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeMap.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnMap.h>
#include <Columns/ColumnReplicated.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IF... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block.h>
#include <Core/Names.h>
#include <map>
namespace DB
{
class IFunctionOverloadResolver;
using FunctionOverloadResolverPtr = std::shared_ptr<IFunctionOverloadResolver>;
class DataTypeArray;
class ColumnArray;
std::shared_ptr<const DataTypeArray> getArrayJoinDataType... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Names.h>
#include <Parsers/ASTSubquery.h>
#include <Parsers/ASTSelectQuery.h>
#include <Parsers/ASTTablesInSelectQuery.h>
#include <Parsers/ASTIdentifier.h>
#include <DataTypes/NestedUtils.h>
#include <Interpreters/InDepthNodeVisitor.h>
#include <Interpreters/IdentifierSeman... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/AsynchronousInsertLog.h>
#include <base/getFQDNOrHostName.h>
#include <Common/DateLUTImpl.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataT<|fim_suff... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/AsynchronousInsertQueueDataKind.h>
#include <Interpreters/SystemLog.h>
#include <Core/NamesAndAliases.h>
#include <Storages/ColumnsDescription.h>
namespace DB
{
struct AsynchronousInsertLogElement
{
enum Status : int8_t
{
Ok = 0,
ParsingError ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> }
catch (...)
{
bool log_error = true;
logQueryException(query_log_elem, insert_context, start_watch, key.query, query_span, internal, log_error);
if (!log_elements.empty())
{
auto exception = getCurrentExceptionMessage(false);
auto flush_t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block.h>
#include <Parsers/IAST_fwd.h>
#include <Processors/Chunk.h>
#include <Common/Logger.h>
#include <Common/MemoryTrackerSwitcher.h>
#include <Common/SettingsChanges.h>
#include <Common/SharedMutex.h>
#include <Common/ThreadPool.h>
#include <Common/StringWithMemoryTrackin... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>onousInsertQueueDataKind : uint8_t
{
Parsed = 0,
Preprocessed = 1,
};
}
<|fim_prefix|>#<|fim_middle|>pragma once
#include <cstdint>
namespace DB
{
enum class Asynchr<|endoftext|> | fim | ClickHouse/ClickHouse | c |
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/AsynchronousMetricLog.h>
#include <Parsers/ExpressionEle... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>har * getDefaultOrderBy() { return "metric, event_date, event_time"; }
};
}
<|fim_prefix|>#pragma once
#include <Interpreters/SystemLog.h>
#include <Common/AsynchronousMetrics.h>
#include <Core/NamesAndAliases.h>
#include <Storages/ColumnsDescription.h>
namespace DB
{
/** AsynchronousMetricLog is a l... | fim | ClickHouse/ClickHouse | c |
#include <Interpreters/BackgroundSchedulePoolLog.h>
#include <base/getFQDNOrHostName.h>
#include <Common/DateLUTImpl.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeDate... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>"BackgroundSchedulePoolLog"; }
static ColumnsDescription getColumnsDescription();
static NamesAndAliases getNamesAndAliases();
void appendToBlock(MutableColumns & columns) const;
};
/// Instead of typedef - to allow forward declaration.
class BackgroundSchedulePoolLog : public SystemLog<Bac... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e number of files inside the archive if the backup is stored as an archive. It is not the same as `num_files` if it's an incremental backup or if it contains empty files or duplicates. The following is always true: `num_entries ≤ num_files`."},
{"uncompressed_size", std::make_shared<DataTypeUInt64... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/Syste<|fim_suffix|>:system_clock::time_point event_time{};
Decimal64 event_time_usec{};
BackupOperationInfo info{}; /// NOLINT(bugprone-throw-keyword-missing)
static std::string name() { return "BackupLog"; }
static ColumnsDescription getColumnsDescrip... | fim | ClickHouse/ClickHouse | c |
#include <Interpreters/BlobStorageLog.h>
#include <base/getFQDNOrHostName.h>
#include <Common/DateLUTImpl.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeEnum.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <Data... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma on<|fim_suffix|>orageLog"; }
static ColumnsDescription getColumnsDescription();
static NamesAndAliases getNamesAndAliases() { return {}; }
void appendToBlock(MutableColumns & columns) const;
};
class BlobStorageLog : public SystemLog<BlobStorageLogElement>
{
public:
using System... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/BloomFilter.h>
#include <city.h>
#include <Columns/ColumnArray.h>
#include <Common/Exception.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnLowCardinality.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeLowC... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>d addHashWithSeed(const UInt64 & hash, const UInt64 & hash_seed);
bool findHashWithSeed(const UInt64 & hash, const UInt64 & hash_seed) const;
/// Checks if this contains everything from another bloom filter.
/// Bloom filters must have equal size and seed.
bool contains(const BloomFilter ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/HashTable/Hash.h>
#include <Columns/IColumn.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnDecimal.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnString.h>
#include <Columns/Colu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ignore_aliases=*/ true) &&
ast->getColumnName() == rhs.ast->getColumnName();
}
}
<|fim_prefix|>#include <Interpreters/CNFQueryAtomicFormula.h>
#include <Parsers/IAST.h>
namespace DB
{
/// for set
bool CNFQueryAtomicFormula::operator<(const CNFQueryAtomicFormula<|fim_middle|> & rhs) const
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Parsers/IAST_fwd.h>
namespace DB<|fim_suffix|>rmula & rhs) const;
bool operator==(const CNFQueryAtomicFormula & rhs) const;
};
}
<|fim_middle|>
{
struct CNFQueryAtomicFormula
{
bool negative = false;
ASTPtr ast;
/// for set
bool operator<(const CNFQueryAtomi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/Cache/QueryConditionCache.h>
#include <Common/ProfileEvents.h>
#include <Common/CurrentMetrics.h>
#include <Common/SipHash.h>
#include <Common/logger_useful.h>
#include <Core/UUID.h>
#include <IO/WriteHelpers.h>
namespace ProfileEvents
{
extern const Event QueryConditionCacheHi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/CacheBase.h>
#include <Common/HashTable/Hash.h>
#include <Common/Logger.h>
#include <Storages/MergeTree/MarkRange.h>
#include <Common/SharedMutex.h>
namespace DB
{
/// An implementation of predicate caching a la https://doi.org/10.1145/3626246.3653395
///
/// Given the tab... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/Cache/QueryResultCache.h>
#include <Functions/FunctionFactory.h>
#include <Functions/UserDefined/UserDefinedSQLFunctionFactory.h>
#include <Functions/UserDefined/UserDefinedExecutableFunctionFactory.h>
#include <Interpreters/Context.h>
#include <Interpreters/DatabaseCatalog.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nique_ptr<SourceFromChunks> source_from_chunks_extremes;
std::chrono::time_point<std::chrono::system_clock> created_at;
std::chrono::time_point<std::chrono::system_clock> expires_at;
LoggerPtr logger = getLogger("QueryResultCache");
friend class QueryResultCache; /// for createReader()
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Write, /// query result written into query result cache
Read, /// query result read from query result cache
};
}
<|fim_prefix|>#pragma once
#include <cstdint>
namespace DB
{
enum class QueryResultCacheUsage : uint8_t
{
Unknown, /// <|fim_middle|>we don't know what what happened
Non... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Common/CacheBase.h>
#include <Common/CurrentMetrics.h>
#include <Common/PODArray.h>
#include <Common/SipHash.h>
namespace DB
{
struct CacheKey
{
UInt128 domain_id;
UInt128 value_hash;
bool operator==(const CacheKey & rhs) const { return domain... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> This ensures tasks are never cancelled before their timeout, only slightly after.
const UInt64 end_time = ((now_ms + capped_timeout + CANCELLATION_GRID_MS - 1) / CANCELLATION_GRID_MS) * CANCELLATION_GRID_MS;
auto iter = query_set.emplace(query, capped_timeout, end_time, overflow_mode);
if (it... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>= delete;
CancellationChecker & operator=(const CancellationChecker &) = delete;
void terminateThread();
// Method to add a new task to the multiset. Returns true if the task was added.
[[nodiscard]] bool appendTask(const QueryStatusPtr & query, Int64 timeout, OverflowMode overflow_mode)... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tatement.
enum class CancellationCode : uint8_t
{
NotFound = 0, /// already cancelled
QueryIsNotInitializedYet = 1,
CancelCannotBeSent = 2,
CancelSent = 3,
Unknown = 255
};
}
<|fim_prefix|>#pragma once
namespace DB
{
/// A result cod<|fim_middle|>e for the KILL Q... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ient_tcp_protocol_version == other.client_tcp_protocol_version;
}
String ClientInfo::getVersionStr() const
{
return fmt::format("{}.{}.{} ({})", client_version_major, client_version_minor, client_version_patch, client_tcp_protocol_version);
}
void ClientInfo::fillOSUserHostNameAndVersionInfo()
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ool is_shared_catalog_internal = false;
/// For parallel processing on replicas
bool collaborate_with_initiator{false};
UInt64 obsolete_count_participating_replicas{0};
UInt64 number_of_current_replica{0};
bool empty() const { return query_kind == QueryKind::NO_QUERY; }
/** Seri... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> address.password,
address.proto_send_chunked,
address.proto_recv_chunked,
address.quota_key,
address.cluster,
address.cluster_secret,
"server",
addres... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Client/ConnectionPool_fwd.h>
#include <Core/Protocol.h>
#include <Core/Types.h>
#include <Common/Macros.h>
#include <Common/Exception.h>
#include <Common/MultiVersion.h>
#include <Common/Priority.h>
#include <Poco/Net/SocketAddress.h>
#include <Poco/Timespan.h>
#include <map>
#include <optiona... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <algorithm>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <unordered_map>
#include <unordered_set>
#include <base/getFQDNOrHostName.h>
#include <Common/Config/ConfigHelper.h>
#include <Common/Exception.h>
#include <Common/FailPoint.h>
#include <Comm... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> size_t zk_root_index;
ClusterInfo(const String & name_,
const String & zk_name_,
const String & zk_root_,
const String & host_name,
const String & username_,
const String & password_,
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ClusterFunctionReadTask.h>
#include <Interpreters/SetSerialization.h>
#include <Interpreters/Context.h>
#include <AggregateFunctions/AggregateFunctionGroupBitmapData.h>
#include <Core/Settings.h>
#include <Core/ProtocolDefines.h>
#include <Common/Exception.h>
#include <Common/logger... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Storages/ObjectStorage/DataLakes/DataLakeObjectMetadata.h>
#include <Processors/Formats/IInputFormat.h>
#include <Storages/ObjectStorage/DataLakes/Iceberg/IcebergDataObjectInfo.h>
#include <Storages/ObjectStorage/IObjectIterator.h>
namespace DB
{
class Read... | fim | ClickHouse/ClickHouse | c |
#include <Client/IConnections.h>
#include <Core/Settings.h>
#include <Interpreters/AddDefaultDatabaseVisitor.h>
#include <Interpreters/Cluster.h>
#include <Interpreters/ClusterProxy/SelectStreamFactory.h>
#include <Interpreters/DatabaseCatalog.h>
#include <Interpreters/InterpreterSelectQueryAnalyzer.h>
#include <Interp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreeNode.h>
#include <Client/ConnectionPool.h>
#include <Core/QueryProcessingStage.h>
#include <Interpreters/Cluster.h>
#include <Interpreters/StorageID.h>
#include <Parsers/IAST_fwd.h>
#include <QueryPipeline/UnavailableShardTracker.h>
#include <Storages/IStorage_fw... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <algorithm>
#include <Common/CurrentThread.h>
#include <unordered_map>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnBLOB.h>
#include <Columns/ColumnTuple.h>
#include <Columns/FilterDescription.h>
#include <Columns/IColumn_fwd.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ector<std::pair<std::string, IndexAnalysisPartsRanges>>;
using LocalIndexAnalysisCallback = std::function<IndexAnalysisPartsRanges(const std::vector<std::string_view> & parts)>;
/// Do index analysis on replicas from the cluster_for_parallel_replicas
/// by sending mergeTreeAnalyzeIndexesUUID() to each ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/QueryNode.h>
#include <Analyzer/UnionNode.h>
#include <Columns/ColumnConst.h>
#include <Common/ProfileEvents.h>
#include <Core/QueryProcessingStage.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/Cluster.h>
#include <Interpreters/ClusterProxy/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> QueryPlan & query_plan,
const StorageID & storage_id,
const SelectQueryInfo & query_info,
const ColumnsDescription & columns,
const StorageSnapshotPtr & snapshot,
QueryProcessingStage::Enum processed_stage,
const QueryTreeNodePtr & query_tree,
ContextPtr context);
void execu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Parsers/ASTIdentifier.h>
#include <Interpreters/CollectJoinOnKeysVisitor.h>
#include <Interpreters/Identifie<|fim_suffix|>ftIdentifier(table_numbers.second)))
{
bool null_safe_comparison = func.name == "isNotDistinctFrom";
data.addJoinKeys(left, right, table_numb... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ction>())
{
visit(*func, ast, data);
}
else if (auto * ident = ast->as<ASTIdentifier>())
{
visit(*ident, ast, data);
}
else
{
if (ast->children.empty())
throw Exception(ErrorCodes::INVALID_JOIN_ON_E... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ias columns
Visitor(data).visit(ast);
}
}
}
}
<|fim_prefix|>#include <Interpreters/ColumnAliasesVisitor.h>
#include <Interpreters/IdentifierSemantic.h>
#include <Interpreters/RequiredSourceColumnsVisitor.h>
#include <Interpreters/addTypeConversionToAST.h>
#include <Parsers/ASTTa<... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_columns;
NameSet array_join_source_columns;
ContextPtr context;
const std::unordered_set<IAST *> & excluded_nodes;
/// private_aliases are from lambda, so these are local names.
NameSet private_aliases;
/// Check if query is changed by this visitor.
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ComparisonGraph.h>
#include <Parsers/IAST.h>
#include <Parsers/ASTLiteral.h>
#include <Parsers/ASTFunction.h>
#include <Common/FieldAccurateComparison.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/ConstantNode.h>
#include <Functions/FunctionFactory.h>
#include <algor... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|><std::pair<size_t, size_t>> not_equal;
/// Maximal constant value for each component that
/// is lower bound for all expressions in component.
std::vector<ssize_t> node_const_lower_bound;
/// Minimal constant value for each component that
/// is upper bound for all expressions in com... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ComparisonTupleEliminationVisitor.h>
#include <Parsers/ASTSelectQuery.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTLiteral.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
namespace
{
ASTs splitTuple(const ASTPtr & node)
{
if (const ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
static bool needChildVisit(ASTPtr &, const ASTPtr &);
static void visit(ASTPtr & ast, Data & data);
};
using ComparisonTupleEliminationVisitor = InDepthNodeVisitor<ComparisonTupleEliminationMatcher, true>;
}
<|fim_prefix|>#pragma once
#include <Interpreters/InDepthNodeVisitor.h>
#include <Inte... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnSparse.h>
#include <Columns/FilterDescription.h>
#include <Columns/IColumn.h>
#include <Core/Names.h>
#include <Core/NamesAndTypes.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/Serializations/ISerialization.h>
#include <Interp... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ing_params, any_take_last_row, external_join_threshold);
}
std::shared_ptr<IJoin> cloneNoParallel(const std::shared_ptr<TableJoin> & table_join_, SharedHeader, SharedHeader right_sample_block_) const override
{
return std::make_shared<HashJoin>(table_join_, right_sample_block_, any_ta... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> (In particular, such cancellation can be done from DDL worker thread itself.
/// We do it when dropping refreshable materialized views.)
/// 4. If the query was interrupted, it'll throw a QUERY_WAS_CANCELLED and will have no effect.
/// If the query already started execution, int... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_WARNING_FOR_READ(const_cast<ContextTimeSeriesTagsCollector *>(this)->getIDMap<IDType>());
}
#define TIME_SERIES_ID_TO_TAGS_MAP_INSTANTIATE(IDType) \
template void ContextTimeSeriesTagsCollector::storeTags<IDType>(const IDType & id, const TagNamesAndValuesPtr & tags); \
template void ContextTime... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Common/SharedMutex.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Core/Types.h>
namespace DB
{
class ColumnString;
/// Mapping between identifiers and tags which are collected in the context of the currently executed query.
///
/// Set of tags are always sorted.
///
/// Different i... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
<|fim_prefix|>#include <Interpreters/Context_fwd.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
template <typename Shared>
Shared WithContextImpl<Shared>::getContext() const
{
auto ptr = context.lock();
if (!ptr)
throw Exce... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <map>
#include <memory>
namespace DB
{
class Block;
/// Scalar results of subqueries
using Scalars = std::map<String, Block>;
class Context;
/// Most used types have shorter names
using ContextPtr = std::shared_ptr<const Context>;
using ContextMutableP... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ConvertFunctionOrLikeVisitor.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTLiteral.h>
#include <Parsers/IAST.h>
#include <Common/likePatternToRegexp.h>
#include <Common/typeid_cast.h>
namespace DB
{
void ConvertFunctionOrLikeData::vis... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/InDepthNodeVisitor.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class ASTFunction;
/// Replaces all the "or"'s with {i}like to mult<|fim_suffix|>or<OneTypeMatcher<ConvertFunctionOrLikeData>, true>;
}
<|fim_middle|>iMatchAny
class ConvertFunctionOrLikeData
{
publ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>visit(*func, data);
}
void ConvertStringsToEnumMatcher::visit(ASTFunction & function_node, Data & data)
{
if (!function_node.arguments)
return;
/// We are not sure we could change the type of function result
/// cause it is present in other function as argument
if (data.used_func... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <Interpreters/InDepthNodeVisitor.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class ASTFunction;
struct FindUsedFunctionsMatcher
{
using Visitor = ConstInDepthNodeVisitor<FindUsedFun<|fim_suffix|>tatic b... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>dress not mapped to object')."},
{"current_exception_trace_full", std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>()), "Current exception stack trace with symbolized frames (std::terminate crashes only)."},
{"version", std::make_shared<DataTypeString>(), "ClickHouse server ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>std::shared_ptr<CrashLog> crash_log_)
{
crash_log = crash_log_;
}
static consteval size_t getDefaultMaxSize() { return 1024; }
static consteval size_t getDefaultReservedSize() { return 1024; }
static consteval size_t getDefaultFlushIntervalMilliseconds() { return 1000; }
s... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/typeid_cast.h>
#include <Interpreters/CrossToInnerJoinVisitor.h>
#include <Interpreters/DatabaseAndTableWithAlias.h>
#include <Interpreters/IdentifierSemantic.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTLiteral.h>
#include <Parsers/ASTSelect... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ta & data);
};
using CrossToInnerJoinVisitor = InDepthNodeVisitor<CrossToInnerJoinMatcher, true>;
}
<|fim_prefix|>#pragma once
#include <Interpreters/InDepthNodeVisitor.h>
#include <In<|fim_middle|>terpreters/Aliases.h>
namespace DB
{
class ASTSelectQuery;
struct TableWithColumnNamesAndTypes;
/// AS... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/SharedMutex.h>
#include <mutex>
namespace DB
{
/// Allows executing DDL query only in one thread.
/// Puts an element into the map, locks tables's mutex, counts how much threads run parallel query on the table,
/// when counter is 0 erases element in the destructor.
/// I... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rt(current_active_hosts.size());
}
bool DDLOnClusterQueryStatusSource::nullableErrorAndStatusFields(DistributedDDLOutputMode output_mode)
{
return !(
output_mode == DistributedDDLOutputMode::THROW || ///
output_mode == DistributedDDLOutputMode::NONE || ///
output_mode == Distr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>edHosts() const override;
Strings getNodesToWait() override;
Chunk handleTimeoutExceeded() override;
Chunk stopWaitingOfflineHosts() override;
void handleNonZeroStatusCode(const ExecutionStatus & status, const String & host_id) override;
void fillHostStatus(const String & host_id, cons... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/AccessControl.h>
#include <Access/Role.h>
#include <Access/User.h>
#include <Core/ServerSettings.h>
#include <Core/ServerUUID.h>
#include <Core/Settings.h>
#include <Databases/DatabaseReplicated.h>
#include <IO/Operators.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Interpreters/Cluster.h>
#include <Common/OpenTelemetryTracingContext.h>
#include <Common/SettingsChanges.h>
#include <Common/ZooKeeper/Types.h>
#include <filesystem>
namespace Poco
{
class Logger;
}
namespace zkutil
{
class ZooKeeper;
}
namespace fs = std... | fim | ClickHouse/ClickHouse | c |
#include <Common/CurrentThread.h>
#include <Common/QueryScope.h>
#include <Core/ServerSettings.h>
#include <Core/ServerUUID.h>
#include <Core/Settings.h>
#include <Databases/DatabaseReplicated.h>
#include <IO/NullWriteBuffer.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>oKeeperPtr, zkutil::EphemeralNodeHolderPtr>> active_node_holders;
};
}
<|fim_prefix|>#pragma once
#include <Core/Names.h>
#include <Interpreters/Context_fwd.h>
#include <Interpreters/DDLTask.h>
#include <Parsers/IAST_fwd.h>
#include <Storages/IStorage_fwd.h>
#include <Poco/Event.h>
#include <Common/Cur... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>me from different servers.
*/
task_handle->scheduleAfter(static_cast<size_t>(update_period_seconds) * 1000);
}
void DNSCacheUpdater::start()
{
LOG_INFO(getLogger("DNSCacheUpdater"), "Update period {} seconds", update_period_seconds);
task_handle->activateAndSchedule();
}
DNSCacheUpdate... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>period_seconds_, UInt32 max_consecutive_failures);
~DNSCacheUpdater();
void start();
private:
void run();
Int32 update_period_seconds;
UInt32 max_consecutive_failures;
BackgroundSchedulePool & pool;
BackgroundSchedulePoolTaskHolder task_handle;
};
}
<|fim_prefix|>#pragma o... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/DatabaseAndTableWithAlias.h>
#include <Interpreters/IdentifierSemantic.h>
#include <Interpreters/Context.h>
#include <Interpreters/getTableExpressions.h>
#include <Common/quoteString.h>
#include <Common/typeid_cast.h>
#include <Parsers/IAST.h>
#include <Parsers/ASTIdentifier.h>
#i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Names.h>
#include <base/types.h>
#include <Core/NamesAndTypes.h>
#include <Parsers/IAST_fwd.h>
#include <memory>
#include <optional>
#include <Core/UUID.h>
namespace DB
{
class ASTSelectQuery;
class ASTIdentifier;
class ASTTableIdentifier;
struct ASTTableExpression;
/// E... | fim | ClickHouse/ClickHouse | c |
#include <Interpreters/DatabaseCatalog.h>
#include <Common/CurrentThread.h>
#include <Access/ContextAccess.h>
#include <Core/BackgroundSchedulePool.h>
#include <Core/ServerSettings.h>
#include <Core/Settings.h>
#include <Core/UUID.h>
#include <Databases/DatabaseMemory.h>
#include <Databases/DatabaseOnDisk.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>x, counter),
/// counter: how many threads are running a query on the table at the same time
/// For the duration of the operation, an element is placed here, and an object is returned,
/// which deletes the element in the destructor when counter becomes zero.
/// In case the element alrea... | fim | ClickHouse/ClickHouse | c |
#include <Interpreters/DeadLetterQueue.h>
#include <Core/Settings.h>
#include <Common/DateLUTImpl.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypeString.h>
#include <DataTy... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>{ return "DeadLetterQueue"; }
static ColumnsDescription getColumnsDescription();
static NamesAndAliases getNamesAndAliases();
void appendToBlock(MutableColumns & columns) const;
};
class DeadLetterQueue : public SystemLog<DeadLetterQueueElement>
{
using SystemLog<DeadLetterQueueElement>:... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/ContextAccess.h>
#include <Core/Settings.h>
#include <Core/SettingsTierType.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeEnum.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/SystemLog.h>
#include <Storages/ColumnsDescription.h>
namespace DB
{
struct DeltaMetadataLogElement
{
time_t current_time{};
String query_id;
String table_path;
String file_path;
String metadata_content;
static std::string name() { return "De... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> 0);
NullMap filtered_null_map(offsets.size(), 0);
size_t offset = 0;
for (size_t i = 0; i < offsets.size(); ++i)
{
size_t n = offsets[i] - offsets[i - 1];
if (n == 0)
continue;
filtered_null_map[i] = null_map[offset];
filter[offset] = 1;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nResultPtr joinBlock(Block block) override;
size_t getTotalRowCount() const override { return 0; }
size_t getTotalByteCount() const override { return 0; }
bool alwaysReturnsEmptySet() const override { return false; }
bool isFilled() const override { return true; }
IBlocksStreamPtr... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/DirectJoinMergeTreeEntity.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnSet.h>
#include <Columns/ColumnsNumber.h>
#include <Core/Block.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeSet.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionF... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/PODArray_fwd.h>
#include <Core/Block.h>
#include <Core/ColumnsWithTypeAndName.h>
#include <Core/Names.h>
#include <Processors/Chunk.h>
#include <Interpreters/IKeyValueEntity.h>
#include <Storages/IStorage_fwd.h>
#include <Storages/StorageSnapshot.h>
#include <Interpreters/Co... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>utedDDLOutputMode::THROW_ONLY_ACTIVE || output_mode == DistributedDDLOutputMode::NONE_ONLY_ACTIVE;
waiting_hosts = NameSet(hosts_to_wait.begin(), hosts_to_wait.end());
only_running_hosts = output_mode == DistributedDDLOutputMode::THROW_ONLY_ACTIVE
|| output_mode == DistributedDDLOutputMo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>20;
bool throw_on_timeout = true;
bool throw_on_timeout_only_active = false;
bool only_running_hosts = false;
bool timeout_exceeded = false;
bool stop_waiting_offline_hosts = false;
};
}
<|fim_prefix|>#pragma once
#include <filesystem>
#include <DataTypes/DataTypeEnum.h>
#include <In... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.