Analyzer: always qualify execution names

src/Analyzer/Passes/QueryAnalysisPass.cpp

@@ -51,6 +51,7 @@
 
 #include <Processors/Executors/PullingAsyncPipelineExecutor.h>
 
+#include <Analyzer/createUniqueTableAliases.h>
 #include <Analyzer/Utils.h>
 #include <Analyzer/SetUtils.h>
 #include <Analyzer/AggregationUtils.h>
@@ -7174,6 +7175,7 @@ void QueryAnalysisPass::run(QueryTreeNodePtr query_tree_node, ContextPtr context
 {
     QueryAnalyzer analyzer;
     analyzer.resolve(query_tree_node, table_expression, context);
+    createUniqueTableAliases(query_tree_node, context);
 }
 
 }

src/Analyzer/createUniqueTableAliases.cpp

@@ -0,0 +1,62 @@
+#include <unordered_map>
+#include <Analyzer/createUniqueTableAliases.h>
+#include <Analyzer/InDepthQueryTreeVisitor.h>
+#include <Analyzer/IQueryTreeNode.h>
+
+namespace DB
+{
+
+namespace
+{
+
+class CreateUniqueTableAliasesVisitor : public InDepthQueryTreeVisitorWithContext<CreateUniqueTableAliasesVisitor>
+{
+public:
+    using Base = InDepthQueryTreeVisitorWithContext<CreateUniqueTableAliasesVisitor>;
+
+    explicit CreateUniqueTableAliasesVisitor(const ContextPtr & context)
+        : Base(context)
+    {}
+
+    void enterImpl(QueryTreeNodePtr & node)
+    {
+        switch (node->getNodeType())
+        {
+            case QueryTreeNodeType::QUERY:
+                [[fallthrough]];
+            case QueryTreeNodeType::UNION:
+                if (getSubqueryDepth() == 1)
+                    break;
+                [[fallthrough]];
+            case QueryTreeNodeType::TABLE:
+                [[fallthrough]];
+            case QueryTreeNodeType::TABLE_FUNCTION:
+                [[fallthrough]];
+            case QueryTreeNodeType::ARRAY_JOIN:
+            {
+                auto & alias = table_expression_to_alias[node];
+                if (alias.empty())
+                {
+                    alias = fmt::format("__table{}", table_expression_to_alias.size());
+                    node->setAlias(alias);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+private:
+    // We need to use raw pointer as a key, not a QueryTreeNodePtrWithHash.
+    std::unordered_map<QueryTreeNodePtr, String> table_expression_to_alias;
+};
+
+}
+
+
+void createUniqueTableAliases(QueryTreeNodePtr & node, const ContextPtr & context)
+{
+    CreateUniqueTableAliasesVisitor(context).visit(node);
+}
+
+}

src/Analyzer/createUniqueTableAliases.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <memory>
+#include <Interpreters/Context_fwd.h>
+
+class IQueryTreeNode;
+using QueryTreeNodePtr = std::shared_ptr<IQueryTreeNode>;
+
+namespace DB
+{
+
+/*
+ * For each table expression in the Query Tree generate and add a unique alias.
+ * If table expression had an alias in initial query tree, override it.
+ */
+void createUniqueTableAliases(QueryTreeNodePtr & node, const ContextPtr & context);
+
+}

src/Planner/PlannerContext.cpp

@@ -20,12 +20,15 @@ const ColumnIdentifier & GlobalPlannerContext::createColumnIdentifier(const Quer
     return createColumnIdentifier(column_node_typed.getColumn(), column_source_node);
 }
 
-const ColumnIdentifier & GlobalPlannerContext::createColumnIdentifier(const NameAndTypePair & column, const QueryTreeNodePtr & /*column_source_node*/)
+const ColumnIdentifier & GlobalPlannerContext::createColumnIdentifier(const NameAndTypePair & column, const QueryTreeNodePtr & column_source_node)
 {
     std::string column_identifier;
 
-    column_identifier += column.name;
-    column_identifier += '_' + std::to_string(column_identifiers.size());
+    const auto & source_alias = column_source_node->getAlias();
+    if (!source_alias.empty())
+        column_identifier = source_alias + "." + column.name;
+    else
+        column_identifier = column.name;
 
     auto [it, inserted] = column_identifiers.emplace(column_identifier);
     assert(inserted);