ClickHouse/dbms/src/Interpreters/QueryNormalizer.cpp

243 lines
7.1 KiB
C++
Raw Normal View History

#include <Poco/String.h>
#include <Core/Names.h>
#include <Interpreters/QueryNormalizer.h>
#include <Interpreters/IdentifierSemantic.h>
#include <Interpreters/Context.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTSelectQuery.h>
2019-06-16 16:47:47 +00:00
#include <Parsers/ASTQueryParameter.h>
#include <Parsers/ASTTablesInSelectQuery.h>
#include <Common/StringUtils/StringUtils.h>
#include <Common/quoteString.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int TOO_DEEP_AST;
extern const int CYCLIC_ALIASES;
2019-06-16 16:47:47 +00:00
extern const int UNKNOWN_QUERY_PARAMETER;
}
2019-01-11 14:09:23 +00:00
class CheckASTDepth
{
2019-01-11 14:09:23 +00:00
public:
CheckASTDepth(QueryNormalizer::Data & data_)
: data(data_)
{
if (data.level > data.settings.max_ast_depth)
throw Exception("Normalized AST is too deep. Maximum: " + toString(data.settings.max_ast_depth), ErrorCodes::TOO_DEEP_AST);
++data.level;
}
2019-01-11 14:09:23 +00:00
~CheckASTDepth()
{
2019-01-11 14:09:23 +00:00
--data.level;
}
2019-01-11 14:09:23 +00:00
private:
QueryNormalizer::Data & data;
};
class RestoreAliasOnExitScope
{
public:
RestoreAliasOnExitScope(String & alias_)
: alias(alias_)
, copy(alias_)
{}
~RestoreAliasOnExitScope()
{
2019-01-11 14:09:23 +00:00
alias = copy;
}
2019-01-11 14:09:23 +00:00
private:
String & alias;
const String copy;
};
void QueryNormalizer::visit(ASTIdentifier & node, ASTPtr & ast, Data & data)
{
auto & current_asts = data.current_asts;
String & current_alias = data.current_alias;
if (!IdentifierSemantic::getColumnName(node))
return;
/// If it is an alias, but not a parent alias (for constructs like "SELECT column + 1 AS column").
auto it_alias = data.aliases.find(node.name);
if (it_alias != data.aliases.end() && current_alias != node.name)
{
if (!IdentifierSemantic::canBeAlias(node))
{
/// This means that column had qualified name, which was translated (so, canBeAlias() returns false).
/// But there is an alias with the same name. So, let's use original name for that column.
/// If alias wasn't set, use original column name as alias.
/// That helps to avoid result set with columns which have same names but different values.
if (node.alias.empty())
{
node.name.swap(node.alias);
node.restoreCompoundName();
node.name.swap(node.alias);
}
return;
}
auto & alias_node = it_alias->second;
/// Let's replace it with the corresponding tree node.
if (current_asts.count(alias_node.get()))
throw Exception("Cyclic aliases", ErrorCodes::CYCLIC_ALIASES);
String my_alias = ast->tryGetAlias();
if (!my_alias.empty() && my_alias != alias_node->getAliasOrColumnName())
{
/// Avoid infinite recursion here
auto opt_name = IdentifierSemantic::getColumnName(alias_node);
bool is_cycle = opt_name && *opt_name == node.name;
if (!is_cycle)
{
/// In a construct like "a AS b", where a is an alias, you must set alias b to the result of substituting alias a.
ast = alias_node->clone();
ast->setAlias(my_alias);
}
}
else
ast = alias_node;
}
}
2019-02-14 12:31:13 +00:00
void QueryNormalizer::visit(ASTTablesInSelectQueryElement & node, const ASTPtr &, Data & data)
{
2019-02-14 12:31:13 +00:00
/// normalize JOIN ON section
if (node.table_join)
{
auto & join = node.table_join->as<ASTTableJoin &>();
if (join.on_expression)
visit(join.on_expression, data);
2019-02-14 12:31:13 +00:00
}
}
static bool needVisitChild(const ASTPtr & child)
{
2019-03-11 13:22:51 +00:00
if (child->as<ASTSelectQuery>() || child->as<ASTTableExpression>())
2019-02-14 12:31:13 +00:00
return false;
return true;
}
/// special visitChildren() for ASTSelectQuery
void QueryNormalizer::visit(ASTSelectQuery & select, const ASTPtr &, Data & data)
{
for (auto & child : select.children)
2019-02-14 12:31:13 +00:00
if (needVisitChild(child))
visit(child, data);
2019-04-09 14:59:06 +00:00
/// If the WHERE clause or HAVING consists of a single alias, the reference must be replaced not only in children,
/// but also in where_expression and having_expression.
if (select.prewhere())
2019-04-09 14:59:06 +00:00
visit(select.refPrewhere(), data);
if (select.where())
2019-04-09 14:59:06 +00:00
visit(select.refWhere(), data);
if (select.having())
2019-04-09 14:59:06 +00:00
visit(select.refHaving(), data);
}
/// Don't go into subqueries.
/// Don't go into select query. It processes children itself.
/// Do not go to the left argument of lambda expressions, so as not to replace the formal parameters
/// on aliases in expressions of the form 123 AS x, arrayMap(x -> 1, [2]).
void QueryNormalizer::visitChildren(const ASTPtr & node, Data & data)
{
2019-03-11 13:22:51 +00:00
if (const auto * func_node = node->as<ASTFunction>())
{
/// We skip the first argument. We also assume that the lambda function can not have parameters.
2019-02-14 12:31:13 +00:00
size_t first_pos = 0;
if (func_node->name == "lambda")
first_pos = 1;
2019-02-14 12:31:13 +00:00
auto & func_children = func_node->arguments->children;
2019-02-14 12:31:13 +00:00
for (size_t i = first_pos; i < func_children.size(); ++i)
{
auto & child = func_children[i];
if (needVisitChild(child))
visit(child, data);
}
}
2019-03-11 13:22:51 +00:00
else if (!node->as<ASTSelectQuery>())
{
for (auto & child : node->children)
2019-02-14 12:31:13 +00:00
if (needVisitChild(child))
visit(child, data);
}
}
void QueryNormalizer::visit(ASTPtr & ast, Data & data)
{
CheckASTDepth scope1(data);
RestoreAliasOnExitScope scope2(data.current_alias);
auto & finished_asts = data.finished_asts;
auto & current_asts = data.current_asts;
if (finished_asts.count(ast))
{
ast = finished_asts[ast];
return;
}
ASTPtr initial_ast = ast;
current_asts.insert(initial_ast.get());
{
String my_alias = ast->tryGetAlias();
if (!my_alias.empty())
data.current_alias = my_alias;
}
if (auto * node_id = ast->as<ASTIdentifier>())
2019-06-16 16:47:47 +00:00
visit(*node_id, ast, data);
else if (auto * node_tables = ast->as<ASTTablesInSelectQueryElement>())
visit(*node_tables, ast, data);
else if (auto * node_select = ast->as<ASTSelectQuery>())
visit(*node_select, ast, data);
else if (auto * node_param = ast->as<ASTQueryParameter>())
throw Exception("Query parameter " + backQuote(node_param->name) + " was not set", ErrorCodes::UNKNOWN_QUERY_PARAMETER);
/// If we replace the root of the subtree, we will be called again for the new root, in case the alias is replaced by an alias.
if (ast.get() != initial_ast.get())
visit(ast, data);
else
visitChildren(ast, data);
current_asts.erase(initial_ast.get());
current_asts.erase(ast.get());
finished_asts[initial_ast] = ast;
2019-01-11 14:09:23 +00:00
/// @note can not place it in CheckASTDepth dtor cause of exception.
2019-01-11 14:09:23 +00:00
if (data.level == 1)
{
try
{
ast->checkSize(data.settings.max_expanded_ast_elements);
}
catch (Exception & e)
{
e.addMessage("(after expansion of aliases)");
throw;
}
}
}
}