text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>functions by it's arguments in GROUP BY section."; }
void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
};
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
<|fim_middle|>
/* Eliminates injective functions in GROUP BY section.
*/
class Optimi... | fim | ClickHouse/ClickHouse | c |
#include <Analyzer/Passes/OptimizeRedundantFunctionsInOrderByPass.h>
#include <Functions/IFunction.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/HashUtils.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/QueryNode.h>
#include <Analyzer/SortNode.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** If ORDER BY has argument x followed by f(x) transforms it to ORDER BY x.
* Optimize ORDER BY x, y, f(x), g(x, y), f(h(x)), t(f(x), g(x)) into ORDER BY x, y
* in case if f(), g(), h(), t() are deterministic (in scope of query).
*... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/OptimizeTrivialGroupByLimitPass.h>
#include <Analyzer/AggregationUtils.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/QueryNode.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/Context.h>
#include <Interpreters/convertFieldToT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/// When a query has GROUP BY and LIMIT without HAVING, ORDER BY, WINDOW, LIMIT BY clauses,
/// GROUP BY modifiers or aggregate functions in the projection, we can optimize it by setting
/// max_rows_to_group_b<|fim_suffix|>_by_overflow_m... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
auto & query_limit_by_nodes = query_node->getLimitBy().getNodes();
for (auto & limit_by_node : query_limit_by_nodes)
{
auto [_, inserted] = unique_expressions_nodes_set.emplace(limit_by_node.get());
if (inserted)
res... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Eliminate duplicate columns from ORDER BY and LIMIT BY.
*
* Example: SELECT * FROM test_table ORDER BY id, id;
* Result: SELECT<|fim_suffix|>ation"; }
String getDescription() override { return "Remove duplicate columns from... | fim | ClickHouse/ClickHouse | c |
#include <Analyzer/Passes/OrderByTupleEliminationPass.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/QueryNode.h>
#include <Analyzer/SortNode.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
class OrderByTupleEliminationVisitor : public InD... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ROM test_table ORDER BY a, b;
*/
class OrderByTupleEliminationPass final : public IQueryTreePass
{
public:
String getName() override { return "OrderByTupleElimination"; }
String getDescription() override { return "Remove tuple from ORDER BY."; }
void run(QueryTreeNodePtr & query_tree_node,... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/PruneArrayJoinColumnsPass.h>
#include <Analyzer/ArrayJoinNode.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/QueryNode.h>
#include <Analyzer/Utils.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Prune unused ARRAY JOIN expressions and unused subcolumns from `nested()` functions.
*
* 1. If ARRAY JOIN has multiple expressions and some are not referenced
* anywhere in the query, remove the unused expressions.
*
* 2.... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** This pass make initial query analysis.
*
* 1. All identifiers are resolved. Next passes can expect that there will be no IdentifierNode in query tree.
* 2. All matchers are resolved. Next p... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> = function_node_arguments_nodes[1]->as<ConstantNode>();
if (!constant_node)
return;
if (auto constant_type = constant_node->getResultType(); !isString(constant_type))
return;
String regexp = constant_node->getValue().safeGet<String>();
RegexpAnaly... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r than
/// \1 and some subpatterns in the regexp, or \0 and no subpatterns in the regexp, rewrite it with extract.
///
/// 3. If an extract function has a regexp with some subpatterns and the regexp starts with ^.* or ending with an
/// unescaped .*$, remove this prefix and/or suffix.
class RegexpFunction... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/RemoveUnusedProjectionColumnsPass.h>
#include <Functions/FunctionFactory.h>
#include <Analyzer/AggregationUtils.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/QueryNode.h>
#include <Analyzer/SortNode.h>
#include <Analyzer/UnionNode.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Remove unused projection columns in subqueries.
*
* Example: SELECT a FROM (SELECT a, b FROM test_table);
* Result: SELECT a FROM (SELECT a FROM test_table);
*/
class RemoveUnusedProjectionColumnsPass final : public IQueryTree... | fim | ClickHouse/ClickHouse | c |
#include <Analyzer/Passes/RewriteAggregateFunctionWithIfPass.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeAggregateFunction.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <Core/Settings.h>
#include <Functions/FunctionFactory.h>
#include <Analyzer/ConstantNode.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/// Rewrite '<aggregate-function>(if())' to '<aggregate-function>If[OrNull]()'
/// sum(if(cond, a, 0)) -> sumIf[OrNull](a, cond)
/// sum(if(cond, a, null)) -> sumIf[OrNull](a, cond)
/// <|fim_suffix|>final : public IQueryTreePass
{
public... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>etNodes().push_back(func_plus_minus_nodes[column_id]);
resolveAggregateFunctionNodeByName(*lhs, lhs->getFunctionName());
const auto rhs_count = std::make_shared<FunctionNode>("count");
rhs_count->getArguments().getNodes().push_back(func_plus_minus_nodes[column_id]);
resolv... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/**
* Rewrites `sum(column +/- literal)` into two individual functions
* `sum(column)` and `literal * count(column)`.
* sum(column + literal) -> sum(column) + literal * count(column)
* sum(literal + column) -> literal * count(column) ... | fim | ClickHouse/ClickHouse | c |
#include <Analyzer/Passes/ShardNumColumnToFunctionPass.h>
#include <Storages/IStorage.h>
#include <Functions/FunctionFactory.h>
#include <Interpreters/Context.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/Utils.h>
#include <Analyzer/FunctionNode.h>
#include <An... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>num column into shardNum() function"; }
void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
};
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Rewrite _shard_num column into shardNum(<|fim_middle|>) function.
*
* Example: SELECT _sh... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/SumIfToCountIfPass.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <AggregateFunctions/IAggregateFunction.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/Utils.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Rewrite `sum(if(cond, value_1, value_2))` and `sumIf` functions to `countIf`.
*
* Example: SELECT sumIf(1, cond);
* Result: SELECT countIf(cond);
*
* Example: SELECT sum(if(cond, 1, 0));
* Result: SELECT countIf(cond);
*... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tics depend on the full ORDER BY list.
if (query->isLimitWithTies())
return;
/// If any ORDER BY element uses WITH FILL or COLLATE, do not optimize.
/// Collation can make distinct GROUP BY key values compare equal,
/// so tiebreaker expressions after them must... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tr context) override;
};
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** When a query has both GROUP BY and ORDER BY, the sort order is fully determined
* once all GROUP BY keys (or injective functions of them) appear in the ORDER BY prefix.
* Any remaining ORD... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/UniqInjectiveFunctionsEliminationPass.h>
#include <Functions/IFunction.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <AggregateFunctions/IAggregateFunction.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/FunctionNode.h>
#include <Anal... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Remove injective functions from `uniq*` functions arguments.
*
* Exampl<|fim_suffix|>rride;
};
}
<|fim_middle|>e: SELECT uniq(injectiveFunction(argument));
* Result: SELECT uniq(argument);
*/
class UniqInjectiveFunctionsElim... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ePtr & node)
{
if (!getSettings()[Setting::optimize_uniq_to_count])
return;
auto * query_node = node->as<QueryNode>();
if (!query_node)
return;
/// Check that query has only single table expression which is subquery
auto * subquery_node... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once<|fim_suffix|>unt` over subquery.
* Example: 'SELECT uniq(x ...) FROM (SELECT DISTINCT x ...)' to
* Result: 'SELECT count() FROM (SELECT DISTINCT x ...)'
*
* Example: 'SELECT uniq(x ...) FROM (SELECT x ... GROUP BY x ...)' to
* Result: 'SELECT count() FROM (SELECT x ... GR... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> return it->second;
auto column = std::make_shared<ColumnNode>(NameAndTypePair(col_name, type), node);
resolved_map[col_name] = column;
return column;
}
/// it is constant
return node;
}
QueryTreeNodes new_args;
for (const auto ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ss, DB::DataTypePtr columnType, const String & cond, const String & expected);
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
#include <base/types.h>
void testPassOnCondition(DB::Quer<|fim_middle|>yTreePassPtr pa<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/IdentifierNode.h>
#include <Analyzer/QueryTreeBuilder.h>
#include <Analyzer/Passes/LikePerfectAffixRewritePass.h>
#include <Analyzer/Passes/tests/gtest_analyzer_utils.h>
#include <Analyzer/Util... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/IdentifierNode.h>
#include <Analyzer/Passes/LogicalExpressionOptimizerPass.h>
#include <Analyzer/Passes/tests/gtest_analyzer_utils.h>
#include <Analyzer/QueryTreeBuilder.h>
#include <Analyzer/U... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>);
if (hasOffset())
select_query->setExpression(ASTSelectQuery::Expression::LIMIT_OFFSET, getOffset()->toAST(options));
if (hasSettingsChanges())
{
auto settings_query = make_intrusive<ASTSetQuery>();
settings_query->changes = settings_changes;
settings_query-... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>= 5;
static constexpr size_t having_child_index = 6;
static constexpr size_t window_child_index = 7;
static constexpr size_t qualify_child_index = 8;
static constexpr size_t order_by_child_index = 9;
static constexpr size_t interpolate_child_index = 10;
static constexpr size_t limi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/QueryTreeBuilder.h>
#include <unordered_set>
#include <Common/FieldVisitorToString.h>
#include <Common/quoteString.h>
#include <DataTypes/FieldToDataType.h>
#include <Parsers/ASTSelectWithUnionQuery.h>
#include <Parsers/ASTSelectIntersectExceptQuery.h>
#include <Parsers/ASTExpression... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Parsers/IAST_fwd.h>
#include <Storages/IStorage_fwd.h>
#include <Interpreters/Context_fwd.h>
#include <Analyzer/IQu<|fim_suffix|> represent a list of expressions ASTExpressionList.
* AST that represent expression ASTIdentifier, ASTAsterisk, ASTLiteral, ASTFunction.
*
* For QU... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/QueryTreePassManager.h>
#include <memory>
#include <Common/Exception.h>
#include <IO/WriteHelpers.h>
#include <IO/Operators.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <Interpreters/Context.h>
#include <Analyzer/ColumnNode.h>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ssPtr> passes;
};
void addQueryTreePasses(QueryTreePassManager & manager, bool only_analyze = false);
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
/** Query tree pass manager provide functionality to register and run passes
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/RecursiveCTE.h>
#include <Storage<|fim_suffix|>std::move(columns_))
{}
StorageID RecursiveCTETable::getStorageID() const
{
return storage->getStorageID();
}
}
<|fim_middle|>s/IStorage.h>
namespace DB
{
RecursiveCTETable::RecursiveCTETable(TemporaryTableHolderPtr holder_,
St... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/NamesAndTypes.h>
#include <Interpreters/DatabaseCatalog.h>
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/TableNode.h>
namespace DB
{
/** Recursive CTEs allow to recursively evaluate UNION subqueries.
*
* Overview:
* https://www.postgresql.org/docs/current/q... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nd())
visitExpression(current, &it->second);
/// If not in the map, skip this subquery — we cannot properly
/// determine column correlation without its scope information.
continue;
}
}
... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <ranges>
#include <IO/Operators.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <Analyzer/FunctionNode.h>
namespace DB
{
class ExpressionsStack
{
public:
void push(const QueryTreeNodePtr & node)
{
if (node->hasAlias())
{
const auto & node... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ontext::EXPRESSION;
}
bool isFunctionLookup() const
{
return lookup_context == IdentifierLookupContext::FUNCTION;
}
bool isTableExpressionLookup() const
{
return lookup_context == IdentifierLookupContext::TABLE_EXPRESSION;
}
String dump() const
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Resolve/IdentifierResolveScope.h>
#include <Analyzer/QueryNode.h>
#include <Analyzer/UnionNode.h>
#include <Core/Settings.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace Setting
{
extern const SettingsBool group_by_use_nulls;
extern const SettingsBool join_use_nu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>or table:
* Table node can be used in expression context only as right argument of IN function. In that case identifier is used
* as table node projection name.
* Example: SELECT id IN test_table FROM test_table;
* Result projection name is `in(id, test_table)`.
*/
using ProjectionName = String;... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/IQueryTreeNode.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/NestedUtils.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Interpreters/MaterializedCTE.h>
#include <Storages/IStorage.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ierResolveScope & scope);
static bool tryBindIdentifierToArrayJoinExpressions(
const IdentifierLookup & identifier_lookup,
const IdentifierResolveScope & scope);
static std::shared_ptr<TableNode> tryResolveTableIdentifier(
const Identifier & table_identifier,
cons... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>r table_expression_, bool only_analyze_)
: table_expression(std::move(table_expression_))
, only_analyze(only_analyze_)
{}
QueryAnalysisPass::QueryAnalysisPass(bool only_analyze_) : only_analyze(only_analyze_) {}
void QueryAnalysisPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <unordered_map>
#include <unordered_set>
#include <Analyzer/TableNode.h>
#include <Interpreters/Context_fwd.h>
#include <Analyzer/HashUtils.h>
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/Resolve/IdentifierLookup.h>
#include <Analyzer/Resolve/IdentifierResolver.h>
#inclu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>mbda_node.contains(alias))
addDuplicatingAlias(cloned_alias_node);
break;
}
}
}
ScopeAliases & aliases;
};
}
<|fim_prefix|>#pragma once
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/Resolve/ScopeAliases.h>
#include <Anal... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/Utils.h>
#include <fmt/ranges.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
/// Used to replace columns that changed type because of JOIN to their original type
class ReplaceColumnsVisitor : ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/Resolve/IdentifierLookup.h>
namespace DB
{
struct ScopeAliases
{
/// Alias name to query expression node
std::unordered_map<std::string, QueryTreeNodePtr> alias_name_to_expression_node;
/// Alias name to lambda node
s... | fim | ClickHouse/ClickHouse | c |
#include <Analyzer/Resolve/TableExpressionData.h>
namespace DB
{
void AnalysisTableExpressionData::ensureColumnMembershipSetsArePopulated() const
{
if (column_membership_sets_populated)
return;
column_names.reserve(column_names_and_types.size());
column_identifier_first_parts.reserve(column_names_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/Operators.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/Identifier.h>
#include <DataTypes/NestedUtils.h>
namespace DB
{
struct StringTransparentHash
{
using is_transparent = void;
using hash = std::hash<std::string_view>;
[[maybe_unused]] size_t operator(... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>().get();
}
default:
{
break;
}
}
return false;
}
private:
void updateAliasesIfNeeded(const QueryTreeNodePtr & node)
{
if (!node->hasAlias())
return;
const auto & node_alias = node->g... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>OIN)
has_join = true;
}
bool needChildVisit(const QueryTreeNodePtr &, const QueryTreeNodePtr &) { return true; }
bool shouldReplaceWithClusterAlternatives() const
{
return subquery_count <= 1 && !has_join && ((table_count + table_function_count) == 1 || (table_functio... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> {
auto expression_identifier = Identifier(argument_name);
valid_identifiers_result.insert(expression_identifier);
auto result_type = getExpressionNodeResultTypeOrNull(expression);
if (identifier_is_compound && result_type)
{
co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>id_identifiers);
};
}
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <unordered_set>
#include <vector>
namespace DB
{
class IDataType;
using DataTypePtr = std::shared_ptr<const IDataType>;
class IQueryTreeNode;
using QueryTreeNodePtr = std::shared_ptr<IQueryTreeNode>;
class Identifier;
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Resolve/QueryAnalyzer.h>
#include <DataTypes/DataTypeString.h>
#include <Columns/ColumnTuple.h>
#include <Analyzer/Resolve/IdentifierResolveScope.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/QueryNode.h>
#include <Analyzer/QueryTreePassManager.h>
#include <Analyzer/UnionNode... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Analyzer/Resolve/QueryAnalyzer.h>
#include <DataTypes/DataTypeString.h>
#include <Analyzer/Resolve/IdentifierResolveScope.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/IdentifierNode.h>
#include <Analyzer/JoinNode.h>
#include <Analyzer/LambdaNode.h>
#include <Analyzer/MatcherNode.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>, NULL, (NULL, NULL)}
if (all_tuple_elements_nullable)
append_set_elements(res, build_from_single_value(rhs, rhs_type));
}
return res;
}
}
/// 1 in 1; (1, 2) in (1, 2); identity(tuple(tuple(tuple(1)))... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/ColumnsWithTypeAndName.h>
#include <memory>
namespace DB
{
class IDataType;
using DataTypePtr = std::shared_ptr<const IDataType>;
class Field;
class Set;
using SetPtr = std::shared_ptr<Set>;
struct GetSetElementParams
{
bool transform_null_in = true;
bool forbid_un... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>onst ConvertToASTOptions & options) const
{
auto result = make_intrusive<ASTOrderByElement>();
result->direction = sort_direction == SortDirection::ASCENDING ? 1 : -1;
result->nulls_direction = result->direction;
if (nulls_sort_direction)
result->nulls_direction = *nulls_sort_direc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>{
ASCENDING = 0,
DESCENDING = 1
};
const char * toString(SortDirection sort_direction);
class SortNode final : public IQueryTreeNode
{
public:
/// Initialize sort node with sort expression
explicit SortNode(QueryTreeNodePtr expression_,
SortDirection sort_direction_ = SortDirecti... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/TableExpressionModifiers.h>
#include <Common/SipHash.h>
#include <Core/Streaming/CursorTree.h>
#include <<|fim_suffix|>(SipHash & hash_state) const
{
hash_state.update(has_final);
hash_state.update(sample_size_ratio.has_value());
hash_state.update(sample_offset_ratio.has_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>onModifiers::StreamSettings & rhs)
{
if ((lhs.cursor_tree == nullptr) != (rhs.cursor_tree == nullptr))
return false;
if (lhs.cursor_tree == nullptr)
return true;
return cursorTreeToMap(lhs.cursor_tree) == cursorTreeToMap(rhs.cursor_tree);
}
inline bool operator==(const Table... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/TableFunctionNode.h>
#include <Common/assert_cast.h>
#include <Common/SipHash.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteHelpers.h>
#include <IO/Operators.h>
#include <Storages/IStorage.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTSetQuery.h>
#include <Interpreter... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ngs changes passed to table function
const SettingsChanges & getSettingsChanges() const
{
return settings_changes;
}
/// Set settings changes passed as last argument to table function
void setSettingsChanges(SettingsChanges settings_changes_)
{
settings_changes = s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>;
if (hasAlias())
buffer << ", alias: " << getAlias();
buffer << ", table_name: " << storage_id.getFullNameNotQuoted();
if (!temporary_table_name.empty())
buffer << ", temporary_table_name: " << temporary_table_name;
if (table_expression_modifiers)
{
buffer ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/HashUtils.h>
#include <Storages/IStorage_fwd.h>
#include <Storages/TableLockHolder.h>
#include <Interpreters/Context_fwd.h>
#include <Interpreters/StorageID.h>
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/TableExpressionModifiers.h>
namespace DB
{
/** Table ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/UnionNode.h>
#include <Common/assert_cast.h>
#include <Common/SipHash.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteHelpers.h>
#include <IO/Operators.h>
#include <Parsers/ASTExpressionList.h>
#include <Parsers/ASTTablesInSelectQuery.h>
#include <Parsers/ASTWithElement.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ld_index]->as<ListNode &>();
}
/// Get union node queries node
const QueryTreeNodePtr & getQueriesNode() const
{
return children[queries_child_index];
}
/// Get union node queries node
QueryTreeNodePtr & getQueriesNode()
{
return children[queries_child_ind... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>| name == "nothingUInt64" || name == "nothingNull")
return;
function_node->resolveAsAggregateFunction(resolveAggregateFunction(*function_node, function_node->getFunctionName()));
}
else if (function_node->isWindowFunction())
{
function_node->resolveAsWindowFunction(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Storages/IStorage_fwd.h>
#include <Interpreters/Context_fwd.h>
#include <Analyzer/IQueryTreeNode.h>
#include <Core/Field.h>
#include <Core/Names.h>
#include <Columns/IColumn_fwd.h>
namespace DB
{
class FunctionNode;
class ColumnNode;
using ColumnNodePtr = std::shared_ptr<Colu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> subtree_size += node_to_tree_size[constant_node->getSourceExpression()];
node_to_tree_size.emplace(node_to_process, subtree_size);
continue;
}
auto node_to_size_it = node_to_tree_size.find(node_to_process);
if (node_to_size_it != node_to_tree_size.end(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>reeNodePtr & group_by_key_node);
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreeNode.h>
namespace DB
{
/// Validate PREWHERE, WHERE, HAVING in query node
void validateFilters(const QueryTreeNodePtr & query_node);
struct AggregatesValidationParams
{
bool group_by_use_nulls = false;
};
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>empty())
throw Exception(ErrorCodes::ILLEGAL_AGGREGATION,
"Window function {} is found {} in query",
function_node->formatASTForErrorMessage(),
assert_no_window_functions_place_message);
if (window_function_nodes)
window_func... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rt_no_window_functions_place_message);
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreeNode.h>
namespace DB
{
/** Collect window function nodes in node children.
* Do not visit subqueries.
*/
QueryTreeNodes collectWindowFunctionNodes(const QueryTreeNodePtr & node);
/** Collect window fu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> hash_state.update(window_frame.begin_type);
applyVisitor(FieldVisitorHash(hash_state), window_frame.begin_offset);
hash_state.update(window_frame.begin_preceding);
hash_state.update(window_frame.end_type);
applyVisitor(FieldVisitorHash(hash_state), window_frame.end_offset);
hash_state... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> {
return children[frame_end_offset_child_index];
}
QueryTreeNodeType getNodeType() const override
{
return QueryTreeNodeType::WINDOW;
}
void dumpTreeImpl(WriteBuffer & buffer, FormatState & format_state, size_t indent) const override;
protected:
bool isEqualImp... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>eplaced_nodes_set;
};
}
void createUniqueAliasesIfNecessary(QueryTreeNodePtr & node, const ContextPtr & context)
{
/*
* For each table expression in the Query Tree generate and add a unique alias.
* If table expression had an alias in initial query tree, override it.
*/
CreateUniq... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma on<|fim_suffix|>ryTreeNodePtr & node, const ContextPtr & context);
}
<|fim_middle|>ce
#include <memory>
#include <Interpreters/Context_fwd.h>
namespace DB
{
class IQueryTreeNode;
using QueryTreeNodePtr = std::shared_ptr<IQueryTreeNode>;
void createUniqueAliasesIfNecessary(Que<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ode)
{
if (auto * table_node = node->as<TableNode>())
{
if (table_node->isMaterializedCTE())
{
const auto & materialized_cte = table_node->getMaterializedCTE();
if (!reused_materialized_cte.contains(materialized_cte))
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
#include <unorde<|fim_suffix|>edCTEIfNeeded(QueryTreeNodePtr & node, ReusedMaterializedCTEs & reused_materialized_cte, ContextPtr context);
}
<|fim_middle|>red_set>
namespace DB
{
class IQueryTreeNode;
using QueryTreeNodePtr = std::shared_ptr<IQueryT... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>(identifier_view.getFullName(), "value3");
identifier_view.popFirst();
ASSERT_EQ(identifier_view.getFullName(), "");
ASSERT_TRUE(identifier_view.isEmpty());
}
{
Identifier identifier("value1.value2.value3");
IdentifierView identifier_view(identifier);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <DataTypes/DataTypesNumber.h>
#include <Analyzer/Identifier.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/ListNode.h>
using namespace DB;
class SourceNode final : public IQueryTreeNode
{
public:
SourceNode() : IQueryTreeNode(0 /*children_size*/) {}<|fim_s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#<|fim_suffix|> else
{
for (const auto & child : current_node->getChildren())
{
if (!child)
continue;
if (should_visit_predicate(current_node, child))
nodes_to_process.push_back({ .... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> size_t num_local_restores = counters.local_restores;
size_t num_on_cluster_restores = counters.on_cluster_restores.size();
if (on_cluster)
{
if (!counters.on_cluster_restores.contains(zookeeper_path))
++num_on_cluster_rest... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/defines.h>
#include <base/scope_guard.h>
#include <base/types.h>
#include <mutex>
#include <unordered_map>
namespace DB
{
class BackupConcurrencyCounters;
/// Local checker for concurrent BACKUP or RESTORE operations.
/// This class is used by implementations of IBackupCoor... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>sControlHolder("removeAllNodes", retries_kind);
holder.retries_ctl.retryLoop([&, &zookeeper = holder.faulty_zookeeper]()
{
with_retries.renewZooKeeper(zookeeper);
zookeeper->removeRecursive(zookeeper_path);
});
std::lock_guard lock{mutex};
t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/WithRetries.h>
namespace DB
{
/// Removes all the nodes from ZooKeeper used to coordinate a BACKUP ON C<|fim_suffix|>Cleaner
{
public:
BackupCoordinationCleaner(bool is_restore_, const String & zookeeper_path_, const WithRetries & with_retries_, LoggerPtr log_);
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Backups/BackupCoordinationFileInfos.h>
#include <Backups/getBackupDataFileName.h>
#include <Common/quoteString.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BACKUP_ENTRY_ALREADY_EXISTS;
extern const int BAD_ARGUMENTS;
extern const int LOGI... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_length;
};
explicit BackupCoordinationFileInfos(const Config & config_)
: config(config_)
{
}
/// Adds file infos for the specified host.
void addFileInfos(BackupFileInfos && file_infos, const String & host_id);
/// Returns file infos for the specified host after pr... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ionKeeperMapTables::getDataPath(const std::string & table_zookeeper_root_path) const
{
return tables_with_info.at(table_zookeeper_root_path).data_path_in_backup;
}
}
<|fim_prefix|>#include <Backups/Ba<|fim_middle|>ckupCoordinationKeeperMapTables.h>
namespace DB
{
void BackupCoordinationKeeperMapTab... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <unordered_map>
#include <string>
namespace DB
{
struct BackupCoordinationKeeperMapTables
{
void addTable(const std::string & table_zookeeper_root_path, const std::string & table_id, const std::string & data_path_in_backup);
std::string getDataPath(const std::string & tabl... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ookeeper_root_path, table_id, data_path_in_backup);
}
String BackupCoordinationLocal::getKeeperMapDataPath(const String & table_zookeeper_root_path) const
{
std::lock_guard lock(keeper_map_tables_mutex);
return keeper_map_tables.getDataPath(table_zookeeper_root_path);
}
void BackupCoordinationL... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Backups/IBackupCoordination.h>
#include <Backups/BackupConcurrencyCheck.h>
#include <Backups/BackupCoordinationFileInfos.h>
#include <Backups/BackupCoordinationReplicatedAccess.h>
#include <Backups/BackupCoordinationReplicatedSQLObjects.h>
#include <Backups/BackupCoordinationReplic... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>s_list_element_)
: backup_uuid(*backup_settings_.backup_uuid)
, root_zookeeper_path(root_zookeeper_path_)
, zookeeper_path(root_zookeeper_path_ + "/backup-" + toString(backup_uuid))
, keeper_settings(keeper_settings_)
, all_hosts(all_hosts_)
, all_hosts_without_initiator(excludeIni... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.