Revert recent DynamicFieldType changes (#73834)

We recently introduced support for static fields as part of DynamicFieldType, as well as for dynamic runtime fields. We were thinking we would use this to emit multiple field from a single runtime script, but as we made progress on that task, we realized that we don't need any dynamic behaviour and we are taking a much simpler and static approach.

server/src/main/java/org/elasticsearch/index/mapper/DynamicFieldType.java

@@ -8,9 +8,6 @@
 
 package org.elasticsearch.index.mapper;
 
-import java.util.Collections;
-import java.util.Set;
-
 /**
  * Defines a MappedFieldType that exposes dynamic child field types
  *
@@ -33,14 +30,4 @@ public interface DynamicFieldType {
      * Returns a dynamic MappedFieldType for the given path
      */
     MappedFieldType getChildFieldType(String path);
-
-    /**
-     * Returns the subfields that this dynamic field is known to hold. Not all the sub-fields are necessarily known in advance,
-     * but this method makes the ones that are known in advance discoverable, so that for instance they can then be returned by field_caps
-     * when using wildcards to match field names.
-     * @return a set of field names that this dynamic field is known to resolve
-     */
-    default Set<String> getKnownSubfields() {
-        return Collections.emptySet();
-    }
 }

server/src/main/java/org/elasticsearch/index/mapper/FieldTypeLookup.java

@@ -17,6 +17,7 @@ import java.util.HashSet;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 /**
  * An immutable container for looking up {@link MappedFieldType}s by their name.
@@ -77,15 +78,9 @@ final class FieldTypeLookup {
         }
 
         for (RuntimeField runtimeField : runtimeFields) {
-            if (runtimeField instanceof DynamicFieldType) {
-                dynamicFieldTypes.put(runtimeField.name(), (DynamicFieldType) runtimeField);
-            }
             MappedFieldType runtimeFieldType = runtimeField.asMappedFieldType();
-            assert runtimeFieldType != null || runtimeField instanceof DynamicFieldType;
-            if (runtimeFieldType != null) {
-                //this will override concrete fields with runtime fields that have the same name
-                fullNameToFieldType.put(runtimeFieldType.name(), runtimeFieldType);
-            }
+            //this will override concrete fields with runtime fields that have the same name
+            fullNameToFieldType.put(runtimeFieldType.name(), runtimeFieldType);
         }
     }
 
@@ -152,39 +147,14 @@ final class FieldTypeLookup {
      */
     Set<String> getMatchingFieldNames(String pattern) {
         if (Regex.isMatchAllPattern(pattern)) {
-            if (dynamicFieldTypes.isEmpty()) {
-                return fullNameToFieldType.keySet();
-            }
-            Set<String> fieldNames = new HashSet<>(fullNameToFieldType.keySet());
-            for (Map.Entry<String, DynamicFieldType> dynamicFieldTypeEntry : dynamicFieldTypes.entrySet()) {
-                String parentName = dynamicFieldTypeEntry.getKey();
-                DynamicFieldType dynamicFieldType = dynamicFieldTypeEntry.getValue();
-                for (String subfield : dynamicFieldType.getKnownSubfields()) {
-                    fieldNames.add(parentName + "." + subfield);
-                }
-            }
-            return Collections.unmodifiableSet(fieldNames);
+            return Collections.unmodifiableSet(fullNameToFieldType.keySet());
         }
         if (Regex.isSimpleMatchPattern(pattern) == false) {
             // no wildcards
             return get(pattern) == null ? Collections.emptySet() : Collections.singleton(pattern);
         }
-        Set<String> matchingFields = new HashSet<>();
-        for (String field : fullNameToFieldType.keySet()) {
-            if (Regex.simpleMatch(pattern, field)) {
-                matchingFields.add(field);
-            }
-        }
-        for (Map.Entry<String, DynamicFieldType> dynamicFieldTypeEntry : dynamicFieldTypes.entrySet()) {
-            String parentName = dynamicFieldTypeEntry.getKey();
-            for (String subfield : dynamicFieldTypeEntry.getValue().getKnownSubfields()) {
-                String fullPath = parentName + "." + subfield;
-                if (Regex.simpleMatch(pattern, fullPath)) {
-                    matchingFields.add(fullPath);
-                }
-            }
-        }
-        return matchingFields;
+        return fullNameToFieldType.keySet().stream().filter(field -> Regex.simpleMatch(pattern, field))
+            .collect(Collectors.toUnmodifiableSet());
     }
 
     /**

server/src/test/java/org/elasticsearch/index/mapper/FieldTypeLookupTests.java

@@ -20,7 +20,6 @@ import java.util.Set;
 
 import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
-import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.containsInAnyOrder;
@@ -63,23 +62,17 @@ public class FieldTypeLookupTests extends ESTestCase {
         FieldAliasMapper alias2 = new FieldAliasMapper("barometer", "barometer", "bar");
 
         TestRuntimeField runtimeField = new TestRuntimeField("baz", "type");
-        TestDynamicRuntimeField dynamicRuntimeField = new TestDynamicRuntimeField("baro",
-            Collections.singletonMap("meter", new TestRuntimeField("meter", "test")));
 
         FieldTypeLookup lookup = new FieldTypeLookup(List.of(field1, field2, field3), List.of(alias1, alias2),
-            List.of(runtimeField, dynamicRuntimeField));
+            List.of(runtimeField));
 
         {
             Collection<String> names = lookup.getMatchingFieldNames("*");
-            assertThat(names, containsInAnyOrder("foo", "food", "bar", "baz", "barometer", "baro.meter"));
+            assertThat(names, containsInAnyOrder("foo", "food", "bar", "baz", "barometer"));
         }
         {
             Collection<String> names = lookup.getMatchingFieldNames("b*");
-            assertThat(names, containsInAnyOrder("bar", "baz", "barometer", "baro.meter"));
-        }
-        {
-            Collection<String> names = lookup.getMatchingFieldNames("baro.anything");
-            assertThat(names, containsInAnyOrder("baro.anything"));
+            assertThat(names, containsInAnyOrder("bar", "baz", "barometer"));
         }
         {
             Collection<String> names = lookup.getMatchingFieldNames("baro.any*");
@@ -136,16 +129,13 @@ public class FieldTypeLookupTests extends ESTestCase {
         TestRuntimeField fieldOverride = new TestRuntimeField("field", "type");
         TestRuntimeField subfieldOverride = new TestRuntimeField("object.subfield", "type");
         TestRuntimeField runtime = new TestRuntimeField("runtime", "type");
-        TestDynamicRuntimeField dynamicRuntimeField = new TestDynamicRuntimeField("flattened",
-            Collections.singletonMap("sub", new TestRuntimeField("sub", "ip")));
 
         FieldTypeLookup fieldTypeLookup = new FieldTypeLookup(List.of(field, concrete, subfield, flattened), emptyList(),
-            List.of(fieldOverride, runtime, subfieldOverride, dynamicRuntimeField));
+            List.of(fieldOverride, runtime, subfieldOverride));
         assertThat(fieldTypeLookup.get("field"), instanceOf(TestRuntimeField.class));
         assertThat(fieldTypeLookup.get("object.subfield"), instanceOf(TestRuntimeField.class));
         assertThat(fieldTypeLookup.get("concrete"), instanceOf(MockFieldMapper.FakeFieldType.class));
         assertThat(fieldTypeLookup.get("runtime"), instanceOf(TestRuntimeField.class));
-        assertThat(fieldTypeLookup.get("flattened.sub").typeName(), equalTo("ip"));
     }
 
     public void testRuntimeFieldsSourcePaths() {
@@ -174,20 +164,6 @@ public class FieldTypeLookupTests extends ESTestCase {
         }
     }
 
-    public void testDynamicRuntimeFields() {
-        FieldTypeLookup fieldTypeLookup = new FieldTypeLookup(emptyList(), emptyList(),
-            Collections.singletonList(new TestDynamicRuntimeField("test")));
-
-        assertNull(fieldTypeLookup.get("test"));
-        assertEquals(0, fieldTypeLookup.getMatchingFieldNames("test").size());
-
-        String fieldName = "test." + randomAlphaOfLengthBetween(3, 6);
-        assertEquals(KeywordFieldMapper.CONTENT_TYPE, fieldTypeLookup.get(fieldName).typeName());
-        Set<String> matchingFieldNames = fieldTypeLookup.getMatchingFieldNames(fieldName);
-        assertEquals(1, matchingFieldNames.size());
-        assertEquals(fieldName, matchingFieldNames.iterator().next());
-    }
-
     public void testFlattenedLookup() {
         String fieldName = "object1.object2.field";
         FlattenedFieldMapper mapper = createFlattenedMapper(fieldName);

server/src/test/java/org/elasticsearch/index/mapper/TestDynamicRuntimeField.java

@@ -1,63 +0,0 @@
-/*
- * 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 and the Server Side Public License, v 1; you may not use this file except
- * in compliance with, at your election, the Elastic License 2.0 or the Server
- * Side Public License, v 1.
- */
-
-package org.elasticsearch.index.mapper;
-
-import org.elasticsearch.common.xcontent.XContentBuilder;
-
-import java.util.Collections;
-import java.util.Map;
-import java.util.Set;
-
-public class TestDynamicRuntimeField implements RuntimeField, DynamicFieldType {
-
-    private final String name;
-    private final Map<String, MappedFieldType> subfields;
-
-    public TestDynamicRuntimeField(String name) {
-        this(name, Collections.emptyMap());
-    }
-
-    public TestDynamicRuntimeField(String name, Map<String, MappedFieldType> subfields) {
-        this.name = name;
-        this.subfields = subfields;
-    }
-
-    @Override
-    public void doXContentBody(XContentBuilder builder, Params params) {
-
-    }
-
-    @Override
-    public String name() {
-        return name;
-    }
-
-    @Override
-    public String typeName() {
-        return "dynamic";
-    }
-
-    @Override
-    public MappedFieldType asMappedFieldType() {
-        return null;
-    }
-
-    @Override
-    public MappedFieldType getChildFieldType(String path) {
-        if (subfields.containsKey(path)) {
-            return subfields.get(path);
-        }
-        return new KeywordScriptFieldType(name + "." + path);
-    }
-
-    @Override
-    public Set<String> getKnownSubfields() {
-        return subfields.keySet();
-    }
-}

server/src/test/java/org/elasticsearch/index/query/QueryStringQueryBuilderTests.java

@@ -60,6 +60,7 @@ import java.time.DateTimeException;
 import java.time.ZoneId;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
@@ -1548,11 +1549,10 @@ public class QueryStringQueryBuilderTests extends AbstractQueryTestCase<QueryStr
             .field(TEXT_FIELD_NAME, 0.3f)
             .field(TEXT_FIELD_NAME.substring(0, TEXT_FIELD_NAME.length()-2) + "*", 0.5f)
             .toQuery(createSearchExecutionContext());
-        List<Query> terms = new ArrayList<>();
-        terms.add(new BoostQuery(new TermQuery(new Term(TEXT_FIELD_NAME, "first")), 0.075f));
-        terms.add(new BoostQuery(new TermQuery(new Term(KEYWORD_FIELD_NAME, "first")), 0.5f));
-        Query expected = new DisjunctionMaxQuery(terms, 1.0f);
-        assertEquals(expected, query);
+        assertThat(query, instanceOf(DisjunctionMaxQuery.class));
+        Collection<Query> disjuncts = ((DisjunctionMaxQuery) query).getDisjuncts();
+        assertThat(disjuncts, hasItems(new BoostQuery(new TermQuery(new Term(TEXT_FIELD_NAME, "first")), 0.075f),
+            new BoostQuery(new TermQuery(new Term(KEYWORD_FIELD_NAME, "first")), 0.5f)));
     }
 
     private static IndexMetadata newIndexMeta(String name, Settings oldIndexSettings, Settings indexSettings) {