Backport ClickHouse#85966 to 25.8: Analyzer: check for valid correlated subqueries in the FROM clause

Author: robot-clickhouse

src/Analyzer/Resolve/QueryAnalyzer.cpp

@@ -6094,6 +6094,7 @@ void QueryAnalyzer::resolveQuery(const QueryTreeNodePtr & query_node, Identifier
 
     expandGroupByAll(query_node_typed);
 
+    validateFromClause(query_node);
     validateFilters(query_node);
     validateAggregates(query_node, {.group_by_use_nulls = scope.group_by_use_nulls});
 

src/Analyzer/ValidationUtils.cpp

@@ -1,27 +1,32 @@
 #include <Analyzer/ValidationUtils.h>
 
 #include <Analyzer/AggregationUtils.h>
+#include <Analyzer/ArrayJoinNode.h>
 #include <Analyzer/ColumnNode.h>
 #include <Analyzer/ConstantNode.h>
 #include <Analyzer/FunctionNode.h>
 #include <Analyzer/InDepthQueryTreeVisitor.h>
+#include <Analyzer/JoinNode.h>
 #include <Analyzer/QueryNode.h>
 #include <Analyzer/TableNode.h>
 #include <Analyzer/WindowFunctionsUtils.h>
 #include <Storages/IStorage.h>
 
+#include <memory>
+
 namespace DB
 {
 
 namespace ErrorCodes
 {
-    extern const int NOT_AN_AGGREGATE;
-    extern const int NOT_IMPLEMENTED;
     extern const int BAD_ARGUMENTS;
-    extern const int ILLEGAL_TYPE_OF_COLUMN_FOR_FILTER;
     extern const int ILLEGAL_PREWHERE;
-    extern const int UNSUPPORTED_METHOD;
+    extern const int ILLEGAL_TYPE_OF_COLUMN_FOR_FILTER;
+    extern const int LOGICAL_ERROR;
+    extern const int NOT_AN_AGGREGATE;
+    extern const int NOT_IMPLEMENTED;
     extern const int UNEXPECTED_EXPRESSION;
+    extern const int UNSUPPORTED_METHOD;
 }
 
 namespace
@@ -541,4 +546,76 @@ void validateCorrelatedSubqueries(const QueryTreeNodePtr & node)
     }
 }
 
+void validateFromClause(const QueryTreeNodePtr & node)
+{
+    const auto & root_query_node = node->as<QueryNode &>();
+    auto correlated_columns_set = root_query_node.getCorrelatedColumnsSet();
+
+    std::vector<QueryTreeNodePtr> nodes_to_process = { root_query_node.getJoinTree() };
+
+    while (!nodes_to_process.empty())
+    {
+        auto node_to_process = std::move(nodes_to_process.back());
+        nodes_to_process.pop_back();
+
+        auto node_type = node_to_process->getNodeType();
+
+        switch (node_type)
+        {
+            case QueryTreeNodeType::TABLE:
+                [[fallthrough]];
+            case QueryTreeNodeType::TABLE_FUNCTION:
+                break;
+            case QueryTreeNodeType::QUERY:
+            {
+                auto & query_node = node_to_process->as<QueryNode &>();
+                const auto & correlated_columns = query_node.getCorrelatedColumns();
+                for (const auto & column : correlated_columns)
+                {
+                    if (!correlated_columns_set.contains(std::static_pointer_cast<ColumnNode>(column)))
+                        throw Exception(ErrorCodes::NOT_IMPLEMENTED,
+                            "Lateral joins are not supported. Correlated column '{}' is found in the FROM clause. In query {}",
+                            column->formatASTForErrorMessage(),
+                            node->formatASTForErrorMessage());
+                }
+                break;
+            }
+            case QueryTreeNodeType::UNION:
+            {
+                for (const auto & union_node : node_to_process->as<UnionNode>()->getQueries().getNodes())
+                    nodes_to_process.push_back(union_node);
+                break;
+            }
+            case QueryTreeNodeType::ARRAY_JOIN:
+            {
+                auto & array_join_node = node_to_process->as<ArrayJoinNode &>();
+                nodes_to_process.push_back(array_join_node.getTableExpression());
+                break;
+            }
+            case QueryTreeNodeType::CROSS_JOIN:
+            {
+                auto & join_node = node_to_process->as<CrossJoinNode &>();
+                for (const auto & expr : std::ranges::reverse_view(join_node.getTableExpressions()))
+                    nodes_to_process.push_back(expr);
+                break;
+            }
+            case QueryTreeNodeType::JOIN:
+            {
+                auto & join_node = node_to_process->as<JoinNode &>();
+                nodes_to_process.push_back(join_node.getRightTableExpression());
+                nodes_to_process.push_back(join_node.getLeftTableExpression());
+                break;
+            }
+            default:
+            {
+                throw Exception(ErrorCodes::LOGICAL_ERROR,
+                                "Unexpected node type for table expression. "
+                                "Expected table, table function, query, union, join or array join. Actual {}",
+                                node_to_process->getNodeTypeName());
+            }
+        }
+    }
+
+}
+
 }

src/Analyzer/ValidationUtils.h

@@ -41,8 +41,16 @@ void validateTreeSize(const QueryTreeNodePtr & node,
     size_t max_size,
     std::unordered_map<QueryTreeNodePtr, size_t> & node_to_tree_size);
 
+/**
+  * Validate that correlated subqueries do not present in the context of distributed query.
+  */
 void validateCorrelatedSubqueries(const QueryTreeNodePtr & node);
 
+/**
+  * Validate that if correlated subquery appears in the FROM clause then it uses columns from outer query.
+  */
+void validateFromClause(const QueryTreeNodePtr & node);
+
 /** Compare node with group by key node.
   * Such comparison does not take into account aliases, but checks types and column sources.
   */

tests/queries/0_stateless/03595_analyzer_lateral_join.reference

@@ -0,0 +1,82 @@
+SET enable_analyzer = 1;
+SET allow_experimental_correlated_subqueries = 1;
+
+SELECT
+    t.a,
+    u.a
+FROM
+    (
+        SELECT
+            1 AS a
+    ) AS t,
+    (
+        SELECT 1 AS a
+        QUALIFY 0 = (t.a AS alias668)
+    ) AS u; -- { serverError NOT_IMPLEMENTED }
+
+SELECT
+    t.a,
+    u.a
+FROM
+    (
+        SELECT
+            1 AS a
+    ) AS t,
+    (
+        SELECT
+            DISTINCT *,
+            *,
+            27,
+            '======Before Truncate======',
+            materialize(27),
+            27,
+            *,
+            isZeroOrNull(27),
+            27,
+            materialize(27),
+            *,
+            * IS NOT NULL,
+            *,
+            27,
+            *,
+            toFixedString('======Before Truncate======', 27),
+            27,
+            27,
+            27,
+            27,
+            toLowCardinality(27),
+            toNullable(materialize(27)),
+            * IS NOT NULL,
+            1 AS a QUALIFY (
+                (
+                    *,
+                    27,
+                    materialize(27),
+                    27,
+                    '======Before Truncate======',
+                    27,
+                    27,
+                    (27 IS NOT NULL),
+                    * IS NOT NULL
+                ) IS NULL
+            ) = (t.a AS alias668)
+    ) AS u; -- { serverError NOT_IMPLEMENTED }
+
+SELECT
+    c,
+    a c
+FROM
+    (
+        SELECT
+            1 a
+    ) X
+    CROSS JOIN (
+        SELECT
+            1
+        WHERE
+            c = 1
+    ) Y
+    CROSS JOIN (
+        SELECT
+            1 c
+    ) Z; -- { serverError NOT_IMPLEMENTED }