Prevent slow lookups for non-existent fields.

We now track the maximum depth of any JSON field, which allows the JSON field
lookup to be short-circuited as soon as that depth is reached. This helps
prevent slow lookups when the user is searching over a very deep field that is
not in the mappings.

Author: jtibshirani

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

@@ -25,6 +25,7 @@
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 
@@ -35,20 +36,25 @@ class FieldTypeLookup implements Iterable<MappedFieldType> {
 
     final CopyOnWriteHashMap<String, MappedFieldType> fullNameToFieldType;
     private final CopyOnWriteHashMap<String, String> aliasToConcreteName;
+
     private final CopyOnWriteHashMap<String, JsonFieldMapper> fullNameToJsonMapper;
+    private final int maxJsonFieldDepth;
 
     FieldTypeLookup() {
         fullNameToFieldType = new CopyOnWriteHashMap<>();
         aliasToConcreteName = new CopyOnWriteHashMap<>();
         fullNameToJsonMapper = new CopyOnWriteHashMap<>();
+        maxJsonFieldDepth = 0;
     }
 
     private FieldTypeLookup(CopyOnWriteHashMap<String, MappedFieldType> fullNameToFieldType,
                             CopyOnWriteHashMap<String, String> aliasToConcreteName,
-                            CopyOnWriteHashMap<String, JsonFieldMapper> fullNameToJsonMapper) {
+                            CopyOnWriteHashMap<String, JsonFieldMapper> fullNameToJsonMapper,
+                            int maxJsonFieldDepth) {
         this.fullNameToFieldType = fullNameToFieldType;
         this.aliasToConcreteName = aliasToConcreteName;
         this.fullNameToJsonMapper = fullNameToJsonMapper;
+        this.maxJsonFieldDepth = maxJsonFieldDepth;
     }
 
     /**
@@ -70,6 +76,7 @@ public FieldTypeLookup copyAndAddAll(String type,
         CopyOnWriteHashMap<String, JsonFieldMapper> jsonMappers = this.fullNameToJsonMapper;
 
         for (FieldMapper fieldMapper : fieldMappers) {
+            String fieldName = fieldMapper.name();
             MappedFieldType fieldType = fieldMapper.fieldType();
             MappedFieldType fullNameFieldType = fullName.get(fieldType.name());
 
@@ -78,7 +85,7 @@ public FieldTypeLookup copyAndAddAll(String type,
             }
 
             if (fieldMapper instanceof JsonFieldMapper) {
-                jsonMappers = fullNameToJsonMapper.copyAndPut(fieldType.name(), (JsonFieldMapper) fieldMapper);
+                jsonMappers = fullNameToJsonMapper.copyAndPut(fieldName, (JsonFieldMapper) fieldMapper);
             }
         }
 
@@ -88,7 +95,43 @@ public FieldTypeLookup copyAndAddAll(String type,
             aliases = aliases.copyAndPut(aliasName, path);
         }
 
-        return new FieldTypeLookup(fullName, aliases, jsonMappers);
+        int maxFieldDepth = getMaxJsonFieldDepth(aliases, jsonMappers);
+
+        return new FieldTypeLookup(fullName, aliases, jsonMappers, maxFieldDepth);
+    }
+
+    private static int getMaxJsonFieldDepth(CopyOnWriteHashMap<String, String> aliases,
+                                            CopyOnWriteHashMap<String, JsonFieldMapper> jsonMappers) {
+        int maxFieldDepth = 0;
+        for (Map.Entry<String, String> entry : aliases.entrySet()) {
+            String aliasName = entry.getKey();
+            String path = entry.getValue();
+            if (jsonMappers.containsKey(path)) {
+                maxFieldDepth = Math.max(maxFieldDepth, fieldDepth(aliasName));
+            }
+        }
+
+        for (String fieldName : jsonMappers.keySet()) {
+            if (jsonMappers.containsKey(fieldName)) {
+                maxFieldDepth = Math.max(maxFieldDepth, fieldDepth(fieldName));
+            }
+        }
+
+        return maxFieldDepth;
+    }
+
+    /**
+     * Computes the total depth of this field by counting the number of parent fields
+     * in its path. As an example, the field 'parent1.parent2.field' has depth 3.
+     */
+    private static int fieldDepth(String field) {
+        int numDots = 0;
+        for (int i = 0; i < field.length(); ++i) {
+            if (field.charAt(i) == '.') {
+                numDots++;
+            }
+        }
+        return numDots + 1;
     }
 
 
@@ -107,9 +150,20 @@ public MappedFieldType get(String field) {
         return !fullNameToJsonMapper.isEmpty() ? getKeyedJsonField(field) : null;
     }
 
+    /**
+     * Check if the given field corresponds to a keyed JSON field of the form
+     * 'path_to_json_field.path_to_key'. If so, returns a field type that can
+     * be used to perform searches on this field.
+     */
     private MappedFieldType getKeyedJsonField(String field) {
         int dotIndex = -1;
+        int fieldDepth = 0;
+
         while (true) {
+            if (++fieldDepth > maxJsonFieldDepth) {
+                return null;
+            }
+
             dotIndex = field.indexOf('.', dotIndex + 1);
             if (dotIndex < 0) {
                 return null;
@@ -148,4 +202,9 @@ public Collection<String> simpleMatchToFullName(String pattern) {
     public Iterator<MappedFieldType> iterator() {
         return fullNameToFieldType.values().iterator();
     }
+
+    // Visible for testing.
+    int maxJsonFieldDepth() {
+        return maxJsonFieldDepth;
+    }
 }

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

@@ -186,6 +186,36 @@ public void testJsonFieldTypeWithAlias() {
         assertEquals(objectKey, keyedFieldType.key());
     }
 
+    public void testMaxJsonFieldDepth() {
+        FieldTypeLookup lookup = new FieldTypeLookup();
+        assertEquals(0, lookup.maxJsonFieldDepth());
+
+        // Add a JSON field.
+        String jsonFieldName = "object1.object2.field";
+        JsonFieldMapper jsonField = createJsonMapper(jsonFieldName);
+        lookup = lookup.copyAndAddAll("type", newList(jsonField), emptyList());
+        assertEquals(3, lookup.maxJsonFieldDepth());
+
+        // Add a short alias to that field.
+        String aliasName = "alias";
+        FieldAliasMapper alias = new FieldAliasMapper(aliasName, aliasName, jsonFieldName);
+        lookup = lookup.copyAndAddAll("type", emptyList(), newList(alias));
+        assertEquals(3, lookup.maxJsonFieldDepth());
+
+        // Add a longer alias to that field.
+        String longAliasName = "object1.object2.object3.alias";
+        FieldAliasMapper longAlias = new FieldAliasMapper(longAliasName, longAliasName, jsonFieldName);
+        lookup = lookup.copyAndAddAll("type", emptyList(), newList(longAlias));
+        assertEquals(4, lookup.maxJsonFieldDepth());
+
+        // Update the long alias to refer to a non-JSON field.
+        String fieldName = "field";
+        MockFieldMapper field = new MockFieldMapper(fieldName);
+        longAlias = new FieldAliasMapper(longAliasName, longAliasName, fieldName);
+        lookup = lookup.copyAndAddAll("type", newList(field), newList(longAlias));
+        assertEquals(3, lookup.maxJsonFieldDepth());
+    }
+
     private JsonFieldMapper createJsonMapper(String fieldName) {
         Settings settings = Settings.builder()
             .put("index.version.created", Version.CURRENT)