text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#include <AggregateFunctions/registerAggregateFunctions.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <AggregateFunctions/Combinators/AggregateFunctionCombinatorFactory.h>
namespace DB
{
struct Settings;
class AggregateFunctionFactory;
void registerAggregateFunctionAvg(Aggregate... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
n<|fim_suffix|>uct Settings;
void registerAggregateFunctions();
}
<|fim_middle|>amespace DB
{
str<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>erializeDeserializeEmpty)
{
TheilsUWindowData data;
TheilsUWindowData restored;
roundTrip(data, restored);
EXPECT_EQ(restored.count, 0u);
EXPECT_TRUE(std::isnan(restored.getResult()));
}
TEST(TheilsUWindowData, GetResultCountLessThanTwo)
{
/// count == 0
TheilsUWindowData em... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <string>
#include <base/types.h>
#include <AggregateFunctions/DDSketch.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/ReadBufferFromString.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteBufferFromVector.h>
#include <IO/WriteHelpers.h>
#include <Common/Base64.h>
#include <Common... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <IO/WriteBufferFromString.h>
#include <IO/ReadBufferFromString.h>
#include <Common/PODArray.h>
#include <AggregateFunctions/StatCommon.h>
#include <gtest/gtest.h>
TEST(Ranks, Simple)
{
using namespace DB;
RanksArray sample = {310, 195, 480,<|fim_suffix|>85, 450, 450, 465, 545, 170, 180... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <AggregateFunctions/UniqExactSet.h>
#include <Common/HashTable/HashSet.h>
#include <Common/ThreadPool.h>
#include <Common/VectorWithMemoryTracking.h>
#include <gtest/gtest.h>
using namespace DB;
namespace
{
/// Instantiate the same concrete type used by AggregateFunctionUniqExact<UInt64>.
usin... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
return result;
}
void collectAggregateFunctionNodes(const QueryTreeNodePtr & node, QueryTreeNodes & result)
{
CollectAggregateFunctionNodesVisitor visitor(&result);
visitor.visit(node);
}
bool hasAggregateFunctionNodes(const QueryTreeNodePtr & node)
{
CollectAggregateFunctionNodesVisit... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Analyzer/IQueryTreeNode.h>
namespace DB
{
/** Collect aggregate function nodes in node children.
* Do not visit subqueries.
*/
QueryTreeNodes collectAggregateFunctionNodes(const QueryTreeNodePtr & node);
/** Collect aggregate function nodes in node children and add them into result.
* D... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/ArrayJoinNode.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/Utils.h>
#include <IO/Operators.h>
#include <IO/WriteBuffer.h>
#include <Parsers/ASTExpressionList.h>
#include <Parsers/ASTTablesInSelectQuery.h>
#include <Common/assert_cast.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>istNode & getJoinExpressions()
{
return children[join_expressions_child_index]->as<ListNode &>();
}
/// Get join expressions node
const QueryTreeNodePtr & getJoinExpressionsNode() const
{
return children[join_expressions_child_index];
}
/// Get join expression... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/ColumnNode.h>
#include <Analyzer/TableNode.h>
#include <IO/Operators.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteHelpers.h>
#include <Parsers/ASTIdentifier.h>
#include <Common/SipHash.h>
#include <Common/assert_cast.h>
namespace DB
{
namespace ErrorCodes
{
extern const int L... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/NamesAndTypes.h>
#include <Analyzer/IQueryTreeNode.h>
#include <DataTypes/DataTypeNullable.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
/** Column node represents column in query tree.
* Column node can have weak pointer to its column so... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>auto & column_name : except_column_names)
{
hash_state.update(column_name.size());
hash_state.update(column_name);
}
if (column_matcher)
{
const auto & pattern = column_matcher->pattern();
hash_state.update(pattern.size());
hash_state.update(pattern... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/ListNode.h>
#include <Core/Names.h>
namespace re2
{
class RE2;
}
namespace DB
{
/** Transformers are query tree nodes that handle additional logic that you can apply after MatcherQueryTreeNode is resolved.
* Check MatcherQueryT... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> from_field = [](const ConstantNode &node){ return make_intrusive<ASTLiteral>(node.getValue()); };
if (options.use_source_expression_for_constants && source_expression)
return source_expression->toAST(options);
if (!options.add_cast_for_constants)
return getCachedAST(from_column)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>l be derived from field value
explicit ConstantNode(Field value_);
/// Get constant value
const ColumnConstPtr & getColumn() const
{
return constant_value.getColumn();
}
/// Get constant value
Field getValue() const
{
Field out;
constant_value.getC... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ue
{
public:
ConstantValue(ColumnConstPtr column_, DataTypePtr data_type_)
: column(std::move(column_))
, data_type(std::move(data_type_))
{}
ConstantValue(const Field & field_, DataTypePtr data_type_)
: column(data_type_->createColumnConst(1, field_))
, data_t... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/FunctionNode.h>
#include <Columns/ColumnConst.h>
#include <Common/SipHash.h>
#include <Common/FieldVisitorToString.h>
#include <IO/WriteBufferFromString.h>
#include <IO/Operators.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypeSet.h>
#include <Parsers/ASTFunction.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <AggregateFunctions/IAggregateFunction_fwd.h>
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/ListNode.h>
#include <Core/ColumnsWithTypeAndName.h>
#include <Core/IResolvedFunction.h>
#include <DataTypes/DataTypeNullable.h>
#include <Functions/IFunction.h>
#... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> const IQueryTreeNode * argument = nullptr;
};
class ArgumentsTreeNode : public Arguments
{
public:
explicit ArgumentsTreeNode(const QueryTreeNodes * arguments_) : arguments(arguments_) {}
size_t size() const override { return arguments ? arguments->size() : 0; }
... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <city.h>
namespace DB
{
class IQueryTreeNode;
using QueryTreeNodePtr = std::shared_ptr<IQueryTreeNode>;
/** This structure holds query tree node ptr and its hash. It can be used as hash map key to avoid unnecessary hash
* r... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/IQueryTreeNode.h>
#include <unordered_map>
#include <Common/SipHash.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteHelpers.h>
#include <IO/Operators.h>
#include <Parsers/ASTWithAlias.h>
#include <Parsers/IAST.h>
#include <boost/functional/hash.hpp>
namespace DB
{
namespace Erro... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> & buffer) const;
class FormatState
{
public:
size_t getNodeId(const IQueryTreeNode * node);
private:
std::unordered_map<const IQueryTreeNode *, size_t> node_to_id;
};
/** Dump query tree to buffer starting with indent.
*
* Node must also dump its chi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once<|fim_suffix|> virtual String getDescription() = 0;
/// Run pass over query tree
virtual void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) = 0;
};
}
<|fim_middle|>
#include <Interpreters/Context_fwd.h>
#include <Analyzer/IQueryTreeNode.h>
namespace DB
{
/** Afte... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Identifier.h>
#include <base/defines.h>
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/split.hpp>
namespace DB
{
/// Create Identifier from parts
Identifier::Identifier(const std::vector<std::string> & parts_)
: parts(parts_)
, full_name(boost::a... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>FullName() == rhs.getFullName();
}
inline bool operator!=(const IdentifierView & lhs, const IdentifierView & rhs)
{
return !(lhs == rhs);
}
inline std::ostream & operator<<(std::ostream & stream, const IdentifierView & identifier_view)
{
stream << identifier_view.getFullName();
return stream... | fim | ClickHouse/ClickHouse | c |
#include <Analyzer/IdentifierNode.h>
#include <Common/assert_cast.h>
#include <Common/SipHash.h>
#include <IO/WriteBufferFromString.h>
#include <IO/Operators.h>
#include <Parsers/ASTIdentifier.h>
namespace DB
{
IdentifierNode::IdentifierNode(Identifier identifier_)
: IQueryTreeNode(children_size)
, identif... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>::optional<TableExpressionModifiers> table_expression_modifiers;
static constexpr size_t children_size = 0;
};
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/Identifier.h>
#include <Analyzer/TableExpressionModifiers.h>
namespace DB
{
/** Identifier node repre... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>WithContext(ContextPtr context, size_t initial_subquery_depth = 0)
: current_context(std::move(context))
, subquery_depth(initial_subquery_depth)
{}
/// Return true if visitor should visit child, false otherwise
bool needChildVisit(VisitQueryTreeNodeType & parent [[maybe_unuse... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/InterpolateNode.h>
#include <Common/SipHash.h>
#include <IO/WriteBufferFromString.h>
#include <IO/Operators.h>
#include <Parsers/ASTInterpolateElement.h>
namespace DB
{
InterpolateNode::InterpolateNode(std::shared_ptr<IdentifierNode> expression_, QueryTreeNodePtr interpolate_expres... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ssion()
{
return children[expression_child_index];
}
/// Get interpolate expression
const QueryTreeNodePtr & getInterpolateExpression() const
{
return children[interpolate_expression_child_index];
}
/// Get interpolate expression
QueryTreeNodePtr & getInte... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>TableJoin();
addTableExpressionOrJoinIntoTablesInSelectQuery(tables_in_select_query_ast, children[right_table_expression_child_index], options);
auto & table_element = tables_in_select_query_ast->children.at(join_table_index)->as<ASTTablesInSelectQueryElement &>();
table_element.children.pus... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> {
return strictness;
}
/// Get join kind
JoinKind getKind() const
{
return kind;
}
/// Set join kind
void setKind(JoinKind kind_value)
{
kind = kind_value;
}
/// Convert join node to ASTTableJoin
ASTPtr toASTTableJoin() const;
Q... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/LambdaNode.h>
#include <Common/assert_cast.h>
#include <Common/SipHash.h>
#include <Parsers/ASTExpressionList.h>
#include <Parsers/ASTFunction.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteHelpers.h>
#include <IO/Operators.h>
namespace DB
{
LambdaNode::LambdaNode(Names argument_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/ListNode.h>
#include <Analyzer/IdentifierNode.h>
#include <Core/Names.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
/** Lambda node represents lambda expression in query tree.
*
* Lambda consist of argument names and lambda expr... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/ListNode.h>
#include <Common/SipHash.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteHelpers.h>
#include <IO/Operators.h>
#include <Parsers/ASTExpressionList.h>
namespace DB
{
ListNode::ListNode()
: IQueryTreeNode(0 /*children_size*/)
{}
ListNode::ListNode(QueryTreeNodes node... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eNodes::iterator;
using const_iterator = QueryTreeNodes::const_iterator;
/// Initialize list node with empty nodes
ListNode();
/// Initialize list node with nodes
explicit ListNode(QueryTreeNodes nodes);
/// Get list nodes
const QueryTreeNodes & getNodes() const
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ke_intrusive<ASTQualifiedAsterisk>();
auto identifier_parts = qualified_identifier.getParts();
qualified_asterisk->qualifier = make_intrusive<ASTIdentifier>(std::move(identifier_parts));
qualified_asterisk->children.push_back(qualified_asterisk->qualifier);
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Analyzer/Identifier.h>
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/ColumnTransformers.h>
#include <Parsers/ASTAsterisk.h>
#include <Common/re2.h>
namespace DB
{
/** Matcher query tree node.
* Matcher can be unqualified with identifier and qualified with identifier.
* It can be... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/AggregateFunctionOfGroupByKeysPass.h>
#include <Analyzer/ArrayJoinNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/HashUtils.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/QueryNode.h>
#include <Core/Settings.h>
namespace DB
{
namespace Setti... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_node, ContextPtr context) override;
};
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Eliminates min/max/any/anyLast aggregators of GROUP BY keys in SELECT section.
*
* Example: SELECT max(column) FROM table GROUP BY column;
* Result: SELECT column FROM t... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/AggregateFunctionsArithmeticOperationsPass.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/Fu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>) override { return "Extract arithmetic operations from aggregate functions."; }
void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
};
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Extract arithmetic operations from aggregate functio... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/ArrayExistsToHasPass.h>
#include <Functions/array/has.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/LambdaNode.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeArray.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Rewrite possible 'arrayExists(func, arr)' to 'has(arr, elem)' to improve performance.
*
* Example: SELECT arrayExists(x -> x = 1, arr);
* Result: SELECT has(arr, 1);
*
* Example: SELECT arrayExists(x -> 1 = x, arr);
* Resu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Pass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
{
auto visitor = AutoFinalOnQueryPassVisitor(std::move(context));
visitor.visit(query_tree_node);
}
}
<|fim_prefix|>#include <Analyzer/Passes/AutoFinalOnQueryPass.h>
#include <Storages/IStorage.h>
#include <Analyzer/Utils.h>
#inc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
#include <Storages/IStorage_fwd.h>
#include <Analyzer/TableNode.h>
namespace DB
{
/** Automatically applies final modifier to table expressions in queries if it is supported and if user level final setting is set.
*
* Example: SELECT id, value FROM ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>context);
visitor.visit(node_cloned);
}
{
PushNotVisitor visitor;
visitor.visit(node_cloned, false);
}
if (PushOrVisitor visitor(max_atoms);
!visitor.visit(node_cloned, atom_count))
return std::nullopt;
CollectGroupsVisitor collect_visitor... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>.h>
#include <Interpreters/Context_fwd.h>
#include <set>
namespace DB::Analyzer
{
class CNF
{
public:
// Different hash is generated for different order, so we use std::set
using OrGroup = std::set<CNFAtomicFormula>;
using AndGroup = std::set<OrGroup>;
std::string dump() const;
s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>node_with_hash.hash < rhs.node_with_hash.hash || negative < rhs.negative;
}
}
<|fim_prefix|>#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/Passes/CNFAtomicFormula.h>
namespace DB::Analyzer
{
bool CNFAtomicFormula::opera<|fim_middle|>tor==(const CNFAtomicFormula & rhs) const
{
return negati... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Analyzer/HashUtils.h>
namespace DB::Analyzer
{
struct CNFAtomicFormula
{
bool negative = false;
QueryTreeNodePtrWithHash node_with_hash;
bool operator==(const CNFAtomicFormula & rhs) const;
bool operator<(const CNFAtomicFormula & rhs) const;
};
}
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/ComparisonTupleEliminationPass.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeNothing.h>
#include <Functions/FunctionFactory.h>
#include <Interpreters/Context.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Rewrite tuples comparison into equi<|fim_suffix|>mparison into equivalent comparison of tuples arguments"; }
void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
};
}
<|fim_middle|>valent comparison of tup... | fim | ClickHouse/ClickHouse | c |
#include <Analyzer/Passes/ConvertEmptyStringComparisonToFunctionPass.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/Utils.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeString.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTre<|fim_suffix|>lic:
String getName() override { return "ConvertEmptyStringComparisonToFunction"; }
String getDescription() override { return "Convert comparisons to '' into empty() / notEmpty() functions."; }
void run(QueryTreeNodePtr & query_tree_nod... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nOverloadResolverPtr or_function_resolver_,
FunctionOverloadResolverPtr match_function_resolver_,
ContextPtr context)
: Base(std::move(context))
, or_function_resolver(std::move(or_function_resolver_))
, match_function_resolver(std::move(match_function_resolver_))
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Replaces all the "or"'s with {i}like to multiMatchAny
*/
class ConvertOrLikeChainPass final : public IQueryTreePass
{
public:
String getName() override { return "ConvertOrLikeChain"; }
String getDescription() override { return "Replaces a... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/ConvertQueryToCNFPass.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/TableNode.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/TableFunctionNode.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/Passes/CNF.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>reeNodePtr & query_tree_node, ContextPtr context) override;
};
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
class ConvertLogicalExpressionToCNFPass final : public IQueryTreePass
{
public:
Strin<|fim_middle|>g getName() override { return "ConvertLogicalExpression... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Anal<|fim_suffix|>s to preserve semantics.
if (isNullableOrLowCardinalityNullable(count_distinct_argument_column_typed.getColumnType()))
return;
/// Build subquery SELECT count_distinct_argument_column FROM table_expression GROUP BY count_distinct_argument_column
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Optimize single `countDistinct` into `count` over subquery.
*
* Example: SELECT countDistinct(column) FROM table;
* Result: SELECT count() FROM (SELECT column FROM tabl<|fim_suffix|> GROUP BY column);
*/
class CountDistinctPas... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>);
if (equi_conditions.empty())
{
checkNotRewritten(cross_join_node.getJoinTypes(), join_tree_node);
return;
}
auto join_graph = buildJoinGraph(cross_join_node.getTableExpressions(), cross_join_node.getJoinTypes(), equi_conditions, other_conditions)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Replace CROSS JOIN with INNER JOIN.
* Exa<|fim_suffix|> {
return "Replace CROSS JOIN with INNER JOIN";
}
void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
};
}
<|fim_middle|>mple:
* ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ay differ — they don't affect cast semantics).
const auto * default_tuple_type = typeid_cast<const DataTypeTuple *>(default_arg->getResultType().get());
const auto * result_tuple_type = typeid_cast<const DataTypeTuple *>(dict_get_function->getResultType().get());
if (!d... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** If `dictGet` is called with a tuple of attribute names and the result is immediately
* indexed with `tupleElement`, rewrite the expression to fetch only the single needed attribute.
*
* Example: SELECT tupleElement(dictGet('dict', ('a', 'b', ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>isitor : public InDepthQueryTreeVisitorWithContext<DisableParallelReplicasVisitor>
{
public:
using Base = InDepthQueryTreeVisitorWithContext<DisableParallelReplicasVisitor>;
using Base::Base;
void enterImpl(QueryTreeNodePtr & node)
{
if (is_correlated)
return;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Disable par<|fim_suffix|>ide { return "DisableParallelReplicas"; }
String getDescription() override
{
return "Disable parallel replicas if correlated subquery is present";
}
void run(QueryTreeNodePtr & query_... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>unction_builder->build(cast_function->getArgumentColumns()));
new_args.push_back(cast_function);
}
auto original_result_type = function_node->getResultType();
/// Re-resolve function with new arguments
function_node->getArguments().getNodes() = std::move(new_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>/...]DistanceTransposed(vec, reference_vec, N)` into single `DistanceTransposed(vec.1, vec.2, ..., vec.N, qbit_size, reference_vec)`.
* This allows to read the first N groups of vec instead of all.
*
* Example: SELECT id, vec, L2DistanceTransposed(vec, reference_vec, 3) AS dist FROM qbit;
* Result... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>diates);
if (!result_type->equals(*node->getResultType()))
node = buildCastFunction(node, result_type, getContext());
}
}
}
void leaveImpl(const QueryTreeNodePtr & node)
{
if (!getSettings()[Setting::optimize_functions_to_subcol... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>SELECT nullable_column.null FROM test_table;
*/
class FunctionToSubcolumnsPass final : public IQueryTreePass
{
public:
String getName() override { return "FunctionToSubcolumns"; }
String getDescription() override { return "Rewrite function to subcolumns, for example tupleElement(column, subcolu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>SIONS_FOR_ALIAS`
/// by tree hash, which only trips when two nodes with the same alias differ).
auto mapping = collectUniqueQuantileLevels(nodes);
/// Nothing to fuse if there is only one distinct level (e.g. the user wrote the same
/// `quantile(0.99)(x)` in SELECT, HAVIN... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/*
* This pass replaces several calls of aggregate functions of the same family into one call.
* Result will be calculated only once because of CSE.
*
* Replaces:
* `sum(x), count(x), avg(x)` with `sumCount(x).1, sumCount(x).2, sumCount(x).1 / toF... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/GroupingFunctionsResolvePass.h>
#include <Core/ColumnNumbers.h>
#include <Core/Settings.h>
#include <Functions/grouping.h>
#include <Functions/IFunctionAdaptors.h>
#include <Interpreters/Context.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/QueryNode.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>orGroupingSets(__grouping_set, id), groupingForGroupingSets(__grouping_set, value)
* FROM test_table GROUP BY GROUPING SETS ((id), (value));
*/
class GroupingFunctionsResolvePass final : public IQueryTreePass
{
public:
String getName() override { return "GroupingFunctionsResolvePass"; }
Strin... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/HasToInPass.h>
#include <DataTypes/IDataType.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/Utils.h>
#i... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Rewrite 'has(const_array, x)' to 'in(x, const_array)' when the first argument is a constant array.
* The has() implementation has to handle both const/non-const arrays and it uses Field.
* With a medium to large array, has() is si... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/IfChainToMul<|fim_suffix|>64(number))), Null) FROM numbers(2)
if (!multi_if_function->getResultType()->equals(*function_node->getResultType()))
return;
node = std::move(multi_if_function);
}
private:
FunctionOverloadResolverPtr multi_if_funct... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Convert `if` chain into single `multiIf`.
* Replace if(cond_1, then_1_value, if(cond_2, ...)) chains into multiIf(cond_1, then_1_value, cond_2, ...).
*
* Example: SELECT if(cond_1, then_1_value, if(cond_2, then_2_value, else_val... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/IfConstantConditionPass.h>
#include <Functions/FunctionFactory.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/Utils.h>
namespace DB
{
namespace
{
class IfConstantConditionVisitor : pub... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> String getName() override { return "IfConstantCondition"; }
String getDescription() override { return "Optimize if, multiIf for constant condition."; }
void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
};
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> function_node.resolveAsFunction(to_string_function->build(function_node.getArgumentColumns()));
chassert(isString(removeNullable(function_node.getResultType())));
}
class ConvertStringsToEnumVisitor : public InDepthQueryTreeVisitorWithContext<ConvertStringsToEnumVisitor>
{
public:
using Base... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/**
* This pass replaces string-type arguments in If and Transform to enum.
*
* E.g.
* -------------------------------
* SELECT if(number > 5, 'a', 'b')
* FROM system.numbers;
*
* will be transformed into
*
* SELECT if(number > ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/InjectRandomOrderIfNoOrderByPass.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/FunctionNode.h><|fim_suffix|>nalyzer/SortNode.h>
#include <Analyzer/UnionNode.h>
#include <Core/Settings.h>
#include <Core/UUID.h>
#include <Functions/FunctionFactory.h>
#include <Interpreter... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>l SELECT when missing (tests only)"; }
void run(QueryTreeNodePtr & root, ContextPtr context) override;
};
}
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Injects an ORDER BY rand() clause into the top-level SELECT query when no explicit ORDER BY is present.
* I... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>de::LHS,
attr_comparison_function_name,
getContext()))
return;
auto dict_table_function = std::make_shared<TableFunctionNode>("dictionary");
dict_table_function->getArguments().getNodes().push_back(dictget_function_info.dict_name_node);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Optimize `dictGetFamily(..., ATTR_COL, COL) = CONSTEXPR` into `COL IN (SELECT ... FROM dictionary WHERE ATTR_COL = CONSTEXPR)`
*
* Example: SELECT col FROM tab WHERE dictGet(DICT_NAME, DICT_ATTRIBUTE_COL, col) = CONSTEXPR;
* Res... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/LikePerfectAffixRewritePass.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/IdentifierNode.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Core/Settings.h>
#include <Common/StringUtils.h>... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
class LikePerfectAffixRewritePass final : public IQueryTreePass
{
public:
String getName() override { return "LikePerfectAffixRewritePass"; }
String getDescription() override { return "Rewrite LIKE expressions with perfect affix (prefix or suff... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/LogicalExpressionOptimizerPass.h>
#include <Analyzer/ConstantNode.h>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/HashUtils.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/JoinNode.h>
#include <Analyzer/Utils.h>
#include <Common/FieldAccurateComparis... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>- equality check with explicit IS NULL check replaced with <=> operator
* -------------------------------
* SELECT * FROM t1 JOIN t2 ON a = b OR (a IS NULL AND b IS NULL)
* SELECT * FROM t1 JOIN t2 ON a <=> b OR (a IS NULL AND b IS NULL)
*
* will be transformed into
*
* SELECT * FROM t1 JOIN t2 ON ... | fim | ClickHouse/ClickHouse | c |
#include <Analyzer/Passes/MultiIfToIfPass.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/FunctionNode.h>
#include <Core/Settings.h>
#include <Functions/FunctionFactory.h>
#include <Functions/if.h>
namespace DB
{
namespace Setting
{
extern const SettingsBool optimize_multiif_to_if;
extern ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/** Convert `multiIf` with single condition into `if`.
*
<|fim_suffix|>fToIfPass final : public IQueryTreePass
{
public:
String getName() override { return "MultiIfToIf"; }
String getDescription() override { return "Optimize m... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>auto & first_argument = function_node->getArguments().getNodes()[0];
auto * first_argument_constant_node = first_argument->as<ConstantNode>();
if (!first_argument_constant_node)
return;
const auto & first_argument_constant_literal = first_argument_constant_node->getVal... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ueryTreePass
{
public:
String getName() override { return "NormalizeCountVariants"; }
String getDescription() override { return "Optimize count(literal), sum(1) into count()."; }
void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
};
}
<|fim_prefix|>#pragma once
#in... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/OptimizeDateOrDateTimeConverterWithPreimagePass.h>
#include <Functions/FieldInterval.h>
#include <Functions/FunctionFactory.h>
#include <Analyzer/ColumnNod<|fim_suffix|> bool needChildVisit(QueryTreeNodePtr & node, QueryTreeNodePtr & /*child*/)
{
const static std::u... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>their preimages to improve performance.
* Given a Date column c, toYear(c) = 2023 -> c >= '2023-01-01' AND c < '2024-01-01'
* Or if c is a DateTime column, toYear(c) = 2023 -> c >= '2023-01-01 00:00:00' AND c < '2024-01-01 00:00:00'.
* The similar optimization also applies to other converters.
*/
c... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Analyzer/Passes/OptimizeGroupByFunctionKeysPass.h>
#include <algorithm>
#include <queue>
#include <Analyzer/FunctionNode.h>
#include <Analyzer/HashUtils.h>
#include <Analyzer/IQueryTreeNode.h>
#include <Analyzer/InDepthQueryTreeVisitor.h>
#include <Analyzer/QueryNode.h>
#include <Core/Settings... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Analyzer/IQueryTreePass.h>
namespace DB
{
/* Eliminates functions of other keys in GROUP BY section.
* Ex.: GROUP BY x, f(x)
* Output: GROUP BY x
*/
class O<|fim_suffix|> keys in GROUP BY section."; }
void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) ove... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> nodes_to_process.push(group_by_elem);
while (!nodes_to_process.empty())
{
auto node_to_process = nodes_to_process.front();
nodes_to_process.pop();
auto const * function_node = node_to_process->as<FunctionNode>();
... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.