private static String getNestedScope(String path, Map<String, ObjectMapper> fullPathObjectMappers) { for (String parentPath = parentObject(path); parentPath != null; parentPath = parentObject(parentPath)) { ObjectMapper objectMapper = fullPathObjectMappers.get(parentPath); if (objectMapper != null && objectMapper.nested().isNested()) { return parentPath; } } return null; }
ObjectMapper nestedObjectMapper = null; for (ObjectMapper objectMapper : objectMappers().values()) { if (!objectMapper.nested().isNested()) { continue;
hasNested = true; for (ObjectMapper objectMapper : docMapper.objectMappers().values()) { if (objectMapper.nested().isNested()) { ObjectMapper parentObjectMapper = objectMapper.getParentObjectMapper(mapperService); if (parentObjectMapper != null && parentObjectMapper.nested().isNested()) { warmUp.add(parentObjectMapper.nestedTypeFilter());
private void checkNestedFieldsLimit(Map<String, ObjectMapper> fullPathObjectMappers) { long allowedNestedFields = indexSettings.getValue(INDEX_MAPPING_NESTED_FIELDS_LIMIT_SETTING); long actualNestedFields = 0; for (ObjectMapper objectMapper : fullPathObjectMappers.values()) { if (objectMapper.nested().isNested()) { actualNestedFields++; } } if (actualNestedFields > allowedNestedFields) { throw new IllegalArgumentException("Limit of nested fields [" + allowedNestedFields + "] in index [" + index().getName() + "] has been exceeded"); } }
if (!nestedObjectMapper.nested().isNested()) { throw new IllegalStateException("[" + NAME + "] nested object under path [" + path + "] is not of nested type");
/** * Returns whether all parent objects fields are nested too. */ public boolean parentObjectMapperAreNested(MapperService mapperService) { for (ObjectMapper parent = getParentObjectMapper(mapperService); parent != null; parent = parent.getParentObjectMapper(mapperService)) { if (parent.nested().isNested() == false) { return false; } } return true; }
throw new QueryShardException(context, "[nested] failed to find nested object under path [" + nestedPath + "]"); if (!nestedObjectMapper.nested().isNested()) { throw new QueryShardException(context, "[nested] nested object under path [" + nestedPath + "] is not of nested type");
/** Returns true if a query on the given field might match parent documents * or documents that are nested under a different path. */ boolean mightMatchNonNestedDocs(String field, String nestedPath) { if (field.startsWith("_")) { // meta field. Every meta field behaves differently, eg. nested // documents have the same _uid as their parent, put their path in // the _type field but do not have _field_names. So we just ignore // meta fields and return true, which is always safe, it just means // we might add a nested filter when it is nor required. return true; } if (mapperService.fullName(field) == null) { return false; } for (String parent = parentObject(field); parent != null; parent = parentObject(parent)) { ObjectMapper mapper = mapperService.getObjectMapper(parent); if (mapper!= null && mapper.nested().isNested()) { if (mapper.fullPath().equals(nestedPath)) { // If the mapper does not include in its parent or in the root object then // the query might only match nested documents with the given path return mapper.nested().isIncludeInParent() || mapper.nested().isIncludeInRoot(); } else { // the first parent nested mapper does not have the expected path // It might be misconfiguration or a sub nested mapper return true; } } } return true; // the field is not a sub field of the nested path }
nestedParentObjectMapper = current.getParentObjectMapper(mapperService); if (nestedParentObjectMapper != null) { if (nestedParentObjectMapper.nested().isNested() == false) { current = nestedParentObjectMapper; continue;
protected void doMerge(final ObjectMapper mergeWith, boolean updateAllTypes) { if (nested().isNested()) { if (!mergeWith.nested().isNested()) { throw new IllegalArgumentException("object mapping [" + name() + "] can't be changed from nested to non-nested"); } } else { if (mergeWith.nested().isNested()) { throw new IllegalArgumentException("object mapping [" + name() + "] can't be changed from non-nested to nested"); } } this.includeInAll = mergeWith.includeInAll; if (mergeWith.dynamic != null) { this.dynamic = mergeWith.dynamic; } for (Mapper mergeWithMapper : mergeWith) { Mapper mergeIntoMapper = mappers.get(mergeWithMapper.simpleName()); checkEnabledFieldChange(mergeWith, mergeWithMapper, mergeIntoMapper); Mapper merged; if (mergeIntoMapper == null) { // no mapping, simply add it merged = mergeWithMapper; } else { // root mappers can only exist here for backcompat, and are merged in Mapping merged = mergeIntoMapper.merge(mergeWithMapper, updateAllTypes); } putMapper(merged); } }
/** Returns true if a query on the given field might match nested documents. */ boolean mightMatchNestedDocs(String field) { if (field.startsWith("_")) { // meta field. Every meta field behaves differently, eg. nested // documents have the same _uid as their parent, put their path in // the _type field but do not have _field_names. So we just ignore // meta fields and return true, which is always safe, it just means // we might add a nested filter when it is nor required. return true; } if (mapperService.fullName(field) == null) { // field does not exist return false; } for (String parent = parentObject(field); parent != null; parent = parentObject(parent)) { ObjectMapper mapper = mapperService.getObjectMapper(parent); if (mapper != null && mapper.nested().isNested()) { return true; } } return false; }
private static Mapper getMapper(ObjectMapper objectMapper, String fieldName, String[] subfields) { for (int i = 0; i < subfields.length - 1; ++i) { Mapper mapper = objectMapper.getMapper(subfields[i]); if (mapper == null || (mapper instanceof ObjectMapper) == false) { return null; } objectMapper = (ObjectMapper)mapper; if (objectMapper.nested().isNested()) { throw new MapperParsingException("Cannot add a value for field [" + fieldName + "] since one of the intermediate objects is mapped as a nested object: [" + mapper.name() + "]"); } } return objectMapper.getMapper(subfields[subfields.length - 1]); } }
this.objectMappers = Collections.unmodifiableMap(builder); for (ObjectMapper objectMapper : newObjectMappers) { if (objectMapper.nested().isNested()) { hasNestedObjects = true;
String type = mapper.nested().isNested() ? "nested" : "object"; FieldCapabilities fieldCap = new FieldCapabilities(parentField, type, false, false); responseMap.put(parentField, fieldCap);
if (objectMapper.nested().isNested()) { hasNested = true;
@Override protected AggregatorFactory<?> doBuild(SearchContext context, AggregatorFactory<?> parent, Builder subFactoriesBuilder) throws IOException { ObjectMapper childObjectMapper = context.getObjectMapper(path); if (childObjectMapper == null) { // in case the path has been unmapped: return new NestedAggregatorFactory(name, null, null, context, parent, subFactoriesBuilder, metaData); } if (childObjectMapper.nested().isNested() == false) { throw new AggregationExecutionException("[nested] nested path [" + path + "] is not nested"); } try { ObjectMapper parentObjectMapper = context.getQueryShardContext().nestedScope().nextLevel(childObjectMapper); return new NestedAggregatorFactory(name, parentObjectMapper, childObjectMapper, context, parent, subFactoriesBuilder, metaData); } finally { context.getQueryShardContext().nestedScope().previousLevel(); } }
@Override protected AggregatorFactory<?> doBuild(SearchContext context, AggregatorFactory<?> parent, Builder subFactoriesBuilder) throws IOException { if (findNestedAggregatorFactory(parent) == null) { throw new SearchParseException(context, "Reverse nested aggregation [" + name + "] can only be used inside a [nested] aggregation", null); } ObjectMapper parentObjectMapper = null; if (path != null) { parentObjectMapper = context.getObjectMapper(path); if (parentObjectMapper == null) { return new ReverseNestedAggregatorFactory(name, true, null, context, parent, subFactoriesBuilder, metaData); } if (parentObjectMapper.nested().isNested() == false) { throw new AggregationExecutionException("[reverse_nested] nested path [" + path + "] is not nested"); } } NestedScope nestedScope = context.getQueryShardContext().nestedScope(); try { nestedScope.nextLevel(parentObjectMapper); return new ReverseNestedAggregatorFactory(name, false, parentObjectMapper, context, parent, subFactoriesBuilder, metaData); } finally { nestedScope.previousLevel(); } }
context.path()); mapper = (ObjectMapper) builder.build(builderContext); if (mapper.nested() != ObjectMapper.Nested.NO) { throw new MapperParsingException("It is forbidden to create dynamic nested objects ([" + context.path().pathAsText(paths[i]) + "]) through `copy_to` or dots in field names");
ObjectMapper.Nested nested = mapper.nested(); if (nested.isNested()) { context = nestedContext(context, mapper);
private static String getNestedScope(String path, Map<String, ObjectMapper> fullPathObjectMappers) { for (String parentPath = parentObject(path); parentPath != null; parentPath = parentObject(parentPath)) { ObjectMapper objectMapper = fullPathObjectMappers.get(parentPath); if (objectMapper != null && objectMapper.nested().isNested()) { return parentPath; } } return null; }