Java MapperService类代码示例

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
public void testMultiplePercolatorFields() throws Exception {
    String typeName = "another_type";
    String percolatorMapper = XContentFactory.jsonBuilder().startObject().startObject(typeName)
            .startObject("_field_names").field("enabled", false).endObject() // makes testing easier
            .startObject("properties")
                .startObject("query_field1").field("type", "percolator").endObject()
                .startObject("query_field2").field("type", "percolator").endObject()
            .endObject()
            .endObject().endObject().string();
    mapperService.merge(typeName, new CompressedXContent(percolatorMapper), MapperService.MergeReason.MAPPING_UPDATE, true);

    QueryBuilder queryBuilder = matchQuery("field", "value");
    ParsedDocument doc = mapperService.documentMapper(typeName).parse("test", typeName, "1",
            jsonBuilder().startObject()
                    .field("query_field1", queryBuilder)
                    .field("query_field2", queryBuilder)
                    .endObject().bytes()
    );
    assertThat(doc.rootDoc().getFields().size(), equalTo(14)); // also includes all other meta fields
    BytesRef queryBuilderAsBytes = doc.rootDoc().getField("query_field1.query_builder_field").binaryValue();
    assertQueryBuilder(queryBuilderAsBytes, queryBuilder);

    queryBuilderAsBytes = doc.rootDoc().getField("query_field2.query_builder_field").binaryValue();
    assertQueryBuilder(queryBuilderAsBytes, queryBuilder);
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
public ParentChildIndexFieldData(Index index, Settings indexSettings, MappedFieldType.Names fieldNames,
                                 FieldDataType fieldDataType, IndexFieldDataCache cache, MapperService mapperService,
                                 CircuitBreakerService breakerService) {
    super(index, indexSettings, fieldNames, fieldDataType, cache);
    this.breakerService = breakerService;
    if (Version.indexCreated(indexSettings).before(Version.V_2_0_0_beta1)) {
        parentTypes = new TreeSet<>();
        for (DocumentMapper documentMapper : mapperService.docMappers(false)) {
            beforeCreate(documentMapper);
        }
        mapperService.addTypeListener(this);
    } else {
        ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.naturalOrder();
        for (DocumentMapper mapper : mapperService.docMappers(false)) {
            ParentFieldMapper parentFieldMapper = mapper.parentFieldMapper();
            if (parentFieldMapper.active()) {
                builder.add(parentFieldMapper.type());
            }
        }
        parentTypes = builder.build();
    }
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
@Inject
public IndexQueryParserService(Index index, IndexSettingsService indexSettingsService,
                               IndicesQueriesRegistry indicesQueriesRegistry,
                               ScriptService scriptService, AnalysisService analysisService,
                               MapperService mapperService, IndexCache indexCache, IndexFieldDataService fieldDataService,
                               BitsetFilterCache bitsetFilterCache,
                               @Nullable SimilarityService similarityService) {
    super(index, indexSettingsService.getSettings());
    this.indexSettingsService = indexSettingsService;
    this.scriptService = scriptService;
    this.analysisService = analysisService;
    this.mapperService = mapperService;
    this.similarityService = similarityService;
    this.indexCache = indexCache;
    this.fieldDataService = fieldDataService;
    this.bitsetFilterCache = bitsetFilterCache;

    Settings indexSettings = indexSettingsService.getSettings();
    this.defaultField = indexSettings.get(DEFAULT_FIELD, AllFieldMapper.NAME);
    this.queryStringLenient = indexSettings.getAsBoolean(QUERY_STRING_LENIENT, false);
    this.parseFieldMatcher = new ParseFieldMatcher(indexSettings);
    this.defaultAllowUnmappedFields = indexSettings.getAsBoolean(ALLOW_UNMAPPED, true);
    this.indicesQueriesRegistry = indicesQueriesRegistry;
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
public static MapperService newMapperService(NamedXContentRegistry xContentRegistry, Path tempDir, Settings settings,
        IndicesModule indicesModule) throws IOException {
    Settings.Builder settingsBuilder = Settings.builder()
        .put(Environment.PATH_HOME_SETTING.getKey(), tempDir)
        .put(settings);
    if (settings.get(IndexMetaData.SETTING_VERSION_CREATED) == null) {
        settingsBuilder.put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT);
    }
    Settings finalSettings = settingsBuilder.build();
    MapperRegistry mapperRegistry = indicesModule.getMapperRegistry();
    IndexSettings indexSettings = IndexSettingsModule.newIndexSettings("test", finalSettings);
    IndexAnalyzers indexAnalyzers = createTestAnalysis(indexSettings, finalSettings).indexAnalyzers;
    SimilarityService similarityService = new SimilarityService(indexSettings, Collections.emptyMap());
    return new MapperService(indexSettings,
        indexAnalyzers,
        xContentRegistry,
        similarityService,
        mapperRegistry,
        () -> null);
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
@Override
public SuggestionSearchContext.SuggestionContext parse(XContentParser parser, MapperService mapperService,
        IndexQueryParserService queryParserService, HasContextAndHeaders headersContext) throws IOException {
    XContentParser.Token token;
    String fieldName = null;
    TermSuggestionContext suggestion = new TermSuggestionContext(suggester);
    DirectSpellcheckerSettings settings = suggestion.getDirectSpellCheckerSettings();
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            fieldName = parser.currentName();
        } else if (token.isValue()) {
            parseTokenValue(parser, mapperService, fieldName, suggestion, settings, queryParserService.parseFieldMatcher());
        } else {
            throw new IllegalArgumentException("suggester[term]  doesn't support field [" + fieldName + "]");
        }
    }
    return suggestion;
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
@Override
public IndexFieldData<?> build(Index index, Settings indexSettings, MappedFieldType fieldType, IndexFieldDataCache cache,
                               CircuitBreakerService breakerService, MapperService mapperService) {
    // Ignore Circuit Breaker
    final Names fieldNames = fieldType.names();
    final Settings fdSettings = fieldType.fieldDataType().getSettings();
    final Map<String, Settings> filter = fdSettings.getGroups("filter");
    if (filter != null && !filter.isEmpty()) {
        throw new IllegalArgumentException("Doc values field data doesn't support filters [" + fieldNames.fullName() + "]");
    }

    if (BINARY_INDEX_FIELD_NAMES.contains(fieldNames.indexName())) {
        assert numericType == null;
        return new BinaryDVIndexFieldData(index, fieldNames, fieldType.fieldDataType());
    } else if (numericType != null) {
        if (TimestampFieldMapper.NAME.equals(fieldNames.indexName())
                || Version.indexCreated(indexSettings).onOrAfter(Version.V_1_4_0_Beta1)) {
            return new SortedNumericDVIndexFieldData(index, fieldNames, numericType, fieldType.fieldDataType());
        } else {
            // prior to ES 1.4: multi-valued numerics were boxed inside a byte[] as BINARY
            return new BinaryDVNumericIndexFieldData(index, fieldNames, numericType, fieldType.fieldDataType());
        }
    } else {
        return new SortedSetDVOrdinalsIndexFieldData(index, cache, indexSettings, fieldNames, breakerService, fieldType.fieldDataType());
    }
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
/**
 * we need to declare parse fields for each metadata field, except for _ID, _INDEX and _TYPE which are
 * handled individually. All other fields are parsed to an entry in the fields map
 */
private static void declareMetaDataFields(ObjectParser<Map<String, Object>, Void> parser) {
    for (String metadatafield : MapperService.getAllMetaFields()) {
        if (metadatafield.equals(Fields._ID) == false && metadatafield.equals(Fields._INDEX) == false
                && metadatafield.equals(Fields._TYPE) == false) {
            parser.declareField((map, field) -> {
                @SuppressWarnings("unchecked")
                Map<String, SearchHitField> fieldMap = (Map<String, SearchHitField>) map.computeIfAbsent(Fields.FIELDS,
                        v -> new HashMap<String, SearchHitField>());
                fieldMap.put(field.getName(), field);
            }, (p, c) -> {
                List<Object> values = new ArrayList<>();
                values.add(parseStoredFieldsValue(p));
                return new SearchHitField(metadatafield, values);
            }, new ParseField(metadatafield), ValueType.VALUE);
        }
    }
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
protected MappedFieldType.Relation getRelation(QueryRewriteContext queryRewriteContext) throws IOException {
    IndexReader reader = queryRewriteContext.getIndexReader();
    // If the reader is null we are not on the shard and cannot
    // rewrite so just pretend there is an intersection so that the rewrite is a noop
    if (reader == null) {
        return MappedFieldType.Relation.INTERSECTS;
    }
    final MapperService mapperService = queryRewriteContext.getMapperService();
    final MappedFieldType fieldType = mapperService.fullName(fieldName);
    if (fieldType == null) {
        // no field means we have no values
        return MappedFieldType.Relation.DISJOINT;
    } else {
        DateMathParser dateMathParser = format == null ? null : new DateMathParser(format);
        return fieldType.isFieldWithinQuery(queryRewriteContext.getIndexReader(), from, to, includeLower,
                includeUpper, timeZone, dateMathParser, queryRewriteContext);
    }
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
public Context convert(WhereClause whereClause,
                       MapperService mapperService,
                       IndexFieldDataService indexFieldDataService,
                       IndexCache indexCache) throws UnsupportedFeatureException {
    Context ctx = new Context(inputSymbolVisitor, mapperService, indexFieldDataService, indexCache);
    if (whereClause.noMatch()) {
        ctx.query = Queries.newMatchNoDocsQuery();
    } else if (!whereClause.hasQuery()) {
        ctx.query = Queries.newMatchAllQuery();
    } else {
        ctx.query = VISITOR.process(whereClause.query(), ctx);
    }
    if (LOGGER.isTraceEnabled()) {
        if (whereClause.hasQuery()) {
            LOGGER.trace("WHERE CLAUSE [{}] -> LUCENE QUERY [{}] ", SymbolPrinter.INSTANCE.printSimple(whereClause.query()), ctx.query);
        }
    }
    return ctx;
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
@Inject
public ShadowIndexShard(ShardId shardId, IndexSettingsService indexSettingsService,
                        IndicesLifecycle indicesLifecycle, Store store, StoreRecoveryService storeRecoveryService,
                        ThreadPool threadPool, MapperService mapperService,
                        IndexQueryParserService queryParserService, IndexCache indexCache,
                        IndexAliasesService indexAliasesService, IndicesQueryCache indicesQueryCache,
                        ShardPercolateService shardPercolateService, CodecService codecService,
                        ShardTermVectorsService termVectorsService, IndexFieldDataService indexFieldDataService,
                        IndexService indexService, @Nullable IndicesWarmer warmer,
                        SnapshotDeletionPolicy deletionPolicy, SimilarityService similarityService,
                        EngineFactory factory, ClusterService clusterService,
                        ShardPath path, BigArrays bigArrays, IndexSearcherWrappingService wrappingService,
                        IndexingMemoryController indexingMemoryController, SearchService shardSearchService) throws IOException {
    super(shardId, indexSettingsService, indicesLifecycle, store, storeRecoveryService,
          threadPool, mapperService, queryParserService, indexCache, indexAliasesService,
          indicesQueryCache, shardPercolateService, codecService,
          termVectorsService, indexFieldDataService, indexService,
          warmer, deletionPolicy, similarityService,
          factory, clusterService, path, bigArrays, wrappingService, indexingMemoryController, shardSearchService);
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
@Inject
public AutoCreateIndex(Settings settings, IndexNameExpressionResolver resolver) {
    this.resolver = resolver;
    dynamicMappingDisabled = !settings.getAsBoolean(MapperService.INDEX_MAPPER_DYNAMIC_SETTING, MapperService.INDEX_MAPPER_DYNAMIC_DEFAULT);
    String value = settings.get("action.auto_create_index");
    if (value == null || Booleans.isExplicitTrue(value)) {
        needToCheck = true;
        globallyDisabled = false;
        matches = null;
        matches2 = null;
    } else if (Booleans.isExplicitFalse(value)) {
        needToCheck = false;
        globallyDisabled = true;
        matches = null;
        matches2 = null;
    } else {
        needToCheck = true;
        globallyDisabled = false;
        matches = Strings.commaDelimitedListToStringArray(value);
        matches2 = new String[matches.length];
        for (int i = 0; i < matches.length; i++) {
            matches2[i] = matches[i].substring(1);
        }
    }
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
@Override
protected void initializeAdditionalMappings(MapperService mapperService) throws IOException {
    similarity = randomFrom("classic", "BM25");
    mapperService.merge(PARENT_TYPE, new CompressedXContent(PutMappingRequest.buildFromSimplifiedDef(PARENT_TYPE,
            STRING_FIELD_NAME, "type=text",
            STRING_FIELD_NAME_2, "type=keyword",
            INT_FIELD_NAME, "type=integer",
            DOUBLE_FIELD_NAME, "type=double",
            BOOLEAN_FIELD_NAME, "type=boolean",
            DATE_FIELD_NAME, "type=date",
            OBJECT_FIELD_NAME, "type=object"
    ).string()), MapperService.MergeReason.MAPPING_UPDATE, false);
    mapperService.merge(CHILD_TYPE, new CompressedXContent(PutMappingRequest.buildFromSimplifiedDef(CHILD_TYPE,
            "_parent", "type=" + PARENT_TYPE,
            STRING_FIELD_NAME, "type=text",
            "custom_string", "type=text,similarity=" + similarity,
            INT_FIELD_NAME, "type=integer",
            DOUBLE_FIELD_NAME, "type=double",
            BOOLEAN_FIELD_NAME, "type=boolean",
            DATE_FIELD_NAME, "type=date",
            OBJECT_FIELD_NAME, "type=object"
    ).string()), MapperService.MergeReason.MAPPING_UPDATE, false);
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
public void postProcess(MapperService mapperService) {
    if (uid != null) {
        DocumentMapper documentMapper = mapperService.documentMapper(uid.type());
        if (documentMapper != null) {
            // we can derive the exact type for the mapping
            postProcess(documentMapper);
            return;
        }
    }
    // can't derive exact mapping type
    for (Map.Entry<String, List<Object>> entry : fields().entrySet()) {
        MappedFieldType fieldType = mapperService.indexName(entry.getKey());
        if (fieldType == null) {
            continue;
        }
        List<Object> fieldValues = entry.getValue();
        for (int i = 0; i < fieldValues.size(); i++) {
            fieldValues.set(i, fieldType.valueForSearch(fieldValues.get(i)));
        }
    }
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
@Override
protected void initializeAdditionalMappings(MapperService mapperService) throws IOException {
    mapperService.merge(PARENT_TYPE, new CompressedXContent(PutMappingRequest.buildFromSimplifiedDef(PARENT_TYPE,
            STRING_FIELD_NAME, "type=text",
            INT_FIELD_NAME, "type=integer",
            DOUBLE_FIELD_NAME, "type=double",
            BOOLEAN_FIELD_NAME, "type=boolean",
            DATE_FIELD_NAME, "type=date",
            OBJECT_FIELD_NAME, "type=object"
    ).string()), MapperService.MergeReason.MAPPING_UPDATE, false);
    mapperService.merge(CHILD_TYPE, new CompressedXContent(PutMappingRequest.buildFromSimplifiedDef(CHILD_TYPE,
            "_parent", "type=" + PARENT_TYPE,
            STRING_FIELD_NAME, "type=text",
            INT_FIELD_NAME, "type=integer",
            DOUBLE_FIELD_NAME, "type=double",
            BOOLEAN_FIELD_NAME, "type=boolean",
            DATE_FIELD_NAME, "type=date",
            OBJECT_FIELD_NAME, "type=object"
    ).string()), MapperService.MergeReason.MAPPING_UPDATE, false);
}
 

import org.elasticsearch.index.mapper.MapperService; //导入依赖的package包/类
public void testChangeSearchAnalyzerToDefault() throws Exception {
    MapperService mapperService = createIndex("test").mapperService();
    String mapping1 = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "text").field("analyzer", "standard").field("search_analyzer", "whitespace").endObject().endObject()
            .endObject().endObject().string();
    String mapping2 = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "text").field("analyzer", "standard").endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper existing = mapperService.merge("type", new CompressedXContent(mapping1), MapperService.MergeReason.MAPPING_UPDATE, false);
    DocumentMapper merged = mapperService.merge("type", new CompressedXContent(mapping2), MapperService.MergeReason.MAPPING_UPDATE, false);

    assertThat(((NamedAnalyzer) existing.mappers().getMapper("field").fieldType().searchAnalyzer()).name(), equalTo("whitespace"));

    assertThat(((NamedAnalyzer) merged.mappers().getMapper("field").fieldType().searchAnalyzer()).name(), equalTo("standard"));
}