Java Mapper类代码示例

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
/** Creates an IndicesModule for testing with the given mappers and metadata mappers. */
public static IndicesModule newTestIndicesModule(Map<String, Mapper.TypeParser> extraMappers,
                                                 Map<String, MetadataFieldMapper.TypeParser> extraMetadataMappers) {
    return new IndicesModule(Collections.singletonList(
        new MapperPlugin() {
            @Override
            public Map<String, Mapper.TypeParser> getMappers() {
                return extraMappers;
            }
            @Override
            public Map<String, MetadataFieldMapper.TypeParser> getMetadataMappers() {
                return extraMetadataMappers;
            }
        }
    ));
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException {
    ByteFieldMapper.Builder builder = byteField(name);
    parseNumberField(builder, name, node, parserContext);
    for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext();) {
        Map.Entry<String, Object> entry = iterator.next();
        String propName = Strings.toUnderscoreCase(entry.getKey());
        Object propNode = entry.getValue();
        if (propName.equals("null_value")) {
            if (propNode == null) {
                throw new MapperParsingException("Property [null_value] cannot be null.");
            }
            builder.nullValue(nodeByteValue(propNode));
            iterator.remove();
        }
    }
    return builder;
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException {
    IntegerFieldMapper.Builder builder = integerField(name);
    parseNumberField(builder, name, node, parserContext);
    for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext();) {
        Map.Entry<String, Object> entry = iterator.next();
        String propName = Strings.toUnderscoreCase(entry.getKey());
        Object propNode = entry.getValue();
        if (propName.equals("null_value")) {
            if (propNode == null) {
                throw new MapperParsingException("Property [null_value] cannot be null.");
            }
            builder.nullValue(nodeIntegerValue(propNode));
            iterator.remove();
        }
    }
    return builder;
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
public Mapper.Builder<?, ?> parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException {
    Builder builder = new Builder(name);

    // tweaking these settings is no longer allowed, the entire purpose of murmur3 fields is to store a hash
    if (node.get("doc_values") != null) {
        throw new MapperParsingException("Setting [doc_values] cannot be modified for field [" + name + "]");
    }
    if (node.get("index") != null) {
        throw new MapperParsingException("Setting [index] cannot be modified for field [" + name + "]");
    }

    if (parserContext.indexVersionCreated().before(Version.V_5_0_0_alpha2)) {
        node.remove("precision_step");
    }

    TypeParsers.parseField(builder, name, node, parserContext);

    return builder;
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
private MappedFieldType failIfFieldMappingNotFound(String name, MappedFieldType fieldMapping) {
    if (fieldMapping != null || allowUnmappedFields) {
        return fieldMapping;
    } else if (mapUnmappedFieldAsString){
        StringFieldMapper.Builder builder = MapperBuilders.stringField(name);
        // it would be better to pass the real index settings, but they are not easily accessible from here...
        Settings settings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, indexQueryParser.getIndexCreatedVersion()).build();
        return builder.build(new Mapper.BuilderContext(settings, new ContentPath(1))).fieldType();
    } else {
        Version indexCreatedVersion = indexQueryParser.getIndexCreatedVersion();
        if (fieldMapping == null && indexCreatedVersion.onOrAfter(Version.V_1_4_0_Beta1)) {
            throw new QueryParsingException(this, "Strict field resolution and no field mapping can be found for the field with name ["
                    + name + "]");
        } else {
            return fieldMapping;
        }
    }
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException {
    LongFieldMapper.Builder builder = longField(name);
    parseNumberField(builder, name, node, parserContext);
    for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext();) {
        Map.Entry<String, Object> entry = iterator.next();
        String propName = Strings.toUnderscoreCase(entry.getKey());
        Object propNode = entry.getValue();
        if (propName.equals("null_value")) {
            if (propNode == null) {
                throw new MapperParsingException("Property [null_value] cannot be null.");
            }
            builder.nullValue(nodeLongValue(propNode));
            iterator.remove();
        }
    }
    return builder;
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException {
    IpFieldMapper.Builder builder = ipField(name);
    parseNumberField(builder, name, node, parserContext);
    for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext();) {
        Map.Entry<String, Object> entry = iterator.next();
        String propName = Strings.toUnderscoreCase(entry.getKey());
        Object propNode = entry.getValue();
        if (propName.equals("null_value")) {
            if (propNode == null) {
                throw new MapperParsingException("Property [null_value] cannot be null.");
            }
            builder.nullValue(propNode.toString());
            iterator.remove();
        }
    }
    return builder;
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
protected void doMerge(Mapper mergeWith, boolean updateAllTypes) {
    TTLFieldMapper ttlMergeWith = (TTLFieldMapper) mergeWith;
    if (ttlMergeWith.enabledState != Defaults.ENABLED_STATE) {//only do something if actually something was set for the document mapper that we merge with
        if (this.enabledState == EnabledAttributeMapper.ENABLED && ttlMergeWith.enabledState == EnabledAttributeMapper.DISABLED) {
            throw new IllegalArgumentException("_ttl cannot be disabled once it was enabled.");
        } else {
            this.enabledState = ttlMergeWith.enabledState;
        }
    }
    if (ttlMergeWith.defaultTTL != -1) {
        // we never build the default when the field is disabled so we should also not set it
        // (it does not make a difference though as everything that is not build in toXContent will also not be set in the cluster)
        if (enabledState == EnabledAttributeMapper.ENABLED) {
            this.defaultTTL = ttlMergeWith.defaultTTL;
        }
    }
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
protected void doMerge(Mapper mergeWith, boolean updateAllTypes) {
    SourceFieldMapper sourceMergeWith = (SourceFieldMapper) mergeWith;
    List<String> conflicts = new ArrayList<>();
    if (this.enabled != sourceMergeWith.enabled) {
        conflicts.add("Cannot update enabled setting for [_source]");
    }
    if (Arrays.equals(includes(), sourceMergeWith.includes()) == false) {
        conflicts.add("Cannot update includes setting for [_source]");
    }
    if (Arrays.equals(excludes(), sourceMergeWith.excludes()) == false) {
        conflicts.add("Cannot update excludes setting for [_source]");
    }
    if (conflicts.isEmpty() == false) {
        throw new IllegalArgumentException("Can't merge because of conflicts: " + conflicts);
    }
    if (sourceMergeWith.compress != null) {
        this.compress = sourceMergeWith.compress;
    }
    if (sourceMergeWith.compressThreshold != -1) {
        this.compressThreshold = sourceMergeWith.compressThreshold;
    }
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
protected void doMerge(Mapper mergeWith, boolean updateAllTypes) {
    super.doMerge(mergeWith, updateAllTypes);
    ParentFieldMapper fieldMergeWith = (ParentFieldMapper) mergeWith;
    if (Objects.equals(parentType, fieldMergeWith.parentType) == false) {
        throw new IllegalArgumentException("The _parent field's type option can't be changed: [" + parentType + "]->[" + fieldMergeWith.parentType + "]");
    }

    List<String> conflicts = new ArrayList<>();
    fieldType().checkCompatibility(fieldMergeWith.fieldType(), conflicts, true, false); // always strict, this cannot change
    parentJoinFieldType.checkCompatibility(fieldMergeWith.parentJoinFieldType, conflicts, true, false); // same here
    if (childJoinFieldType != null) {
        // TODO: this can be set to false when the old parent/child impl is removed, we can do eager global ordinals loading per type.
        childJoinFieldType.checkCompatibility(fieldMergeWith.childJoinFieldType, conflicts, updateAllTypes == false, false);
    }
    if (conflicts.isEmpty() == false) {
        throw new IllegalArgumentException("Merge conflicts: " + conflicts);
    }

    if (active()) {
        childJoinFieldType = fieldMergeWith.childJoinFieldType.clone();
    }
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
public Y build(BuilderContext context) {
    ContentPath.Type origPathType = context.path().pathType();
    context.path().pathType(pathType);
    context.path().add(name);

    Map<String, Mapper> mappers = new HashMap<>();
    for (Mapper.Builder builder : mappersBuilders) {
        Mapper mapper = builder.build(context);
        mappers.put(mapper.simpleName(), mapper);
    }
    context.path().pathType(origPathType);
    context.path().remove();

    ObjectMapper objectMapper = createMapper(name, context.path().fullPathAsText(name), enabled, nested, dynamic, pathType, mappers, context.indexSettings());
    objectMapper = objectMapper.includeInAllIfNotSet(includeInAll);

    return (Y) objectMapper;
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
ObjectMapper(String name, String fullPath, boolean enabled, Nested nested, Dynamic dynamic, ContentPath.Type pathType, Map<String, Mapper> mappers) {
    super(name);
    this.fullPath = fullPath;
    this.enabled = enabled;
    this.nested = nested;
    this.dynamic = dynamic;
    this.pathType = pathType;
    if (mappers == null) {
        this.mappers = new CopyOnWriteHashMap<>();
    } else {
        this.mappers = CopyOnWriteHashMap.copyOf(mappers);
    }
    this.nestedTypePathAsString = "__" + fullPath;
    this.nestedTypePathAsBytes = new BytesRef(nestedTypePathAsString);
    this.nestedTypeFilter = new TermQuery(new Term(TypeFieldMapper.NAME, nestedTypePathAsBytes));
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
public ObjectMapper includeInAllIfNotSet(Boolean includeInAll) {
    if (includeInAll == null || this.includeInAll != null) {
        return this;
    }

    ObjectMapper clone = clone();
    clone.includeInAll = includeInAll;
    // when called from outside, apply this on all the inner mappers
    for (Mapper mapper : clone.mappers.values()) {
        if (mapper instanceof AllFieldMapper.IncludeInAll) {
            clone.putMapper(((AllFieldMapper.IncludeInAll) mapper).includeInAllIfNotSet(includeInAll));
        }
    }
    return clone;
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
protected ObjectMapper createMapper(String name, String fullPath, boolean enabled, Nested nested, Dynamic dynamic, ContentPath.Type pathType, Map<String, Mapper> mappers, @Nullable Settings settings) {
    assert !nested.isNested();
    FormatDateTimeFormatter[] dates = null;
    if (dynamicDateTimeFormatters == null) {
        dates = new FormatDateTimeFormatter[0];
    } else if (dynamicDateTimeFormatters.isEmpty()) {
        // add the default one
        dates = Defaults.DYNAMIC_DATE_TIME_FORMATTERS;
    } else {
        dates = dynamicDateTimeFormatters.toArray(new FormatDateTimeFormatter[dynamicDateTimeFormatters.size()]);
    }
    return new RootObjectMapper(name, enabled, dynamic, pathType, mappers,
            dates,
            dynamicTemplates.toArray(new DynamicTemplate[dynamicTemplates.size()]),
            dateDetection, numericDetection);
}
 

import org.elasticsearch.index.mapper.Mapper; //导入依赖的package包/类
@Override
public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException {

    ObjectMapper.Builder builder = createBuilder(name);
    Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator();
    while (iterator.hasNext()) {
        Map.Entry<String, Object> entry = iterator.next();
        String fieldName = Strings.toUnderscoreCase(entry.getKey());
        Object fieldNode = entry.getValue();
        if (parseObjectOrDocumentTypeProperties(fieldName, fieldNode, parserContext, builder)
                || processField(builder, fieldName, fieldNode)) {
            iterator.remove();
        }
    }
    return builder;
}