Java IndexService.mapperService方法代码示例

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
public void testRewriteMissingReader() throws Exception {
    IndexService indexService = createIndex("test");
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties")
                .startObject("foo")
                    .field("type", "date")
                .endObject()
            .endObject()
        .endObject().endObject().string();
    indexService.mapperService().merge("type",
            new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE, false);
    QueryRewriteContext context = new QueryShardContext(0, indexService.getIndexSettings(), null, null, indexService.mapperService(),
            null, null, xContentRegistry(), null, null, null);
    RangeQueryBuilder range = new RangeQueryBuilder("foo");
    // can't make assumptions on a missing reader, so it must return INTERSECT
    assertEquals(Relation.INTERSECTS, range.getRelation(context));
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
public void testRewriteEmptyReader() throws Exception {
    IndexService indexService = createIndex("test");
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties")
                .startObject("foo")
                    .field("type", "date")
                .endObject()
            .endObject()
        .endObject().endObject().string();
    indexService.mapperService().merge("type",
            new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE, false);
    IndexReader reader = new MultiReader();
    QueryRewriteContext context = new QueryShardContext(0, indexService.getIndexSettings(), null, null, indexService.mapperService(),
            null, null, xContentRegistry(), null, reader, null);
    RangeQueryBuilder range = new RangeQueryBuilder("foo");
    // no values -> DISJOINT
    assertEquals(Relation.DISJOINT, range.getRelation(context));
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
public void testTypes() throws Exception {
    IndexService indexService1 = createIndex("index1");
    MapperService mapperService = indexService1.mapperService();
    assertEquals(Collections.emptySet(), mapperService.types());

    mapperService.merge("type1", new CompressedXContent("{\"type1\":{}}"), MapperService.MergeReason.MAPPING_UPDATE, false);
    assertNull(mapperService.documentMapper(MapperService.DEFAULT_MAPPING));
    assertEquals(Collections.singleton("type1"), mapperService.types());

    mapperService.merge(MapperService.DEFAULT_MAPPING, new CompressedXContent("{\"_default_\":{}}"), MapperService.MergeReason.MAPPING_UPDATE, false);
    assertNotNull(mapperService.documentMapper(MapperService.DEFAULT_MAPPING));
    assertEquals(Collections.singleton("type1"), mapperService.types());

    mapperService.merge("type2", new CompressedXContent("{\"type2\":{}}"), MapperService.MergeReason.MAPPING_UPDATE, false);
    assertNotNull(mapperService.documentMapper(MapperService.DEFAULT_MAPPING));
    assertEquals(new HashSet<>(Arrays.asList("type1", "type2")), mapperService.types());
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
public void testMergeWithMap() throws Throwable {
    IndexService indexService1 = createIndex("index1");
    MapperService mapperService = indexService1.mapperService();
    Map<String, Map<String, Object>> mappings = new HashMap<>();

    mappings.put(MapperService.DEFAULT_MAPPING, MapperService.parseMapping(xContentRegistry(), "{}"));
    MapperException e = expectThrows(MapperParsingException.class,
        () -> mapperService.merge(mappings, MergeReason.MAPPING_UPDATE, false));
    assertThat(e.getMessage(), startsWith("Failed to parse mapping [" + MapperService.DEFAULT_MAPPING + "]: "));

    mappings.clear();
    mappings.put("type1", MapperService.parseMapping(xContentRegistry(), "{}"));

    e = expectThrows( MapperParsingException.class,
        () -> mapperService.merge(mappings, MergeReason.MAPPING_UPDATE, false));
    assertThat(e.getMessage(), startsWith("Failed to parse mapping [type1]: "));
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
private ParsedDocument parseFetchedDoc(PercolateContext context, BytesReference fetchedDoc, IndexService documentIndexService, String index, String type) {
    ParsedDocument doc = null;
    XContentParser parser = null;
    try {
        parser = XContentFactory.xContent(fetchedDoc).createParser(fetchedDoc);
        MapperService mapperService = documentIndexService.mapperService();
        DocumentMapperForType docMapper = mapperService.documentMapperWithAutoCreate(type);
        doc = docMapper.getDocumentMapper().parse(source(parser).index(index).type(type).flyweight(true));

        if (context.highlight() != null) {
            doc.setSource(fetchedDoc);
        }
    } catch (Throwable e) {
        throw new ElasticsearchParseException("failed to parse request", e);
    } finally {
        if (parser != null) {
            parser.close();
        }
    }

    if (doc == null) {
        throw new ElasticsearchParseException("No doc to percolate in the request");
    }

    return doc;
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
@Override
protected FieldStatsShardResponse shardOperation(FieldStatsShardRequest request) {
    ShardId shardId = request.shardId();
    Map<String, FieldStats> fieldStats = new HashMap<>();
    IndexService indexServices = indicesService.indexServiceSafe(shardId.getIndex());
    MapperService mapperService = indexServices.mapperService();
    IndexShard shard = indexServices.shardSafe(shardId.id());
    try (Engine.Searcher searcher = shard.acquireSearcher("fieldstats")) {
        for (String field : request.getFields()) {
            MappedFieldType fieldType = mapperService.fullName(field);
            if (fieldType != null) {
                IndexReader reader = searcher.reader();
                Terms terms = MultiFields.getTerms(reader, field);
                if (terms != null) {
                    fieldStats.put(field, fieldType.stats(terms, reader.maxDoc()));
                }
            } else {
                throw new IllegalArgumentException("field [" + field + "] doesn't exist");
            }
        }
    } catch (IOException e) {
        throw ExceptionsHelper.convertToElastic(e);
    }
    return new FieldStatsShardResponse(shardId, fieldStats);
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
@Override
public void setUp() throws Exception {
    super.setUp();
    IndexService index = createIndex("test", Settings.EMPTY, "type", "d", "type=double");
    service = new ExpressionScriptEngineService(Settings.EMPTY);
    lookup = new SearchLookup(index.mapperService(), index.fieldData(), null);
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
public void testAllowNoAdditionalSettings() throws Exception {
    addQueryMapping();
    IndexService indexService = createIndex("test1", Settings.EMPTY);
    MapperService mapperService = indexService.mapperService();

    String percolatorMapper = XContentFactory.jsonBuilder().startObject().startObject(typeName)
        .startObject("properties").startObject(fieldName).field("type", "percolator").field("index", "no").endObject().endObject()
        .endObject().endObject().string();
    MapperParsingException e = expectThrows(MapperParsingException.class, () ->
        mapperService.merge(typeName, new CompressedXContent(percolatorMapper), MapperService.MergeReason.MAPPING_UPDATE, true));
    assertThat(e.getMessage(), containsString("Mapping definition for [" + fieldName + "] has unsupported parameters:  [index : no]"));
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
@Before
public void init() throws Exception {
    directory = newDirectory();
    IndexWriterConfig config = new IndexWriterConfig(new WhitespaceAnalyzer());
    config.setMergePolicy(NoMergePolicy.INSTANCE);
    indexWriter = new IndexWriter(directory, config);

    String indexName = "test";
    IndexService indexService = createIndex(indexName, Settings.EMPTY);
    mapperService = indexService.mapperService();

    String mapper = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties")
            .startObject("int_field").field("type", "integer").endObject()
            .startObject("long_field").field("type", "long").endObject()
            .startObject("half_float_field").field("type", "half_float").endObject()
            .startObject("float_field").field("type", "float").endObject()
            .startObject("double_field").field("type", "double").endObject()
            .startObject("ip_field").field("type", "ip").endObject()
            .startObject("field").field("type", "keyword").endObject()
            .endObject().endObject().endObject().string();
    documentMapper = mapperService.merge("type", new CompressedXContent(mapper), MapperService.MergeReason.MAPPING_UPDATE, true);

    String queryField = "query_field";
    String mappingType = "query";
    String percolatorMapper = XContentFactory.jsonBuilder().startObject().startObject(mappingType)
            .startObject("properties").startObject(queryField).field("type", "percolator").endObject().endObject()
            .endObject().endObject().string();
    mapperService.merge(mappingType, new CompressedXContent(percolatorMapper), MapperService.MergeReason.MAPPING_UPDATE, true);
    fieldMapper = (PercolatorFieldMapper) mapperService.documentMapper(mappingType).mappers().getMapper(queryField);
    fieldType = (PercolatorFieldMapper.FieldType) fieldMapper.fieldType();

    queries = new ArrayList<>();
    queryStore = ctx -> docId -> this.queries.get(docId);
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
public void testNeedsScores() {
    IndexService index = createIndex("test", Settings.EMPTY, "type", "d", "type=double");

    PainlessScriptEngineService service = new PainlessScriptEngineService(Settings.EMPTY);
    SearchLookup lookup = new SearchLookup(index.mapperService(), index.fieldData(), null);

    Object compiled = service.compile(null, "1.2", Collections.emptyMap());
    SearchScript ss = service.search(new CompiledScript(ScriptType.INLINE, "randomName", "painless", compiled),
                                     lookup, Collections.<String, Object>emptyMap());
    assertFalse(ss.needsScores());

    compiled = service.compile(null, "doc['d'].value", Collections.emptyMap());
    ss = service.search(new CompiledScript(ScriptType.INLINE, "randomName", "painless", compiled),
                        lookup, Collections.<String, Object>emptyMap());
    assertFalse(ss.needsScores());

    compiled = service.compile(null, "1/_score", Collections.emptyMap());
    ss = service.search(new CompiledScript(ScriptType.INLINE, "randomName", "painless", compiled),
                        lookup, Collections.<String, Object>emptyMap());
    assertTrue(ss.needsScores());

    compiled = service.compile(null, "doc['d'].value * _score", Collections.emptyMap());
    ss = service.search(new CompiledScript(ScriptType.INLINE, "randomName", "painless", compiled),
                        lookup, Collections.<String, Object>emptyMap());
    assertTrue(ss.needsScores());
    service.close();
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
public void testRewriteMissingField() throws Exception {
    IndexService indexService = createIndex("test");
    IndexReader reader = new MultiReader();
    QueryRewriteContext context = new QueryShardContext(0, indexService.getIndexSettings(), null, null, indexService.mapperService(),
            null, null, xContentRegistry(), null, reader, null);
    RangeQueryBuilder range = new RangeQueryBuilder("foo");
    assertEquals(Relation.DISJOINT, range.getRelation(context));
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
@Before
public void setup() throws IOException {
    Settings settings = Settings.builder()
        .put("index.analysis.filter.syns.type","synonym")
        .putArray("index.analysis.filter.syns.synonyms","quick,fast")
        .put("index.analysis.analyzer.syns.tokenizer","standard")
        .put("index.analysis.analyzer.syns.filter","syns").build();
    IndexService indexService = createIndex("test", settings);
    MapperService mapperService = indexService.mapperService();
    String mapping = "{\n" +
            "    \"person\":{\n" +
            "        \"properties\":{\n" +
            "            \"name\":{\n" +
            "                  \"properties\":{\n" +
            "                        \"first\": {\n" +
            "                            \"type\":\"text\",\n" +
            "                            \"analyzer\":\"syns\"\n" +
            "                        }," +
            "                        \"last\": {\n" +
            "                            \"type\":\"text\",\n" +
            "                            \"analyzer\":\"syns\"\n" +
            "                        }" +
            "                   }" +
            "            }\n" +
            "        }\n" +
            "    }\n" +
            "}";
    mapperService.merge("person", new CompressedXContent(mapping), MapperService.MergeReason.MAPPING_UPDATE, false);
    this.indexService = indexService;
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
public  static final IndexShard newIndexShard(IndexService indexService, IndexShard shard, IndexSearcherWrapper wrapper,
                                              IndexingOperationListener... listeners) throws IOException {
    ShardRouting initializingShardRouting = getInitializingShardRouting(shard.routingEntry());
    IndexShard newShard = new IndexShard(initializingShardRouting, indexService.getIndexSettings(), shard.shardPath(),
        shard.store(), indexService.cache(), indexService.mapperService(), indexService.similarityService(),
        indexService.fieldData(), shard.getEngineFactory(), indexService.getIndexEventListener(), wrapper,
        indexService.getThreadPool(), indexService.getBigArrays(), null, () -> {}, Collections.emptyList(), Arrays.asList(listeners));
    return newShard;
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
public FetchCollector createCollector(int readerId) {
    IndexService indexService = fetchContext.indexService(readerId);
    LuceneReferenceResolver resolver = new LuceneReferenceResolver(indexService.mapperService());
    ArrayList<LuceneCollectorExpression<?>> exprs = new ArrayList<>(refs.size());
    for (Reference reference : refs) {
        exprs.add(resolver.getImplementation(reference.info()));
    }
    return new FetchCollector(exprs,
            indexService.mapperService(),
            fetchContext.searcher(readerId),
            indexService.fieldData(),
            readerId
    );
}
 

import org.elasticsearch.index.IndexService; //导入方法依赖的package包/类
public void testExternalValues() throws Exception {
    Version version = VersionUtils.randomVersionBetween(random(), Version.V_2_0_0, Version.CURRENT);
    Settings settings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, version).build();
    IndexService indexService = createIndex("test", settings);
    MapperRegistry mapperRegistry = new MapperRegistry(
            Collections.singletonMap(ExternalMapperPlugin.EXTERNAL, new ExternalMapper.TypeParser(ExternalMapperPlugin.EXTERNAL, "foo")),
            Collections.singletonMap(ExternalMetadataMapper.CONTENT_TYPE, new ExternalMetadataMapper.TypeParser()));

    Supplier<QueryShardContext> queryShardContext = () -> {
        return indexService.newQueryShardContext(0, null, () -> { throw new UnsupportedOperationException(); });
    };
    DocumentMapperParser parser = new DocumentMapperParser(indexService.getIndexSettings(), indexService.mapperService(),
            indexService.getIndexAnalyzers(), indexService.xContentRegistry(), indexService.similarityService(), mapperRegistry,
            queryShardContext);
    DocumentMapper documentMapper = parser.parse("type", new CompressedXContent(
            XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject(ExternalMetadataMapper.CONTENT_TYPE)
            .endObject()
            .startObject("properties")
                .startObject("field").field("type", "external").endObject()
            .endObject()
        .endObject().endObject().string()
    ));

    ParsedDocument doc = documentMapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
                .field("field", "1234")
            .endObject()
            .bytes());

    assertThat(doc.rootDoc().getField("field.bool"), notNullValue());
    assertThat(doc.rootDoc().getField("field.bool").stringValue(), is("T"));

    assertThat(doc.rootDoc().getField("field.point"), notNullValue());
    GeoPoint point = new GeoPoint().resetFromIndexableField(doc.rootDoc().getField("field.point"));
    assertThat(point.lat(), closeTo(42.0, 1e-5));
    assertThat(point.lon(), closeTo(51.0, 1e-5));

    assertThat(doc.rootDoc().getField("field.shape"), notNullValue());

    assertThat(doc.rootDoc().getField("field.field"), notNullValue());
    assertThat(doc.rootDoc().getField("field.field").stringValue(), is("foo"));

    assertThat(doc.rootDoc().getField(ExternalMetadataMapper.FIELD_NAME).stringValue(), is(ExternalMetadataMapper.FIELD_VALUE));

}