ClickHouse/dbms/src/Interpreters/ExpressionAnalyzer.cpp

#include <Poco/Util/Application.h>
#include <Poco/String.h>

#include <DB/DataTypes/FieldToDataType.h>

#include <DB/Parsers/ASTFunction.h>
#include <DB/Parsers/ASTIdentifier.h>
#include <DB/Parsers/ASTLiteral.h>
#include <DB/Parsers/ASTAsterisk.h>
#include <DB/Parsers/ASTExpressionList.h>
#include <DB/Parsers/ASTSelectQuery.h>
#include <DB/Parsers/ASTSubquery.h>
#include <DB/Parsers/ASTSet.h>
#include <DB/Parsers/ASTOrderByElement.h>

#include <DB/DataTypes/DataTypeSet.h>
#include <DB/DataTypes/DataTypeTuple.h>
#include <DB/DataTypes/DataTypeExpression.h>
#include <DB/DataTypes/DataTypeNested.h>

#include <DB/Columns/ColumnSet.h>
#include <DB/Columns/ColumnExpression.h>

#include <DB/Interpreters/InterpreterSelectQuery.h>
#include <DB/Interpreters/ExpressionAnalyzer.h>
#include <DB/Interpreters/ExpressionActions.h>
#include <DB/Interpreters/InJoinSubqueriesPreprocessor.h>
#include <DB/Interpreters/LogicalExpressionsOptimizer.h>
#include <DB/Interpreters/ExternalDictionaries.h>

#include <DB/AggregateFunctions/AggregateFunctionFactory.h>

#include <DB/Storages/StorageDistributed.h>
#include <DB/Storages/StorageMemory.h>
#include <DB/Storages/StorageSet.h>
#include <DB/Storages/StorageJoin.h>

#include <DB/DataStreams/LazyBlockInputStream.h>
#include <DB/DataStreams/copyData.h>

#include <DB/Dictionaries/IDictionary.h>

#include <DB/Common/typeid_cast.h>
#include <DB/Common/StringUtils.h>

#include <DB/Parsers/formatAST.h>

#include <DB/Functions/FunctionFactory.h>

#include <ext/range.hpp>
#include <DB/DataTypes/DataTypeFactory.h>


namespace DB
{

namespace ErrorCodes
{
	extern const int MULTIPLE_EXPRESSIONS_FOR_ALIAS;
	extern const int UNKNOWN_IDENTIFIER;
	extern const int CYCLIC_ALIASES;
	extern const int INCORRECT_RESULT_OF_SCALAR_SUBQUERY;
	extern const int TOO_MUCH_ROWS;
	extern const int NOT_FOUND_COLUMN_IN_BLOCK;
	extern const int INCORRECT_ELEMENT_OF_SET;
	extern const int ALIAS_REQUIRED;
	extern const int EMPTY_NESTED_TABLE;
	extern const int NOT_AN_AGGREGATE;
	extern const int UNEXPECTED_EXPRESSION;
	extern const int PARAMETERS_TO_AGGREGATE_FUNCTIONS_MUST_BE_LITERALS;
	extern const int DUPLICATE_COLUMN;
	extern const int FUNCTION_CANNOT_HAVE_PARAMETERS;
	extern const int ILLEGAL_AGGREGATION;
	extern const int SUPPORT_IS_DISABLED;
}


/** Calls to these functions in the GROUP BY statement would be
  * replaced by their immediate argument.
  */
const std::unordered_set<String> injective_function_names
{
	"negate",
	"bitNot",
	"reverse",
	"reverseUTF8",
	"toString",
	"toFixedString",
	"toStringCutToZero",
	"IPv4NumToString",
	"IPv4StringToNum",
	"hex",
	"unhex",
	"bitmaskToList",
	"bitmaskToArray",
	"tuple",
	"regionToName",
	"concatAssumeInjective",
};

const std::unordered_set<String> possibly_injective_function_names
{
	"dictGetString",
	"dictGetUInt8",
	"dictGetUInt16",
	"dictGetUInt32",
	"dictGetUInt64",
	"dictGetInt8",
	"dictGetInt16",
	"dictGetInt32",
	"dictGetInt64",
	"dictGetFloat32",
	"dictGetFloat64",
	"dictGetDate",
	"dictGetDateTime"
};

namespace
{

bool functionIsInOperator(const String & name)
{
	return name == "in" || name == "notIn";
}

bool functionIsInOrGlobalInOperator(const String & name)
{
	return name == "in" || name == "notIn" || name == "globalIn" || name == "globalNotIn";
}

void removeDuplicateColumns(NamesAndTypesList & columns)
{
	std::set<String> names;
	for (auto it = columns.begin(); it != columns.end();)
	{
		if (names.emplace(it->name).second)
			++it;
		else
			columns.erase(it++);
	}
}

}

void ExpressionAnalyzer::init()
{
	removeDuplicateColumns(columns);

	select_query = typeid_cast<ASTSelectQuery *>(ast.get());

	/// В зависимости от профиля пользователя проверить наличие прав на выполнение
	/// распределённых подзапросов внутри секций IN или JOIN и обработать эти подзапросы.
	InJoinSubqueriesPreprocessor<>(select_query, context, storage).perform();

	/// Оптимизирует логические выражения.
	LogicalExpressionsOptimizer(select_query, settings).perform();

	/// Создаёт словарь aliases: alias -> ASTPtr
	addASTAliases(ast);

	/// Common subexpression elimination. Rewrite rules.
	normalizeTree();

	/// ALIAS столбцы не должны подставляться вместо ASTAsterisk, добавим их теперь, после normalizeTree.
	addAliasColumns();

	/// Выполнение скалярных подзапросов - замена их на значения-константы.
	executeScalarSubqueries();

	/// Optimize if with constant condition after constats are substituted instead of sclalar subqueries
	optimizeIfWithConstantCondition();

	/// GROUP BY injective function elimination.
	optimizeGroupBy();

	/// Удалить из ORDER BY повторяющиеся элементы.
	optimizeOrderBy();

	// Remove duplicated elements from LIMIT BY clause.
	optimizeLimitBy();

	/// array_join_alias_to_name, array_join_result_to_source.
	getArrayJoinedColumns();

	/// Удалить ненужное из списка columns. Создать unknown_required_columns. Сформировать columns_added_by_join.
	collectUsedColumns();

	/// external_tables, subqueries_for_sets для глобальных подзапросов.
	/// Заменяет глобальные подзапросы на сгенерированные имена временных таблиц, которые будут отправлены на удалённые серверы.
	initGlobalSubqueriesAndExternalTables();

	/// has_aggregation, aggregation_keys, aggregate_descriptions, aggregated_columns.
	/// Этот анализ надо провести после обработки глобальных подзапросов, потому что в противном случае,
	/// если агрегатная функция содержит глобальный подзапрос, то метод analyzeAggregation сохранит
	/// в aggregate_descriptions информацию о параметрах этой агрегатной функции, среди которых окажется
	/// глобальный подзапрос. Затем при вызове метода initGlobalSubqueriesAndExternalTables, этот
	/// глобальный подзапрос будет заменён на временную таблицу, в результате чего aggregate_descriptions
	/// будет содержать устаревшую информацию, что приведёт к ошибке при выполнении запроса.
	analyzeAggregation();
}

void ExpressionAnalyzer::optimizeIfWithConstantCondition()
{
	optimizeIfWithConstantConditionImpl(ast, aliases);
}

bool ExpressionAnalyzer::tryExtractConstValueFromCondition(const ASTPtr & condition, bool & value) const
{
	/// numeric constant in condition
	if (const ASTLiteral * literal = typeid_cast<ASTLiteral *>(condition.get()))
	{
		if (literal->value.getType() == Field::Types::Int64 ||
			literal->value.getType() == Field::Types::UInt64)
		{
			value = literal->value.get<Int64>();
			return true;
		}
	}

	/// cast of numeric constant in condition to UInt8
	if (const ASTFunction * function = typeid_cast<ASTFunction * >(condition.get()))
	{
		if (function->name == "CAST")
		{
			if (ASTExpressionList * expr_list = typeid_cast<ASTExpressionList *>(function->arguments.get()))
			{
				const ASTPtr & type_ast = expr_list->children.at(1);
				if (const ASTLiteral * type_literal = typeid_cast<ASTLiteral *>(type_ast.get()))
				{
					if (type_literal->value.getType() == Field::Types::String &&
						type_literal->value.get<std::string>() == "UInt8")
						return tryExtractConstValueFromCondition(expr_list->children.at(0), value);
				}
			}
		}
	}

	return false;
}

void ExpressionAnalyzer::optimizeIfWithConstantConditionImpl(ASTPtr & current_ast, ExpressionAnalyzer::Aliases & aliases) const
{
	if (!current_ast)
		return;

	for (ASTPtr & child : current_ast->children)
	{
		ASTFunction * function_node = typeid_cast<ASTFunction *>(child.get());
		if (!function_node || function_node->name != "if")
		{
			optimizeIfWithConstantConditionImpl(child, aliases);
			continue;
		}

		optimizeIfWithConstantConditionImpl(function_node->arguments, aliases);
		ASTExpressionList * args = typeid_cast<ASTExpressionList *>(function_node->arguments.get());

		ASTPtr condition_expr = args->children.at(0);
		ASTPtr then_expr = args->children.at(1);
		ASTPtr else_expr = args->children.at(2);


		bool condition;
		if (tryExtractConstValueFromCondition(condition_expr, condition))
		{
			ASTPtr replace_ast = condition ? then_expr : else_expr;
			ASTPtr child_copy = child;
			String replace_alias = replace_ast->tryGetAlias();
			String if_alias = child->tryGetAlias();

			if (replace_alias.empty())
			{
				replace_ast->setAlias(if_alias);
				child = replace_ast;
			}
			else
			{
				/// Only copy of one node is required here.
				/// But IAST has only method for deep copy of subtree.
				/// This can be a reason of performance degradation in case of deep queries.
				ASTPtr replace_ast_deep_copy = replace_ast->clone();
				replace_ast_deep_copy->setAlias(if_alias);
				child = replace_ast_deep_copy;
			}

			if (!if_alias.empty())
			{
				auto alias_it = aliases.find(if_alias);
				if (alias_it != aliases.end() && alias_it->second.get() == child_copy.get())
					alias_it->second = child;
			}
		}
	}
}

void ExpressionAnalyzer::analyzeAggregation()
{
	/** Найдем ключи агрегации (aggregation_keys), информацию об агрегатных функциях (aggregate_descriptions),
	 *  а также набор столбцов, получаемых после агрегации, если она есть,
	 *  или после всех действий, которые обычно выполняются до агрегации (aggregated_columns).
	 *
	 * Всё, что ниже (составление временных ExpressionActions) - только в целях анализа запроса (вывода типов).
	 */

	if (select_query && (select_query->group_expression_list || select_query->having_expression))
		has_aggregation = true;

	ExpressionActionsPtr temp_actions = std::make_shared<ExpressionActions>(columns, settings);

	if (select_query && select_query->array_join_expression_list())
	{
		getRootActions(select_query->array_join_expression_list(), true, false, temp_actions);
		addMultipleArrayJoinAction(temp_actions);
	}

	if (select_query)
	{
		const ASTTablesInSelectQueryElement * join = select_query->join();
		if (join)
		{
			if (static_cast<const ASTTableJoin &>(*join->table_join).using_expression_list)
				getRootActions(static_cast<const ASTTableJoin &>(*join->table_join).using_expression_list, true, false, temp_actions);

			addJoinAction(temp_actions, true);
		}
	}

	getAggregates(ast, temp_actions);

	if (has_aggregation)
	{
		assertSelect();

		/// Find out aggregation keys.
		if (select_query->group_expression_list)
		{
			NameSet unique_keys;
			ASTs & group_asts = select_query->group_expression_list->children;
			for (ssize_t i = 0; i < ssize_t(group_asts.size()); ++i)
			{
				ssize_t size = group_asts.size();
				getRootActions(group_asts[i], true, false, temp_actions);

				const auto & column_name = group_asts[i]->getColumnName();
				const auto & block = temp_actions->getSampleBlock();

				if (!block.has(column_name))
					throw Exception("Unknown identifier (in GROUP BY): " + column_name, ErrorCodes::UNKNOWN_IDENTIFIER);

				const auto & col = block.getByName(column_name);

				/// Constant expressions have non-null column pointer at this stage.
				if (const auto is_constexpr = col.column)
				{
					/// But don't remove last key column if no aggregate functions, otherwise aggregation will not work.
					if (!aggregate_descriptions.empty() || size > 1)
					{
						if (i + 1 < static_cast<ssize_t>(size))
							group_asts[i] = std::move(group_asts.back());

						group_asts.pop_back();

						--i;
						continue;
					}
				}

				NameAndTypePair key{column_name, col.type};

				/// Aggregation keys are uniqued.
				if (!unique_keys.count(key.name))
				{
					unique_keys.insert(key.name);
					aggregation_keys.push_back(key);

					/// Key is no longer needed, therefore we can save a little by moving it.
					aggregated_columns.push_back(std::move(key));
				}
			}

			if (group_asts.empty())
			{
				select_query->group_expression_list = nullptr;
				has_aggregation = select_query->having_expression || aggregate_descriptions.size();
			}
		}

		for (size_t i = 0; i < aggregate_descriptions.size(); ++i)
		{
			AggregateDescription & desc = aggregate_descriptions[i];
			aggregated_columns.emplace_back(desc.column_name, desc.function->getReturnType());
		}
	}
	else
	{
		aggregated_columns = temp_actions->getSampleBlock().getColumnsList();
	}
}


void ExpressionAnalyzer::initGlobalSubqueriesAndExternalTables()
{
	/// Добавляет уже существующие внешние таблицы (не подзапросы) в словарь external_tables.
	findExternalTables(ast);

	/// Преобразует GLOBAL-подзапросы во внешние таблицы; кладёт их в словарь external_tables: name -> StoragePtr.
	initGlobalSubqueries(ast);
}


void ExpressionAnalyzer::initGlobalSubqueries(ASTPtr & ast)
{
	/// Рекурсивные вызовы. Не опускаемся в подзапросы.

	for (auto & child : ast->children)
		if (!typeid_cast<ASTSelectQuery *>(child.get()))
			initGlobalSubqueries(child);

	/// Действия, выполняемые снизу вверх.

	if (ASTFunction * node = typeid_cast<ASTFunction *>(ast.get()))
	{
		/// Для GLOBAL IN.
		if (do_global && (node->name == "globalIn" || node->name == "globalNotIn"))
			addExternalStorage(node->arguments->children.at(1));
	}
	else if (ASTTablesInSelectQueryElement * node = typeid_cast<ASTTablesInSelectQueryElement *>(ast.get()))
	{
		/// Для GLOBAL JOIN.
		if (do_global && node->table_join
			&& static_cast<const ASTTableJoin &>(*node->table_join).locality == ASTTableJoin::Locality::Global)
			addExternalStorage(node->table_expression);
	}
}


void ExpressionAnalyzer::findExternalTables(ASTPtr & ast)
{
	/// Обход снизу. Намеренно опускаемся в подзапросы.
	for (auto & child : ast->children)
		findExternalTables(child);

	/// Если идентификатор типа таблица
	StoragePtr external_storage;

	if (ASTIdentifier * node = typeid_cast<ASTIdentifier *>(ast.get()))
		if (node->kind == ASTIdentifier::Table)
			if ((external_storage = context.tryGetExternalTable(node->name)))
				external_tables[node->name] = external_storage;
}


static std::shared_ptr<InterpreterSelectQuery> interpretSubquery(
	ASTPtr & subquery_or_table_name, const Context & context, size_t subquery_depth, const Names & required_columns);


void ExpressionAnalyzer::addExternalStorage(ASTPtr & subquery_or_table_name_or_table_expression)
{
	/// При нераспределённых запросах, создание временных таблиц не имеет смысла.
	if (!(storage && storage->isRemote()))
		return;

	ASTPtr subquery;
	ASTPtr table_name;
	ASTPtr subquery_or_table_name;

	if (typeid_cast<const ASTIdentifier *>(subquery_or_table_name_or_table_expression.get()))
	{
		table_name = subquery_or_table_name_or_table_expression;
		subquery_or_table_name = table_name;
	}
	else if (auto ast_table_expr = typeid_cast<const ASTTableExpression *>(subquery_or_table_name_or_table_expression.get()))
	{
		if (ast_table_expr->database_and_table_name)
		{
			table_name = ast_table_expr->database_and_table_name;
			subquery_or_table_name = table_name;
		}
		else if (ast_table_expr->subquery)
		{
			subquery = ast_table_expr->subquery;
			subquery_or_table_name = subquery;
		}
	}
	else if (typeid_cast<const ASTSubquery *>(subquery_or_table_name_or_table_expression.get()))
	{
		subquery = subquery_or_table_name_or_table_expression;
		subquery_or_table_name = subquery;
	}

	if (!subquery_or_table_name)
		throw Exception("Logical error: unknown AST element passed to ExpressionAnalyzer::addExternalStorage method", ErrorCodes::LOGICAL_ERROR);

	if (table_name)
	{
		/// Если это уже внешняя таблица, ничего заполять не нужно. Просто запоминаем ее наличие.
		if (external_tables.end() != external_tables.find(static_cast<const ASTIdentifier &>(*table_name).name))
			return;
	}

	/// Сгенерируем имя для внешней таблицы.
	String external_table_name = "_data" + toString(external_table_id);
	while (external_tables.count(external_table_name))
	{
		++external_table_id;
		external_table_name = "_data" + toString(external_table_id);
	}

	auto interpreter = interpretSubquery(subquery_or_table_name, context, subquery_depth, {});

	Block sample = interpreter->getSampleBlock();
	NamesAndTypesListPtr columns = std::make_shared<NamesAndTypesList>(sample.getColumnsList());

	StoragePtr external_storage = StorageMemory::create(external_table_name, columns);

	/** Есть два способа выполнения распределённых GLOBAL-подзапросов.
	  *
	  * Способ push:
	  * Данные подзапроса отправляются на все удалённые серверы, где они затем используются.
	  * Для этого способа, данные отправляются в виде "внешних таблиц" и будут доступны на каждом удалённом сервере по имени типа _data1.
	  * Заменяем в запросе подзапрос на это имя.
	  *
	  * Способ pull:
	  * Удалённые серверы скачивают данные подзапроса с сервера-инициатора запроса.
	  * Для этого способа, заменяем подзапрос на другой подзапрос вида (SELECT * FROM remote('host:port', _query_QUERY_ID, _data1))
	  * Этот подзапрос, по факту, говорит - "надо скачать данные оттуда".
	  *
	  * Способ pull имеет преимущество, потому что в нём удалённый сервер может решить, что ему не нужны данные и не скачивать их в таких случаях.
	  */

	if (settings.global_subqueries_method == GlobalSubqueriesMethod::PUSH)
	{
		/** Заменяем подзапрос на имя временной таблицы.
		  * Именно в таком виде, запрос отправится на удалённый сервер.
		  * На удалённый сервер отправится эта временная таблица, и на его стороне,
		  *  вместо выполнения подзапроса, надо будет просто из неё прочитать.
		  */

		auto database_and_table_name = std::make_shared<ASTIdentifier>(StringRange(), external_table_name, ASTIdentifier::Table);

		if (auto ast_table_expr = typeid_cast<ASTTableExpression *>(subquery_or_table_name_or_table_expression.get()))
		{
			ast_table_expr->subquery.reset();
			ast_table_expr->database_and_table_name = database_and_table_name;

			ast_table_expr->children.clear();
			ast_table_expr->children.emplace_back(database_and_table_name);
		}
		else
			subquery_or_table_name_or_table_expression = database_and_table_name;
	}
	else if (settings.global_subqueries_method == GlobalSubqueriesMethod::PULL)
	{
		throw Exception("Support for 'pull' method of execution of global subqueries is disabled.", ErrorCodes::SUPPORT_IS_DISABLED);

		/// TODO
/*		String host_port = getFQDNOrHostName() + ":" + toString(context.getTCPPort());
		String database = "_query_" + context.getCurrentQueryId();

		auto subquery = std::make_shared<ASTSubquery>();
		subquery_or_table_name = subquery;

		auto select = std::make_shared<ASTSelectQuery>();
		subquery->children.push_back(select);

		auto exp_list = std::make_shared<ASTExpressionList>();
		select->select_expression_list = exp_list;
		select->children.push_back(select->select_expression_list);

		Names column_names = external_storage->getColumnNamesList();
		for (const auto & name : column_names)
			exp_list->children.push_back(std::make_shared<ASTIdentifier>(StringRange(), name));

		auto table_func = std::make_shared<ASTFunction>();
		select->table = table_func;
		select->children.push_back(select->table);

		table_func->name = "remote";
		auto args = std::make_shared<ASTExpressionList>();
		table_func->arguments = args;
		table_func->children.push_back(table_func->arguments);

		auto address_lit = std::make_shared<ASTLiteral>(StringRange(), host_port);
		args->children.push_back(address_lit);

		auto database_lit = std::make_shared<ASTLiteral>(StringRange(), database);
		args->children.push_back(database_lit);

		auto table_lit = std::make_shared<ASTLiteral>(StringRange(), external_table_name);
		args->children.push_back(table_lit);*/
	}
	else
		throw Exception("Unknown global subqueries execution method", ErrorCodes::UNKNOWN_GLOBAL_SUBQUERIES_METHOD);

	external_tables[external_table_name] = external_storage;
	subqueries_for_sets[external_table_name].source = interpreter->execute().in;
	subqueries_for_sets[external_table_name].source_sample = interpreter->getSampleBlock();
	subqueries_for_sets[external_table_name].table = external_storage;

	/** NOTE Если было написано IN tmp_table - существующая временная (но не внешняя) таблица,
	  *  то здесь будет создана новая временная таблица (например, _data1),
	  *  и данные будут затем в неё скопированы.
	  * Может быть, этого можно избежать.
	  */
}


NamesAndTypesList::iterator ExpressionAnalyzer::findColumn(const String & name, NamesAndTypesList & cols)
{
	return std::find_if(cols.begin(), cols.end(),
		[&](const NamesAndTypesList::value_type & val) { return val.name == name; });
}


/// ignore_levels - алиасы в скольки верхних уровнях поддерева нужно игнорировать.
/// Например, при ignore_levels=1 ast не может быть занесен в словарь, но его дети могут.
void ExpressionAnalyzer::addASTAliases(ASTPtr & ast, int ignore_levels)
{
	/// Обход снизу-вверх. Не опускаемся в подзапросы.
	for (auto & child : ast->children)
	{
		int new_ignore_levels = std::max(0, ignore_levels - 1);

		/// Алиасы верхнего уровня в секции ARRAY JOIN имеют особый смысл, их добавлять не будем
		///  (пропустим сам expression list и его детей).
		if (typeid_cast<ASTArrayJoin *>(ast.get()))
			new_ignore_levels = 3;

		/// Don't descent into UNION ALL, table functions and subqueries.
		if (!typeid_cast<ASTTableExpression *>(child.get())
			&& !typeid_cast<ASTSelectQuery *>(child.get()))
			addASTAliases(child, new_ignore_levels);
	}

	if (ignore_levels > 0)
		return;

	String alias = ast->tryGetAlias();
	if (!alias.empty())
	{
		if (aliases.count(alias) && ast->getTreeID() != aliases[alias]->getTreeID())
			throw Exception("Different expressions with the same alias " + alias, ErrorCodes::MULTIPLE_EXPRESSIONS_FOR_ALIAS);

		aliases[alias] = ast;
	}
}


StoragePtr ExpressionAnalyzer::getTable()
{
	if (const ASTSelectQuery * select = typeid_cast<const ASTSelectQuery *>(ast.get()))
	{
		auto select_database = select->database();
		auto select_table = select->table();

		if (select_table
			&& !typeid_cast<const ASTSelectQuery *>(select_table.get())
			&& !typeid_cast<const ASTFunction *>(select_table.get()))
		{
			String database = select_database
				? typeid_cast<const ASTIdentifier &>(*select_database).name
				: "";
			const String & table = typeid_cast<const ASTIdentifier &>(*select_table).name;
			return context.tryGetTable(database, table);
		}
	}

	return StoragePtr();
}


void ExpressionAnalyzer::normalizeTree()
{
	SetOfASTs tmp_set;
	MapOfASTs tmp_map;
	normalizeTreeImpl(ast, tmp_map, tmp_set, "", 0);
}


/// finished_asts - уже обработанные вершины (и на что они заменены)
/// current_asts - вершины в текущем стеке вызовов этого метода
/// current_alias - алиас, повешенный на предка ast (самого глубокого из предков с алиасами)
void ExpressionAnalyzer::normalizeTreeImpl(
	ASTPtr & ast, MapOfASTs & finished_asts, SetOfASTs & current_asts, std::string current_alias, size_t level)
{
	if (level > settings.limits.max_ast_depth)
		throw Exception("Normalized AST is too deep. Maximum: " + toString(settings.limits.max_ast_depth), ErrorCodes::TOO_DEEP_AST);

	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())
		current_alias = my_alias;

	/// rewrite правила, которые действуют при обходе сверху-вниз.
	bool replaced = false;

	ASTFunction * func_node = typeid_cast<ASTFunction *>(ast.get());
	if (func_node)
	{
		/** Нет ли в таблице столбца, название которого полностью совпадает с записью функции?
		  * Например, в таблице есть столбец "domain(URL)", и мы запросили domain(URL).
		  */
		String function_string = func_node->getColumnName();
		NamesAndTypesList::const_iterator it = findColumn(function_string);
		if (columns.end() != it)
		{
			ast = std::make_shared<ASTIdentifier>(func_node->range, function_string);
			current_asts.insert(ast.get());
			replaced = true;
		}

		/// Может быть указано IN t, где t - таблица, что равносильно IN (SELECT * FROM t).
		if (functionIsInOrGlobalInOperator(func_node->name))
			if (ASTIdentifier * right = typeid_cast<ASTIdentifier *>(func_node->arguments->children.at(1).get()))
				right->kind = ASTIdentifier::Table;

		/// Special cases for count function.
		String func_name_lowercase = Poco::toLower(func_node->name);
		if (startsWith(func_name_lowercase, "count"))
		{
			/// Select implementation of countDistinct based on settings.
			/// Important that it is done as query rewrite. It means rewritten query
			///  will be sent to remote servers during distributed query execution,
			///  and on all remote servers, function implementation will be same.
			if (endsWith(func_node->name, "Distinct") && func_name_lowercase == "countdistinct")
				func_node->name = settings.count_distinct_implementation;

			/// As special case, treat count(*) as count(), not as count(list of all columns).
			if (func_name_lowercase == "count" && func_node->arguments->children.size() == 1
				&& typeid_cast<const ASTAsterisk *>(func_node->arguments->children[0].get()))
			{
				func_node->arguments->children.clear();
			}
		}
	}
	else if (ASTIdentifier * node = typeid_cast<ASTIdentifier *>(ast.get()))
	{
		if (node->kind == ASTIdentifier::Column)
		{
			/// Если это алиас, но не родительский алиас (чтобы работали конструкции вроде "SELECT column+1 AS column").
			Aliases::const_iterator jt = aliases.find(node->name);
			if (jt != aliases.end() && current_alias != node->name)
			{
				/// Заменим его на соответствующий узел дерева.
				if (current_asts.count(jt->second.get()))
					throw Exception("Cyclic aliases", ErrorCodes::CYCLIC_ALIASES);
				if (!my_alias.empty() && my_alias != jt->second->getAliasOrColumnName())
				{
					/// В конструкции вроде "a AS b", где a - алиас, нужно перевесить алиас b на результат подстановки алиаса a.
					ast = jt->second->clone();
					ast->setAlias(my_alias);
				}
				else
				{
					ast = jt->second;
				}

				replaced = true;
			}
		}
	}
	else if (ASTExpressionList * node = typeid_cast<ASTExpressionList *>(ast.get()))
	{
		/// Заменим * на список столбцов.
		ASTs & asts = node->children;
		for (int i = static_cast<int>(asts.size()) - 1; i >= 0; --i)
		{
			if (ASTAsterisk * asterisk = typeid_cast<ASTAsterisk *>(asts[i].get()))
			{
				ASTs all_columns;
				for (const auto & column_name_type : columns)
					all_columns.emplace_back(std::make_shared<ASTIdentifier>(asterisk->range, column_name_type.name));

				asts.erase(asts.begin() + i);
				asts.insert(asts.begin() + i, all_columns.begin(), all_columns.end());
			}
		}
	}
	else if (ASTTablesInSelectQueryElement * node = typeid_cast<ASTTablesInSelectQueryElement *>(ast.get()))
	{
		if (node->table_expression)
		{
			auto & database_and_table_name = static_cast<ASTTableExpression &>(*node->table_expression).database_and_table_name;
			if (database_and_table_name)
			{
				if (ASTIdentifier * right = typeid_cast<ASTIdentifier *>(database_and_table_name.get()))
				{
					right->kind = ASTIdentifier::Table;
				}
			}
		}
	}

	/// Если заменили корень поддерева вызовемся для нового корня снова - на случай, если алиас заменился на алиас.
	if (replaced)
	{
		normalizeTreeImpl(ast, finished_asts, current_asts, current_alias, level + 1);
		current_asts.erase(initial_ast.get());
		current_asts.erase(ast.get());
		finished_asts[initial_ast] = ast;
		return;
	}

	/// Рекурсивные вызовы. Не опускаемся в подзапросы.
	/// Также не опускаемся в левый аргумент лямбда-выражений, чтобы не заменять формальные параметры
	///  по алиасам в выражениях вида 123 AS x, arrayMap(x -> 1, [2]).

	if (func_node && func_node->name == "lambda")
	{
		/// Пропускаем первый аргумент. Также предполагаем, что у функции lambda не может быть parameters.
		for (size_t i = 1, size = func_node->arguments->children.size(); i < size; ++i)
		{
			auto & child = func_node->arguments->children[i];

			if (typeid_cast<const ASTSelectQuery *>(child.get())
				|| typeid_cast<const ASTTableExpression *>(child.get()))
				continue;

			normalizeTreeImpl(child, finished_asts, current_asts, current_alias, level + 1);
		}
	}
	else
	{
		for (auto & child : ast->children)
		{
			if (typeid_cast<const ASTSelectQuery *>(child.get())
				|| typeid_cast<const ASTTableExpression *>(child.get()))
				continue;

			normalizeTreeImpl(child, finished_asts, current_asts, current_alias, level + 1);
		}
	}

	/// Если секция WHERE или HAVING состоит из одного алиаса, ссылку нужно заменить не только в children, но и в where_expression и having_expression.
	if (ASTSelectQuery * select = typeid_cast<ASTSelectQuery *>(ast.get()))
	{
		if (select->prewhere_expression)
			normalizeTreeImpl(select->prewhere_expression, finished_asts, current_asts, current_alias, level + 1);
		if (select->where_expression)
			normalizeTreeImpl(select->where_expression, finished_asts, current_asts, current_alias, level + 1);
		if (select->having_expression)
			normalizeTreeImpl(select->having_expression, finished_asts, current_asts, current_alias, level + 1);
	}

	/// Действия, выполняемые снизу вверх.

	if (ASTFunction * node = typeid_cast<ASTFunction *>(ast.get()))
	{
		if (node->kind == ASTFunction::TABLE_FUNCTION)
		{
		}
		else if (node->name == "lambda")
		{
			node->kind = ASTFunction::LAMBDA_EXPRESSION;
		}
		else if (context.getAggregateFunctionFactory().isAggregateFunctionName(node->name))
		{
			node->kind = ASTFunction::AGGREGATE_FUNCTION;
		}
		else if (node->name == "arrayJoin")
		{
			node->kind = ASTFunction::ARRAY_JOIN;
		}
		else
		{
			node->kind = ASTFunction::FUNCTION;
		}

		if (node->parameters && node->kind != ASTFunction::AGGREGATE_FUNCTION)
			throw Exception("The only parametric functions (functions with two separate parenthesis pairs) are aggregate functions"
				", and '" + node->name + "' is not an aggregate function.", ErrorCodes::FUNCTION_CANNOT_HAVE_PARAMETERS);
	}

	current_asts.erase(initial_ast.get());
	current_asts.erase(ast.get());
	finished_asts[initial_ast] = ast;
}


void ExpressionAnalyzer::addAliasColumns()
{
	if (!select_query)
		return;

	if (!storage)
		return;

	columns.insert(std::end(columns), std::begin(storage->alias_columns), std::end(storage->alias_columns));
}


void ExpressionAnalyzer::executeScalarSubqueries()
{
	if (!select_query)
		executeScalarSubqueriesImpl(ast);
	else
	{
		for (auto & child : ast->children)
		{
			/// Не опускаемся в FROM, JOIN, UNION.
			if (!typeid_cast<const ASTTableExpression *>(child.get())
				&& child.get() != select_query->next_union_all.get())
			{
				executeScalarSubqueriesImpl(child);
			}
		}
	}
}


static ASTPtr addTypeConversion(std::unique_ptr<ASTLiteral> && ast, const String & type_name)
{
	auto func = std::make_shared<ASTFunction>(ast->range);
	ASTPtr res = func;
	func->alias = ast->alias;
	ast->alias.clear();
	func->kind = ASTFunction::FUNCTION;
	func->name = "CAST";
	auto exp_list = std::make_shared<ASTExpressionList>(ast->range);
	func->arguments = exp_list;
	func->children.push_back(func->arguments);
	exp_list->children.emplace_back(ast.release());
	exp_list->children.emplace_back(std::make_shared<ASTLiteral>(StringRange(), type_name));
	return res;
}


void ExpressionAnalyzer::executeScalarSubqueriesImpl(ASTPtr & ast)
{
	/** Заменяем подзапросы, возвращающие ровно одну строку
	  * ("скалярные" подзапросы) на соответствующие константы.
	  *
	  * Если подзапрос возвращает более одного столбца, то он заменяется на кортеж констант.
	  *
	  * Особенности:
	  *
	  * Замена происходит во время анализа запроса, а не во время основной стадии выполнения.
	  * Это значит, что не будет работать индикатор прогресса во время выполнения этих запросов,
	  *  а также такие запросы нельзя будет прервать.
	  *
	  * Зато результат запросов может быть использован для индекса в таблице.
	  *
	  * Скалярные подзапросы выполняются на сервере-инициаторе запроса.
	  * На удалённые серверы запрос отправляется с уже подставленными константами.
	  */

	if (ASTSubquery * subquery = typeid_cast<ASTSubquery *>(ast.get()))
	{
		Context subquery_context = context;
		Settings subquery_settings = context.getSettings();
		subquery_settings.limits.max_result_rows = 1;
		subquery_settings.extremes = 0;
		subquery_context.setSettings(subquery_settings);

		ASTPtr query = subquery->children.at(0);
		BlockIO res = InterpreterSelectQuery(query, subquery_context, QueryProcessingStage::Complete, subquery_depth + 1).execute();

		Block block;
		try
		{
			block = res.in->read();

			if (!block)
				throw Exception("Scalar subquery returned empty result", ErrorCodes::INCORRECT_RESULT_OF_SCALAR_SUBQUERY);

			if (block.rows() != 1 || res.in->read())
				throw Exception("Scalar subquery returned more than one row", ErrorCodes::INCORRECT_RESULT_OF_SCALAR_SUBQUERY);
		}
		catch (const Exception & e)
		{
			if (e.code() == ErrorCodes::TOO_MUCH_ROWS)
				throw Exception("Scalar subquery returned more than one row", ErrorCodes::INCORRECT_RESULT_OF_SCALAR_SUBQUERY);
			else
				throw;
		}

		size_t columns = block.columns();
		if (columns == 1)
		{
			auto lit = std::make_unique<ASTLiteral>(ast->range, (*block.safeGetByPosition(0).column)[0]);
			lit->alias = subquery->alias;
			ast = addTypeConversion(std::move(lit), block.safeGetByPosition(0).type->getName());
		}
		else
		{
			auto tuple = std::make_shared<ASTFunction>(ast->range);
			tuple->alias = subquery->alias;
			ast = tuple;
			tuple->kind = ASTFunction::FUNCTION;
			tuple->name = "tuple";
			auto exp_list = std::make_shared<ASTExpressionList>(ast->range);
			tuple->arguments = exp_list;
			tuple->children.push_back(tuple->arguments);

			exp_list->children.resize(columns);
			for (size_t i = 0; i < columns; ++i)
			{
				exp_list->children[i] = addTypeConversion(
					std::make_unique<ASTLiteral>(ast->range, (*block.safeGetByPosition(i).column)[0]),
					block.safeGetByPosition(i).type->getName());
			}
		}
	}
	else
	{
		/** Don't descend into subqueries in FROM section.
		  */
		if (!typeid_cast<ASTTableExpression *>(ast.get()))
		{
			/** Don't descend into subqueries in arguments of IN operator.
			  * But if an argument is not subquery, than deeper may be scalar subqueries and we need to descend in them.
			  */
			ASTFunction * func = typeid_cast<ASTFunction *>(ast.get());

			if (func && func->kind == ASTFunction::FUNCTION
				&& functionIsInOrGlobalInOperator(func->name))
			{
				for (auto & child : ast->children)
				{
					if (child != func->arguments)
						executeScalarSubqueriesImpl(child);
					else
						for (size_t i = 0, size = func->arguments->children.size(); i < size; ++i)
							if (i != 1 || !typeid_cast<ASTSubquery *>(func->arguments->children[i].get()))
								executeScalarSubqueriesImpl(func->arguments->children[i]);
				}
			}
			else
				for (auto & child : ast->children)
					executeScalarSubqueriesImpl(child);
		}
	}
}


void ExpressionAnalyzer::optimizeGroupBy()
{
	if (!(select_query && select_query->group_expression_list))
		return;

	const auto is_literal = [] (const ASTPtr& ast) {
		return typeid_cast<const ASTLiteral*>(ast.get());
	};

	auto & group_exprs = select_query->group_expression_list->children;

	/// removes expression at index idx by making it last one and calling .pop_back()
	const auto remove_expr_at_index = [&group_exprs] (const size_t idx)
	{
		if (idx < group_exprs.size() - 1)
			std::swap(group_exprs[idx], group_exprs.back());

		group_exprs.pop_back();
	};

	/// iterate over each GROUP BY expression, eliminate injective function calls and literals
	for (size_t i = 0; i < group_exprs.size();)
	{
		if (const auto function = typeid_cast<ASTFunction *>(group_exprs[i].get()))
		{
			/// assert function is injective
			if (possibly_injective_function_names.count(function->name))
			{
				/// do not handle semantic errors here
				if (function->arguments->children.size() < 2)
				{
					++i;
					continue;
				}

				const auto & dict_name = typeid_cast<const ASTLiteral &>(*function->arguments->children[0])
					.value.safeGet<String>();

				const auto & dict_ptr = context.getExternalDictionaries().getDictionary(dict_name);

				const auto & attr_name = typeid_cast<const ASTLiteral &>(*function->arguments->children[1])
					.value.safeGet<String>();

				if (!dict_ptr->isInjective(attr_name))
				{
					++i;
					continue;
				}
			}
			else if (!injective_function_names.count(function->name))
			{
				++i;
				continue;
			}

			/// copy shared pointer to args in order to ensure lifetime
			auto args_ast = function->arguments;

			/** remove function call and take a step back to ensure
			  * next iteration does not skip not yet processed data
			  */
			remove_expr_at_index(i);

			/// copy non-literal arguments
			std::remove_copy_if(
				std::begin(args_ast->children), std::end(args_ast->children),
				std::back_inserter(group_exprs), is_literal
			);
		}
		else if (is_literal(group_exprs[i]))
		{
			remove_expr_at_index(i);
		}
		else
		{
			/// if neither a function nor literal - advance to next expression
			++i;
		}
	}

	if (group_exprs.empty())
	{
		/** Нельзя полностью убирать GROUP BY. Потому что если при этом даже агрегатных функций не было, то получится, что не будет агрегации.
		  * Вместо этого оставим GROUP BY const.
		  * Далее см. удаление констант в методе analyzeAggregation.
		  */

		/// Нужно вставить константу, которая не является именем столбца таблицы. Такой случай редкий, но бывает.
		UInt64 unused_column = 0;
		String unused_column_name = toString(unused_column);

		while (columns.end() != std::find_if(columns.begin(), columns.end(),
			[&unused_column_name](const NameAndTypePair & name_type) { return name_type.name == unused_column_name; }))
		{
			++unused_column;
			unused_column_name = toString(unused_column);
		}

		select_query->group_expression_list = std::make_shared<ASTExpressionList>();
		select_query->group_expression_list->children.emplace_back(std::make_shared<ASTLiteral>(StringRange(), UInt64(unused_column)));
	}
}


void ExpressionAnalyzer::optimizeOrderBy()
{
	if (!(select_query && select_query->order_expression_list))
		return;

	/// Уникализируем условия сортировки.
	using NameAndLocale = std::pair<String, String>;
	std::set<NameAndLocale> elems_set;

	ASTs & elems = select_query->order_expression_list->children;
	ASTs unique_elems;
	unique_elems.reserve(elems.size());

	for (const auto & elem : elems)
	{
		String name = elem->children.front()->getColumnName();
		const ASTOrderByElement & order_by_elem = typeid_cast<const ASTOrderByElement &>(*elem);

		if (elems_set.emplace(name, order_by_elem.collation ? order_by_elem.collation->getColumnName() : "").second)
			unique_elems.emplace_back(elem);
	}

	if (unique_elems.size() < elems.size())
		elems = unique_elems;
}


void ExpressionAnalyzer::optimizeLimitBy()
{
	if (!(select_query && select_query->limit_by_expression_list))
		return;

	std::set<String> elems_set;

	ASTs & elems = select_query->limit_by_expression_list->children;
	ASTs unique_elems;
	unique_elems.reserve(elems.size());

	for (const auto & elem : elems)
	{
		if (const auto id = typeid_cast<const ASTIdentifier*>(elem.get()))
		{
			if (elems_set.emplace(id->getColumnName()).second)
				unique_elems.emplace_back(elem);
		}
	}

	if (unique_elems.size() < elems.size())
		elems = unique_elems;
}


void ExpressionAnalyzer::makeSetsForIndex()
{
	if (storage && ast && storage->supportsIndexForIn())
		makeSetsForIndexImpl(ast, storage->getSampleBlock());
}

void ExpressionAnalyzer::makeSetsForIndexImpl(ASTPtr & node, const Block & sample_block)
{
	for (auto & child : node->children)
		makeSetsForIndexImpl(child, sample_block);

	ASTFunction * func = typeid_cast<ASTFunction *>(node.get());
	if (func && func->kind == ASTFunction::FUNCTION && functionIsInOperator(func->name))
	{
		IAST & args = *func->arguments;
		ASTPtr & arg = args.children.at(1);

		if (!typeid_cast<ASTSet *>(arg.get()) && !typeid_cast<ASTSubquery *>(arg.get()) && !typeid_cast<ASTIdentifier *>(arg.get()))
		{
			try
			{
				makeExplicitSet(func, sample_block, true);
			}
			catch (const DB::Exception & e)
			{
				/// в sample_block нет колонок, которые добаляет getActions
				if (e.code() != ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK)
					throw;
			}
		}
	}
}


static std::shared_ptr<InterpreterSelectQuery> interpretSubquery(
	ASTPtr & subquery_or_table_name, const Context & context, size_t subquery_depth, const Names & required_columns)
{
	/// Подзапрос или имя таблицы. Имя таблицы аналогично подзапросу SELECT * FROM t.
	const ASTSubquery * subquery = typeid_cast<const ASTSubquery *>(subquery_or_table_name.get());
	const ASTIdentifier * table = typeid_cast<const ASTIdentifier *>(subquery_or_table_name.get());

	if (!subquery && !table)
		throw Exception("IN/JOIN supports only SELECT subqueries.", ErrorCodes::BAD_ARGUMENTS);

	/** Для подзапроса в секции IN/JOIN не действуют ограничения на максимальный размер результата.
	  * Так как результат этого поздапроса - ещё не результат всего запроса.
	  * Вместо этого работают ограничения
	  *  max_rows_in_set, max_bytes_in_set, set_overflow_mode,
	  *  max_rows_in_join, max_bytes_in_join, join_overflow_mode,
	  *  которые проверяются отдельно (в объектах Set, Join).
	  */
	Context subquery_context = context;
	Settings subquery_settings = context.getSettings();
	subquery_settings.limits.max_result_rows = 0;
	subquery_settings.limits.max_result_bytes = 0;
	/// Вычисление extremes не имеет смысла и не нужно (если его делать, то в результате всего запроса могут взяться extremes подзапроса).
	subquery_settings.extremes = 0;
	subquery_context.setSettings(subquery_settings);

	ASTPtr query;
	if (table)
	{
		/// create ASTSelectQuery for "SELECT * FROM table" as if written by hand
		const auto select_query = std::make_shared<ASTSelectQuery>();
		query = select_query;

		const auto select_expression_list = std::make_shared<ASTExpressionList>();
		select_query->select_expression_list = select_expression_list;
		select_query->children.emplace_back(select_query->select_expression_list);

		/// get columns list for target table
		const auto & storage = context.getTable("", table->name);
		const auto & columns = storage->getColumnsListNonMaterialized();
		select_expression_list->children.reserve(columns.size());

		/// manually substitute column names in place of asterisk
		for (const auto & column : columns)
			select_expression_list->children.emplace_back(std::make_shared<ASTIdentifier>(
				StringRange{}, column.name));

		select_query->replaceDatabaseAndTable("", table->name);
	}
	else
	{
		query = subquery->children.at(0);

		/** В подзапросе могут быть указаны столбцы с одинаковыми именами. Например, SELECT x, x FROM t
		  * Это плохо, потому что результат такого запроса нельзя сохранить в таблицу, потому что в таблице не может быть одноимённых столбцов.
		  * Сохранение в таблицу требуется для GLOBAL-подзапросов.
		  *
		  * Чтобы избежать такой ситуации, будем переименовывать одинаковые столбцы.
		  */

		std::set<std::string> all_column_names;
		std::set<std::string> assigned_column_names;

		if (ASTSelectQuery * select = typeid_cast<ASTSelectQuery *>(query.get()))
		{
			for (auto & expr : select->select_expression_list->children)
				all_column_names.insert(expr->getAliasOrColumnName());

			for (auto & expr : select->select_expression_list->children)
			{
				auto name = expr->getAliasOrColumnName();

				if (!assigned_column_names.insert(name).second)
				{
					size_t i = 1;
					while (all_column_names.end() != all_column_names.find(name + "_" + toString(i)))
						++i;

					name = name + "_" + toString(i);
					expr = expr->clone();	/// Отменяет склейку одинаковых выражений в дереве.
					expr->setAlias(name);

					all_column_names.insert(name);
					assigned_column_names.insert(name);
				}
			}
		}
	}

	if (required_columns.empty())
		return std::make_shared<InterpreterSelectQuery>(
			query, subquery_context, QueryProcessingStage::Complete, subquery_depth + 1);
	else
		return std::make_shared<InterpreterSelectQuery>(
			query, subquery_context, required_columns, QueryProcessingStage::Complete, subquery_depth + 1);
}


void ExpressionAnalyzer::makeSet(ASTFunction * node, const Block & sample_block)
{
	/** Нужно преобразовать правый аргумент в множество.
	  * Это может быть имя таблицы, значение, перечисление значений или подзапрос.
	  * Перечисление значений парсится как функция tuple.
	  */
	IAST & args = *node->arguments;
	ASTPtr & arg = args.children.at(1);

	/// Уже преобразовали.
	if (typeid_cast<ASTSet *>(arg.get()))
		return;

	/// Если подзапрос или имя таблицы для SELECT.
	ASTIdentifier * identifier = typeid_cast<ASTIdentifier *>(arg.get());
	if (typeid_cast<ASTSubquery *>(arg.get()) || identifier)
	{
		/// Получаем поток блоков для подзапроса. Создаём Set и кладём на место подзапроса.
		String set_id = arg->getColumnName();
		auto ast_set = std::make_shared<ASTSet>(set_id);
		ASTPtr ast_set_ptr = ast_set;

		/// Особый случай - если справа оператора IN указано имя таблицы, при чём, таблица имеет тип Set (заранее подготовленное множество).
		/// TODO В этом синтаксисе не поддерживается указание имени БД.
		if (identifier)
		{
			StoragePtr table = context.tryGetTable("", identifier->name);

			if (table)
			{
				StorageSet * storage_set = typeid_cast<StorageSet *>(table.get());

				if (storage_set)
				{
					SetPtr & set = storage_set->getSet();
					ast_set->set = set;
					arg = ast_set_ptr;
					return;
				}
			}
		}

		SubqueryForSet & subquery_for_set = subqueries_for_sets[set_id];

		/// Если уже создали Set с таким же подзапросом/таблицей.
		if (subquery_for_set.set)
		{
			ast_set->set = subquery_for_set.set;
			arg = ast_set_ptr;
			return;
		}

		ast_set->set = std::make_shared<Set>(settings.limits);

		/** Для GLOBAL IN-ов происходит следующее:
		  * - в функции addExternalStorage подзапрос IN (SELECT ...) заменяется на IN _data1,
		  *   в объекте subquery_for_set выставляется этот подзапрос в качестве source и временная таблица _data1 в качестве table.
		  * - в этой функции видно выражение IN _data1.
		  */
		if (!subquery_for_set.source)
		{
			auto interpreter = interpretSubquery(arg, context, subquery_depth, {});
			subquery_for_set.source = std::make_shared<LazyBlockInputStream>(
				[interpreter]() mutable { return interpreter->execute().in; });
			subquery_for_set.source_sample = interpreter->getSampleBlock();

			/** Зачем используется LazyBlockInputStream?
			  *
			  * Дело в том, что при обработке запроса вида
			  *  SELECT ... FROM remote_test WHERE column GLOBAL IN (subquery),
			  *  если распределённая таблица remote_test содержит в качестве одного из серверов localhost,
			  *  то запрос будет ещё раз интерпретирован локально (а не отправлен по TCP, как в случае удалённого сервера).
			  *
			  * Конвейер выполнения запроса будет такой:
			  * CreatingSets
			  *  выполнение подзапроса subquery, заполнение временной таблицы _data1 (1)
			  *  CreatingSets
			  *   чтение из таблицы _data1, создание множества (2)
			  *   чтение из таблицы, подчинённой remote_test.
			  *
			  * (Вторая часть конвейера под CreatingSets - это повторная интерпретация запроса внутри StorageDistributed,
			  *  запрос отличается тем, что имя БД и таблицы заменены на подчинённые, а также подзапрос заменён на _data1.)
			  *
			  * Но при создании конвейера, при создании источника (2), будет обнаружено, что таблица _data1 пустая
			  *  (потому что запрос ещё не начал выполняться), и будет возвращён в качестве источника пустой источник.
			  * И затем, при выполнении запроса, на шаге (2), будет создано пустое множество.
			  *
			  * Поэтому, мы делаем инициализацию шага (2) ленивой
			  *  - чтобы она произошла только после выполнения шага (1), на котором нужная таблица будет заполнена.
			  *
			  * Замечание: это решение не очень хорошее, надо подумать лучше.
			  */
		}

		subquery_for_set.set = ast_set->set;
		arg = ast_set_ptr;
	}
	else
	{
		/// Явное перечисление значений в скобках.
		makeExplicitSet(node, sample_block, false);
	}
}

/// Случай явного перечисления значений.
void ExpressionAnalyzer::makeExplicitSet(ASTFunction * node, const Block & sample_block, bool create_ordered_set)
{
	IAST & args = *node->arguments;

	if (args.children.size() != 2)
		throw Exception("Wrong number of arguments passed to function in", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);

	ASTPtr & arg = args.children.at(1);

	DataTypes set_element_types;
	ASTPtr & left_arg = args.children.at(0);

	ASTFunction * left_arg_tuple = typeid_cast<ASTFunction *>(left_arg.get());

	/** NOTE If tuple in left hand side specified non-explicitly
	  * Example: identity((a, b)) IN ((1, 2), (3, 4))
	  *  instead of        (a, b)) IN ((1, 2), (3, 4))
	  * then set creation of set doesn't work correctly.
	  */
	if (left_arg_tuple && left_arg_tuple->name == "tuple")
	{
		for (const auto & arg : left_arg_tuple->arguments->children)
		{
			const auto & data_type = sample_block.getByName(arg->getColumnName()).type;

			/// @note prevent crash in query: SELECT (1, [1]) in (1, 1)
			if (const auto array = typeid_cast<const DataTypeArray * >(data_type.get()))
				throw Exception("Incorrect element of tuple: " + array->getName(), ErrorCodes::INCORRECT_ELEMENT_OF_SET);

			set_element_types.push_back(data_type);
		}
	}
	else
	{
		DataTypePtr left_type = sample_block.getByName(left_arg->getColumnName()).type;
		if (DataTypeArray * array_type = typeid_cast<DataTypeArray *>(left_type.get()))
			set_element_types.push_back(array_type->getNestedType());
		else
			set_element_types.push_back(left_type);
	}

	/// Отличим случай x in (1, 2) от случая x in 1 (он же x in (1)).
	bool single_value = false;
	ASTPtr elements_ast = arg;

	if (ASTFunction * set_func = typeid_cast<ASTFunction *>(arg.get()))
	{
		if (set_func->name == "tuple")
		{
			if (set_func->arguments->children.empty())
			{
				/// Пустое множество.
				elements_ast = set_func->arguments;
			}
			else
			{
				/// Отличим случай (x, y) in ((1, 2), (3, 4)) от случая (x, y) in (1, 2).
				ASTFunction * any_element = typeid_cast<ASTFunction *>(set_func->arguments->children.at(0).get());
				if (set_element_types.size() >= 2 && (!any_element || any_element->name != "tuple"))
					single_value = true;
				else
					elements_ast = set_func->arguments;
			}
		}
		else
		{
			if (set_element_types.size() >= 2)
				throw Exception("Incorrect type of 2nd argument for function " + node->name
					+ ". Must be subquery or set of " + toString(set_element_types.size()) + "-element tuples.",
					ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);

			single_value = true;
		}
	}
	else if (typeid_cast<ASTLiteral *>(arg.get()))
	{
		single_value = true;
	}
	else
	{
		throw Exception("Incorrect type of 2nd argument for function " + node->name + ". Must be subquery or set of values.",
						ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
	}

	if (single_value)
	{
		ASTPtr exp_list = std::make_shared<ASTExpressionList>();
		exp_list->children.push_back(elements_ast);
		elements_ast = exp_list;
	}

	auto ast_set = std::make_shared<ASTSet>(arg->getColumnName());
	ast_set->set = std::make_shared<Set>(settings.limits);
	ast_set->is_explicit = true;
	ast_set->set->createFromAST(set_element_types, elements_ast, context, create_ordered_set);
	arg = ast_set;
}


static String getUniqueName(const Block & block, const String & prefix)
{
	int i = 1;
	while (block.has(prefix + toString(i)))
		++i;
	return prefix + toString(i);
}


/** Для getActionsImpl.
  * Стек из ExpressionActions, соответствующих вложенным лямбда-выражениям.
  * Новое действие нужно добавлять на самый высокий возможный уровень.
  * Например, в выражении "select arrayMap(x -> x + column1 * column2, array1)"
  *  вычисление произведения нужно делать вне лямбда-выражения (оно не зависит от x), а вычисление суммы - внутри (зависит от x).
  */
struct ExpressionAnalyzer::ScopeStack
{
	struct Level
	{
		ExpressionActionsPtr actions;
		NameSet new_columns;
	};

	using Levels = std::vector<Level>;

	Levels stack;
	Settings settings;

	ScopeStack(const ExpressionActionsPtr & actions, const Settings & settings_)
		: settings(settings_)
	{
		stack.emplace_back();
		stack.back().actions = actions;

		const Block & sample_block = actions->getSampleBlock();
		for (size_t i = 0, size = sample_block.columns(); i < size; ++i)
			stack.back().new_columns.insert(sample_block.getByPosition(i).name);
	}

	void pushLevel(const NamesAndTypesList & input_columns)
	{
		stack.emplace_back();
		Level & prev = stack[stack.size() - 2];

		ColumnsWithTypeAndName all_columns;
		NameSet new_names;

		for (NamesAndTypesList::const_iterator it = input_columns.begin(); it != input_columns.end(); ++it)
		{
			all_columns.emplace_back(nullptr, it->type, it->name);
			new_names.insert(it->name);
			stack.back().new_columns.insert(it->name);
		}

		const Block & prev_sample_block = prev.actions->getSampleBlock();
		for (size_t i = 0, size = prev_sample_block.columns(); i < size; ++i)
		{
			const ColumnWithTypeAndName & col = prev_sample_block.getByPosition(i);
			if (!new_names.count(col.name))
				all_columns.push_back(col);
		}

		stack.back().actions = std::make_shared<ExpressionActions>(all_columns, settings);
	}

	size_t getColumnLevel(const std::string & name)
	{
		for (int i = static_cast<int>(stack.size()) - 1; i >= 0; --i)
			if (stack[i].new_columns.count(name))
				return i;

		throw Exception("Unknown identifier: " + name, ErrorCodes::UNKNOWN_IDENTIFIER);
	}

	void addAction(const ExpressionAction & action, const Names & additional_required_columns = Names())
	{
		size_t level = 0;
		for (size_t i = 0; i < additional_required_columns.size(); ++i)
			level = std::max(level, getColumnLevel(additional_required_columns[i]));
		Names required = action.getNeededColumns();
		for (size_t i = 0; i < required.size(); ++i)
			level = std::max(level, getColumnLevel(required[i]));

		Names added;
		stack[level].actions->add(action, added);

		stack[level].new_columns.insert(added.begin(), added.end());

		for (size_t i = 0; i < added.size(); ++i)
		{
			const ColumnWithTypeAndName & col = stack[level].actions->getSampleBlock().getByName(added[i]);
			for (size_t j = level + 1; j < stack.size(); ++j)
				stack[j].actions->addInput(col);
		}
	}

	ExpressionActionsPtr popLevel()
	{
		ExpressionActionsPtr res = stack.back().actions;
		stack.pop_back();
		return res;
	}

	const Block & getSampleBlock() const
	{
		return stack.back().actions->getSampleBlock();
	}
};


void ExpressionAnalyzer::getRootActions(ASTPtr ast, bool no_subqueries, bool only_consts, ExpressionActionsPtr & actions)
{
	ScopeStack scopes(actions, settings);
	getActionsImpl(ast, no_subqueries, only_consts, scopes);
	actions = scopes.popLevel();
}


void ExpressionAnalyzer::getArrayJoinedColumns()
{
	if (select_query && select_query->array_join_expression_list())
	{
		ASTs & array_join_asts = select_query->array_join_expression_list()->children;
		for (const auto & ast : array_join_asts)
		{
			const String nested_table_name = ast->getColumnName();
			const String nested_table_alias = ast->getAliasOrColumnName();

			if (nested_table_alias == nested_table_name && !typeid_cast<const ASTIdentifier *>(ast.get()))
				throw Exception("No alias for non-trivial value in ARRAY JOIN: " + nested_table_name, ErrorCodes::ALIAS_REQUIRED);

			if (array_join_alias_to_name.count(nested_table_alias) || aliases.count(nested_table_alias))
				throw Exception("Duplicate alias in ARRAY JOIN: " + nested_table_alias, ErrorCodes::MULTIPLE_EXPRESSIONS_FOR_ALIAS);

			array_join_alias_to_name[nested_table_alias] = nested_table_name;
			array_join_name_to_alias[nested_table_name] = nested_table_alias;
		}

		getArrayJoinedColumnsImpl(ast);

		/// Если результат ARRAY JOIN не используется, придется все равно по-ARRAY-JOIN-ить какой-нибудь столбец,
		/// чтобы получить правильное количество строк.
		if (array_join_result_to_source.empty())
		{
			ASTPtr expr = select_query->array_join_expression_list()->children.at(0);
			String source_name = expr->getColumnName();
			String result_name = expr->getAliasOrColumnName();

			/// Это массив.
			if (!typeid_cast<ASTIdentifier *>(expr.get()) || findColumn(source_name, columns) != columns.end())
			{
				array_join_result_to_source[result_name] = source_name;
			}
			else /// Это вложенная таблица.
			{
				bool found = false;
				for (const auto & column_name_type : columns)
				{
					String table_name = DataTypeNested::extractNestedTableName(column_name_type.name);
					String column_name = DataTypeNested::extractNestedColumnName(column_name_type.name);
					if (table_name == source_name)
					{
						array_join_result_to_source[DataTypeNested::concatenateNestedName(result_name, column_name)] = column_name_type.name;
						found = true;
						break;
					}
				}
				if (!found)
					throw Exception("No columns in nested table " + source_name, ErrorCodes::EMPTY_NESTED_TABLE);
			}
		}
	}
}


/// Заполняет array_join_result_to_source: по каким столбцам-массивам размножить, и как их после этого назвать.
void ExpressionAnalyzer::getArrayJoinedColumnsImpl(ASTPtr ast)
{
	if (typeid_cast<ASTTablesInSelectQuery *>(ast.get()))
		return;

	if (ASTIdentifier * node = typeid_cast<ASTIdentifier *>(ast.get()))
	{
		if (node->kind == ASTIdentifier::Column)
		{
			String table_name = DataTypeNested::extractNestedTableName(node->name);

			if (array_join_alias_to_name.count(node->name))
			{
				/// Был написан ARRAY JOIN со столбцом-массивом. Пример: SELECT K1 FROM ... ARRAY JOIN ParsedParams.Key1 AS K1
				array_join_result_to_source[node->name] = array_join_alias_to_name[node->name];	/// K1 -> ParsedParams.Key1
			}
			else if (array_join_alias_to_name.count(table_name))
			{
				/// Был написан ARRAY JOIN с вложенной таблицей. Пример: SELECT PP.Key1 FROM ... ARRAY JOIN ParsedParams AS PP
				String nested_column = DataTypeNested::extractNestedColumnName(node->name);	/// Key1
				array_join_result_to_source[node->name]	/// PP.Key1 -> ParsedParams.Key1
					= DataTypeNested::concatenateNestedName(array_join_alias_to_name[table_name], nested_column);
			}
			else if (array_join_name_to_alias.count(table_name))
			{
				/** Пример: SELECT ParsedParams.Key1 FROM ... ARRAY JOIN ParsedParams AS PP.
				  * То есть, в запросе используется исходный массив, размноженный по самому себе.
				  */

				String nested_column = DataTypeNested::extractNestedColumnName(node->name);	/// Key1
				array_join_result_to_source[	/// PP.Key1 -> ParsedParams.Key1
					DataTypeNested::concatenateNestedName(array_join_name_to_alias[table_name], nested_column)] = node->name;
			}
		}
	}
	else
	{
		for (auto & child : ast->children)
			if (!typeid_cast<const ASTSubquery *>(child.get())
				&& !typeid_cast<const ASTSelectQuery *>(child.get()))
				getArrayJoinedColumnsImpl(child);
	}
}


void ExpressionAnalyzer::getActionsImpl(ASTPtr ast, bool no_subqueries, bool only_consts, ScopeStack & actions_stack)
{
	/// Если результат вычисления уже есть в блоке.
	if ((typeid_cast<ASTFunction *>(ast.get()) || typeid_cast<ASTLiteral *>(ast.get()))
		&& actions_stack.getSampleBlock().has(ast->getColumnName()))
		return;

	if (ASTIdentifier * node = typeid_cast<ASTIdentifier *>(ast.get()))
	{
		std::string name = node->getColumnName();
		if (!only_consts && !actions_stack.getSampleBlock().has(name))
		{
			/// Запрошенного столбца нет в блоке.
			/// Если такой столбец есть в таблице, значит пользователь наверно забыл окружить его агрегатной функцией или добавить в GROUP BY.

			bool found = false;
			for (const auto & column_name_type : columns)
				if (column_name_type.name == name)
					found = true;

			if (found)
				throw Exception("Column " + name + " is not under aggregate function and not in GROUP BY.",
					ErrorCodes::NOT_AN_AGGREGATE);
		}
	}
	else if (ASTFunction * node = typeid_cast<ASTFunction *>(ast.get()))
	{
		if (node->kind == ASTFunction::LAMBDA_EXPRESSION)
			throw Exception("Unexpected lambda expression", ErrorCodes::UNEXPECTED_EXPRESSION);

		/// Функция arrayJoin.
		if (node->kind == ASTFunction::ARRAY_JOIN)
		{
			if (node->arguments->children.size() != 1)
				throw Exception("arrayJoin requires exactly 1 argument", ErrorCodes::TYPE_MISMATCH);

			ASTPtr arg = node->arguments->children.at(0);
			getActionsImpl(arg, no_subqueries, only_consts, actions_stack);
			if (!only_consts)
			{
				String result_name = node->getColumnName();
				actions_stack.addAction(ExpressionAction::copyColumn(arg->getColumnName(), result_name));
				NameSet joined_columns;
				joined_columns.insert(result_name);
				actions_stack.addAction(ExpressionAction::arrayJoin(joined_columns, false));
			}

			return;
		}

		if (node->kind == ASTFunction::FUNCTION)
		{
			if (functionIsInOrGlobalInOperator(node->name))
			{
				if (!no_subqueries)
				{
					/// Найдем тип первого аргумента (потом getActionsImpl вызовется для него снова и ни на что не повлияет).
					getActionsImpl(node->arguments->children.at(0), no_subqueries, only_consts, actions_stack);

					/// Превратим tuple или подзапрос в множество.
					makeSet(node, actions_stack.getSampleBlock());
				}
				else
				{
					if (!only_consts)
					{
						/// Мы в той части дерева, которую не собираемся вычислять. Нужно только определить типы.
						/// Не будем выполнять подзапросы и составлять множества. Вставим произвольный столбец правильного типа.
						ColumnWithTypeAndName fake_column;
						fake_column.name = node->getColumnName();
						fake_column.type = std::make_shared<DataTypeUInt8>();
						actions_stack.addAction(ExpressionAction::addColumn(fake_column));
						getActionsImpl(node->arguments->children.at(0), no_subqueries, only_consts, actions_stack);
					}
					return;
				}
			}

			/// Особая функция indexHint. Всё, что внутри неё не вычисляется
			/// (а используется только для анализа индекса, см. PKCondition).
			if (node->name == "indexHint")
			{
				actions_stack.addAction(ExpressionAction::addColumn(ColumnWithTypeAndName(
					std::make_shared<ColumnConstUInt8>(1, 1), std::make_shared<DataTypeUInt8>(), node->getColumnName())));
				return;
			}

			const FunctionPtr & function = FunctionFactory::instance().get(node->name, context);

			Names argument_names;
			DataTypes argument_types;
			bool arguments_present = true;

			/// Если у функции есть аргумент-лямбда-выражение, нужно определить его тип до рекурсивного вызова.
			bool has_lambda_arguments = false;

			for (auto & child : node->arguments->children)
			{
				ASTFunction * lambda = typeid_cast<ASTFunction *>(child.get());
				ASTSet * set = typeid_cast<ASTSet *>(child.get());
				if (lambda && lambda->name == "lambda")
				{
					/// Если аргумент - лямбда-выражение, только запомним его примерный тип.
					if (lambda->arguments->children.size() != 2)
						throw Exception("lambda requires two arguments", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);

					ASTFunction * lambda_args_tuple = typeid_cast<ASTFunction *>(lambda->arguments->children.at(0).get());

					if (!lambda_args_tuple || lambda_args_tuple->name != "tuple")
						throw Exception("First argument of lambda must be a tuple", ErrorCodes::TYPE_MISMATCH);

					has_lambda_arguments = true;
					argument_types.emplace_back(std::make_shared<DataTypeExpression>(DataTypes(lambda_args_tuple->arguments->children.size())));
					/// Выберем название в следующем цикле.
					argument_names.emplace_back();
				}
				else if (set)
				{
					ColumnWithTypeAndName column;
					column.type = std::make_shared<DataTypeSet>();

					/// Если аргумент - множество, заданное перечислением значений, дадим ему уникальное имя,
					///  чтобы множества с одинаковой записью не склеивались (у них может быть разный тип).
					if (set->is_explicit)
						column.name = getUniqueName(actions_stack.getSampleBlock(), "__set");
					else
						column.name = set->getColumnName();

					if (!actions_stack.getSampleBlock().has(column.name))
					{
						column.column = std::make_shared<ColumnSet>(1, set->set);

						actions_stack.addAction(ExpressionAction::addColumn(column));
					}

					argument_types.push_back(column.type);
					argument_names.push_back(column.name);
				}
				else
				{
					/// Если аргумент не лямбда-выражение, вызовемся рекурсивно и узнаем его тип.
					getActionsImpl(child, no_subqueries, only_consts, actions_stack);
					std::string name = child->getColumnName();
					if (actions_stack.getSampleBlock().has(name))
					{
						argument_types.push_back(actions_stack.getSampleBlock().getByName(name).type);
						argument_names.push_back(name);
					}
					else
					{
						if (only_consts)
						{
							arguments_present = false;
						}
						else
						{
							throw Exception("Unknown identifier: " + name, ErrorCodes::UNKNOWN_IDENTIFIER);
						}
					}
				}
			}

			if (only_consts && !arguments_present)
				return;

			Names additional_requirements;

			if (has_lambda_arguments && !only_consts)
			{
				function->getLambdaArgumentTypes(argument_types);

				/// Вызовемся рекурсивно для лямбда-выражений.
				for (size_t i = 0; i < node->arguments->children.size(); ++i)
				{
					ASTPtr child = node->arguments->children[i];

					ASTFunction * lambda = typeid_cast<ASTFunction *>(child.get());
					if (lambda && lambda->name == "lambda")
					{
						DataTypeExpression * lambda_type = typeid_cast<DataTypeExpression *>(argument_types[i].get());
						ASTFunction * lambda_args_tuple = typeid_cast<ASTFunction *>(lambda->arguments->children.at(0).get());
						ASTs lambda_arg_asts = lambda_args_tuple->arguments->children;
						NamesAndTypesList lambda_arguments;

						for (size_t j = 0; j < lambda_arg_asts.size(); ++j)
						{
							ASTIdentifier * identifier = typeid_cast<ASTIdentifier *>(lambda_arg_asts[j].get());
							if (!identifier)
								throw Exception("lambda argument declarations must be identifiers", ErrorCodes::TYPE_MISMATCH);

							String arg_name = identifier->name;

							lambda_arguments.emplace_back(arg_name, lambda_type->getArgumentTypes()[j]);
						}

						actions_stack.pushLevel(lambda_arguments);
						getActionsImpl(lambda->arguments->children.at(1), no_subqueries, only_consts, actions_stack);
						ExpressionActionsPtr lambda_actions = actions_stack.popLevel();

						String result_name = lambda->arguments->children.at(1)->getColumnName();
						lambda_actions->finalize(Names(1, result_name));
						DataTypePtr result_type = lambda_actions->getSampleBlock().getByName(result_name).type;
						argument_types[i] = std::make_shared<DataTypeExpression>(lambda_type->getArgumentTypes(), result_type);

						Names captured = lambda_actions->getRequiredColumns();
						for (size_t j = 0; j < captured.size(); ++j)
							if (findColumn(captured[j], lambda_arguments) == lambda_arguments.end())
								additional_requirements.push_back(captured[j]);

						/// Не можем дать название getColumnName(),
						///  потому что оно не однозначно определяет выражение (типы аргументов могут быть разными).
						argument_names[i] = getUniqueName(actions_stack.getSampleBlock(), "__lambda");

						ColumnWithTypeAndName lambda_column;
						lambda_column.column = std::make_shared<ColumnExpression>(1, lambda_actions, lambda_arguments, result_type, result_name);
						lambda_column.type = argument_types[i];
						lambda_column.name = argument_names[i];
						actions_stack.addAction(ExpressionAction::addColumn(lambda_column));
					}
				}
			}

			if (only_consts)
			{
				for (size_t i = 0; i < argument_names.size(); ++i)
				{
					if (!actions_stack.getSampleBlock().has(argument_names[i]))
					{
						arguments_present = false;
						break;
					}
				}
			}

			if (arguments_present)
				actions_stack.addAction(ExpressionAction::applyFunction(function, argument_names, node->getColumnName()),
										additional_requirements);
		}
	}
	else if (ASTLiteral * node = typeid_cast<ASTLiteral *>(ast.get()))
	{
		DataTypePtr type = apply_visitor(FieldToDataType(), node->value);

		ColumnWithTypeAndName column;
		column.column = type->createConstColumn(1, node->value);
		column.type = type;
		column.name = node->getColumnName();

		actions_stack.addAction(ExpressionAction::addColumn(column));
	}
	else
	{
		for (auto & child : ast->children)
			getActionsImpl(child, no_subqueries, only_consts, actions_stack);
	}
}


void ExpressionAnalyzer::getAggregates(const ASTPtr & ast, ExpressionActionsPtr & actions)
{
	/// Внутри WHERE и PREWHERE не может быть агрегатных функций.
	if (select_query && (ast.get() == select_query->where_expression.get() || ast.get() == select_query->prewhere_expression.get()))
	{
		assertNoAggregates(ast, "in WHERE or PREWHERE");
		return;
	}

	/// Если мы анализируем не запрос SELECT, а отдельное выражение, то в нём не может быть агрегатных функций.
	if (!select_query)
	{
		assertNoAggregates(ast, "in wrong place");
		return;
	}

	const ASTFunction * node = typeid_cast<const ASTFunction *>(ast.get());
	if (node && node->kind == ASTFunction::AGGREGATE_FUNCTION)
	{
		has_aggregation = true;
		AggregateDescription aggregate;
		aggregate.column_name = node->getColumnName();

		/// Агрегатные функции уникализируются.
		for (size_t i = 0; i < aggregate_descriptions.size(); ++i)
			if (aggregate_descriptions[i].column_name == aggregate.column_name)
				return;

		const ASTs & arguments = node->arguments->children;
		aggregate.argument_names.resize(arguments.size());
		DataTypes types(arguments.size());

		for (size_t i = 0; i < arguments.size(); ++i)
		{
			/// Внутри агрегатных функций не может быть других агрегатных функций.
			assertNoAggregates(arguments[i], "inside another aggregate function");

			getRootActions(arguments[i], true, false, actions);
			const std::string & name = arguments[i]->getColumnName();
			types[i] = actions->getSampleBlock().getByName(name).type;
			aggregate.argument_names[i] = name;
		}

		aggregate.function = context.getAggregateFunctionFactory().get(node->name, types);

		if (node->parameters)
		{
			const ASTs & parameters = typeid_cast<const ASTExpressionList &>(*node->parameters).children;
			Array params_row(parameters.size());

			for (size_t i = 0; i < parameters.size(); ++i)
			{
				const ASTLiteral * lit = typeid_cast<const ASTLiteral *>(parameters[i].get());
				if (!lit)
					throw Exception("Parameters to aggregate functions must be literals",
						ErrorCodes::PARAMETERS_TO_AGGREGATE_FUNCTIONS_MUST_BE_LITERALS);

				params_row[i] = lit->value;
			}

			aggregate.parameters = params_row;
			aggregate.function->setParameters(params_row);
		}

		aggregate.function->setArguments(types);

		aggregate_descriptions.push_back(aggregate);
	}
	else
	{
		for (const auto & child : ast->children)
			if (!typeid_cast<const ASTSubquery *>(child.get())
				&& !typeid_cast<const ASTSelectQuery *>(child.get()))
				getAggregates(child, actions);
	}
}


void ExpressionAnalyzer::assertNoAggregates(const ASTPtr & ast, const char * description)
{
	const ASTFunction * node = typeid_cast<const ASTFunction *>(ast.get());

	if (node && node->kind == ASTFunction::AGGREGATE_FUNCTION)
		throw Exception("Aggregate function " + node->getColumnName()
			+ " is found " + String(description) + " in query", ErrorCodes::ILLEGAL_AGGREGATION);

	for (const auto & child : ast->children)
		if (!typeid_cast<const ASTSubquery *>(child.get())
			&& !typeid_cast<const ASTSelectQuery *>(child.get()))
			assertNoAggregates(child, description);
}


void ExpressionAnalyzer::assertSelect() const
{
	if (!select_query)
		throw Exception("Not a select query", ErrorCodes::LOGICAL_ERROR);
}

void ExpressionAnalyzer::assertAggregation() const
{
	if (!has_aggregation)
		throw Exception("No aggregation", ErrorCodes::LOGICAL_ERROR);
}

void ExpressionAnalyzer::initChain(ExpressionActionsChain & chain, const NamesAndTypesList & columns) const
{
	if (chain.steps.empty())
	{
		chain.settings = settings;
		chain.steps.emplace_back(std::make_shared<ExpressionActions>(columns, settings));
	}
}

/// "Big" ARRAY JOIN.
void ExpressionAnalyzer::addMultipleArrayJoinAction(ExpressionActionsPtr & actions) const
{
	NameSet result_columns;
	for (const auto & result_source : array_join_result_to_source)
	{
		/// Assign new names to columns, if needed.
		if (result_source.first != result_source.second)
			actions->add(ExpressionAction::copyColumn(result_source.second, result_source.first));

		/// Сделать ARRAY JOIN (заменить массивы на их внутренности) для столбцов в этими новыми именами.
		result_columns.insert(result_source.first);
	}

	actions->add(ExpressionAction::arrayJoin(result_columns, select_query->array_join_is_left()));
}

bool ExpressionAnalyzer::appendArrayJoin(ExpressionActionsChain & chain, bool only_types)
{
	assertSelect();

	if (!select_query->array_join_expression_list())
		return false;

	initChain(chain, columns);
	ExpressionActionsChain::Step & step = chain.steps.back();

	getRootActions(select_query->array_join_expression_list(), only_types, false, step.actions);

	addMultipleArrayJoinAction(step.actions);

	return true;
}

void ExpressionAnalyzer::addJoinAction(ExpressionActionsPtr & actions, bool only_types) const
{
	if (only_types)
		actions->add(ExpressionAction::ordinaryJoin(nullptr, columns_added_by_join));
	else
		for (auto & subquery_for_set : subqueries_for_sets)
			if (subquery_for_set.second.join)
				actions->add(ExpressionAction::ordinaryJoin(subquery_for_set.second.join, columns_added_by_join));
}

bool ExpressionAnalyzer::appendJoin(ExpressionActionsChain & chain, bool only_types)
{
	assertSelect();

	if (!select_query->join())
		return false;

	initChain(chain, columns);
	ExpressionActionsChain::Step & step = chain.steps.back();

	const ASTTablesInSelectQueryElement & join_element = static_cast<const ASTTablesInSelectQueryElement &>(*select_query->join());
	const ASTTableJoin & join_params = static_cast<const ASTTableJoin &>(*join_element.table_join);
	const ASTTableExpression & table_to_join = static_cast<const ASTTableExpression &>(*join_element.table_expression);

	if (join_params.using_expression_list)
		getRootActions(join_params.using_expression_list, only_types, false, step.actions);

	/// Не поддерживается два JOIN-а с одинаковым подзапросом, но разными USING-ами.
	String join_id = join_element.getTreeID();

	SubqueryForSet & subquery_for_set = subqueries_for_sets[join_id];

	/// Особый случай - если справа JOIN указано имя таблицы, при чём, таблица имеет тип Join (заранее подготовленное отображение).
	/// TODO В этом синтаксисе не поддерживается указание имени БД.
	if (table_to_join.database_and_table_name)
	{
		StoragePtr table = context.tryGetTable("", static_cast<const ASTIdentifier &>(*table_to_join.database_and_table_name).name);

		if (table)
		{
			StorageJoin * storage_join = typeid_cast<StorageJoin *>(table.get());

			if (storage_join)
			{
				storage_join->assertCompatible(join_params.kind, join_params.strictness);
				/// TODO Проверять набор ключей.

				JoinPtr & join = storage_join->getJoin();
				subquery_for_set.join = join;
			}
		}
	}

	if (!subquery_for_set.join)
	{
		JoinPtr join = std::make_shared<Join>(
			join_key_names_left, join_key_names_right, settings.limits,
			join_params.kind, join_params.strictness);

		Names required_joined_columns(join_key_names_right.begin(), join_key_names_right.end());
		for (const auto & name_type : columns_added_by_join)
			required_joined_columns.push_back(name_type.name);

		/** Для GLOBAL JOIN-ов (в случае, например, push-метода выполнения GLOBAL подзапросов) происходит следующее:
		  * - в функции addExternalStorage подзапрос JOIN (SELECT ...) заменяется на JOIN _data1,
		  *   в объекте subquery_for_set выставляется этот подзапрос в качестве source и временная таблица _data1 в качестве table.
		  * - в этой функции видно выражение JOIN _data1.
		  */
		if (!subquery_for_set.source)
		{
			ASTPtr table;
			if (table_to_join.database_and_table_name)
				table = table_to_join.database_and_table_name;
			else
				table = table_to_join.subquery;

			auto interpreter = interpretSubquery(table, context, subquery_depth, required_joined_columns);
			subquery_for_set.source = std::make_shared<LazyBlockInputStream>([interpreter]() mutable { return interpreter->execute().in; });
			subquery_for_set.source_sample = interpreter->getSampleBlock();
		}

		/// TODO Это не нужно выставлять, когда JOIN нужен только на удалённых серверах.
		subquery_for_set.join = join;
		subquery_for_set.join->setSampleBlock(subquery_for_set.source_sample);
	}

	addJoinAction(step.actions, false);

	return true;
}


bool ExpressionAnalyzer::appendWhere(ExpressionActionsChain & chain, bool only_types)
{
	assertSelect();

	if (!select_query->where_expression)
		return false;

	initChain(chain, columns);
	ExpressionActionsChain::Step & step = chain.steps.back();

	step.required_output.push_back(select_query->where_expression->getColumnName());
	getRootActions(select_query->where_expression, only_types, false, step.actions);

	return true;
}

bool ExpressionAnalyzer::appendGroupBy(ExpressionActionsChain & chain, bool only_types)
{
	assertAggregation();

	if (!select_query->group_expression_list)
		return false;

	initChain(chain, columns);
	ExpressionActionsChain::Step & step = chain.steps.back();

	ASTs asts = select_query->group_expression_list->children;
	for (size_t i = 0; i < asts.size(); ++i)
	{
		step.required_output.push_back(asts[i]->getColumnName());
		getRootActions(asts[i], only_types, false, step.actions);
	}

	return true;
}

void ExpressionAnalyzer::appendAggregateFunctionsArguments(ExpressionActionsChain & chain, bool only_types)
{
	assertAggregation();

	initChain(chain, columns);
	ExpressionActionsChain::Step & step = chain.steps.back();

	for (size_t i = 0; i < aggregate_descriptions.size(); ++i)
	{
		for (size_t j = 0; j < aggregate_descriptions[i].argument_names.size(); ++j)
		{
			step.required_output.push_back(aggregate_descriptions[i].argument_names[j]);
		}
	}

	getActionsBeforeAggregation(select_query->select_expression_list, step.actions, only_types);

	if (select_query->having_expression)
		getActionsBeforeAggregation(select_query->having_expression, step.actions, only_types);

	if (select_query->order_expression_list)
		getActionsBeforeAggregation(select_query->order_expression_list, step.actions, only_types);
}

bool ExpressionAnalyzer::appendHaving(ExpressionActionsChain & chain, bool only_types)
{
	assertAggregation();

	if (!select_query->having_expression)
		return false;

	initChain(chain, aggregated_columns);
	ExpressionActionsChain::Step & step = chain.steps.back();

	step.required_output.push_back(select_query->having_expression->getColumnName());
	getRootActions(select_query->having_expression, only_types, false, step.actions);

	return true;
}

void ExpressionAnalyzer::appendSelect(ExpressionActionsChain & chain, bool only_types)
{
	assertSelect();

	initChain(chain, aggregated_columns);
	ExpressionActionsChain::Step & step = chain.steps.back();

	getRootActions(select_query->select_expression_list, only_types, false, step.actions);

	ASTs asts = select_query->select_expression_list->children;
	for (size_t i = 0; i < asts.size(); ++i)
	{
		step.required_output.push_back(asts[i]->getColumnName());
	}
}

bool ExpressionAnalyzer::appendOrderBy(ExpressionActionsChain & chain, bool only_types)
{
	assertSelect();

	if (!select_query->order_expression_list)
		return false;

	initChain(chain, aggregated_columns);
	ExpressionActionsChain::Step & step = chain.steps.back();

	getRootActions(select_query->order_expression_list, only_types, false, step.actions);

	ASTs asts = select_query->order_expression_list->children;
	for (size_t i = 0; i < asts.size(); ++i)
	{
		ASTOrderByElement * ast = typeid_cast<ASTOrderByElement *>(asts[i].get());
		if (!ast || ast->children.size() < 1)
			throw Exception("Bad order expression AST", ErrorCodes::UNKNOWN_TYPE_OF_AST_NODE);
		ASTPtr order_expression = ast->children.at(0);
		step.required_output.push_back(order_expression->getColumnName());
	}

	return true;
}

void ExpressionAnalyzer::appendProjectResult(DB::ExpressionActionsChain & chain, bool only_types) const
{
	assertSelect();

	initChain(chain, aggregated_columns);
	ExpressionActionsChain::Step & step = chain.steps.back();

	NamesWithAliases result_columns;

	ASTs asts = select_query->select_expression_list->children;
	for (size_t i = 0; i < asts.size(); ++i)
	{
		result_columns.emplace_back(asts[i]->getColumnName(), asts[i]->getAliasOrColumnName());
		step.required_output.push_back(result_columns.back().second);
	}

	step.actions->add(ExpressionAction::project(result_columns));
}


Block ExpressionAnalyzer::getSelectSampleBlock()
{
	assertSelect();

	ExpressionActionsPtr temp_actions = std::make_shared<ExpressionActions>(aggregated_columns, settings);
	NamesWithAliases result_columns;

	ASTs asts = select_query->select_expression_list->children;
	for (size_t i = 0; i < asts.size(); ++i)
	{
		result_columns.emplace_back(asts[i]->getColumnName(), asts[i]->getAliasOrColumnName());
		getRootActions(asts[i], true, false, temp_actions);
	}

	temp_actions->add(ExpressionAction::project(result_columns));

	return temp_actions->getSampleBlock();
}

void ExpressionAnalyzer::getActionsBeforeAggregation(ASTPtr ast, ExpressionActionsPtr & actions, bool no_subqueries)
{
	ASTFunction * node = typeid_cast<ASTFunction *>(ast.get());

	if (node && node->kind == ASTFunction::AGGREGATE_FUNCTION)
		for (auto & argument : node->arguments->children)
			getRootActions(argument, no_subqueries, false, actions);
	else
		for (auto & child : ast->children)
			getActionsBeforeAggregation(child, actions, no_subqueries);
}


ExpressionActionsPtr ExpressionAnalyzer::getActions(bool project_result)
{
	ExpressionActionsPtr actions = std::make_shared<ExpressionActions>(columns, settings);
	NamesWithAliases result_columns;
	Names result_names;

	ASTs asts;

	if (auto node = typeid_cast<const ASTExpressionList *>(ast.get()))
		asts = node->children;
	else
		asts = ASTs(1, ast);

	for (size_t i = 0; i < asts.size(); ++i)
	{
		std::string name = asts[i]->getColumnName();
		std::string alias;
		if (project_result)
			alias = asts[i]->getAliasOrColumnName();
		else
			alias = name;
		result_columns.emplace_back(name, alias);
		result_names.push_back(alias);
		getRootActions(asts[i], false, false, actions);
	}

	if (project_result)
	{
		actions->add(ExpressionAction::project(result_columns));
	}
	else
	{
		/// Не будем удалять исходные столбцы.
		for (const auto & column_name_type : columns)
			result_names.push_back(column_name_type.name);
	}

	actions->finalize(result_names);

	return actions;
}


ExpressionActionsPtr ExpressionAnalyzer::getConstActions()
{
	ExpressionActionsPtr actions = std::make_shared<ExpressionActions>(NamesAndTypesList(), settings);

	getRootActions(ast, true, true, actions);

	return actions;
}

void ExpressionAnalyzer::getAggregateInfo(Names & key_names, AggregateDescriptions & aggregates) const
{
	for (const auto & name_and_type : aggregation_keys)
		key_names.emplace_back(name_and_type.name);

	aggregates = aggregate_descriptions;
}

void ExpressionAnalyzer::collectUsedColumns()
{
	/** Вычислим, какие столбцы требуются для выполнения выражения.
	  * Затем, удалим все остальные столбцы из списка доступных столбцов.
	  * После выполнения, columns будет содержать только список столбцов, нужных для чтения из таблицы.
	  */

	NameSet required;
	NameSet ignored;

	if (select_query && select_query->array_join_expression_list())
	{
		ASTs & expressions = select_query->array_join_expression_list()->children;
		for (size_t i = 0; i < expressions.size(); ++i)
		{
			/// Игнорируем идентификаторы верхнего уровня из секции ARRAY JOIN.
			/// Их потом добавим отдельно.
			if (typeid_cast<ASTIdentifier *>(expressions[i].get()))
			{
				ignored.insert(expressions[i]->getColumnName());
			}
			else
			{
				/// Для выражений в ARRAY JOIN ничего игнорировать не нужно.
				NameSet empty;
				getRequiredColumnsImpl(expressions[i], required, empty, empty, empty);
			}

			ignored.insert(expressions[i]->getAliasOrColumnName());
		}
	}

	/** Также нужно не учитывать идентификаторы столбцов, получающихся путём JOIN-а.
	  * (Не считать, что они требуются для чтения из "левой" таблицы).
	  */
	NameSet available_joined_columns;
	collectJoinedColumns(available_joined_columns, columns_added_by_join);

	NameSet required_joined_columns;
	getRequiredColumnsImpl(ast, required, ignored, available_joined_columns, required_joined_columns);

	for (NamesAndTypesList::iterator it = columns_added_by_join.begin(); it != columns_added_by_join.end();)
	{
		if (required_joined_columns.count(it->name))
			++it;
		else
			columns_added_by_join.erase(it++);
	}

/*	for (const auto & name_type : columns_added_by_join)
		std::cerr << "JOINed column (required, not key): " << name_type.name << std::endl;
	std::cerr << std::endl;*/

	/// Вставляем в список требуемых столбцов столбцы, нужные для вычисления ARRAY JOIN.
	NameSet array_join_sources;
	for (const auto & result_source : array_join_result_to_source)
		array_join_sources.insert(result_source.second);

	for (const auto & column_name_type : columns)
		if (array_join_sources.count(column_name_type.name))
			required.insert(column_name_type.name);

	/// Нужно прочитать хоть один столбец, чтобы узнать количество строк.
	if (required.empty())
		required.insert(ExpressionActions::getSmallestColumn(columns));

	unknown_required_columns = required;

	for (NamesAndTypesList::iterator it = columns.begin(); it != columns.end();)
	{
		unknown_required_columns.erase(it->name);

		if (!required.count(it->name))
			columns.erase(it++);
		else
			++it;
	}

	/// Возможно, среди неизвестных столбцов есть виртуальные. Удаляем их из списка неизвестных и добавляем
	/// в columns list, чтобы при дальнейшей обработке запроса они воспринимались как настоящие.
	if (storage)
	{
		for (auto it = unknown_required_columns.begin(); it != unknown_required_columns.end();)
		{
			if (storage->hasColumn(*it))
			{
				columns.push_back(storage->getColumn(*it));
				unknown_required_columns.erase(it++);
			}
			else
				++it;
		}
	}
}

void ExpressionAnalyzer::collectJoinedColumns(NameSet & joined_columns, NamesAndTypesList & joined_columns_name_type)
{
	if (!select_query)
		return;

	const ASTTablesInSelectQueryElement * node = select_query->join();

	if (!node)
		return;

	const ASTTableJoin & table_join = static_cast<const ASTTableJoin &>(*node->table_join);
	const ASTTableExpression & table_expression = static_cast<const ASTTableExpression &>(*node->table_expression);

	Block nested_result_sample;
	if (table_expression.database_and_table_name)
	{
		const auto & table = context.getTable("", static_cast<const ASTIdentifier &>(*table_expression.database_and_table_name).name);
		nested_result_sample = table->getSampleBlockNonMaterialized();
	}
	else if (table_expression.subquery)
	{
		const auto & subquery = table_expression.subquery->children.at(0);
		nested_result_sample = InterpreterSelectQuery::getSampleBlock(subquery, context);
	}

	if (table_join.using_expression_list)
	{
		auto & keys = typeid_cast<ASTExpressionList &>(*table_join.using_expression_list);
		for (const auto & key : keys.children)
		{
			if (join_key_names_left.end() == std::find(join_key_names_left.begin(), join_key_names_left.end(), key->getColumnName()))
				join_key_names_left.push_back(key->getColumnName());
			else
				throw Exception("Duplicate column " + key->getColumnName() + " in USING list", ErrorCodes::DUPLICATE_COLUMN);

			if (join_key_names_right.end() == std::find(join_key_names_right.begin(), join_key_names_right.end(), key->getAliasOrColumnName()))
				join_key_names_right.push_back(key->getAliasOrColumnName());
			else
				throw Exception("Duplicate column " + key->getAliasOrColumnName() + " in USING list", ErrorCodes::DUPLICATE_COLUMN);
		}
	}

	for (const auto i : ext::range(0, nested_result_sample.columns()))
	{
		const auto & col = nested_result_sample.safeGetByPosition(i);
		if (join_key_names_right.end() == std::find(join_key_names_right.begin(), join_key_names_right.end(), col.name)
			&& !joined_columns.count(col.name))	/// Дублирующиеся столбцы в подзапросе для JOIN-а не имеют смысла.
		{
			joined_columns.insert(col.name);
			joined_columns_name_type.emplace_back(col.name, col.type);
		}
	}

/*	for (const auto & name : join_key_names_left)
		std::cerr << "JOIN key (left): " << name << std::endl;
	for (const auto & name : join_key_names_right)
		std::cerr << "JOIN key (right): " << name << std::endl;
	std::cerr << std::endl;
	for (const auto & name : joined_columns)
		std::cerr << "JOINed column: " << name << std::endl;
	std::cerr << std::endl;*/
}


Names ExpressionAnalyzer::getRequiredColumns()
{
	if (!unknown_required_columns.empty())
		throw Exception("Unknown identifier: " + *unknown_required_columns.begin(), ErrorCodes::UNKNOWN_IDENTIFIER);

	Names res;
	for (const auto & column_name_type : columns)
		res.push_back(column_name_type.name);

	return res;
}


void ExpressionAnalyzer::getRequiredColumnsImpl(ASTPtr ast,
	NameSet & required_columns, NameSet & ignored_names,
	const NameSet & available_joined_columns, NameSet & required_joined_columns)
{
	/** Найдём все идентификаторы в запросе.
	  * Будем искать их рекурсивно, обходя в глубину AST.
	  * При этом:
	  * - для лямбда функций не будем брать формальные параметры;
	  * - не опускаемся в подзапросы (там свои идентификаторы);
	  * - некоторое исключение для секции ARRAY JOIN (в ней идентификаторы немного другие);
	  * - идентификаторы, доступные из JOIN-а, кладём в required_joined_columns.
	  */

	if (ASTIdentifier * node = typeid_cast<ASTIdentifier *>(ast.get()))
	{
		if (node->kind == ASTIdentifier::Column
			&& !ignored_names.count(node->name)
			&& !ignored_names.count(DataTypeNested::extractNestedTableName(node->name)))
		{
			if (!available_joined_columns.count(node->name))
				required_columns.insert(node->name);
			else
				required_joined_columns.insert(node->name);
		}

		return;
	}

	if (ASTFunction * node = typeid_cast<ASTFunction *>(ast.get()))
	{
		if (node->kind == ASTFunction::LAMBDA_EXPRESSION)
		{
			if (node->arguments->children.size() != 2)
				throw Exception("lambda requires two arguments", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);

			ASTFunction * lambda_args_tuple = typeid_cast<ASTFunction *>(node->arguments->children.at(0).get());

			if (!lambda_args_tuple || lambda_args_tuple->name != "tuple")
				throw Exception("First argument of lambda must be a tuple", ErrorCodes::TYPE_MISMATCH);

			/// Не нужно добавлять формальные параметры лямбда-выражения в required_columns.
			Names added_ignored;
			for (auto & child : lambda_args_tuple->arguments->children)
			{
				ASTIdentifier * identifier = typeid_cast<ASTIdentifier *>(child.get());
				if (!identifier)
					throw Exception("lambda argument declarations must be identifiers", ErrorCodes::TYPE_MISMATCH);

				String & name = identifier->name;
				if (!ignored_names.count(name))
				{
					ignored_names.insert(name);
					added_ignored.push_back(name);
				}
			}

			getRequiredColumnsImpl(node->arguments->children.at(1),
				required_columns, ignored_names,
				available_joined_columns, required_joined_columns);

			for (size_t i = 0; i < added_ignored.size(); ++i)
				ignored_names.erase(added_ignored[i]);

			return;
		}

		/// Особая функция indexHint. Всё, что внутри неё не вычисляется
		/// (а используется только для анализа индекса, см. PKCondition).
		if (node->name == "indexHint")
			return;
	}

	/// Рекурсивный обход выражения.
	for (auto & child : ast->children)
	{
		/** Не пойдем в секцию ARRAY JOIN, потому что там нужно смотреть на имена не-ARRAY-JOIN-енных столбцов.
		  * Туда collectUsedColumns отправит нас отдельно.
		  */
		if (!typeid_cast<ASTSelectQuery *>(child.get())
			&& !typeid_cast<ASTArrayJoin *>(child.get()))
			getRequiredColumnsImpl(child, required_columns, ignored_names, available_joined_columns, required_joined_columns);
    }
}

}