mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-09-29 21:20:49 +00:00
112 lines
3.4 KiB
C++
112 lines
3.4 KiB
C++
#include <Interpreters/ExtractExpressionInfoVisitor.h>
|
|
#include <Functions/FunctionFactory.h>
|
|
#include <AggregateFunctions/AggregateFunctionFactory.h>
|
|
#include <Interpreters/IdentifierSemantic.h>
|
|
#include <Parsers/ASTSubquery.h>
|
|
|
|
|
|
namespace DB
|
|
{
|
|
|
|
void ExpressionInfoMatcher::visit(const ASTPtr & ast, Data & data)
|
|
{
|
|
if (const auto * function = ast->as<ASTFunction>())
|
|
visit(*function, ast, data);
|
|
else if (const auto * identifier = ast->as<ASTIdentifier>())
|
|
visit(*identifier, ast, data);
|
|
}
|
|
|
|
void ExpressionInfoMatcher::visit(const ASTFunction & ast_function, const ASTPtr &, Data & data)
|
|
{
|
|
if (ast_function.name == "arrayJoin")
|
|
{
|
|
data.is_array_join = true;
|
|
}
|
|
// "is_aggregate_function" is used to determine whether we can move a filter
|
|
// (1) from HAVING to WHERE or (2) from WHERE of a parent query to HAVING of
|
|
// a subquery.
|
|
// For aggregate functions we can't do (1) but can do (2).
|
|
// For window functions both don't make sense -- they are not allowed in
|
|
// WHERE or HAVING.
|
|
else if (!ast_function.is_window_function
|
|
&& AggregateFunctionFactory::instance().isAggregateFunctionName(
|
|
ast_function.name))
|
|
{
|
|
data.is_aggregate_function = true;
|
|
}
|
|
else if (ast_function.is_window_function)
|
|
{
|
|
data.is_window_function = true;
|
|
}
|
|
else
|
|
{
|
|
const auto & function = FunctionFactory::instance().tryGet(ast_function.name, data.context);
|
|
|
|
/// Skip lambda, tuple and other special functions
|
|
if (function)
|
|
{
|
|
if (function->isStateful())
|
|
data.is_stateful_function = true;
|
|
|
|
if (!function->isDeterministicInScopeOfQuery())
|
|
data.is_deterministic_function = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ExpressionInfoMatcher::visit(const ASTIdentifier & identifier, const ASTPtr &, Data & data)
|
|
{
|
|
if (!identifier.compound())
|
|
{
|
|
for (size_t index = 0; index < data.tables.size(); ++index)
|
|
{
|
|
const auto & table = data.tables[index];
|
|
|
|
// TODO: make sure no collision ever happens
|
|
if (table.hasColumn(identifier.name()))
|
|
{
|
|
data.unique_reference_tables_pos.emplace(index);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (auto best_table_pos = IdentifierSemantic::chooseTable(identifier, data.tables))
|
|
data.unique_reference_tables_pos.emplace(*best_table_pos);
|
|
}
|
|
}
|
|
|
|
bool ExpressionInfoMatcher::needChildVisit(const ASTPtr & node, const ASTPtr &)
|
|
{
|
|
return !node->as<ASTSubquery>();
|
|
}
|
|
|
|
bool hasNonRewritableFunction(const ASTPtr & node, const Context & context)
|
|
{
|
|
for (const auto & select_expression : node->children)
|
|
{
|
|
ExpressionInfoVisitor::Data expression_info{.context = context, .tables = {}};
|
|
ExpressionInfoVisitor(expression_info).visit(select_expression);
|
|
|
|
if (expression_info.is_stateful_function
|
|
|| expression_info.is_window_function)
|
|
{
|
|
// If an outer query has a WHERE on window function, we can't move
|
|
// it into the subquery, because window functions are not allowed in
|
|
// WHERE and HAVING. Example:
|
|
// select * from (
|
|
// select number,
|
|
// count(*) over (partition by intDiv(number, 3)) c
|
|
// from numbers(3)
|
|
// ) where c > 1;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|