From 8f2703847c9447b80fca9290aabb70150cea1dda Mon Sep 17 00:00:00 2001
From: tomerqodo <tomer.y@qodo.ai>
Date: Thu, 4 Dec 2025 22:36:44 +0200
Subject: [PATCH] Apply changes for benchmark PR

---
 .../xpack/esql/action/EsqlExecutionInfo.java  |  13 ++
 .../esql/enrich/EnrichPolicyResolver.java     |  44 ++---
 .../fulltext/QueryBuilderResolver.java        |   2 +-
 .../xpack/esql/session/EsqlCCSUtils.java      |  15 +-
 .../xpack/esql/session/EsqlSession.java       |  98 +++++++----
 .../xpack/esql/session/IndexResolver.java     | 158 +++++++++++-------
 .../xpack/esql/analysis/AnalyzerTests.java    |  22 +--
 .../esql/type/EsqlDataTypeRegistryTests.java  |   2 +-
 8 files changed, 210 insertions(+), 144 deletions(-)

diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlExecutionInfo.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlExecutionInfo.java
index 05abd4b107f6d..96aa0a398a594 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlExecutionInfo.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlExecutionInfo.java
@@ -275,6 +275,19 @@ public Map<String, Cluster> getClusters() {
         return clusterInfo;
     }
 
+    /**
+     * This creates an initial Cluster object with indexExpression and skipUnavailable.
+     */
+    public void initCluster(String clusterAlias, String indexExpression) {
+        swapCluster(clusterAlias, (ca, previous) -> {
+            var expr = indexExpression;
+            if (previous != null) {
+                expr = previous.getIndexExpression() + "," + indexExpression;
+            }
+            return new Cluster(clusterAlias, expr, shouldSkipOnFailure(clusterAlias));
+        });
+    }
+
     /**
      * Utility to swap a Cluster object. Guidelines for the remapping function:
      * <ul>
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/enrich/EnrichPolicyResolver.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/enrich/EnrichPolicyResolver.java
index a54aa219623b6..af84b38ae0ae9 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/enrich/EnrichPolicyResolver.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/enrich/EnrichPolicyResolver.java
@@ -447,34 +447,22 @@ public void messageReceived(LookupRequest request, TransportChannel channel, Tas
                     }
                     try (ThreadContext.StoredContext ignored = threadContext.stashWithOrigin(ClientHelper.ENRICH_ORIGIN)) {
                         String indexName = EnrichPolicy.getBaseName(policyName);
-                        indexResolver.resolveIndices(
-                            indexName,
-                            IndexResolver.ALL_FIELDS,
-                            null,
-                            false,
-                            // Disable aggregate_metric_double and dense_vector until we get version checks in planning
-                            false,
-                            false,
-                            refs.acquire(indexResult -> {
-                                if (indexResult.isValid() && indexResult.get().concreteQualifiedIndices().size() == 1) {
-                                    EsIndex esIndex = indexResult.get();
-                                    var concreteIndices = Map.of(
-                                        request.clusterAlias,
-                                        Iterables.get(esIndex.concreteQualifiedIndices(), 0)
-                                    );
-                                    var resolved = new ResolvedEnrichPolicy(
-                                        p.getMatchField(),
-                                        p.getType(),
-                                        p.getEnrichFields(),
-                                        concreteIndices,
-                                        esIndex.mapping()
-                                    );
-                                    resolvedPolices.put(policyName, resolved);
-                                } else {
-                                    failures.put(policyName, indexResult.toString());
-                                }
-                            })
-                        );
+                        indexResolver.resolveIndices(indexName, IndexResolver.ALL_FIELDS, refs.acquire(indexResult -> {
+                            if (indexResult.isValid() && indexResult.get().concreteQualifiedIndices().size() == 1) {
+                                EsIndex esIndex = indexResult.get();
+                                var concreteIndices = Map.of(request.clusterAlias, Iterables.get(esIndex.concreteQualifiedIndices(), 0));
+                                var resolved = new ResolvedEnrichPolicy(
+                                    p.getMatchField(),
+                                    p.getType(),
+                                    p.getEnrichFields(),
+                                    concreteIndices,
+                                    esIndex.mapping()
+                                );
+                                resolvedPolices.put(policyName, resolved);
+                            } else {
+                                failures.put(policyName, indexResult.toString());
+                            }
+                        }));
                     }
                 }
             }
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/fulltext/QueryBuilderResolver.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/fulltext/QueryBuilderResolver.java
index e070c81a81429..e1ada7f42da51 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/fulltext/QueryBuilderResolver.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/fulltext/QueryBuilderResolver.java
@@ -63,7 +63,7 @@ private static QueryRewriteContext queryRewriteContext(TransportActionServices s
         ClusterState clusterState = services.clusterService().state();
         ResolvedIndices resolvedIndices = ResolvedIndices.resolveWithIndexNamesAndOptions(
             indexNames.toArray(String[]::new),
-            IndexResolver.FIELD_CAPS_INDICES_OPTIONS,
+            IndexResolver.DEFAULT_OPTIONS,
             services.projectResolver().getProjectMetadata(clusterState),
             services.indexNameExpressionResolver(),
             services.transportService().getRemoteClusterService(),
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/EsqlCCSUtils.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/EsqlCCSUtils.java
index 56f9bdaf6338b..4494622a1f25e 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/EsqlCCSUtils.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/EsqlCCSUtils.java
@@ -28,6 +28,7 @@
 import org.elasticsearch.xpack.esql.action.EsqlExecutionInfo;
 import org.elasticsearch.xpack.esql.action.EsqlExecutionInfo.Cluster;
 import org.elasticsearch.xpack.esql.analysis.Analyzer;
+import org.elasticsearch.xpack.esql.index.EsIndex;
 import org.elasticsearch.xpack.esql.index.IndexResolution;
 import org.elasticsearch.xpack.esql.plan.IndexPattern;
 import org.elasticsearch.xpack.esql.plan.logical.LogicalPlan;
@@ -337,13 +338,7 @@ public static void initCrossClusterState(
                 // so that the CCS telemetry handler can recognize that this error is CCS-related
                 try {
                     groupedIndices.forEach((clusterAlias, indices) -> {
-                        executionInfo.swapCluster(clusterAlias, (k, v) -> {
-                            var indexExpr = Strings.arrayToCommaDelimitedString(indices.indices());
-                            if (v != null) {
-                                indexExpr = v.getIndexExpression() + "," + indexExpr;
-                            }
-                            return new EsqlExecutionInfo.Cluster(clusterAlias, indexExpr, executionInfo.shouldSkipOnFailure(clusterAlias));
-                        });
+                        executionInfo.initCluster(clusterAlias, Strings.arrayToCommaDelimitedString(indices.indices()));
                     });
                 } finally {
                     executionInfo.clusterInfoInitializing(false);
@@ -362,6 +357,12 @@ public static void initCrossClusterState(
         }
     }
 
+    public static void initCrossClusterState(EsIndex esIndex, EsqlExecutionInfo executionInfo) {
+        esIndex.originalIndices().forEach((clusterAlias, indices) -> {
+            executionInfo.initCluster(clusterAlias, Strings.collectionToCommaDelimitedString(indices));
+        });
+    }
+
     /**
      * Mark cluster with a final status (success or failure).
      * Most metrics are set to 0 if not set yet, except for "took" which is set to the total time taken so far.
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/EsqlSession.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/EsqlSession.java
index 38df20aa07277..36766375cbc85 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/EsqlSession.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/EsqlSession.java
@@ -605,11 +605,6 @@ private void preAnalyzeLookupIndex(
         indexResolver.resolveIndices(
             EsqlCCSUtils.createQualifiedLookupIndexExpressionFromAvailableClusters(executionInfo, localPattern),
             result.wildcardJoinIndices().contains(localPattern) ? IndexResolver.ALL_FIELDS : result.fieldNames,
-            null,
-            false,
-            // Disable aggregate_metric_double and dense_vector until we get version checks in planning
-            false,
-            false,
             listener.map(indexResolution -> receiveLookupIndexResolution(result, localPattern, executionInfo, indexResolution))
         );
     }
@@ -810,20 +805,34 @@ private void preAnalyzeMainIndices(
         QueryBuilder requestFilter,
         ActionListener<PreAnalysisResult> listener
     ) {
-        EsqlCCSUtils.initCrossClusterState(
-            indicesExpressionGrouper,
-            verifier.licenseState(),
-            preAnalysis.indexes().keySet(),
-            executionInfo
-        );
-        // The main index pattern dictates on which nodes the query can be executed,
-        // so we use the minimum transport version from this field caps request.
-        forAll(
-            preAnalysis.indexes().entrySet().iterator(),
-            result,
-            (entry, r, l) -> preAnalyzeMainIndices(entry.getKey(), entry.getValue(), preAnalysis, executionInfo, r, requestFilter, l),
-            listener
+        assert ThreadPool.assertCurrentThreadPool(
+            ThreadPool.Names.SEARCH,
+            ThreadPool.Names.SEARCH_COORDINATION,
+            ThreadPool.Names.SYSTEM_READ
         );
+        if (crossProjectModeDecider.crossProjectEnabled() == false) {
+            EsqlCCSUtils.initCrossClusterState(
+                indicesExpressionGrouper,
+                verifier.licenseState(),
+                preAnalysis.indexes().keySet(),
+                executionInfo
+            );
+            // The main index pattern dictates on which nodes the query can be executed,
+            // so we use the minimum transport version from this field caps request.
+            forAll(
+                preAnalysis.indexes().entrySet().iterator(),
+                result,
+                (e, r, l) -> preAnalyzeMainIndices(e.getKey(), e.getValue(), preAnalysis, executionInfo, r, requestFilter, l),
+                listener
+            );
+        } else {
+            forAll(
+                preAnalysis.indexes().entrySet().iterator(),
+                result,
+                (e, r, l) -> preAnalyzeFlatMainIndices(e.getKey(), e.getValue(), preAnalysis, executionInfo, r, requestFilter, l),
+                listener
+            );
+        }
     }
 
     private void preAnalyzeMainIndices(
@@ -835,11 +844,6 @@ private void preAnalyzeMainIndices(
         QueryBuilder requestFilter,
         ActionListener<PreAnalysisResult> listener
     ) {
-        assert ThreadPool.assertCurrentThreadPool(
-            ThreadPool.Names.SEARCH,
-            ThreadPool.Names.SEARCH_COORDINATION,
-            ThreadPool.Names.SYSTEM_READ
-        );
         if (executionInfo.clusterAliases().isEmpty()) {
             // return empty resolution if the expression is pure CCS and resolved no remote clusters (like no-such-cluster*:index)
             listener.onResponse(result.withIndices(indexPattern, IndexResolution.empty(indexPattern.indexPattern())));
@@ -847,16 +851,7 @@ private void preAnalyzeMainIndices(
             indexResolver.resolveIndicesVersioned(
                 indexPattern.indexPattern(),
                 result.fieldNames,
-                // Maybe if no indices are returned, retry without index mode and provide a clearer error message.
-                switch (indexMode) {
-                    case IndexMode.TIME_SERIES -> {
-                        var indexModeFilter = new TermQueryBuilder(IndexModeFieldMapper.NAME, IndexMode.TIME_SERIES.getName());
-                        yield requestFilter != null
-                            ? new BoolQueryBuilder().filter(requestFilter).filter(indexModeFilter)
-                            : indexModeFilter;
-                    }
-                    default -> requestFilter;
-                },
+                createQueryFilter(indexMode, requestFilter),
                 indexMode == IndexMode.TIME_SERIES,
                 preAnalysis.useAggregateMetricDoubleWhenNotSupported(),
                 preAnalysis.useDenseVectorWhenNotSupported(),
@@ -872,6 +867,43 @@ private void preAnalyzeMainIndices(
         }
     }
 
+    private void preAnalyzeFlatMainIndices(
+        IndexPattern indexPattern,
+        IndexMode indexMode,
+        PreAnalyzer.PreAnalysis preAnalysis,
+        EsqlExecutionInfo executionInfo,
+        PreAnalysisResult result,
+        QueryBuilder requestFilter,
+        ActionListener<PreAnalysisResult> listener
+    ) {
+        indexResolver.resolveFlatWorldIndicesVersioned(
+            indexPattern.indexPattern(),
+            result.fieldNames,
+            createQueryFilter(indexMode, requestFilter),
+            indexMode == IndexMode.TIME_SERIES,
+            preAnalysis.useAggregateMetricDoubleWhenNotSupported(),
+            preAnalysis.useDenseVectorWhenNotSupported(),
+            listener.delegateFailureAndWrap((l, indexResolution) -> {
+                EsqlCCSUtils.initCrossClusterState(indexResolution.inner().get(), executionInfo);
+                EsqlCCSUtils.updateExecutionInfoWithUnavailableClusters(executionInfo, indexResolution.inner().failures());
+                l.onResponse(
+                    result.withIndices(indexPattern, indexResolution.inner()).withMinimumTransportVersion(indexResolution.minimumVersion())
+                );
+            })
+        );
+    }
+
+    private static QueryBuilder createQueryFilter(IndexMode indexMode, QueryBuilder requestFilter) {
+        // Maybe if no indices are returned, retry without index mode and provide a clearer error message.
+        return switch (indexMode) {
+            case IndexMode.TIME_SERIES -> {
+                var indexModeFilter = new TermQueryBuilder(IndexModeFieldMapper.NAME, IndexMode.TIME_SERIES.getName());
+                yield requestFilter != null ? new BoolQueryBuilder().filter(requestFilter).filter(indexModeFilter) : indexModeFilter;
+            }
+            default -> requestFilter;
+        };
+    }
+
     private void analyzeWithRetry(
         LogicalPlan parsed,
         Configuration configuration,
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/IndexResolver.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/IndexResolver.java
index c187b7e3f2c7c..e58b88ebe3a02 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/IndexResolver.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/IndexResolver.java
@@ -14,6 +14,7 @@
 import org.elasticsearch.action.fieldcaps.FieldCapabilitiesResponse;
 import org.elasticsearch.action.fieldcaps.IndexFieldCapabilities;
 import org.elasticsearch.action.support.IndicesOptions;
+import org.elasticsearch.action.support.IndicesOptions.CrossProjectModeOptions;
 import org.elasticsearch.client.internal.Client;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.util.Maps;
@@ -50,7 +51,6 @@
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.TreeSet;
-import java.util.function.Function;
 
 import static org.elasticsearch.xpack.esql.core.type.DataType.DATETIME;
 import static org.elasticsearch.xpack.esql.core.type.DataType.KEYWORD;
@@ -66,7 +66,7 @@ public class IndexResolver {
     public static final Set<String> INDEX_METADATA_FIELD = Set.of(MetadataAttribute.INDEX);
     public static final String UNMAPPED = "unmapped";
 
-    public static final IndicesOptions FIELD_CAPS_INDICES_OPTIONS = IndicesOptions.builder()
+    public static final IndicesOptions DEFAULT_OPTIONS = IndicesOptions.builder()
         .concreteTargetOptions(IndicesOptions.ConcreteTargetOptions.ALLOW_UNAVAILABLE_TARGETS)
         .wildcardOptions(
             IndicesOptions.WildcardOptions.builder()
@@ -81,6 +81,16 @@ public class IndexResolver {
         )
         .build();
 
+    /**
+     * Configuration options used for resolving indices in a "flat world"/CPS context.
+     * Those options shift index resolution validation to FieldCaps action itself
+     * as well as automatically expand flat expressions to multiple qualified ones.
+     */
+    private static final IndicesOptions FLAT_WORLD_OPTIONS = IndicesOptions.builder(DEFAULT_OPTIONS)
+        .concreteTargetOptions(IndicesOptions.ConcreteTargetOptions.ERROR_WHEN_UNAVAILABLE_TARGETS)
+        .crossProjectModeOptions(new CrossProjectModeOptions(true))
+        .build();
+
     private final Client client;
 
     public IndexResolver(Client client) {
@@ -90,63 +100,87 @@ public IndexResolver(Client client) {
     /**
      * Resolves a pattern to one (potentially compound meaning that spawns multiple indices) mapping.
      */
-    public void resolveIndices(
-        String indexWildcard,
+    public void resolveIndices(String indexPattern, Set<String> fieldNames, ActionListener<IndexResolution> listener) {
+        doResolveIndices(
+            createFieldCapsRequest(DEFAULT_OPTIONS, indexPattern, fieldNames, null, false, false),
+            indexPattern,
+            false,
+            false,
+            DO_NOT_GROUP,
+            listener.map(Versioned::inner)
+        );
+    }
+
+    /**
+     * Resolves a pattern to one (potentially compound meaning that spawns multiple indices) mapping. Also retrieves the minimum transport
+     * version available in the cluster (and remotes).
+     */
+    public void resolveIndicesVersioned(
+        String indexPattern,
         Set<String> fieldNames,
         QueryBuilder requestFilter,
         boolean includeAllDimensions,
         boolean useAggregateMetricDoubleWhenNotSupported,
         boolean useDenseVectorWhenNotSupported,
-        ActionListener<IndexResolution> listener
+        IndicesExpressionGrouper indicesExpressionGrouper,
+        ActionListener<Versioned<IndexResolution>> listener
     ) {
-        resolveIndicesVersioned(
-            indexWildcard,
-            fieldNames,
-            requestFilter,
-            includeAllDimensions,
+        doResolveIndices(
+            createFieldCapsRequest(DEFAULT_OPTIONS, indexPattern, fieldNames, requestFilter, includeAllDimensions, false),
+            indexPattern,
             useAggregateMetricDoubleWhenNotSupported,
             useDenseVectorWhenNotSupported,
-            null,
-            listener.map(Versioned::inner)
+            (indexPattern1, fieldCapabilitiesResponse) -> Maps.transformValues(
+                indicesExpressionGrouper.groupIndices(IndicesOptions.DEFAULT, Strings.splitStringByCommaToArray(indexPattern1), false),
+                v -> List.of(v.indices())
+            ),
+            listener
         );
     }
 
-    /**
-     * Resolves a pattern to one (potentially compound meaning that spawns multiple indices) mapping. Also retrieves the minimum transport
-     * version available in the cluster (and remotes).
-     */
-    public void resolveIndicesVersioned(
-        String indexWildcard,
+    public void resolveFlatWorldIndicesVersioned(
+        String indexPattern,
         Set<String> fieldNames,
         QueryBuilder requestFilter,
         boolean includeAllDimensions,
         boolean useAggregateMetricDoubleWhenNotSupported,
         boolean useDenseVectorWhenNotSupported,
-        /* nullable */ IndicesExpressionGrouper indicesExpressionGrouper,
         ActionListener<Versioned<IndexResolution>> listener
     ) {
-        client.execute(
-            EsqlResolveFieldsAction.TYPE,
-            createFieldCapsRequest(indexWildcard, fieldNames, requestFilter, includeAllDimensions),
-            listener.delegateFailureAndWrap((l, response) -> {
-                FieldsInfo info = new FieldsInfo(
-                    response.caps(),
-                    response.caps().minTransportVersion(),
-                    Build.current().isSnapshot(),
-                    useAggregateMetricDoubleWhenNotSupported,
-                    useDenseVectorWhenNotSupported
-                );
-                LOGGER.debug("minimum transport version {} {}", response.caps().minTransportVersion(), info.effectiveMinTransportVersion());
-                l.onResponse(
-                    new Versioned<>(
-                        mergedMappings(indexWildcard, info, groupOriginalIndices(indicesExpressionGrouper)),
-                        info.effectiveMinTransportVersion()
-                    )
-                );
-            })
+        doResolveIndices(
+            createFieldCapsRequest(FLAT_WORLD_OPTIONS, indexPattern, fieldNames, requestFilter, includeAllDimensions, true),
+            indexPattern,
+            useAggregateMetricDoubleWhenNotSupported,
+            useDenseVectorWhenNotSupported,
+            (indexPattern1, fieldCapabilitiesResponse) -> Maps.transformValues(
+                EsqlResolvedIndexExpression.from(fieldCapabilitiesResponse),
+                v -> List.copyOf(v.expression())
+            ),
+            listener
         );
     }
 
+    private void doResolveIndices(
+        FieldCapabilitiesRequest request,
+        String indexPattern,
+        boolean useAggregateMetricDoubleWhenNotSupported,
+        boolean useDenseVectorWhenNotSupported,
+        OriginalIndexExtractor originalIndexExtractor,
+        ActionListener<Versioned<IndexResolution>> listener
+    ) {
+        client.execute(EsqlResolveFieldsAction.TYPE, request, listener.delegateFailureAndWrap((l, response) -> {
+            FieldsInfo info = new FieldsInfo(
+                response.caps(),
+                response.caps().minTransportVersion(),
+                Build.current().isSnapshot(),
+                useAggregateMetricDoubleWhenNotSupported,
+                useDenseVectorWhenNotSupported
+            );
+            LOGGER.debug("minimum transport version {} {}", response.caps().minTransportVersion(), info.effectiveMinTransportVersion());
+            l.onResponse(new Versioned<>(mergedMappings(indexPattern, info, originalIndexExtractor), info.effectiveMinTransportVersion()));
+        }));
+    }
+
     /**
      * Information for resolving a field.
      * @param caps {@link FieldCapabilitiesResponse} from all indices involved in the query
@@ -211,7 +245,7 @@ TransportVersion effectiveMinTransportVersion() {
     public static IndexResolution mergedMappings(
         String indexPattern,
         FieldsInfo fieldsInfo,
-        Function<String, Map<String, List<String>>> indexSplitter
+        OriginalIndexExtractor originalIndexExtractor
     ) {
         assert ThreadPool.assertCurrentThreadPool(ThreadPool.Names.SEARCH_COORDINATION); // too expensive to run this on a transport worker
         int numberOfIndices = fieldsInfo.caps.getIndexResponses().size();
@@ -296,7 +330,7 @@ public static IndexResolution mergedMappings(
             // instead of using indexSplitter we could use original indices from
             // FieldCapabilitiesResponse#resolvedLocally and FieldCapabilitiesResponse#resolvedRemotely
             // once all remotes support it (v9.3+)
-            indexSplitter.apply(indexPattern),
+            originalIndexExtractor.apply(indexPattern, fieldsInfo.caps),
             concreteIndices,
             partiallyUnmappedFields
         );
@@ -304,18 +338,6 @@ public static IndexResolution mergedMappings(
         return IndexResolution.valid(index, indexNameWithModes.keySet(), failures);
     }
 
-    private static Function<String, Map<String, List<String>>> groupOriginalIndices(IndicesExpressionGrouper indicesExpressionGrouper) {
-        return indexPattern -> {
-            if (indicesExpressionGrouper == null) {
-                return Map.of();
-            }
-            return Maps.transformValues(
-                indicesExpressionGrouper.groupIndices(IndicesOptions.DEFAULT, Strings.splitStringByCommaToArray(indexPattern), false),
-                v -> List.of(v.indices())
-            );
-        };
-    }
-
     private record IndexFieldCapabilitiesWithSourceHash(List<IndexFieldCapabilities> fieldCapabilities, String indexMappingHash) {}
 
     private record CollectedFieldCaps(
@@ -454,26 +476,36 @@ private static EsField conflictingMetricTypes(String name, String fullName, Fiel
     }
 
     private static FieldCapabilitiesRequest createFieldCapsRequest(
+        IndicesOptions options,
         String index,
         Set<String> fieldNames,
         QueryBuilder requestFilter,
-        boolean includeAllDimensions
+        boolean includeAllDimensions,
+        boolean includeResolvedTo
     ) {
-        FieldCapabilitiesRequest req = new FieldCapabilitiesRequest().indices(Strings.commaDelimitedListToStringArray(index));
-        req.fields(fieldNames.toArray(String[]::new));
-        req.includeUnmapped(true);
-        req.indexFilter(requestFilter);
-        req.returnLocalAll(false);
+        FieldCapabilitiesRequest request = new FieldCapabilitiesRequest();
+        request.indices(Strings.commaDelimitedListToStringArray(index));
+        request.fields(fieldNames.toArray(String[]::new));
+        request.includeUnmapped(true);
+        request.indexFilter(requestFilter);
+        request.returnLocalAll(false);
         // lenient because we throw our own errors looking at the response e.g. if something was not resolved
         // also because this way security doesn't throw authorization exceptions but rather honors ignore_unavailable
-        req.indicesOptions(FIELD_CAPS_INDICES_OPTIONS);
+        request.indicesOptions(options);
         // we ignore the nested data type fields starting with https://github.com/elastic/elasticsearch/pull/111495
         if (includeAllDimensions) {
-            req.filters("-nested", "+dimension");
+            request.filters("-nested", "+dimension");
         } else {
-            req.filters("-nested");
+            request.filters("-nested");
         }
-        req.setMergeResults(false);
-        return req;
+        request.setMergeResults(false);
+        request.includeResolvedTo(includeResolvedTo);
+        return request;
     }
+
+    public interface OriginalIndexExtractor {
+        Map<String, List<String>> apply(String indexPattern, FieldCapabilitiesResponse fieldCapabilitiesResponse);
+    }
+
+    public static final OriginalIndexExtractor DO_NOT_GROUP = (indexPattern, fieldCapabilitiesResponse) -> Map.of();
 }
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/analysis/AnalyzerTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/analysis/AnalyzerTests.java
index 78d212a372438..a73df80532aa7 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/analysis/AnalyzerTests.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/analysis/AnalyzerTests.java
@@ -3189,7 +3189,7 @@ public void testResolveInsist_multiIndexFieldPartiallyMappedWithSingleKeywordTyp
                     List.of()
                 )
             ),
-            indexPattern -> Map.of()
+            IndexResolver.DO_NOT_GROUP
         );
 
         String query = "FROM foo, bar | INSIST_🐔 message";
@@ -3215,7 +3215,7 @@ public void testResolveInsist_multiIndexFieldExistsWithSingleTypeButIsNotKeyword
                     List.of()
                 )
             ),
-            indexPattern -> Map.of()
+            IndexResolver.DO_NOT_GROUP
         );
         var plan = analyze("FROM foo, bar | INSIST_🐔 message", analyzer(resolution, TEST_VERIFIER));
         var limit = as(plan, Limit.class);
@@ -3243,7 +3243,7 @@ public void testResolveInsist_multiIndexFieldPartiallyExistsWithMultiTypesNoKeyw
                     List.of()
                 )
             ),
-            indexPattern -> Map.of()
+            IndexResolver.DO_NOT_GROUP
         );
         var plan = analyze("FROM foo, bar | INSIST_🐔 message", analyzer(resolution, TEST_VERIFIER));
         var limit = as(plan, Limit.class);
@@ -3269,7 +3269,7 @@ public void testResolveInsist_multiIndexSameMapping_fieldIsMapped() {
                     List.of()
                 )
             ),
-            indexPattern -> Map.of()
+            IndexResolver.DO_NOT_GROUP
         );
         var plan = analyze("FROM foo, bar | INSIST_🐔 message", analyzer(resolution, TEST_VERIFIER));
         var limit = as(plan, Limit.class);
@@ -3295,7 +3295,7 @@ public void testResolveInsist_multiIndexFieldPartiallyExistsWithMultiTypesWithKe
                     List.of()
                 )
             ),
-            indexPattern -> Map.of()
+            IndexResolver.DO_NOT_GROUP
         );
         var plan = analyze("FROM foo, bar | INSIST_🐔 message", analyzer(resolution, TEST_VERIFIER));
         var limit = as(plan, Limit.class);
@@ -3322,7 +3322,7 @@ public void testResolveInsist_multiIndexFieldPartiallyExistsWithMultiTypesWithCa
                     List.of()
                 )
             ),
-            indexPattern -> Map.of()
+            IndexResolver.DO_NOT_GROUP
         );
         VerificationException e = expectThrows(
             VerificationException.class,
@@ -3345,7 +3345,7 @@ public void testResolveDenseVector() {
             IndexResolution resolution = IndexResolver.mergedMappings(
                 "foo",
                 new IndexResolver.FieldsInfo(caps, TransportVersion.minimumCompatible(), false, true, true),
-                indexPattern -> Map.of()
+                IndexResolver.DO_NOT_GROUP
             );
             var plan = analyze("FROM foo", analyzer(resolution, TEST_VERIFIER));
             assertThat(plan.output(), hasSize(1));
@@ -3355,7 +3355,7 @@ public void testResolveDenseVector() {
             IndexResolution resolution = IndexResolver.mergedMappings(
                 "foo",
                 new IndexResolver.FieldsInfo(caps, TransportVersion.minimumCompatible(), false, true, false),
-                indexPattern -> Map.of()
+                IndexResolver.DO_NOT_GROUP
             );
             var plan = analyze("FROM foo", analyzer(resolution, TEST_VERIFIER));
             assertThat(plan.output(), hasSize(1));
@@ -3378,7 +3378,7 @@ public void testResolveAggregateMetricDouble() {
             IndexResolution resolution = IndexResolver.mergedMappings(
                 "foo",
                 new IndexResolver.FieldsInfo(caps, TransportVersion.minimumCompatible(), false, true, true),
-                indexPattern -> Map.of()
+                IndexResolver.DO_NOT_GROUP
             );
             var plan = analyze("FROM foo", analyzer(resolution, TEST_VERIFIER));
             assertThat(plan.output(), hasSize(1));
@@ -3391,7 +3391,7 @@ public void testResolveAggregateMetricDouble() {
             IndexResolution resolution = IndexResolver.mergedMappings(
                 "foo",
                 new IndexResolver.FieldsInfo(caps, TransportVersion.minimumCompatible(), false, false, true),
-                indexPattern -> Map.of()
+                IndexResolver.DO_NOT_GROUP
             );
             var plan = analyze("FROM foo", analyzer(resolution, TEST_VERIFIER));
             assertThat(plan.output(), hasSize(1));
@@ -3843,7 +3843,7 @@ private static LogicalPlan analyzeWithEmptyFieldCapsResponse(String query) throw
             new FieldCapabilitiesIndexResponse("idx", "idx", Map.of(), true, IndexMode.STANDARD)
         );
         IndexResolver.FieldsInfo caps = fieldsInfoOnCurrentVersion(new FieldCapabilitiesResponse(idxResponses, List.of()));
-        IndexResolution resolution = IndexResolver.mergedMappings("test*", caps, indexPattern -> Map.of());
+        IndexResolution resolution = IndexResolver.mergedMappings("test*", caps, IndexResolver.DO_NOT_GROUP);
         var analyzer = analyzer(indexResolutions(resolution), TEST_VERIFIER, configuration(query));
         return analyze(query, analyzer);
     }
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/type/EsqlDataTypeRegistryTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/type/EsqlDataTypeRegistryTests.java
index 182652027e0d7..d87d705c0310c 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/type/EsqlDataTypeRegistryTests.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/type/EsqlDataTypeRegistryTests.java
@@ -57,7 +57,7 @@ private void resolve(String esTypeName, TimeSeriesParams.MetricType metricType,
         IndexResolution resolution = IndexResolver.mergedMappings(
             "idx-*",
             new IndexResolver.FieldsInfo(caps, TransportVersion.current(), false, false, false),
-            indexPattern -> Map.of()
+            IndexResolver.DO_NOT_GROUP
         );
         EsField f = resolution.get().mapping().get(field);
         assertThat(f.getDataType(), equalTo(expected));