move prefer_alias_to_column_name logic out of parser

dbms/src/Interpreters/QueryAliasesVisitor.cpp

@@ -5,6 +5,7 @@
 #include <Interpreters/QueryAliasesVisitor.h>
 #include <Parsers/ASTTablesInSelectQuery.h>
 #include <Parsers/ASTSelectWithUnionQuery.h>
+#include <Parsers/ASTSelectQuery.h>
 #include <Parsers/formatAST.h>
 #include <Parsers/ASTSubquery.h>
 #include <IO/WriteHelpers.h>
@@ -41,12 +42,25 @@ void QueryAliasesMatcher::visit(ASTPtr & ast, Data & data)
 {
     if (auto * s = ast->as<ASTSubquery>())
         visit(*s, ast, data);
+    else if (auto * q = ast->as<ASTSelectQuery>())
+        visit(*q, ast, data);
     else if (auto * aj = ast->as<ASTArrayJoin>())
         visit(*aj, ast, data);
     else
         visitOther(ast, data);
 }
 
+void QueryAliasesMatcher::visit(const ASTSelectQuery & select, const ASTPtr &, Data &)
+{
+    ASTPtr with = select.with();
+    if (!with)
+        return;
+
+    for (auto & child : with->children)
+        if (auto * ast_with_alias = dynamic_cast<ASTWithAlias *>(child.get()))
+            ast_with_alias->prefer_alias_to_column_name = true;
+}
+
 /// The top-level aliases in the ARRAY JOIN section have a special meaning, we will not add them
 /// (skip the expression list itself and its children).
 void QueryAliasesMatcher::visit(const ASTArrayJoin &, const ASTPtr & ast, Data & data)
@@ -83,11 +97,12 @@ void QueryAliasesMatcher::visit(ASTSubquery & subquery, const ASTPtr & ast, Data
         while (aliases.count(alias));
 
         subquery.setAlias(alias);
-        subquery.prefer_alias_to_column_name = true;
         aliases[alias] = ast;
     }
     else
         visitOther(ast, data);
+
+    subquery.prefer_alias_to_column_name = true;
 }
 
 void QueryAliasesMatcher::visitOther(const ASTPtr & ast, Data & data)

dbms/src/Interpreters/QueryAliasesVisitor.h

@@ -6,7 +6,7 @@
 namespace DB
 {
 
-class ASTSelectWithUnionQuery;
+class ASTSelectQuery;
 class ASTSubquery;
 struct ASTTableExpression;
 struct ASTArrayJoin;
@@ -26,6 +26,7 @@ public:
     static bool needChildVisit(ASTPtr & node, const ASTPtr & child);
 
 private:
+    static void visit(const ASTSelectQuery & select, const ASTPtr & ast, Data & data);
     static void visit(ASTSubquery & subquery, const ASTPtr & ast, Data & data);
     static void visit(const ASTArrayJoin &, const ASTPtr & ast, Data & data);
     static void visitOther(const ASTPtr & ast, Data & data);

dbms/src/Parsers/ExpressionElementParsers.cpp

@@ -1337,7 +1337,6 @@ bool ParserWithOptionalAlias::parseImpl(Pos & pos, ASTPtr & node, Expected & exp
         if (auto * ast_with_alias = dynamic_cast<ASTWithAlias *>(node.get()))
         {
             getIdentifierName(alias_node, ast_with_alias->alias);
-            ast_with_alias->prefer_alias_to_column_name = prefer_alias_to_column_name;
         }
         else
         {

dbms/src/Parsers/ExpressionElementParsers.h

@@ -274,13 +274,12 @@ protected:
 class ParserWithOptionalAlias : public IParserBase
 {
 public:
-    ParserWithOptionalAlias(ParserPtr && elem_parser_, bool allow_alias_without_as_keyword_, bool prefer_alias_to_column_name_ = false)
-    : elem_parser(std::move(elem_parser_)), allow_alias_without_as_keyword(allow_alias_without_as_keyword_),
-      prefer_alias_to_column_name(prefer_alias_to_column_name_) {}
+    ParserWithOptionalAlias(ParserPtr && elem_parser_, bool allow_alias_without_as_keyword_)
+    : elem_parser(std::move(elem_parser_)), allow_alias_without_as_keyword(allow_alias_without_as_keyword_)
+    {}
 protected:
     ParserPtr elem_parser;
     bool allow_alias_without_as_keyword;
-    bool prefer_alias_to_column_name;
 
     const char * getName() const { return "element of expression with optional alias"; }
     bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected);

dbms/src/Parsers/ExpressionListParsers.cpp

@@ -522,9 +522,9 @@ bool ParserTupleElementExpression::parseImpl(Pos & pos, ASTPtr & node, Expected
 }
 
 
-ParserExpressionWithOptionalAlias::ParserExpressionWithOptionalAlias(bool allow_alias_without_as_keyword, bool prefer_alias_to_column_name)
+ParserExpressionWithOptionalAlias::ParserExpressionWithOptionalAlias(bool allow_alias_without_as_keyword)
     : impl(std::make_unique<ParserWithOptionalAlias>(std::make_unique<ParserExpression>(),
-                                                     allow_alias_without_as_keyword, prefer_alias_to_column_name))
+                                                     allow_alias_without_as_keyword))
 {
 }
 
@@ -532,7 +532,7 @@ ParserExpressionWithOptionalAlias::ParserExpressionWithOptionalAlias(bool allow_
 bool ParserExpressionList::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
     return ParserList(
-        std::make_unique<ParserExpressionWithOptionalAlias>(allow_alias_without_as_keyword, prefer_alias_to_column_name),
+        std::make_unique<ParserExpressionWithOptionalAlias>(allow_alias_without_as_keyword),
         std::make_unique<ParserToken>(TokenType::Comma))
         .parse(pos, node, expected);
 }

dbms/src/Parsers/ExpressionListParsers.h

@@ -322,7 +322,7 @@ using ParserExpression = ParserLambdaExpression;
 class ParserExpressionWithOptionalAlias : public IParserBase
 {
 public:
-    ParserExpressionWithOptionalAlias(bool allow_alias_without_as_keyword, bool prefer_alias_to_column_name_ = false);
+    ParserExpressionWithOptionalAlias(bool allow_alias_without_as_keyword);
 protected:
     ParserPtr impl;
 
@@ -339,12 +339,11 @@ protected:
 class ParserExpressionList : public IParserBase
 {
 public:
-    ParserExpressionList(bool allow_alias_without_as_keyword_, bool prefer_alias_to_column_name_ = false)
-        : allow_alias_without_as_keyword(allow_alias_without_as_keyword_), prefer_alias_to_column_name(prefer_alias_to_column_name_) {}
+    ParserExpressionList(bool allow_alias_without_as_keyword_)
+        : allow_alias_without_as_keyword(allow_alias_without_as_keyword_) {}
 
 protected:
     bool allow_alias_without_as_keyword;
-    bool prefer_alias_to_column_name;
 
     const char * getName() const { return "list of expressions"; }
     bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected);
@@ -354,8 +353,8 @@ protected:
 class ParserNotEmptyExpressionList : public IParserBase
 {
 public:
-    ParserNotEmptyExpressionList(bool allow_alias_without_as_keyword, bool prefer_alias_to_column_name = false)
-        : nested_parser(allow_alias_without_as_keyword, prefer_alias_to_column_name) {}
+    ParserNotEmptyExpressionList(bool allow_alias_without_as_keyword)
+        : nested_parser(allow_alias_without_as_keyword) {}
 private:
     ParserExpressionList nested_parser;
 protected:

dbms/src/Parsers/ParserSelectQuery.cpp

@@ -44,7 +44,7 @@ bool ParserSelectQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     ParserKeyword s_offset("OFFSET");
 
     ParserNotEmptyExpressionList exp_list(false);
-    ParserNotEmptyExpressionList exp_list_for_with_clause(false, true); /// Set prefer_alias_to_column_name for each alias.
+    ParserNotEmptyExpressionList exp_list_for_with_clause(false);
     ParserNotEmptyExpressionList exp_list_for_select_clause(true);    /// Allows aliases without AS keyword.
     ParserExpressionWithOptionalAlias exp_elem(false);
     ParserOrderByExpressionList order_list;