Create index mapping from FieldCaps response (#137962)

Author: idegtiarenko

x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/session/EsqlResolvedIndexExpressionIT.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.esql.session;
+
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.xpack.esql.action.AbstractCrossClusterTestCase;
+
+import java.util.Map;
+import java.util.Set;
+
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.hasEntry;
+
+public class EsqlResolvedIndexExpressionIT extends AbstractCrossClusterTestCase {
+
+    public void testLocalIndices() {
+        createIndex(LOCAL_CLUSTER, "index-1");
+
+        assertThat(resolveIndices("index-1"), hasEntry(LOCAL_CLUSTER, resolvedIndexExpression("index-1", "index-1")));
+    }
+
+    public void testLocalAlias() {
+        createIndex(LOCAL_CLUSTER, "index-1");
+        createAlias(LOCAL_CLUSTER, "alias-1", "index-1");
+
+        assertThat(resolveIndices("alias-1"), hasEntry(LOCAL_CLUSTER, resolvedIndexExpression("alias-1", "index-1")));
+    }
+
+    public void testLocalPattern() {
+        createIndex(LOCAL_CLUSTER, "index-1");
+        createIndex(LOCAL_CLUSTER, "index-2");
+
+        assertThat(resolveIndices("index-*"), hasEntry(LOCAL_CLUSTER, resolvedIndexExpression("index-*", "index-1,index-2")));
+    }
+
+    public void testLocalMultiple() {
+        createIndex(LOCAL_CLUSTER, "index-1");
+        createIndex(LOCAL_CLUSTER, "index-2");
+
+        assertThat(
+            resolveIndices("index-1,index-2"),
+            hasEntry(LOCAL_CLUSTER, resolvedIndexExpression("index-1,index-2", "index-1,index-2"))
+        );
+    }
+
+    public void testLocalAndRemote() {
+        createIndex(LOCAL_CLUSTER, "index-1");
+        createIndex(REMOTE_CLUSTER_1, "index-2");
+        createIndex(REMOTE_CLUSTER_2, "index-3");
+
+        assertThat(
+            resolveIndices("index-*,*:index-*"),
+            allOf(
+                hasEntry(LOCAL_CLUSTER, resolvedIndexExpression("index-*", "index-1")),
+                hasEntry(REMOTE_CLUSTER_1, resolvedIndexExpression("index-*", "index-2")),
+                hasEntry(REMOTE_CLUSTER_2, resolvedIndexExpression("index-*", "index-3"))
+            )
+        );
+    }
+
+    private Map<String, EsqlResolvedIndexExpression> resolveIndices(String indices) {
+        return EsqlResolvedIndexExpression.from(
+            client(LOCAL_CLUSTER).prepareFieldCaps(Strings.splitStringByCommaToArray(indices))
+                .setFields("*")
+                .setIncludeResolvedTo(true)
+                .get()
+        );
+    }
+
+    private void createIndex(String clusterAlias, String index) {
+        client(clusterAlias).admin().indices().prepareCreate(index).get();
+    }
+
+    private void createAlias(String clusterAlias, String alias, String index) {
+        client(clusterAlias).admin().indices().prepareAliases(TEST_REQUEST_TIMEOUT, TEST_REQUEST_TIMEOUT).addAlias(index, alias).get();
+    }
+
+    private static EsqlResolvedIndexExpression resolvedIndexExpression(String expression, String resolved) {
+        return new EsqlResolvedIndexExpression(
+            Set.of(Strings.splitStringByCommaToArray(expression)),
+            Set.of(Strings.splitStringByCommaToArray(resolved))
+        );
+    }
+}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.esql.session;
+
+import org.elasticsearch.action.fieldcaps.FieldCapabilitiesResponse;
+import org.elasticsearch.common.util.set.Sets;
+import org.elasticsearch.transport.RemoteClusterAware;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toMap;
+import static org.elasticsearch.action.ResolvedIndexExpression.LocalIndexResolutionResult.SUCCESS;
+
+public record EsqlResolvedIndexExpression(Set<String> expression, Set<String> resolved) {
+
+    private static final EsqlResolvedIndexExpression EMPTY = new EsqlResolvedIndexExpression(Set.of(), Set.of());
+
+    public static Map<String, EsqlResolvedIndexExpression> from(FieldCapabilitiesResponse response) {
+        return Stream.concat(
+            Stream.of(Map.entry(RemoteClusterAware.LOCAL_CLUSTER_GROUP_KEY, response.getResolvedLocally())),
+            response.getResolvedRemotely().entrySet().stream()
+        )
+            .map(
+                entry -> Map.entry(
+                    entry.getKey(),
+                    entry.getValue()
+                        .expressions()
+                        .stream()
+                        .filter(e -> e.localExpressions().indices().isEmpty() == false)
+                        .filter(e -> e.localExpressions().localIndexResolutionResult() == SUCCESS)
+                        .map(e -> new EsqlResolvedIndexExpression(Set.of(e.original()), e.localExpressions().indices()))
+                        .reduce(EMPTY, EsqlResolvedIndexExpression::merge)
+                )
+            )
+            .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
+    }
+
+    private static EsqlResolvedIndexExpression merge(EsqlResolvedIndexExpression a, EsqlResolvedIndexExpression b) {
+        return new EsqlResolvedIndexExpression(Sets.union(a.expression(), b.expression()), Sets.union(a.resolved(), b.resolved()));
+    }
+}