Use optimal data structure to check for selected types

Author: luizgpsantos

server/src/main/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesFetcher.java

@@ -30,7 +30,6 @@
 import org.elasticsearch.tasks.CancellableTask;
 
 import java.io.IOException;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
@@ -159,9 +158,11 @@ static Map<String, IndexFieldCapabilities> retrieveFieldCaps(
         IndexShard indexShard,
         boolean includeEmptyFields
     ) {
-        boolean includeParentObjects = checkIncludeParents(filters);
+        Set<String> appliedFilters = Set.of(filters);
+        boolean includeParentObjects = appliedFilters.contains("-parent") == false;
 
-        Predicate<MappedFieldType> filter = buildFilter(filters, types, context);
+        Set<String> acceptedTypes = Set.of(types);
+        Predicate<MappedFieldType> filter = buildFilter(filters, acceptedTypes, context);
         boolean isTimeSeriesIndex = context.getIndexSettings().getTimestampBounds() != null;
         var fieldInfos = indexShard.getFieldInfos();
         includeEmptyFields = includeEmptyFields || enableFieldHasValue == false;
@@ -205,18 +206,17 @@ static Map<String, IndexFieldCapabilities> retrieveFieldCaps(
                     if (context.getFieldType(parentField) == null) {
                         // no field type, it must be an object field
                         String type = context.nestedLookup().getNestedMappers().get(parentField) != null ? "nested" : "object";
-                        IndexFieldCapabilities fieldCap = new IndexFieldCapabilities(
-                            parentField,
-                            type,
-                            false,
-                            false,
-                            false,
-                            false,
-                            null,
-                            Map.of()
-                        );
-
-                        if (filter == null || Arrays.asList(types).contains(type)) {
+                        if (filter == null || acceptedTypes.contains(type) || appliedFilters.contains("parent")) {
+                            IndexFieldCapabilities fieldCap = new IndexFieldCapabilities(
+                                parentField,
+                                type,
+                                false,
+                                false,
+                                false,
+                                false,
+                                null,
+                                Map.of()
+                            );
                             responseMap.put(parentField, fieldCap);
                         }
                     }
@@ -253,12 +253,11 @@ private static boolean alwaysMatches(QueryBuilder indexFilter) {
         return indexFilter == null || indexFilter instanceof MatchAllQueryBuilder;
     }
 
-    private static Predicate<MappedFieldType> buildFilter(String[] filters, String[] fieldTypes, SearchExecutionContext context) {
+    private static Predicate<MappedFieldType> buildFilter(String[] filters, Set<String> fieldTypes, SearchExecutionContext context) {
         // security filters don't exclude metadata fields
         Predicate<MappedFieldType> fcf = null;
-        if (fieldTypes.length > 0) {
-            Set<String> acceptedTypes = Set.of(fieldTypes);
-            fcf = ft -> acceptedTypes.contains(ft.familyTypeName());
+        if (fieldTypes.isEmpty() == false) {
+            fcf = ft -> fieldTypes.contains(ft.familyTypeName());
         }
         for (String filter : filters) {
             if ("parent".equals(filter) || "-parent".equals(filter)) {

server/src/test/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesFilterTests.java

@@ -354,6 +354,64 @@ public void testIncludeAllFieldsWhenNoFieldTypeFiltering() throws IOException {
         assertNotNull(response.get("_index"));
     }
 
+    public void testNotIncludeParentEventWhenItsTypeIsListed() throws IOException {
+        MapperService mapperService = createMapperService("""
+            { "_doc" : {
+              "properties" : {
+                "field1" : {
+                  "type" : "object",
+                  "properties" : {
+                    "field2" : { "type" : "keyword" }
+                  }
+                }
+              }
+            } }
+            """);
+        SearchExecutionContext sec = createSearchExecutionContext(mapperService);
+
+        Map<String, IndexFieldCapabilities> response = FieldCapabilitiesFetcher.retrieveFieldCaps(
+            sec,
+            s -> true,
+            new String[] { "-parent" },
+            new String[] { "keyword", "object" },
+            FieldPredicate.ACCEPT_ALL,
+            getMockIndexShard(),
+            true
+        );
+        assertNull(response.get("field1"));
+        assertNotNull(response.get("field1.field2"));
+        assertNull(response.get("_index"));
+    }
+
+    public void testIncludeParentEventWhenItsTypeIsNotListed() throws IOException {
+        MapperService mapperService = createMapperService("""
+            { "_doc" : {
+              "properties" : {
+                "field1" : {
+                  "type" : "object",
+                  "properties" : {
+                    "field2" : { "type" : "keyword" }
+                  }
+                }
+              }
+            } }
+            """);
+        SearchExecutionContext sec = createSearchExecutionContext(mapperService);
+
+        Map<String, IndexFieldCapabilities> response = FieldCapabilitiesFetcher.retrieveFieldCaps(
+            sec,
+            s -> true,
+            new String[] { "parent" },
+            new String[] { "keyword" },
+            FieldPredicate.ACCEPT_ALL,
+            getMockIndexShard(),
+            true
+        );
+        assertNotNull(response.get("field1"));
+        assertNotNull(response.get("field1.field2"));
+        assertNull(response.get("_index"));
+    }
+
     private IndexShard getMockIndexShard() {
         IndexShard indexShard = mock(IndexShard.class);
         when(indexShard.getFieldInfos()).thenReturn(FieldInfos.EMPTY);