Do not calculate subqueries when only_analyze enabled.

src/DataStreams/PushingToViewsBlockOutputStream.cpp

@@ -66,13 +66,8 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
             std::unique_ptr<ASTInsertQuery> insert = std::make_unique<ASTInsertQuery>();
             insert->table_id = inner_table_id;
 
-            Context local_context = *views_context;
-            local_context.addViewSource(
-                StorageValues::create(
-                    storage->getStorageID(), storage->getColumns(), storage->getSampleBlock(), storage->getVirtuals()));
-
             /// Get list of columns we get from select query.
-            auto header = InterpreterSelectQuery(query, local_context, SelectQueryOptions().analyze()).getSampleBlock();
+            auto header = InterpreterSelectQuery(query, *views_context, SelectQueryOptions().analyze()).getSampleBlock();
 
             /// Insert only columns returned by select.
             auto list = std::make_shared<ASTExpressionList>();
@@ -85,7 +80,7 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
             insert->columns = std::move(list);
 
             ASTPtr insert_query_ptr(insert.release());
-            InterpreterInsertQuery interpreter(insert_query_ptr, local_context);
+            InterpreterInsertQuery interpreter(insert_query_ptr, *views_context);
             BlockIO io = interpreter.execute();
             out = io.out;
         }

src/Interpreters/ExecuteScalarSubqueriesVisitor.cpp

@@ -88,32 +88,48 @@ void ExecuteScalarSubqueriesMatcher::visit(const ASTSubquery & subquery, ASTPtr
         subquery_context.setSettings(subquery_settings);
 
         ASTPtr subquery_select = subquery.children.at(0);
-        BlockIO res = InterpreterSelectWithUnionQuery(
-                subquery_select, subquery_context, SelectQueryOptions(QueryProcessingStage::Complete, data.subquery_depth + 1)).execute();
 
+        auto options = SelectQueryOptions(QueryProcessingStage::Complete, data.subquery_depth + 1);
+        options.analyze(data.only_analyze);
+
+        auto interpreter = InterpreterSelectWithUnionQuery(subquery_select, subquery_context, options);
         Block block;
-        try
+
+        if (data.only_analyze)
+        {
+            /// If query is only analyzed, then constants are not correct.
+            block = interpreter.getSampleBlock();
+            for (auto & column : block)
+                if (column.column->empty())
+                    column.column->cloneResized(1);
+        }
+        else
         {
-            block = res.in->read();
+            BlockIO res = interpreter.execute();
 
-            if (!block)
+            try
             {
-                /// Interpret subquery with empty result as Null literal
-                auto ast_new = std::make_unique<ASTLiteral>(Null());
-                ast_new->setAlias(ast->tryGetAlias());
-                ast = std::move(ast_new);
-                return;
+                block = res.in->read();
+
+                if (!block)
+                {
+                    /// Interpret subquery with empty result as Null literal
+                    auto ast_new = std::make_unique<ASTLiteral>(Null());
+                    ast_new->setAlias(ast->tryGetAlias());
+                    ast = std::move(ast_new);
+                    return;
+                }
+
+                if (block.rows() != 1 || res.in->read())
+                    throw Exception("Scalar subquery returned more than one row", ErrorCodes::INCORRECT_RESULT_OF_SCALAR_SUBQUERY);
+            }
+            catch (const Exception & e)
+            {
+                if (e.code() == ErrorCodes::TOO_MANY_ROWS)
+                    throw Exception("Scalar subquery returned more than one row", ErrorCodes::INCORRECT_RESULT_OF_SCALAR_SUBQUERY);
+                else
+                    throw;
             }
-
-            if (block.rows() != 1 || res.in->read())
-                throw Exception("Scalar subquery returned more than one row", ErrorCodes::INCORRECT_RESULT_OF_SCALAR_SUBQUERY);
-        }
-        catch (const Exception & e)
-        {
-            if (e.code() == ErrorCodes::TOO_MANY_ROWS)
-                throw Exception("Scalar subquery returned more than one row", ErrorCodes::INCORRECT_RESULT_OF_SCALAR_SUBQUERY);
-            else
-                throw;
         }
 
         block = materializeBlock(block);

src/Interpreters/ExecuteScalarSubqueriesVisitor.h

@@ -38,6 +38,7 @@ public:
         const Context & context;
         size_t subquery_depth;
         Scalars & scalars;
+        bool only_analyze;
     };
 
     static bool needChildVisit(ASTPtr & node, const ASTPtr &);

src/Interpreters/SyntaxAnalyzer.cpp

@@ -209,10 +209,10 @@ void removeUnneededColumnsFromSelectClause(const ASTSelectQuery * select_query,
 }
 
 /// Replacing scalar subqueries with constant values.
-void executeScalarSubqueries(ASTPtr & query, const Context & context, size_t subquery_depth, Scalars & scalars)
+void executeScalarSubqueries(ASTPtr & query, const Context & context, size_t subquery_depth, Scalars & scalars, bool only_analyze)
 {
     LogAST log;
-    ExecuteScalarSubqueriesVisitor::Data visitor_data{context, subquery_depth, scalars};
+    ExecuteScalarSubqueriesVisitor::Data visitor_data{context, subquery_depth, scalars, only_analyze};
     ExecuteScalarSubqueriesVisitor(visitor_data, log.stream()).visit(query);
 }
 
@@ -801,7 +801,7 @@ SyntaxAnalyzerResultPtr SyntaxAnalyzer::analyzeSelect(
     removeUnneededColumnsFromSelectClause(select_query, required_result_columns, remove_duplicates);
 
     /// Executing scalar subqueries - replacing them with constant values.
-    executeScalarSubqueries(query, context, subquery_depth, result.scalars);
+    executeScalarSubqueries(query, context, subquery_depth, result.scalars, select_options.only_analyze);
 
     {
         optimizeIf(query, result.aliases, settings.optimize_if_chain_to_miltiif);