ExpressionAnalyzer: remove duplicated code

dbms/src/Interpreters/ExpressionAnalyzer.cpp

@@ -275,55 +275,14 @@ bool ExpressionAnalyzer::isRemoteStorage() const
 }
 
 
-static std::vector<ASTTableExpression> getTableExpressions(const ASTPtr & query)
-{
-    ASTSelectQuery * select_query = typeid_cast<ASTSelectQuery *>(query.get());
-
-    std::vector<ASTTableExpression> table_expressions;
-
-    if (select_query && select_query->tables)
-    {
-        for (const auto & element : select_query->tables->children)
-        {
-            ASTTablesInSelectQueryElement & select_element = static_cast<ASTTablesInSelectQueryElement &>(*element);
-
-            if (select_element.table_expression)
-                table_expressions.emplace_back(static_cast<ASTTableExpression &>(*select_element.table_expression));
-        }
-    }
-
-    return table_expressions;
-}
-
 void ExpressionAnalyzer::translateQualifiedNames()
 {
     if (!select_query || !select_query->tables || select_query->tables->children.empty())
         return;
 
-    std::vector<DatabaseAndTableWithAlias> tables;
-    std::vector<ASTTableExpression> tables_expression = getTableExpressions(query);
+    std::vector<DatabaseAndTableWithAlias> tables = getDatabaseAndTableWithAliases(select_query, context.getCurrentDatabase());
 
     LogAST log;
-
-    for (const auto & table_expression : tables_expression)
-    {
-        auto table = getTableNameWithAliasFromTableExpression(table_expression, context.getCurrentDatabase());
-
-        { /// debug print
-            size_t depth = 0;
-            DumpASTNode dump(table_expression, log.stream(), depth, "getTableNames");
-            if (table_expression.database_and_table_name)
-                DumpASTNode(*table_expression.database_and_table_name, log.stream(), depth);
-            if (table_expression.table_function)
-                DumpASTNode(*table_expression.table_function, log.stream(), depth);
-            if (table_expression.subquery)
-                DumpASTNode(*table_expression.subquery, log.stream(), depth);
-            dump.print("getTableNameWithAlias", table.database + '.' + table.table + ' ' + table.alias);
-        }
-
-        tables.emplace_back(table);
-    }
-
     TranslateQualifiedNamesVisitor visitor(source_columns, tables, log.stream());
     visitor.visit(query);
 }
@@ -602,13 +561,13 @@ void ExpressionAnalyzer::normalizeTree()
     TableNamesAndColumnNames table_names_and_column_names;
     if (select_query && select_query->tables && !select_query->tables->children.empty())
     {
-        std::vector<ASTTableExpression> tables_expression = getTableExpressions(query);
+        std::vector<const ASTTableExpression *> tables_expression = getSelectTablesExpression(select_query);
 
         bool first = true;
-        for (const auto & table_expression : tables_expression)
+        for (const auto * table_expression : tables_expression)
         {
-            const auto table_name = getTableNameWithAliasFromTableExpression(table_expression, context.getCurrentDatabase());
-            NamesAndTypesList names_and_types = getNamesAndTypeListFromTableExpression(table_expression, context);
+            const auto table_name = getTableNameWithAliasFromTableExpression(*table_expression, context.getCurrentDatabase());
+            NamesAndTypesList names_and_types = getNamesAndTypeListFromTableExpression(*table_expression, context);
 
             if (!first)
             {

dbms/src/Interpreters/PredicateExpressionsOptimizer.cpp

@@ -44,11 +44,8 @@ bool PredicateExpressionsOptimizer::optimizeImpl(
     /// split predicate with `and`
     PredicateExpressions outer_predicate_expressions = splitConjunctionPredicate(outer_expression);
 
-    std::vector<ASTTableExpression *> tables_expression = getSelectTablesExpression(ast_select);
-    std::vector<DatabaseAndTableWithAlias> database_and_table_with_aliases;
-    for (const auto & table_expression : tables_expression)
-        database_and_table_with_aliases.emplace_back(
-            getTableNameWithAliasFromTableExpression(*table_expression, context.getCurrentDatabase()));
+    std::vector<DatabaseAndTableWithAlias> database_and_table_with_aliases =
+        getDatabaseAndTableWithAliases(ast_select, context.getCurrentDatabase());
 
     bool is_rewrite_subquery = false;
     for (const auto & outer_predicate : outer_predicate_expressions)
@@ -336,7 +333,7 @@ ASTs PredicateExpressionsOptimizer::evaluateAsterisk(ASTSelectQuery * select_que
     if (!select_query->tables || select_query->tables->children.empty())
         return {};
 
-    std::vector<ASTTableExpression *> tables_expression = getSelectTablesExpression(select_query);
+    std::vector<const ASTTableExpression *> tables_expression = getSelectTablesExpression(select_query);
 
     if (const auto qualified_asterisk = typeid_cast<ASTQualifiedAsterisk *>(asterisk.get()))
     {
@@ -406,25 +403,6 @@ ASTs PredicateExpressionsOptimizer::evaluateAsterisk(ASTSelectQuery * select_que
     return projection_columns;
 }
 
-std::vector<ASTTableExpression *> PredicateExpressionsOptimizer::getSelectTablesExpression(ASTSelectQuery * select_query)
-{
-    if (!select_query->tables)
-        return {};
-
-    std::vector<ASTTableExpression *> tables_expression;
-    const ASTTablesInSelectQuery & tables_in_select_query = static_cast<const ASTTablesInSelectQuery &>(*select_query->tables);
-
-    for (const auto & child : tables_in_select_query.children)
-    {
-        ASTTablesInSelectQueryElement * tables_element = static_cast<ASTTablesInSelectQueryElement *>(child.get());
-
-        if (tables_element->table_expression)
-            tables_expression.emplace_back(static_cast<ASTTableExpression *>(tables_element->table_expression.get()));
-    }
-
-    return tables_expression;
-}
-
 void PredicateExpressionsOptimizer::cleanExpressionAlias(ASTPtr & expression)
 {
     const auto my_alias = expression->tryGetAlias();

dbms/src/Interpreters/PredicateExpressionsOptimizer.h

@@ -105,8 +105,6 @@ private:
 
     ASTs getSelectQueryProjectionColumns(ASTPtr & ast);
 
-    std::vector<ASTTableExpression *> getSelectTablesExpression(ASTSelectQuery * select_query);
-
     ASTs evaluateAsterisk(ASTSelectQuery * select_query, const ASTPtr & asterisk);
 
     void cleanExpressionAlias(ASTPtr & expression);

dbms/src/Interpreters/evaluateQualified.cpp

@@ -5,6 +5,7 @@
 #include <Parsers/IAST.h>
 #include <Parsers/ASTIdentifier.h>
 #include <Parsers/ASTTablesInSelectQuery.h>
+#include <Parsers/ASTSelectQuery.h>
 
 namespace DB
 {
@@ -164,4 +165,35 @@ void DatabaseAndTableWithAlias::makeQualifiedName(const ASTPtr & ast) const
     }
 }
 
+std::vector<const ASTTableExpression *> getSelectTablesExpression(const ASTSelectQuery * select_query)
+{
+    if (!select_query->tables)
+        return {};
+
+    std::vector<const ASTTableExpression *> tables_expression;
+
+    for (const auto & child : select_query->tables->children)
+    {
+        ASTTablesInSelectQueryElement * tables_element = static_cast<ASTTablesInSelectQueryElement *>(child.get());
+
+        if (tables_element->table_expression)
+            tables_expression.emplace_back(static_cast<const ASTTableExpression *>(tables_element->table_expression.get()));
+    }
+
+    return tables_expression;
+}
+
+std::vector<DatabaseAndTableWithAlias> getDatabaseAndTableWithAliases(const ASTSelectQuery * select_query, const String & current_database)
+{
+    std::vector<const ASTTableExpression *> tables_expression = getSelectTablesExpression(select_query);
+
+    std::vector<DatabaseAndTableWithAlias> database_and_table_with_aliases;
+    database_and_table_with_aliases.reserve(tables_expression.size());
+
+    for (const auto & table_expression : tables_expression)
+        database_and_table_with_aliases.emplace_back(getTableNameWithAliasFromTableExpression(*table_expression, current_database));
+
+    return database_and_table_with_aliases;
+}
+
 }

dbms/src/Interpreters/evaluateQualified.h

@@ -9,6 +9,7 @@ namespace DB
 class IAST;
 using ASTPtr = std::shared_ptr<IAST>;
 
+class ASTSelectQuery;
 class ASTIdentifier;
 struct ASTTableExpression;
 
@@ -36,4 +37,7 @@ size_t getNumComponentsToStripInOrderToTranslateQualifiedName(const ASTIdentifie
 
 std::pair<String, String> getDatabaseAndTableNameFromIdentifier(const ASTIdentifier & identifier);
 
+std::vector<const ASTTableExpression *> getSelectTablesExpression(const ASTSelectQuery * select_query);
+std::vector<DatabaseAndTableWithAlias> getDatabaseAndTableWithAliases(const ASTSelectQuery * select_query, const String & current_database);
+
 }