code refactor and remove copy EsqlExecutionInfo

Author: fang-xing-esql

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/analysis/PreAnalyzer.java

@@ -17,7 +17,7 @@
 import org.elasticsearch.xpack.esql.plan.logical.UnresolvedRelation;
 
 import java.util.ArrayList;
-import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -48,19 +48,17 @@ public PreAnalysis preAnalyze(LogicalPlan plan) {
 
     protected PreAnalysis doPreAnalyze(LogicalPlan plan) {
         Holder<IndexMode> indexMode = new Holder<>();
-        Holder<IndexPattern> indexPattern = new Holder<>();
         List<IndexPattern> lookupIndices = new ArrayList<>();
-        Set<IndexPattern> subqueryIndices = new HashSet<>();
+        LinkedHashSet<IndexPattern> mainAndSubqueryIndices = new LinkedHashSet<>();
         plan.forEachUp(UnresolvedRelation.class, p -> {
             if (p.indexMode() == IndexMode.LOOKUP) {
                 lookupIndices.add(p.indexPattern());
             } else if (indexMode.get() == null || indexMode.get() == p.indexMode()) {
                 indexMode.set(p.indexMode());
-                indexPattern.setIfAbsent(p.indexPattern());
-                // the index pattern from main query is always the first to be seen
-                // collect subquery index patterns
-                if (EsqlCapabilities.Cap.SUBQUERY_IN_FROM_COMMAND.isEnabled()) {
-                    collectSubqueryIndexPattern(p, subqueryIndices, indexPattern.get());
+                if (mainAndSubqueryIndices.isEmpty()) { // the index pattern from main query is always the first to be seen
+                    mainAndSubqueryIndices.add(p.indexPattern());
+                } else if (EsqlCapabilities.Cap.SUBQUERY_IN_FROM_COMMAND.isEnabled()) { // collect subquery index patterns
+                    collectSubqueryIndexPattern(p, mainAndSubqueryIndices);
                 }
             } else {
                 throw new IllegalStateException("index mode is already set");
@@ -102,20 +100,18 @@ protected PreAnalysis doPreAnalyze(LogicalPlan plan) {
 
         return new PreAnalysis(
             indexMode.get(),
-            indexPattern.get(),
+            // row command does not have an index pattern, mainAndSubqueryIndices could be empty in this case
+            mainAndSubqueryIndices.isEmpty() ? null : mainAndSubqueryIndices.removeFirst(),
             unresolvedEnriches,
             lookupIndices,
             indexMode.get() == IndexMode.TIME_SERIES || supportsAggregateMetricDouble.get(),
             supportsDenseVector.get(),
-            subqueryIndices
+            mainAndSubqueryIndices
         );
     }
 
-    private void collectSubqueryIndexPattern(
-        UnresolvedRelation relation,
-        Set<IndexPattern> subqueryIndices,
-        IndexPattern mainIndexPattern
-    ) {
+    private void collectSubqueryIndexPattern(UnresolvedRelation relation, LinkedHashSet<IndexPattern> mainAndSubqueryIndices) {
+        IndexPattern mainIndexPattern = mainAndSubqueryIndices.getFirst();
         IndexPattern pattern = relation.indexPattern();
         boolean isLookup = relation.indexMode() == IndexMode.LOOKUP;
         boolean isMainIndexPattern = pattern == mainIndexPattern;
@@ -126,6 +122,6 @@ private void collectSubqueryIndexPattern(
         if (isLookup || isMainIndexPattern) {
             return;
         }
-        subqueryIndices.add(pattern);
+        mainAndSubqueryIndices.add(pattern);
     }
 }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/EsqlSession.java

@@ -472,9 +472,7 @@ private void resolveIndices(
             .<PreAnalysisResult>andThen((l, r) -> {
                 inferenceService.inferenceResolver(functionRegistry).resolveInferenceIds(parsed, l.map(r::withInferenceResolution));
             })
-            .<PreAnalysisResult>andThen(
-                (l, r) -> preAnalyzeSubqueryIndices(preAnalysis, preAnalysis.subqueryIndices().iterator(), r, executionInfo, l)
-            )
+            .<PreAnalysisResult>andThen((l, r) -> preAnalyzeSubqueryIndices(preAnalysis, preAnalysis.subqueryIndices().iterator(), r, l))
             .<LogicalPlan>andThen((l, r) -> analyzeWithRetry(parsed, executionInfo, description, requestFilter, preAnalysis, r, l))
             .addListener(logicalPlanListener);
     }
@@ -483,19 +481,12 @@ private void preAnalyzeSubqueryIndices(
         PreAnalyzer.PreAnalysis preAnalysis,
         Iterator<IndexPattern> subqueryIndices,
         PreAnalysisResult preAnalysisResult,
-        EsqlExecutionInfo executionInfo,
         ActionListener<PreAnalysisResult> listener
     ) {
         if (subqueryIndices.hasNext()) {
-            preAnalyzeSubqueryIndex(
-                preAnalysis,
-                subqueryIndices.next(),
-                preAnalysisResult,
-                executionInfo,
-                listener.delegateFailureAndWrap((l, r) -> {
-                    preAnalyzeSubqueryIndices(preAnalysis, subqueryIndices, r, executionInfo, l);
-                })
-            );
+            preAnalyzeSubqueryIndex(preAnalysis, subqueryIndices.next(), preAnalysisResult, listener.delegateFailureAndWrap((l, r) -> {
+                preAnalyzeSubqueryIndices(preAnalysis, subqueryIndices, r, l);
+            }));
         } else {
             listener.onResponse(preAnalysisResult);
         }
@@ -505,7 +496,6 @@ private void preAnalyzeSubqueryIndex(
         PreAnalyzer.PreAnalysis preAnalysis,
         IndexPattern subqueryIndexPattern,
         PreAnalysisResult result,
-        EsqlExecutionInfo executionInfo,
         ActionListener<PreAnalysisResult> listener
     ) {
         assert ThreadPool.assertCurrentThreadPool(
@@ -523,46 +513,26 @@ private void preAnalyzeSubqueryIndex(
              * EsqlExecutionInfo for this subquery, and reuse the existing API to build
              * the subqueryIndexExpression.
              */
-            EsqlExecutionInfo subqueryExecutionInfo = subqueryExecutionInfo(executionInfo, subqueryIndexPattern);
-            // the following are very similar to preAnalyzeMainIndices
-            if (subqueryExecutionInfo.clusterAliases().isEmpty()) {
-                // return empty resolution if the expression is pure CCS and resolved no remote clusters (like no-such-cluster*:index)
-                listener.onResponse(
-                    result.addSubqueryIndexResolution(
-                        subqueryIndexPattern.indexPattern(),
-                        IndexResolution.valid(new EsIndex(subqueryIndexPattern.indexPattern(), Map.of(), Map.of()))
-                    )
-                );
-            } else {
-                // time-series index is not supported in subqueries yet, the grammar does not allow it
-                indexResolver.resolveAsMergedMapping(
-                    subqueryIndexPattern.indexPattern(),
-                    result.fieldNames,
-                    null,
-                    false,
-                    false,
-                    preAnalysis.supportsDenseVector(),
-                    listener.delegateFailure((l, indexResolution) -> {
-                        l.onResponse(result.addSubqueryIndexResolution(subqueryIndexPattern.indexPattern(), indexResolution));
-                    })
-                );
-            }
+
+            // time-series index mode is not supported in subqueries yet, the grammar does not allow it
+            indexResolver.resolveAsMergedMapping(
+                subqueryIndexPattern.indexPattern(),
+                result.fieldNames,
+                null,
+                false,
+                false,
+                preAnalysis.supportsDenseVector(),
+                listener.delegateFailure((l, indexResolution) -> {
+                    l.onResponse(result.addSubqueryIndexResolution(subqueryIndexPattern.indexPattern(), indexResolution));
+                })
+            );
+
         } else {
             // occurs when dealing with local relations (row a = 1)
             listener.onResponse(result.addSubqueryIndexResolution("invalid subquery", IndexResolution.invalid("[none specified]")));
         }
     }
 
-    private EsqlExecutionInfo subqueryExecutionInfo(EsqlExecutionInfo mainExecutionInfo, IndexPattern subqueryIndexPattern) {
-        // Clone mainInfo (assuming a copy constructor or similar method exists)
-        EsqlExecutionInfo subqueryExecutionInfo = new EsqlExecutionInfo(
-            mainExecutionInfo.skipOnFailurePredicate(),
-            mainExecutionInfo.includeCCSMetadata()
-        );
-        EsqlCCSUtils.initCrossClusterState(indicesExpressionGrouper, verifier.licenseState(), subqueryIndexPattern, subqueryExecutionInfo);
-        return subqueryExecutionInfo;
-    }
-
     private void preAnalyzeLookupIndices(
         Iterator<IndexPattern> lookupIndices,
         PreAnalysisResult preAnalysisResult,