{

IdentifierResolveScope & scope = createIdentifierResolveScope(node, /*parent_scope=*/ nullptr);

if (!scope.context)

scope.context = context;

auto node_type = node->getNodeType();

switch (node_type)

{

case QueryTreeNodeType::QUERY:

{

if (table_expression)

throw Exception(ErrorCodes::LOGICAL_ERROR,

"For query analysis table expression must be empty");

resolveQuery(node, scope);

break;

}

case QueryTreeNodeType::UNION:

{

if (table_expression)

throw Exception(ErrorCodes::LOGICAL_ERROR,

"For union analysis table expression must be empty");

resolveUnion(node, scope);

break;

}

case QueryTreeNodeType::IDENTIFIER:

[[fallthrough]];

case QueryTreeNodeType::CONSTANT:

[[fallthrough]];

case QueryTreeNodeType::COLUMN:

[[fallthrough]];

case QueryTreeNodeType::FUNCTION:

[[fallthrough]];

case QueryTreeNodeType::LIST:

{

if (table_expression)

{

scope.expression_join_tree_node = table_expression;

scope.registered_table_expression_nodes.insert(table_expression);

/// Mark table expression as being in resolve process to prevent

/// premature access during ALIAS column resolution in

/// initializeTableExpressionData (e.g. dictGet ALIAS columns).

scope.table_expressions_in_resolve_process.insert(table_expression.get());

validateTableExpressionModifiers(scope.expression_join_tree_node, scope);

initializeTableExpressionData(scope.expression_join_tree_node, scope);

scope.table_expressions_in_resolve_process.erase(table_expression.get());

}

if (node_type == QueryTreeNodeType::LIST)

{

QueryExpressionsAliasVisitor visitor(scope.aliases);

visitor.visit(node);

resolveExpressionNodeList(node, scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);

}

else

resolveExpressionNode(node, scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);

break;

}

case QueryTreeNodeType::TABLE_FUNCTION:

{

QueryExpressionsAliasVisitor expressions_alias_visitor(scope.aliases);

resolveTableFunction(node, scope, expressions_alias_visitor, false /*nested_table_function*/);

break;

}

default:

{

throw Exception(ErrorCodes::BAD_ARGUMENTS,

"Node {} with type {} is not supported by query analyzer. "

"Supported nodes are query, union, identifier, constant, column, function, list.",

node->formatASTForErrorMessage(),

node->getNodeTypeName());

}

}

validateCorrelatedSubqueries(node);

inlineMaterializedCTEIfNeeded(node, reused_materialized_cte, context);

{

IdentifierResolveScope & scope = createIdentifierResolveScope(node, /*parent_scope=*/ nullptr);

if (!scope.context)

scope.context = context;

auto node_type = node->getNodeType();

if (node_type == QueryTreeNodeType::QUERY || node_type == QueryTreeNodeType::UNION)

{

evaluateScalarSubqueryIfNeeded(node, scope);

return;

}

if (table_expression)

{

scope.expression_join_tree_node = table_expression;

scope.registered_table_expression_nodes.insert(table_expression);

/// Mark table expression as being in resolve process to prevent

/// premature access during ALIAS column resolution in

/// initializeTableExpressionData (e.g. dictGet ALIAS columns).

scope.table_expressions_in_resolve_process.insert(table_expression.get());

validateTableExpressionModifiers(scope.expression_join_tree_node, scope);

initializeTableExpressionData(scope.expression_join_tree_node, scope);

scope.table_expressions_in_resolve_process.erase(table_expression.get());

}

if (node_type == QueryTreeNodeType::LIST)

resolveExpressionNodeList(node, scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);

else

resolveExpressionNode(node, scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);

validateCorrelatedSubqueries(node);

{

if (node_source == tree_node)

return true;

std::stack<const IQueryTreeNode *> stack;

stack.push(tree_node);

while (!stack.empty())

{

const auto * current = stack.top();

stack.pop();

if (node_source == current)

return true;

if (const auto * child_join_node = current->as<JoinNode>())

{

stack.push(child_join_node->getLeftTableExpression().get());

stack.push(child_join_node->getRightTableExpression().get());

}

if (const auto * child_join_node = current->as<CrossJoinNode>())

{

stack.push_range(child_join_node->getTableExpressions() | std::views::transform(&QueryTreeNodePtr::get));

}

}

return false;

{

if (resolved_identifier->getNodeType() == QueryTreeNodeType::CONSTANT)

return {};

if (resolved_identifier->getNodeType() == QueryTreeNodeType::FUNCTION)

{

const auto & resolved_function = resolved_identifier->as<FunctionNode &>();

const auto & argument_nodes = resolved_function.getArguments().getNodes();

std::optional<JoinTableSide> result;

for (const auto & argument_node : argument_nodes)

{

auto table_side = getColumnSideFromJoinTree(argument_node, join_node);

if (table_side && result && *table_side != *result)

return {};

result = table_side;

}

return result;

}

const auto * column_src = resolved_identifier->as<ColumnNode &>().getColumnSource().get();

if (isFromJoinTree(column_src, join_node.getLeftTableExpression().get()))

return JoinTableSide::Left;

if (isFromJoinTree(column_src, join_node.getRightTableExpression().get()))

return JoinTableSide::Right;

return {};

const ProjectionNames & arguments_projection_names)

{

const auto & function_node_typed = function_node->as<FunctionNode &>();

const auto & function_node_name = function_node_typed.getFunctionName();

bool is_array_function = function_node_name == "array";

bool is_tuple_function = function_node_name == "tuple";

WriteBufferFromOwnString buffer;

if (!is_array_function && !is_tuple_function)

buffer << function_node_name;

if (!parameters_projection_names.empty())

{

buffer << '(';

size_t function_parameters_projection_names_size = parameters_projection_names.size();

for (size_t i = 0; i < function_parameters_projection_names_size; ++i)

{

buffer << parameters_projection_names[i];

if (i + 1 != function_parameters_projection_names_size)

buffer << ", ";

}

buffer << ')';

}

char open_bracket = '(';

char close_bracket = ')';

if (is_array_function)

{

open_bracket = '[';

close_bracket = ']';

}

buffer << open_bracket;

size_t function_arguments_projection_names_size = arguments_projection_names.size();

for (size_t i = 0; i < function_arguments_projection_names_size; ++i)

{

buffer << arguments_projection_names[i];

if (i + 1 != function_arguments_projection_names_size)

buffer << ", ";

}

buffer << close_bracket;

return buffer.str();

const QueryTreeNodePtr & parent_window_node,

const String & parent_window_name,

const ProjectionNames & partition_by_projection_names,

const ProjectionNames & order_by_projection_names,

const ProjectionName & frame_begin_offset_projection_name,

const ProjectionName & frame_end_offset_projection_name)

{

const auto & window_node_typed = window_node->as<WindowNode &>();

const auto & window_frame = window_node_typed.getWindowFrame();

bool parent_window_node_has_partition_by = false;

bool parent_window_node_has_order_by = false;

if (parent_window_node)

{

const auto & parent_window_node_typed = parent_window_node->as<WindowNode &>();

parent_window_node_has_partition_by = parent_window_node_typed.hasPartitionBy();

parent_window_node_has_order_by = parent_window_node_typed.hasOrderBy();

}

WriteBufferFromOwnString buffer;

if (!parent_window_name.empty())

buffer << parent_window_name;

if (!partition_by_projection_names.empty() && !parent_window_node_has_partition_by)

{

if (!parent_window_name.empty())

buffer << ' ';

buffer << "PARTITION BY ";

size_t partition_by_projection_names_size = partition_by_projection_names.size();

for (size_t i = 0; i < partition_by_projection_names_size; ++i)

{

buffer << partition_by_projection_names[i];

if (i + 1 != partition_by_projection_names_size)

buffer << ", ";

}

}

if (!order_by_projection_names.empty() && !parent_window_node_has_order_by)

{

if (!partition_by_projection_names.empty() || !parent_window_name.empty())

buffer << ' ';

buffer << "ORDER BY ";

size_t order_by_projection_names_size = order_by_projection_names.size();

for (size_t i = 0; i < order_by_projection_names_size; ++i)

{

buffer << order_by_projection_names[i];

if (i + 1 != order_by_projection_names_size)

buffer << ", ";

}

}

if (!window_frame.is_default)

{

if (!partition_by_projection_names.empty() || !order_by_projection_names.empty() || !parent_window_name.empty())

buffer << ' ';

buffer << window_frame.type << " BETWEEN ";

if (window_frame.begin_type == WindowFrame::BoundaryType::Current)

{

buffer << "CURRENT ROW";

}

else if (window_frame.begin_type == WindowFrame::BoundaryType::Unbounded)

{

buffer << "UNBOUNDED";

buffer << " " << (window_frame.begin_preceding ? "PRECEDING" : "FOLLOWING");

}

else

{

buffer << frame_begin_offset_projection_name;

buffer << " " << (window_frame.begin_preceding ? "PRECEDING" : "FOLLOWING");

}

buffer << " AND ";

if (window_frame.end_type == WindowFrame::BoundaryType::Current)

{

buffer << "CURRENT ROW";

}

else if (window_frame.end_type == WindowFrame::BoundaryType::Unbounded)

{

buffer << "UNBOUNDED";

buffer << " " << (window_frame.end_preceding ? "PRECEDING" : "FOLLOWING");

}

else

{

buffer << frame_end_offset_projection_name;

buffer << " " << (window_frame.end_preceding ? "PRECEDING" : "FOLLOWING");

}

}

return buffer.str();

const QueryTreeNodePtr & sort_column_node,

const ProjectionName & sort_expression_projection_name,

const ProjectionName & fill_from_expression_projection_name,

const ProjectionName & fill_to_expression_projection_name,

const ProjectionName & fill_step_expression_projection_name,

const ProjectionName & fill_staleness_expression_projection_name)

{

auto & sort_node_typed = sort_column_node->as<SortNode &>();

WriteBufferFromOwnString sort_column_projection_name_buffer;

sort_column_projection_name_buffer << sort_expression_projection_name;

auto sort_direction = sort_node_typed.getSortDirection();

sort_column_projection_name_buffer << (sort_direction == SortDirection::ASCENDING ? " ASC" : " DESC");

auto nulls_sort_direction = sort_node_typed.getNullsSortDirection();

if (nulls_sort_direction)

sort_column_projection_name_buffer << " NULLS " << (nulls_sort_direction == sort_direction ? "LAST" : "FIRST");

if (auto collator = sort_node_typed.getCollator())

sort_column_projection_name_buffer << " COLLATE " << collator->getLocale();

if (sort_node_typed.withFill())

{

sort_column_projection_name_buffer << " WITH FILL";

if (sort_node_typed.hasFillFrom())

sort_column_projection_name_buffer << " FROM " << fill_from_expression_projection_name;

if (sort_node_typed.hasFillTo())

sort_column_projection_name_buffer << " TO " << fill_to_expression_projection_name;

if (sort_node_typed.hasFillStep())

sort_column_projection_name_buffer << " STEP " << fill_step_expression_projection_name;

if (sort_node_typed.hasFillStaleness())

sort_column_projection_name_buffer << " STALENESS " << fill_staleness_expression_projection_name;

}

return sort_column_projection_name_buffer.str();

{

const auto * create_function_query = typeid_cast<const ASTCreateSQLFunctionQuery *>(create_function_ast.get());

if (!create_function_query)

return nullptr;

const auto & function_name = create_function_query->getFunctionName();

auto it = function_name_to_user_defined_lambda.find(function_name);

if (it != function_name_to_user_defined_lambda.end())

return it->second;

auto result_node = buildQueryTree(create_function_query->function_core, context);

if (result_node->getNodeType() != QueryTreeNodeType::LAMBDA)

throw Exception(ErrorCodes::LOGICAL_ERROR,

"SQL user defined function {} must represent lambda expression. Actual: {}",

function_name,

create_function_query->function_core->formatForErrorMessage());

function_name_to_user_defined_lambda.emplace(function_name, result_node);

return result_node;

{

auto & window_node_typed = window_node->as<WindowNode &>();

auto parent_window_name = window_node_typed.getParentWindowName();

auto & parent_window_node_typed = parent_window_node->as<WindowNode &>();

/** If an existing_window_name is specified it must refer to an earlier

if (window_node_typed.hasPartitionBy())

{

throw Exception(ErrorCodes::BAD_ARGUMENTS,

"Derived window definition '{}' is not allowed to override PARTITION BY. In scope {}",

window_node_typed.formatASTForErrorMessage(),

scope.scope_node->formatASTForErrorMessage());

}

if (window_node_typed.hasOrderBy() && parent_window_node_typed.hasOrderBy())

{

throw Exception(ErrorCodes::BAD_ARGUMENTS,

"Derived window definition '{}' is not allowed to override a non-empty ORDER BY. In scope {}",

window_node_typed.formatASTForErrorMessage(),

scope.scope_node->formatASTForErrorMessage());

}

if (!parent_window_node_typed.getWindowFrame().is_default)

{

throw Exception(ErrorCodes::BAD_ARGUMENTS,

"Parent window '{}' is not allowed to define a frame: while processing derived window definition '{}'. In scope {}",

parent_window_name,

window_node_typed.formatASTForErrorMessage(),

scope.scope_node->formatASTForErrorMessage());

}

window_node_typed.getPartitionByNode() = parent_window_node_typed.getPartitionBy().clone();

if (parent_window_node_typed.hasOrderBy())

window_node_typed.getOrderByNode() = parent_window_node_typed.getOrderBy().clone();

{

const auto & settings = scope.context->getSettingsRef();

if (!settings[Setting::enable_positional_arguments] || scope.context->getClientInfo().query_kind != ClientInfo::QueryKind::INITIAL_QUERY)

return;

auto & node_list_typed = node_list->as<ListNode &>();

for (auto & node : node_list_typed.getNodes())

{

auto * node_to_replace = &node;

if (auto * sort_node = node->as<SortNode>())

node_to_replace = &sort_node->getExpression();

auto * constant_node = (*node_to_replace)->as<ConstantNode>();

if (!constant_node

|| (constant_node->getValue().getType() != Field::Types::UInt64

&& constant_node->getValue().getType() != Field::Types::Int64))

continue;

UInt64 pos;

if (constant_node->getValue().getType() == Field::Types::UInt64)

{

pos = constant_node->getValue().safeGet<UInt64>();

}

else // Int64

{

auto value = constant_node->getValue().safeGet<Int64>();

if (value > 0)

pos = value;

else

{

if (value < -static_cast<Int64>(projection_nodes.size()))

throw Exception(

ErrorCodes::BAD_ARGUMENTS,

"Negative positional argument number {} is out of bounds. Expected in range [-{}, -1]. In scope {}",

value,

projection_nodes.size(),

scope.scope_node->formatASTForErrorMessage());

pos = projection_nodes.size() + value + 1;

}

}

if (!pos || pos > projection_nodes.size())

throw Exception(

ErrorCodes::BAD_ARGUMENTS,

"Positional argument number {} is out of bounds. Expected in range [1, {}]. In scope {}",

pos,

projection_nodes.size(),

scope.scope_node->formatASTForErrorMessage());

--pos;

*node_to_replace = projection_nodes[pos]->clone();

if (auto it = resolved_expressions.find(projection_nodes[pos]); it != resolved_expressions.end())

{

resolved_expressions[*node_to_replace] = it->second;

}

}

{

const auto * limit_offset_constant_node = expression_node->as<ConstantNode>();

if (!limit_offset_constant_node || !isNativeNumber(removeNullable(limit_offset_constant_node->getResultType())))

throw Exception(ErrorCodes::INVALID_LIMIT_EXPRESSION,

"{} expression must be constant with numeric type. Actual: {}. In scope {}",

expression_description,

expression_node->formatASTForErrorMessage(),

scope.scope_node->formatASTForErrorMessage());

// We support limit in the range [INT64_MIN, UINT64_MAX] for integral limit or (0, 1) for fractional limit

// Consider the nonnegative limit case first as they are more common

{

Field converted_value = convertFieldToType(limit_offset_constant_node->getValue(), DataTypeUInt64());

if (!converted_value.isNull())

{

auto result_constant_node = std::make_shared<ConstantNode>(std::move(converted_value), std::make_shared<DataTypeUInt64>());

result_constant_node->getSourceExpression() = limit_offset_constant_node->getSourceExpression();

expression_node = std::move(result_constant_node);

return;

}

}

// If we are here, then the number is either negative or outside the supported range or float

// Consider the negative limit value case

{

Field converted_value = convertFieldToType(limit_offset_constant_node->getValue(), DataTypeInt64());

if (!converted_value.isNull())

{

auto result_constant_node = std::make_shared<ConstantNode>(std::move(converted_value), std::make_shared<DataTypeInt64>());

result_constant_node->getSourceExpression() = limit_offset_constant_node->getSourceExpression();

expression_node = std::move(result_constant_node);

return;

}

}

{

Field converted_value = convertFieldToType(limit_offset_constant_node->getValue(), DataTypeFloat64());

if (!converted_value.isNull())

{

auto value = converted_value.safeGet<Float64>();

if (value < 1 && value > 0)

{

auto result_constant_node = std::make_shared<ConstantNode>(Field(value), std::make_shared<DataTypeFloat64>());

result_constant_node->getSourceExpression() = limit_offset_constant_node->getSourceExpression();

expression_node = std::move(result_constant_node);

return;

}

}

}

throw Exception(ErrorCodes::INVALID_LIMIT_EXPRESSION,

"The value {} of {} expression is not representable as UInt64 or Int64 or Float64 in the range (0, 1)",

applyVisitor(FieldVisitorToString(), limit_offset_constant_node->getValue()) , expression_description);

{

auto * table_node = table_expression_node->as<TableNode>();

auto * table_function_node = table_expression_node->as<TableFunctionNode>();

auto * query_node = table_expression_node->as<QueryNode>();

auto * union_node = table_expression_node->as<UnionNode>();

if (!table_node && !table_function_node && !query_node && !union_node)

throw Exception(ErrorCodes::LOGICAL_ERROR,

"Unexpected table expression. Expected table, table function, query or union node. Table node: {}, scope node: {}",

table_expression_node->formatASTForErrorMessage(),

scope.scope_node->formatASTForErrorMessage());

if (table_node || table_function_node)

{

auto table_expression_modifiers = table_node ? table_node->getTableExpressionModifiers() : table_function_node->getTableExpressionModifiers();

if (table_expression_modifiers.has_value())

{

const auto & storage = table_node ? table_node->getStorage() : table_function_node->getStorage();

if (table_expression_modifiers->hasFinal() && !storage->supportsFinal())

throw Exception(ErrorCodes::ILLEGAL_FINAL,

"Storage {} doesn't support FINAL",

storage->getName());

if (table_expression_modifiers->hasSampleSizeRatio() && !storage->supportsSampling())

throw Exception(ErrorCodes::SAMPLING_NOT_SUPPORTED,

"Storage {} doesn't support sampling",

storage->getStorageID().getFullNameNotQuoted());

}

}

{

if (!scope.context->getSettingsRef()[Setting::joined_subquery_requires_alias])

return;

bool table_expression_has_alias = table_expression_node->hasAlias();

if (table_expression_has_alias)

return;

if (const auto * join = join_node->as<const JoinNode>(); join && join->getKind() == JoinKind::Paste)

return;

auto * query_node = table_expression_node->as<QueryNode>();

auto * union_node = table_expression_node->as<UnionNode>();

if ((query_node && !query_node->getCTEName().empty()) || (union_node && !union_node->getCTEName().empty()))

return;

auto table_expression_node_type = table_expression_node->getNodeType();

if (table_expression_node_type == QueryTreeNodeType::TABLE_FUNCTION ||

table_expression_node_type == QueryTreeNodeType::QUERY ||

table_expression_node_type == QueryTreeNodeType::UNION)

throw Exception(ErrorCodes::ALIAS_REQUIRED,

"JOIN {} no alias for subquery or table function {}. "

"In scope {} (set joined_subquery_requires_alias = 0 to disable restriction)",

join_node->formatASTForErrorMessage(),

table_expression_node->formatASTForErrorMessage(),

scope.scope_node->formatASTForErrorMessage());

{

checkStackSize();

if (node->as<ColumnNode>())

{

into.push_back(node);

return {false, 1};

}

auto * function = node->as<FunctionNode>();

if (!function)

return {false, 0};

// We don't need to have GROUPING under GROUP BY ALL, so we treat GROUPING

// as an aggregate function for GROUP BY ALL expansion

if (function->isAggregateFunction() || function->isWindowFunction() || Poco::icompare(function->getFunctionName(), "grouping") == 0)

return {true, 0};

UInt64 pushed_children = 0;

bool has_aggregate = false;

for (auto & child : function->getArguments().getNodes())

{

auto [child_has_aggregate, child_pushed_children] = recursivelyCollectMaxOrdinaryExpressions(child, into);

has_aggregate |= child_has_aggregate;

pushed_children += child_pushed_children;

}

/// The current function is not aggregate function and there is no aggregate function in its arguments,

/// so use the current function to replace its arguments

if (!has_aggregate)

{

for (UInt64 i = 0; i < pushed_children; i++)

into.pop_back();

into.push_back(node);

pushed_children = 1;

}

return {has_aggregate, pushed_children};

{

if (!query_tree_node_typed.isGroupByAll())

return;

auto & group_by_nodes = query_tree_node_typed.getGroupBy().getNodes();

auto & projection_list = query_tree_node_typed.getProjection();

for (auto & node : projection_list.getNodes())

recursivelyCollectMaxOrdinaryExpressions(node, group_by_nodes);

query_tree_node_typed.setIsGroupByAll(false);

{

if (!settings[Setting::enable_order_by_all] || !query_tree_node_typed.isOrderByAll())

return;

auto * all_node = query_tree_node_typed.getOrderBy().getNodes()[0]->as<SortNode>();

if (!all_node)

throw Exception(ErrorCodes::LOGICAL_ERROR, "Select analyze for not sort node.");

auto & projection_nodes = query_tree_node_typed.getProjection().getNodes();

auto list_node = std::make_shared<ListNode>();

list_node->getNodes().reserve(projection_nodes.size());

for (auto & node : projection_nodes)

{

/// Detect and reject ambiguous statements:

/// E.g. for a table with columns "all", "a", "b":

/// - SELECT all, a, b ORDER BY all; -- should we sort by all columns in SELECT or by column "all"?

/// - SELECT a, b AS all ORDER BY all; -- like before but "all" as alias

/// - SELECT func(...) AS all ORDER BY all; -- like before but "all" as function

/// - SELECT a, b ORDER BY all; -- tricky in other way: does the user want to sort by columns in SELECT clause or by not SELECTed column "all"?

auto resolved_expression_it = resolved_expressions.find(node);

if (resolved_expression_it != resolved_expressions.end())

{

auto projection_names = resolved_expression_it->second;

if (projection_names.size() != 1)

throw Exception(ErrorCodes::LOGICAL_ERROR,

"Expression nodes list expected 1 projection names. Actual: {}",

projection_names.size());

if (boost::iequals(projection_names[0], "all"))

throw Exception(ErrorCodes::UNEXPECTED_EXPRESSION,

"Cannot use ORDER BY ALL to sort a column with name 'all', please disable setting `enable_order_by_all` and try again");

}

auto sort_node = std::make_shared<SortNode>(node, all_node->getSortDirection(), all_node->getNullsSortDirection());

list_node->getNodes().push_back(sort_node);

}

query_tree_node_typed.getOrderByNode() = list_node;

query_tree_node_typed.setIsOrderByAll(false);

{

if (!query_tree_node_typed.isLimitByAll())

return;

if (!query_tree_node_typed.hasLimitByLimit())

{

throw Exception(ErrorCodes::SYNTAX_ERROR,

"LIMIT BY ALL requires a limit expression. Use LIMIT n BY ALL");

}

auto & limit_by_nodes = query_tree_node_typed.getLimitBy().getNodes();

auto & projection_nodes = query_tree_node_typed.getProjection().getNodes();

limit_by_nodes.clear();

limit_by_nodes.reserve(projection_nodes.size());

for (auto & projection_node : projection_nodes)

{

if (hasAggregateFunctionNodes(projection_node))

continue;

limit_by_nodes.push_back(projection_node->clone());

}

if (limit_by_nodes.empty())

{

throw Exception(ErrorCodes::SYNTAX_ERROR,

"LIMIT BY ALL requires at least one non-aggregate expression in SELECT");

}

query_tree_node_typed.setIsLimitByAll(false);

const std::string & aggregate_function_name, NullsAction action, const ContextPtr & context)

{

std::string result_aggregate_function_name = aggregate_function_name;

auto aggregate_function_name_lowercase = Poco::toLower(aggregate_function_name);

const auto & settings = context->getSettingsRef();

if (aggregate_function_name_lowercase == "countdistinct")

{

result_aggregate_function_name = settings[Setting::count_distinct_implementation];

}

else if (

aggregate_function_name_lowercase == "countifdistinct"

|| (settings[Setting::rewrite_count_distinct_if_with_count_distinct_implementation]

&& aggregate_function_name_lowercase == "countdistinctif"))

{

result_aggregate_function_name = settings[Setting::count_distinct_implementation];

result_aggregate_function_name += "If";

}

else if (aggregate_function_name_lowercase.ends_with("ifdistinct"))

{

/// Replace aggregateFunctionIfDistinct into aggregateFunctionDistinctIf to make execution more optimal

size_t prefix_length = result_aggregate_function_name.size() - strlen("ifdistinct");

result_aggregate_function_name = result_aggregate_function_name.substr(0, prefix_length) + "DistinctIf";

}

bool need_add_or_null = settings[Setting::aggregate_functions_null_for_empty] && !result_aggregate_function_name.ends_with("OrNull");

if (need_add_or_null)

{

auto properties = AggregateFunctionFactory::instance().tryGetProperties(result_aggregate_function_name, action);

if (!properties || !properties->returns_default_when_only_null)

result_aggregate_function_name += "OrNull";

}

/** Move -OrNull suffix ahead, this should execute after add -OrNull suffix.

if (result_aggregate_function_name.ends_with("OrNull"))

{

auto function_properies = AggregateFunctionFactory::instance().tryGetProperties(result_aggregate_function_name, action);

if (function_properies && !function_properies->returns_default_when_only_null)

{

size_t function_name_size = result_aggregate_function_name.size();

static constexpr std::array<std::string_view, 4> suffixes_to_replace = {"MergeState", "Merge", "State", "If"};

for (const auto & suffix : suffixes_to_replace)

{

auto suffix_string_value = String(suffix);

auto suffix_to_check = suffix_string_value + "OrNull";

if (!result_aggregate_function_name.ends_with(suffix_to_check))

continue;

result_aggregate_function_name = result_aggregate_function_name.substr(0, function_name_size - suffix_to_check.size());

result_aggregate_function_name += "OrNull";

result_aggregate_function_name += suffix_string_value;

break;

}

}

}

return result_aggregate_function_name;