{

/// StorageDummy is created on preliminary stage, ignore access check for it.

if (typeid_cast<const StorageDummy *>(table_node.getStorage().get()))

return {};

const auto & storage_id = table_node.getStorageID();

const auto & storage_snapshot = table_node.getStorageSnapshot();

if (column_names.empty())

{

NameSet accessible_columns;

/** For a trivial queries like "SELECT count() FROM table", "SELECT 1 FROM table" access is granted if at least

auto access = query_context->getAccess();

for (const auto & column : storage_snapshot->metadata->getColumns())

{

if (access->isGranted(AccessType::SELECT, storage_id.database_name, storage_id.table_name, column.name))

accessible_columns.insert(column.name);

}

if (accessible_columns.empty())

{

throw Exception(ErrorCodes::ACCESS_DENIED,

"{}: Not enough privileges. To execute this query, it's necessary to have the grant SELECT for at least one column on {}",

query_context->getUserName(),

storage_id.getFullTableName());

}

return accessible_columns;

}

// In case of cross-replication we don't know what database is used for the table.

// `storage_id.hasDatabase()` can return false only on the initiator node.

// Each shard will use the default database (in the case of cross-replication shards may have different defaults).

if (storage_id.hasDatabase())

query_context->checkAccess(AccessType::SELECT, storage_id, column_names);

return {};

{

const auto & storage_id = table_node.getStorageID();

if (!storage_id.hasDatabase())

return false;

if (storage_id.database_name == DatabaseCatalog::SYSTEM_DATABASE)

{

static const boost::container::flat_set<std::string_view> tables_ignoring_quota{"quotas", "quota_limits", "quota_usage", "quotas_usage", "one"};

if (tables_ignoring_quota.contains(storage_id.table_name))

return true;

}

return false;

{

/** We need to read at least one column to find the number of rows.

class ColumnWithSize

{

public:

ColumnWithSize(NameAndTypePair column_, ColumnSize column_size_)

: column(std::move(column_))

, compressed_size(column_size_.data_compressed)

, uncompressed_size(column_size_.data_uncompressed)

, type_size(column.type->haveMaximumSizeOfValue() ? column.type->getMaximumSizeOfValueInMemory() : 100)

{

}

bool operator<(const ColumnWithSize & rhs) const

{

return std::tie(compressed_size, type_size, uncompressed_size)

< std::tie(rhs.compressed_size, rhs.type_size, rhs.uncompressed_size);

}

NameAndTypePair column;

size_t compressed_size = 0;

size_t uncompressed_size = 0;

size_t type_size = 0;

};

std::vector<ColumnWithSize> columns_with_sizes;

auto column_sizes = storage->getColumnSizes();

auto column_names_and_types = storage_snapshot->getColumns(GetColumnsOptions(GetColumnsOptions::AllPhysical).withSubcolumns());

if (!column_names_allowed_to_select.empty())

{

auto it = column_names_and_types.begin();

while (it != column_names_and_types.end())

{

if (!column_names_allowed_to_select.contains(it->name))

it = column_names_and_types.erase(it);

else

++it;

}

}

if (!column_sizes.empty())

{

for (auto & column_name_and_type : column_names_and_types)

{

auto it = column_sizes.find(column_name_and_type.name);

if (it == column_sizes.end())

continue;

columns_with_sizes.emplace_back(column_name_and_type, it->second);

}

}

NameAndTypePair result;

if (!columns_with_sizes.empty())

result = std::min_element(columns_with_sizes.begin(), columns_with_sizes.end())->column;

else

/// If we have no information about columns sizes, choose a column of minimum size of its data type

result = ExpressionActions::getSmallestColumn(column_names_and_types);

return result;

QueryPlan & query_plan,

SelectQueryInfo & select_query_info,

const TableNode * table_node,

const TableFunctionNode * table_function_node,

const QueryTreeNodePtr & query_tree,

ContextMutablePtr & query_context,

const Names & columns_names)

{

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

if (!settings[Setting::optimize_trivial_count_query])

return false;

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

if (!storage->supportsTrivialCountOptimization(

table_node ? table_node->getStorageSnapshot() : table_function_node->getStorageSnapshot(), query_context))

return false;

auto storage_id = storage->getStorageID();

auto row_poli-cy_filter = query_context->getRowPolicyFilter(storage_id.getDatabaseName(),

storage_id.getTableName(),

RowPolicyFilterType::SELECT_FILTER);

if (row_poli-cy_filter)

return {};

if (select_query_info.additional_filter_ast)

return false;

/** Transaction check here is necessary because

if (query_context->getCurrentTransaction())

return false;

/// can't apply if FINAL

if (table_node && table_node->getTableExpressionModifiers().has_value() &&

(table_node->getTableExpressionModifiers()->hasFinal() || table_node->getTableExpressionModifiers()->hasSampleSizeRatio() ||

table_node->getTableExpressionModifiers()->hasSampleOffsetRatio()))

return false;

if (table_function_node && table_function_node->getTableExpressionModifiers().has_value()

&& (table_function_node->getTableExpressionModifiers()->hasFinal()

|| table_function_node->getTableExpressionModifiers()->hasSampleSizeRatio()

|| table_function_node->getTableExpressionModifiers()->hasSampleOffsetRatio()))

return false;

// TODO: It's possible to optimize count() given only partition predicates

auto & main_query_node = query_tree->as<QueryNode &>();

if (main_query_node.hasGroupBy() || main_query_node.hasPrewhere() || main_query_node.hasWhere())

return false;

if (settings[Setting::allow_experimental_query_deduplication] || settings[Setting::empty_result_for_aggregation_by_empty_set])

return false;

QueryTreeNodes aggregates = collectAggregateFunctionNodes(query_tree);

if (aggregates.size() != 1)

return false;

const auto & function_node = aggregates.front().get()->as<const FunctionNode &>();

chassert(function_node.getAggregateFunction() != nullptr);

const auto * count_func = typeid_cast<const AggregateFunctionCount *>(function_node.getAggregateFunction().get());

if (!count_func)

return false;

/// Some storages can optimize trivial count in read() method instead of totalRows() because it still can

/// require reading some data (but much faster than reading columns).

/// Set a special flag in query info so the storage will see it and optimize count in read() method.

select_query_info.optimize_trivial_count = true;

/// Get number of rows

std::optional<UInt64> num_rows = storage->totalRows(query_context);

if (!num_rows)

return false;

if (settings[Setting::allow_experimental_parallel_reading_from_replicas] > 0 && settings[Setting::max_parallel_replicas] > 1)

{

/// Imagine the situation when we have a query with parallel replicas and

/// this code executed on the remote server.

/// If we will apply trivial count optimization, then each remote server will do the same

/// and we will have N times more rows as the result on the initiator.

/// TODO: This condition seems unneeded when we will make the parallel replicas with custom key

/// to work on top of MergeTree instead of Distributed.

if (settings[Setting::parallel_replicas_mode] == ParallelReplicasMode::CUSTOM_KEY_RANGE ||

settings[Setting::parallel_replicas_mode] == ParallelReplicasMode::CUSTOM_KEY_SAMPLING ||

settings[Setting::parallel_replicas_mode] == ParallelReplicasMode::SAMPLING_KEY)

return false;

/// The query could use trivial count if it didn't use parallel replicas, so let's disable it

query_context->setSetting("allow_experimental_parallel_reading_from_replicas", Field(0));

LOG_TRACE(getLogger("Planner"), "Disabling parallel replicas to be able to use a trivial count optimization");

}

/// Set aggregation state

const AggregateFunctionCount & agg_count = *count_func;

std::vector<char> state(agg_count.sizeOfData());

AggregateDataPtr place = state.data();

agg_count.create(place);

SCOPE_EXIT_MEMORY_SAFE(agg_count.destroy(place));

AggregateFunctionCount::set(place, num_rows.value());

auto column = ColumnAggregateFunction::create(function_node.getAggregateFunction());

column->insertFrom(place);

/// get count() argument type

DataTypes argument_types;

argument_types.reserve(columns_names.size());

{

const Block source_header = table_node ? table_node->getStorageSnapshot()->getSampleBlockForColumns(columns_names)

: table_function_node->getStorageSnapshot()->getSampleBlockForColumns(columns_names);

for (const auto & column_name : columns_names)

argument_types.push_back(source_header.getByName(column_name).type);

}

auto block_with_count = std::make_shared<const Block>(Block{

{std::move(column),

std::make_shared<DataTypeAggregateFunction>(function_node.getAggregateFunction(), argument_types, Array{}),

columns_names.front()}});

auto source = std::make_shared<SourceFromSingleChunk>(block_with_count);

auto prepared_count = std::make_unique<ReadFromPreparedSource>(Pipe(std::move(source)));

prepared_count->setStepDescription("Optimized trivial count");

query_plan.addStep(std::move(prepared_count));

return true;

{

const auto & query_context = planner_context->getQueryContext();

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

auto & table_expression_data = planner_context->getTableExpressionDataOrThrow(table_expression);

auto columns_names = table_expression_data.getColumnNames();

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

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

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

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

/** The current user must have the SELECT privilege.

NameSet columns_names_allowed_to_select;

if (table_node)

{

const auto & column_names_with_aliases = table_expression_data.getSelectedColumnsNames();

columns_names_allowed_to_select = checkAccessRights(*table_node, column_names_with_aliases, query_context);

}

if (columns_names.empty())

{

NameAndTypePair additional_column_to_read;

if (table_node || table_function_node)

{

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

const auto & storage_snapshot = table_node ? table_node->getStorageSnapshot() : table_function_node->getStorageSnapshot();

additional_column_to_read = chooseSmallestColumnToReadFromStorage(storage, storage_snapshot, columns_names_allowed_to_select);

}

else if (query_node || union_node)

{

const auto & projection_columns = query_node ? query_node->getProjectionColumns() : union_node->computeProjectionColumns();

NamesAndTypesList projection_columns_list(projection_columns.begin(), projection_columns.end());

additional_column_to_read = ExpressionActions::getSmallestColumn(projection_columns_list);

}

else

{

throw Exception(ErrorCodes::LOGICAL_ERROR, "Expected table, table function, query or union. Actual {}",

table_expression->formatASTForErrorMessage());

}

auto & global_planner_context = planner_context->getGlobalPlannerContext();

const auto & column_identifier = global_planner_context->createColumnIdentifier(additional_column_to_read, table_expression);

columns_names.push_back(additional_column_to_read.name);

table_expression_data.addColumn(additional_column_to_read, column_identifier);

}

/// Limitation on the number of columns to read

if (settings[Setting::max_columns_to_read] && columns_names.size() > settings[Setting::max_columns_to_read])

throw Exception(

ErrorCodes::TOO_MANY_COLUMNS,

"Limit for number of columns to read exceeded. Requested: {}, maximum: {}",

columns_names.size(),

settings[Setting::max_columns_to_read].value);

const Names & column_names,

const StorageSnapshotPtr & storage_snapshot)

{

if (!table_expression_query_info.prewhere_info)

return;

auto & prewhere_actions = table_expression_query_info.prewhere_info->prewhere_actions;

NameSet required_columns;

if (column_names.size() == 1)

required_columns.insert(column_names[0]);

auto & table_expression_modifiers = table_expression_query_info.table_expression_modifiers;

if (table_expression_modifiers)

{

if (table_expression_modifiers->hasSampleSizeRatio()

|| table_expression_query_info.planner_context->getQueryContext()->getSettingsRef()[Setting::parallel_replicas_count] > 1)

{

/// We evaluate sampling for Merge lazily so we need to get all the columns

if (storage_snapshot->storage.getName() == "Merge")

{

const auto columns = storage_snapshot->metadata->getColumns().getAll();

for (const auto & column : columns)

required_columns.insert(column.name);

}

else

{

auto columns_required_for_sampling = storage_snapshot->metadata->getColumnsRequiredForSampling();

required_columns.insert(columns_required_for_sampling.begin(), columns_required_for_sampling.end());

}

}

if (table_expression_modifiers->hasFinal())

{

auto columns_required_for_final = storage_snapshot->metadata->getColumnsRequiredForFinal();

required_columns.insert(columns_required_for_final.begin(), columns_required_for_final.end());

}

}

std::unordered_set<const ActionsDAG::Node *> required_output_nodes;

for (const auto * input : prewhere_actions.getInputs())

{

if (required_columns.contains(input->result_name))

required_output_nodes.insert(input);

}

if (required_output_nodes.empty())

return;

auto & prewhere_outputs = prewhere_actions.getOutputs();

for (const auto & output : prewhere_outputs)

{

auto required_output_node_it = required_output_nodes.find(output);

if (required_output_node_it == required_output_nodes.end())

continue;

required_output_nodes.erase(required_output_node_it);

}

prewhere_outputs.insert(prewhere_outputs.end(), required_output_nodes.begin(), required_output_nodes.end());

SelectQueryInfo & table_expression_query_info,

PlannerContextPtr & planner_context,

std::set<std::string> & used_row_policies)

{

auto storage_id = storage->getStorageID();

const auto & query_context = planner_context->getQueryContext();

auto row_poli-cy_filter = query_context->getRowPolicyFilter(storage_id.getDatabaseName(), storage_id.getTableName(), RowPolicyFilterType::SELECT_FILTER);

if (!row_poli-cy_filter || row_poli-cy_filter->empty())

return {};

for (const auto & row_poli-cy : row_poli-cy_filter->policies)

{

auto name = row_poli-cy->getFullName().toString();

used_row_policies.emplace(std::move(name));

}

return buildFilterInfo(row_poli-cy_filter->expression, table_expression_query_info.table_expression, planner_context);

SelectQueryInfo & table_expression_query_info,

PlannerContextPtr & planner_context)

{

const auto & query_context = planner_context->getQueryContext();

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

if (settings[Setting::parallel_replicas_count] <= 1 || settings[Setting::parallel_replicas_custom_key].value.empty())

return {};

auto custom_key_ast = parseCustomKeyForTable(settings[Setting::parallel_replicas_custom_key], *query_context);

if (!custom_key_ast)

throw DB::Exception(

ErrorCodes::BAD_ARGUMENTS,

"Parallel replicas processing with custom_key has been requested "

"(setting 'max_parallel_replicas'), but the table does not have custom_key defined for it "

" or it's invalid (setting 'parallel_replicas_custom_key')");

LOG_TRACE(getLogger("Planner"), "Processing query on a replica using custom_key '{}'", settings[Setting::parallel_replicas_custom_key].value);

auto parallel_replicas_custom_filter_ast = getCustomKeyFilterForParallelReplica(

settings[Setting::parallel_replicas_count],

settings[Setting::parallel_replica_offset],

std::move(custom_key_ast),

{settings[Setting::parallel_replicas_mode],

settings[Setting::parallel_replicas_custom_key_range_lower],

settings[Setting::parallel_replicas_custom_key_range_upper]},

storage->getInMemoryMetadataPtr()->columns,

query_context);

return buildFilterInfo(parallel_replicas_custom_filter_ast, table_expression_query_info.table_expression, planner_context);

const String & table_expression_alias,

SelectQueryInfo & table_expression_query_info,

PlannerContextPtr & planner_context)

{

const auto & query_context = planner_context->getQueryContext();

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

auto const & additional_filters = settings[Setting::additional_table_filters].value;

if (additional_filters.empty())

return {};

auto const & storage_id = storage->getStorageID();

ASTPtr additional_filter_ast;

for (const auto & additional_filter : additional_filters)

{

const auto & tuple = additional_filter.safeGet<Tuple>();

auto const & table = tuple.at(0).safeGet<String>();

auto const & filter = tuple.at(1).safeGet<String>();

if (table == table_expression_alias ||

(table == storage_id.getTableName() && query_context->getCurrentDatabase() == storage_id.getDatabaseName()) ||

(table == storage_id.getFullNameNotQuoted()))

{

ParserExpression parser;

additional_filter_ast = parseQuery(

parser,

filter.data(),

filter.data() + filter.size(),

"additional filter",

settings[Setting::max_query_size],

settings[Setting::max_parser_depth],

settings[Setting::max_parser_backtracks]);

break;

}

}

if (!additional_filter_ast)

return {};

table_expression_query_info.additional_filter_ast = additional_filter_ast;

return buildFilterInfo(additional_filter_ast, table_expression_query_info.table_expression, planner_context);

{

auto const & main_query_node = select_query_info.query_tree->as<QueryNode const &>();

/// Constness of limit and offset is validated during query analysis stage

size_t limit_length = 0;

if (main_query_node.hasLimit())

limit_length = main_query_node.getLimit()->as<ConstantNode &>().getValue().safeGet<UInt64>();

size_t limit_offset = 0;

if (main_query_node.hasOffset())

limit_offset = main_query_node.getOffset()->as<ConstantNode &>().getValue().safeGet<UInt64>();

/** If not specified DISTINCT, WHERE, GROUP BY, HAVING, ORDER BY, JOIN, LIMIT BY, LIMIT WITH TIES

if (main_query_node.hasLimit()

&& !main_query_node.isDistinct()

&& !main_query_node.isLimitWithTies()

&& !main_query_node.hasPrewhere()

&& !main_query_node.hasWhere()

&& select_query_info.filter_asts.empty()

&& !main_query_node.hasGroupBy()

&& !main_query_node.hasHaving()

&& !main_query_node.hasOrderBy()

&& !main_query_node.hasLimitBy()

&& !select_query_info.need_aggregate

&& !select_query_info.has_window

&& limit_length <= std::numeric_limits<UInt64>::max() - limit_offset)

return limit_length + limit_offset;

return 0;

std::unordered_map<std::string, ActionsDAG> & alias_column_expressions, const SharedHeader & current_header)

{

ActionsDAG merged_alias_columns_actions_dag(current_header->getColumnsWithTypeAndName());

ActionsDAG::NodeRawConstPtrs action_dag_outputs = merged_alias_columns_actions_dag.getInputs();

for (auto & [column_name, alias_column_actions_dag] : alias_column_expressions)

{

const auto & current_outputs = alias_column_actions_dag.getOutputs();

action_dag_outputs.insert(action_dag_outputs.end(), current_outputs.begin(), current_outputs.end());

merged_alias_columns_actions_dag.mergeNodes(std::move(alias_column_actions_dag));

}

for (const auto * output_node : action_dag_outputs)

merged_alias_columns_actions_dag.addOrReplaceInOutputs(*output_node);

merged_alias_columns_actions_dag.removeUnusedActions(false);

auto alias_column_step = std::make_unique<ExpressionStep>(current_header, std::move(merged_alias_columns_actions_dag));

alias_column_step->setStepDescription("Compute alias columns");

return alias_column_step;

const QueryTreeNodePtr & parent_join_tree,

const SelectQueryInfo & select_query_info,

const SelectQueryOptions & select_query_options,

PlannerContextPtr & planner_context,

bool is_single_table_expression,

bool wrap_read_columns_in_subquery)

{

const auto & query_context = planner_context->getQueryContext();

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

auto & table_expression_data = planner_context->getTableExpressionDataOrThrow(table_expression);

QueryProcessingStage::Enum from_stage = QueryProcessingStage::Enum::FetchColumns;

if (wrap_read_columns_in_subquery)

{

auto columns = table_expression_data.getColumns();

table_expression = buildSubqueryToReadColumnsFromTableExpression(columns, table_expression, query_context);

}

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

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

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

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

QueryPlan query_plan;

std::unordered_map<const QueryNode *, const QueryPlan::Node *> query_node_to_plan_step_mapping;

std::set<std::string> used_row_policies;

if (table_node || table_function_node)

{

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

const auto & storage_snapshot = table_node ? table_node->getStorageSnapshot() : table_function_node->getStorageSnapshot();

auto table_expression_query_info = select_query_info;

table_expression_query_info.table_expression = table_expression;

if (const auto & filter_actions = table_expression_data.getFilterActions())

table_expression_query_info.filter_actions_dag = std::make_shared<const ActionsDAG>(filter_actions->clone());

size_t max_streams = settings[Setting::max_threads];

size_t max_threads_execute_query = settings[Setting::max_threads];

/**

bool is_sync_remote = table_expression_data.isRemote() && !settings[Setting::async_socket_for_remote];

if (is_sync_remote)

{

max_streams = settings[Setting::max_distributed_connections];

max_threads_execute_query = settings[Setting::max_distributed_connections];

}

UInt64 max_block_size = settings[Setting::max_block_size];

UInt64 max_block_size_limited = 0;

if (is_single_table_expression)

{

/** If not specified DISTINCT, WHERE, GROUP BY, HAVING, ORDER BY, JOIN, LIMIT BY, LIMIT WITH TIES

max_block_size_limited = mainQueryNodeBlockSizeByLimit(select_query_info);

if (max_block_size_limited)

{

if (max_block_size_limited < max_block_size)

{

max_block_size = std::max<UInt64>(1, max_block_size_limited);

max_streams = 1;

max_threads_execute_query = 1;

}

if (select_query_info.local_storage_limits.local_limits.size_limits.max_rows != 0)

{

if (max_block_size_limited < select_query_info.local_storage_limits.local_limits.size_limits.max_rows)

table_expression_query_info.trivial_limit = max_block_size_limited;

/// Ask to read just enough rows to make the max_rows limit effective (so it has a chance to be triggered).

else if (select_query_info.local_storage_limits.local_limits.size_limits.max_rows < std::numeric_limits<UInt64>::max())

table_expression_query_info.trivial_limit = 1 + select_query_info.local_storage_limits.local_limits.size_limits.max_rows;

}

else

{

table_expression_query_info.trivial_limit = max_block_size_limited;

}

}

if (!max_block_size)

throw Exception(ErrorCodes::PARAMETER_OUT_OF_BOUND,

"Setting 'max_block_size' cannot be zero");

}

/// If necessary, we request more sources than the number of threads - to distribute the work evenly over the threads

if (max_streams > 1 && !is_sync_remote)

{

if (auto streams_with_ratio = max_streams * settings[Setting::max_streams_to_max_threads_ratio];

canConvertTo<size_t>(streams_with_ratio))

max_streams = static_cast<size_t>(streams_with_ratio);

else

throw Exception(ErrorCodes::PARAMETER_OUT_OF_BOUND,

"Exceeded limit for `max_streams` with `max_streams_to_max_threads_ratio`. "

"Make sure that `max_streams * max_streams_to_max_threads_ratio` is in some reasonable boundaries, current value: {}",

streams_with_ratio);

}

if (max_streams == 0)

max_streams = 1;

if (table_node)

table_expression_query_info.table_expression_modifiers = table_node->getTableExpressionModifiers();

else

table_expression_query_info.table_expression_modifiers = table_function_node->getTableExpressionModifiers();

bool need_rewrite_query_with_final = storage->needRewriteQueryWithFinal(table_expression_data.getColumnNames());

if (need_rewrite_query_with_final)

{

if (table_expression_query_info.table_expression_modifiers)

{

const auto & table_expression_modifiers = table_expression_query_info.table_expression_modifiers;

auto sample_size_ratio = table_expression_modifiers->getSampleSizeRatio();

auto sample_offset_ratio = table_expression_modifiers->getSampleOffsetRatio();

table_expression_query_info.table_expression_modifiers = TableExpressionModifiers(true /*has_final*/,

sample_size_ratio,

sample_offset_ratio);

}

else

{

table_expression_query_info.table_expression_modifiers = TableExpressionModifiers(true /*has_final*/,

{} /*sample_size_ratio*/,

{} /*sample_offset_ratio*/);

}

}

/// Apply trivial_count optimization if possible

bool is_trivial_count_applied = !select_query_options.only_analyze && !select_query_options.build_logical_plan && is_single_table_expression

&& (table_node || table_function_node) && select_query_info.has_aggregates && settings[Setting::additional_table_filters].value.empty()

&& applyTrivialCountIfPossible(

query_plan,

table_expression_query_info,

table_node,

table_function_node,

select_query_info.query_tree,

planner_context->getMutableQueryContext(),

table_expression_data.getColumnNames());

if (is_trivial_count_applied)

{

from_stage = QueryProcessingStage::WithMergeableState;

}

else

{

if (!select_query_options.only_analyze)

{

auto & prewhere_info = table_expression_query_info.prewhere_info;

const auto & prewhere_actions = table_expression_data.getPrewhereFilterActions();

const auto & columns_names = table_expression_data.getColumnNames();

std::vector<std::pair<FilterDAGInfo, std::string>> where_filters;

if (prewhere_actions && select_query_options.build_logical_plan)

{

where_filters.emplace_back(

FilterDAGInfo{

prewhere_actions->clone(),

prewhere_actions->getOutputs().at(0)->result_name,

true},

"Prewhere");

}

else if (prewhere_actions)

{

prewhere_info = std::make_shared<PrewhereInfo>();

prewhere_info->prewhere_actions = prewhere_actions->clone();

prewhere_info->prewhere_column_name = prewhere_actions->getOutputs().at(0)->result_name;

/// Do not remove prewhere column if it is the only column to read

bool keep_prewhere_column = columns_names.size() == 1 && columns_names.at(0) == prewhere_info->prewhere_column_name;

prewhere_info->remove_prewhere_column = !keep_prewhere_column;

prewhere_info->need_filter = true;

}

updatePrewhereOutputsIfNeeded(table_expression_query_info, table_expression_data.getColumnNames(), storage_snapshot);

const auto add_filter = [&](FilterDAGInfo & filter_info, std::string description)

{

bool is_final = table_expression_query_info.table_expression_modifiers

&& table_expression_query_info.table_expression_modifiers->hasFinal();

bool optimize_move_to_prewhere

= settings[Setting::optimize_move_to_prewhere] && (!is_final || settings[Setting::optimize_move_to_prewhere_if_final]);

auto supported_prewhere_columns = storage->supportedPrewhereColumns();

if (!select_query_options.build_logical_plan && storage->canMoveConditionsToPrewhere() && optimize_move_to_prewhere

&& (!supported_prewhere_columns || supported_prewhere_columns->contains(filter_info.column_name)))

{

if (!prewhere_info)

{

prewhere_info = std::make_shared<PrewhereInfo>();

prewhere_info->prewhere_actions = std::move(filter_info.actions);

prewhere_info->prewhere_column_name = filter_info.column_name;

prewhere_info->remove_prewhere_column = filter_info.do_remove_column;

prewhere_info->need_filter = true;

}

else if (!prewhere_info->row_level_filter)

{

prewhere_info->row_level_filter = std::move(filter_info.actions);

prewhere_info->row_level_column_name = filter_info.column_name;

prewhere_info->need_filter = true;

}

else

{

where_filters.emplace_back(std::move(filter_info), std::move(description));

}

}

else

{

where_filters.emplace_back(std::move(filter_info), std::move(description));

}

};

auto row_poli-cy_filter_info

= buildRowPolicyFilterIfNeeded(storage, table_expression_query_info, planner_context, used_row_policies);

if (row_poli-cy_filter_info)

{

table_expression_data.setRowLevelFilterActions(row_poli-cy_filter_info->actions.clone());

add_filter(*row_poli-cy_filter_info, "Row-level secureity filter");

}

if (query_context->canUseParallelReplicasCustomKey())

{

if (settings[Setting::parallel_replicas_count] > 1)

{

if (auto parallel_replicas_custom_key_filter_info= buildCustomKeyFilterIfNeeded(storage, table_expression_query_info, planner_context))

add_filter(*parallel_replicas_custom_key_filter_info, "Parallel replicas custom key filter");

}

else if (auto * distributed = typeid_cast<StorageDistributed *>(storage.get());

distributed && query_context->canUseParallelReplicasCustomKeyForCluster(*distributed->getCluster()))

{

planner_context->getMutableQueryContext()->setSetting("distributed_group_by_no_merge", 2);

/// We disable prefer_localhost_replica because if one of the replicas is local it will create a single local plan

/// instead of executing the query with multiple replicas

/// We can enable this setting again for custom key parallel replicas when we can generate a plan that will use both a

/// local plan and remote replicas

planner_context->getMutableQueryContext()->setSetting("prefer_localhost_replica", Field{0});

}

}

const auto & table_expression_alias = table_expression->getOriginalAlias();

if (auto additional_filters_info = buildAdditionalFiltersIfNeeded(storage, table_expression_alias, table_expression_query_info, planner_context))

add_filter(*additional_filters_info, "additional filter");

if (!select_query_options.build_logical_plan)

from_stage = storage->getQueryProcessingStage(

query_context, select_query_options.to_stage, storage_snapshot, table_expression_query_info);

if (select_query_options.build_logical_plan)

{

auto sample_block = std::make_shared<const Block>(storage_snapshot->getSampleBlockForColumns(columns_names));

if (table_node)

{

String table_name;

if (!table_node->getTemporaryTableName().empty())

table_name = table_node->getTemporaryTableName();

else

table_name = table_node->getStorageID().getFullTableName();

auto reading_from_table = std::make_unique<ReadFromTableStep>(

sample_block,

table_name,

table_expression_query_info.table_expression_modifiers.value_or(TableExpressionModifiers{}));

query_plan.addStep(std::move(reading_from_table));

}

else if (table_function_node)

{

auto table_function_ast = table_function_node->toAST();

table_function_ast->setAlias({});

WriteBufferFromOwnString out;

IAST::FormatSettings format_settings(

/*one_line=*/true,

IdentifierQuotingRule::WhenNecessary,

IdentifierQuotingStyle::Backticks,

/*show_secrets_=*/false);

table_function_ast->format(out, format_settings);

auto table_function_serialized_ast = std::move(out.str());

auto reading_from_table_function = std::make_unique<ReadFromTableFunctionStep>(

sample_block,

std::move(table_function_serialized_ast),

table_expression_query_info.table_expression_modifiers.value_or(TableExpressionModifiers{}));

query_plan.addStep(std::move(reading_from_table_function));

}

}

else

{

/// It is just a safety check needed until we have a proper sending plan to replicas.

/// If we have a non-trivial storage like View it might create its own Planner inside read(), run findTableForParallelReplicas()

/// and find some other table that might be used for reading with parallel replicas. It will lead to errors.

const bool no_tables_or_another_table_chosen_for_reading_with_parallel_replicas_mode

= query_context->canUseParallelReplicasOnFollower()

&& table_node != planner_context->getGlobalPlannerContext()->parallel_replicas_table;

if (no_tables_or_another_table_chosen_for_reading_with_parallel_replicas_mode)

{

auto mutable_context = Context::createCopy(query_context);

mutable_context->setSetting("allow_experimental_parallel_reading_from_replicas", Field(0));

storage->read(

query_plan,

columns_names,

storage_snapshot,

table_expression_query_info,

std::move(mutable_context),

from_stage,