Examples with IndexService org.elasticsearch.index.IndexService used on opensource projects

Example 41 with IndexService

use of org.elasticsearch.index.IndexService in project elasticsearch by elastic.

the class ExternalFieldMapperTests method testExternalValuesWithMultifieldTwoLevels.

public void testExternalValuesWithMultifieldTwoLevels() 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);
    Map<String, Mapper.TypeParser> mapperParsers = new HashMap<>();
    mapperParsers.put(ExternalMapperPlugin.EXTERNAL, new ExternalMapper.TypeParser(ExternalMapperPlugin.EXTERNAL, "foo"));
    mapperParsers.put(ExternalMapperPlugin.EXTERNAL_BIS, new ExternalMapper.TypeParser(ExternalMapperPlugin.EXTERNAL, "bar"));
    mapperParsers.put(TextFieldMapper.CONTENT_TYPE, new TextFieldMapper.TypeParser());
    MapperRegistry mapperRegistry = new MapperRegistry(mapperParsers, Collections.emptyMap());
    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("properties").startObject("field").field("type", ExternalMapperPlugin.EXTERNAL).startObject("fields").startObject("field").field("type", "text").startObject("fields").startObject("generated").field("type", ExternalMapperPlugin.EXTERNAL_BIS).endObject().startObject("raw").field("type", "text").endObject().endObject().endObject().startObject("raw").field("type", "text").endObject().endObject().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());
    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("field.field.generated.generated"), notNullValue());
    assertThat(doc.rootDoc().getField("field.field.generated.generated").stringValue(), is("bar"));
    assertThat(doc.rootDoc().getField("field.field.raw"), notNullValue());
    assertThat(doc.rootDoc().getField("field.field.raw").stringValue(), is("foo"));
    assertThat(doc.rootDoc().getField("field.raw"), notNullValue());
    assertThat(doc.rootDoc().getField("field.raw").stringValue(), is("foo"));
}

Example 42 with IndexService

use of org.elasticsearch.index.IndexService in project elasticsearch by elastic.

the class DynamicMappingTests method testReuseExistingMappings.

public void testReuseExistingMappings() throws IOException, Exception {
    IndexService indexService = createIndex("test", Settings.EMPTY, "type", "my_field1", "type=text,store=true", "my_field2", "type=integer,store=false", "my_field3", "type=long,doc_values=false", "my_field4", "type=float,index=false", "my_field5", "type=double,store=true", "my_field6", "type=date,doc_values=false", "my_field7", "type=boolean,doc_values=false");
    // Even if the dynamic type of our new field is long, we already have a mapping for the same field
    // of type string so it should be mapped as a string
    DocumentMapper newMapper = indexService.mapperService().documentMapperWithAutoCreate("type2").getDocumentMapper();
    Mapper update = parse(newMapper, indexService.mapperService().documentMapperParser(), XContentFactory.jsonBuilder().startObject().field("my_field1", 42).field("my_field2", 43).field("my_field3", 44).field("my_field4", 45).field("my_field5", 46).field("my_field6", 47).field("my_field7", true).endObject());
    Mapper myField1Mapper = null;
    Mapper myField2Mapper = null;
    Mapper myField3Mapper = null;
    Mapper myField4Mapper = null;
    Mapper myField5Mapper = null;
    Mapper myField6Mapper = null;
    Mapper myField7Mapper = null;
    for (Mapper m : update) {
        switch(m.name()) {
            case "my_field1":
                myField1Mapper = m;
                break;
            case "my_field2":
                myField2Mapper = m;
                break;
            case "my_field3":
                myField3Mapper = m;
                break;
            case "my_field4":
                myField4Mapper = m;
                break;
            case "my_field5":
                myField5Mapper = m;
                break;
            case "my_field6":
                myField6Mapper = m;
                break;
            case "my_field7":
                myField7Mapper = m;
                break;
        }
    }
    assertNotNull(myField1Mapper);
    // same type
    assertTrue(myField1Mapper instanceof TextFieldMapper);
    // and same option
    assertTrue(((TextFieldMapper) myField1Mapper).fieldType().stored());
    // Even if dynamic mappings would map a numeric field as a long, here it should map it as a integer
    // since we already have a mapping of type integer
    assertNotNull(myField2Mapper);
    // same type
    assertEquals("integer", ((FieldMapper) myField2Mapper).fieldType().typeName());
    // and same option
    assertFalse(((FieldMapper) myField2Mapper).fieldType().stored());
    assertNotNull(myField3Mapper);
    assertTrue(myField3Mapper instanceof NumberFieldMapper);
    assertFalse(((NumberFieldType) ((NumberFieldMapper) myField3Mapper).fieldType()).hasDocValues());
    assertNotNull(myField4Mapper);
    assertTrue(myField4Mapper instanceof NumberFieldMapper);
    assertEquals(IndexOptions.NONE, ((FieldMapper) myField4Mapper).fieldType().indexOptions());
    assertNotNull(myField5Mapper);
    assertTrue(myField5Mapper instanceof NumberFieldMapper);
    assertTrue(((NumberFieldMapper) myField5Mapper).fieldType().stored());
    assertNotNull(myField6Mapper);
    assertTrue(myField6Mapper instanceof DateFieldMapper);
    assertFalse(((DateFieldType) ((DateFieldMapper) myField6Mapper).fieldType()).hasDocValues());
    assertNotNull(myField7Mapper);
    assertTrue(myField7Mapper instanceof BooleanFieldMapper);
    assertFalse(((BooleanFieldType) ((BooleanFieldMapper) myField7Mapper).fieldType()).hasDocValues());
    // This can't work
    try {
        parse(newMapper, indexService.mapperService().documentMapperParser(), XContentFactory.jsonBuilder().startObject().field("my_field2", "foobar").endObject());
        fail("Cannot succeed, incompatible types");
    } catch (MapperParsingException e) {
    // expected
    }
}

Example 43 with IndexService

use of org.elasticsearch.index.IndexService in project elasticsearch by elastic.

the class DynamicMappingTests method testIncremental.

public void testIncremental() throws Exception {
    IndexService indexService = createIndex("test");
    DocumentMapperParser parser = indexService.mapperService().documentMapperParser();
    // Make sure that mapping updates are incremental, this is important for performance otherwise
    // every new field introduction runs in linear time with the total number of fields
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties").startObject("foo").field("type", "text").endObject().endObject().endObject().endObject().string();
    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
    assertEquals(mapping, serialize(mapper));
    Mapper update = parse(mapper, parser, XContentFactory.jsonBuilder().startObject().field("foo", "bar").field("bar", "baz").endObject());
    assertNotNull(update);
    // original mapping not modified
    assertEquals(mapping, serialize(mapper));
    // but we have an update
    assertEquals(XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties").startObject("bar").field("type", "text").startObject("fields").startObject("keyword").field("type", "keyword").field("ignore_above", 256).endObject().endObject().endObject().endObject().endObject().endObject().string(), serialize(update));
}

Example 44 with IndexService

use of org.elasticsearch.index.IndexService in project elasticsearch by elastic.

the class DynamicMappingTests method testDynamicTemplateOrder.

public void testDynamicTemplateOrder() throws IOException {
    // https://github.com/elastic/elasticsearch/issues/18625
    // elasticsearch used to apply templates that do not have a match_mapping_type first
    XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startArray("dynamic_templates").startObject().startObject("type-based").field("match_mapping_type", "string").startObject("mapping").field("type", "keyword").endObject().endObject().endObject().startObject().startObject("path-based").field("path_match", "foo").startObject("mapping").field("type", "long").endObject().endObject().endObject().endArray().endObject().endObject();
    IndexService index = createIndex("test", Settings.EMPTY, "type", mapping);
    client().prepareIndex("test", "type", "1").setSource("foo", "abc").get();
    assertThat(index.mapperService().fullName("foo"), instanceOf(KeywordFieldMapper.KeywordFieldType.class));
}

Example 45 with IndexService

use of org.elasticsearch.index.IndexService in project elasticsearch by elastic.

the class DynamicMappingTests method testTypeNotCreatedOnIndexFailure.

public void testTypeNotCreatedOnIndexFailure() throws IOException, InterruptedException {
    XContentBuilder mapping = jsonBuilder().startObject().startObject("_default_").field("dynamic", "strict").endObject().endObject();
    IndexService indexService = createIndex("test", Settings.EMPTY, "_default_", mapping);
    try {
        client().prepareIndex().setIndex("test").setType("type").setSource(jsonBuilder().startObject().field("test", "test").endObject()).get();
        fail();
    } catch (StrictDynamicMappingException e) {
    }
    GetMappingsResponse getMappingsResponse = client().admin().indices().prepareGetMappings("test").get();
    assertNull(getMappingsResponse.getMappings().get("test").get("type"));
}