Method inlineViewSubqueryIfNeeded

src/Analyzer/Resolve/QueryAnalyzer.cpp:5427–5599

Try to expand an ordinary (non-materialized, non-parameterized) VIEW into an inline subquery. * This replaces the TableNode wrapping a StorageView with a QueryNode/UnionNode built from the * view's inner query AST, making the view transparent to the analyzer and all optimization passes. */

  * view's inner query AST, making the view transparent to the analyzer and all optimization passes.
  */
void QueryAnalyzer::inlineViewSubqueryIfNeeded(QueryTreeNodePtr & join_tree_node, IdentifierResolveScope & scope) const
{
    if (!scope.context->getSettingsRef()[Setting::analyzer_inline_views])
        return;

    auto * table_node = join_tree_node->as<TableNode>();
    if (!table_node)
        return;

    const auto & storage = table_node->getStorage();
    const auto * view = typeid_cast<const StorageView *>(storage.get());
    if (!view || view->isParameterizedView())
        return;

    /// Do not inline views with FINAL/SAMPLE modifiers for now.
    if (table_node->hasTableExpressionModifiers())
        return;

    /// Get the view's inner query AST.
    const auto & storage_snapshot = table_node->getStorageSnapshot();

    auto view_context = StorageView::getViewSubqueryContext(scope.context, storage_snapshot);

    /// Check for row policies on the view itself.
    auto storage_id = storage->getStorageID();
    auto row_policy_filter = scope.context->getRowPolicyFilter(
        storage_id.getDatabaseName(), storage_id.getTableName(), RowPolicyFilterType::SELECT_FILTER);
    bool has_row_policy = row_policy_filter && !row_policy_filter->isAlwaysTrue();

    /// Build the query tree from the view's inner query AST.
    ASTPtr view_ast = storage_snapshot->metadata->getSelectQuery().inner_query->clone();
    auto view_query_tree = buildQueryTree(view_ast, view_context);
    QueryAnalyzer view_analyzer(this->only_analyze);
    view_analyzer.resolve(view_query_tree, {}, view_context);

    /// Mark the inlined query as a subquery so it is wrapped in parentheses when serialized to AST
    /// (e.g. for sending to parallel replicas). Without this, it produces `FROM SELECT ...` instead
    /// of `FROM (SELECT ...)`.
    if (auto * query_node = view_query_tree->as<QueryNode>())
        query_node->setIsSubquery(true);
    else if (auto * union_node = view_query_tree->as<UnionNode>())
        union_node->setIsSubquery(true);

    /// The VIEW's declared column types may differ from what the inner subquery actually produces
    /// (e.g. the view was created with explicit column types, or implicit conversions apply).
    /// Normally StorageView adds a converting step in the query pipeline. When inlining, we must
    /// reproduce that by wrapping the subquery in SELECT CAST(col, 'ViewType') ... FROM (subquery).
    auto view_columns_list = storage_snapshot->metadata->getColumns().getOrdinary();
    NamesAndTypes view_columns(view_columns_list.begin(), view_columns_list.end());

    NamesAndTypes subquery_columns;
    if (const auto * query_node = view_query_tree->as<QueryNode>())
        subquery_columns = query_node->getProjectionColumns();
    else if (const auto * union_node = view_query_tree->as<UnionNode>())
        subquery_columns = union_node->computeProjectionColumns();

    bool needs_type_conversion = false;
    if (view_columns.size() == subquery_columns.size())