@Test
public void testGeoHashValue() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("properties")
.startObject("point")
.field("type", "geo_point")
.field("lat_lon", true)
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper defaultMapper = MapperTestUtils.newParser().parse(mapping);
ParsedDocument doc =
defaultMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("point", GeoHashUtils.encode(1.2, 1.3))
.endObject()
.bytes());
assertThat(doc.rootDoc().getField("point.lat"), notNullValue());
assertThat(doc.rootDoc().getField("point.lon"), notNullValue());
assertThat(doc.rootDoc().get("point"), notNullValue());
}
@Test
public void testEnabled() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_timestamp")
.field("enabled", "yes")
.field("store", "yes")
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper docMapper = MapperTests.newParser().parse(mapping);
byte[] source =
XContentFactory.jsonBuilder()
.startObject()
.field("field", "value")
.endObject()
.copiedBytes();
ParsedDocument doc =
docMapper.parse(SourceToParse.source(source).type("type").id("1").timestamp(1));
assertThat(doc.rootDoc().getFieldable("_timestamp").isStored(), equalTo(true));
assertThat(doc.rootDoc().getFieldable("_timestamp").isIndexed(), equalTo(true));
assertThat(doc.rootDoc().getFieldable("_timestamp").tokenStreamValue(), notNullValue());
}
@Test
public void testLatLonInOneValueStored() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("properties")
.startObject("point")
.field("type", "geo_point")
.field("lat_lon", true)
.field("store", "yes")
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper defaultMapper = MapperTestUtils.newParser().parse(mapping);
ParsedDocument doc =
defaultMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("point", "1.2,1.3")
.endObject()
.bytes());
assertThat(doc.rootDoc().getField("point.lat"), notNullValue());
assertThat(doc.rootDoc().getField("point.lat").numericValue().doubleValue(), equalTo(1.2));
assertThat(doc.rootDoc().getField("point.lon"), notNullValue());
assertThat(doc.rootDoc().getField("point.lon").numericValue().doubleValue(), equalTo(1.3));
assertThat(doc.rootDoc().get("point"), equalTo("1.2,1.3"));
}
public void testIncludeInAll() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("properties")
.startObject("field")
.field("type", "ip")
.field("include_in_all", true)
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc =
mapper.parse(
"test",
"type",
"1",
XContentFactory.jsonBuilder().startObject().field("field", "::1").endObject().bytes());
IndexableField[] fields = doc.rootDoc().getFields("_all");
assertEquals(1, fields.length);
assertEquals("::1", fields[0].stringValue());
mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("properties")
.startObject("field")
.field("type", "ip")
.endObject()
.endObject()
.endObject()
.endObject()
.string();
mapper = parser.parse("type", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
doc =
mapper.parse(
"test",
"type",
"1",
XContentFactory.jsonBuilder().startObject().field("field", "::1").endObject().bytes());
fields = doc.rootDoc().getFields("_all");
assertEquals(0, fields.length);
}
public void testPercolatorFieldMapper() throws Exception {
addQueryMapping();
QueryBuilder queryBuilder = termQuery("field", "value");
ParsedDocument doc =
mapperService
.documentMapper(typeName)
.parse(
"test",
typeName,
"1",
XContentFactory.jsonBuilder()
.startObject()
.field(fieldName, queryBuilder)
.endObject()
.bytes());
assertThat(doc.rootDoc().getFields(fieldType.getExtractedTermsField()).length, equalTo(1));
assertThat(
doc.rootDoc().getFields(fieldType.getExtractedTermsField())[0].binaryValue().utf8ToString(),
equalTo("field\0value"));
assertThat(doc.rootDoc().getFields(fieldType.getQueryBuilderFieldName()).length, equalTo(1));
assertThat(
doc.rootDoc().getFields(fieldType.getExtractionResultFieldName()).length, equalTo(1));
assertThat(
doc.rootDoc().getFields(fieldType.getExtractionResultFieldName())[0].stringValue(),
equalTo(EXTRACTION_COMPLETE));
BytesRef qbSource =
doc.rootDoc().getFields(fieldType.getQueryBuilderFieldName())[0].binaryValue();
assertQueryBuilder(qbSource, queryBuilder);
// add an query for which we don't extract terms from
queryBuilder = rangeQuery("field").from("a").to("z");
doc =
mapperService
.documentMapper(typeName)
.parse(
"test",
typeName,
"1",
XContentFactory.jsonBuilder()
.startObject()
.field(fieldName, queryBuilder)
.endObject()
.bytes());
assertThat(
doc.rootDoc().getFields(fieldType.getExtractionResultFieldName()).length, equalTo(1));
assertThat(
doc.rootDoc().getFields(fieldType.getExtractionResultFieldName())[0].stringValue(),
equalTo(EXTRACTION_FAILED));
assertThat(doc.rootDoc().getFields(fieldType.getExtractedTermsField()).length, equalTo(0));
assertThat(doc.rootDoc().getFields(fieldType.getQueryBuilderFieldName()).length, equalTo(1));
qbSource = doc.rootDoc().getFields(fieldType.getQueryBuilderFieldName())[0].binaryValue();
assertQueryBuilder(qbSource, queryBuilder);
}
// multiple percolator fields are allowed in the mapping, but only one field can be used at index
// time.
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(11)); // also includes _uid (1), type (2), source (1)
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);
}
public void testJoinFieldSet() throws Exception {
String parentMapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("parent_type")
.endObject()
.endObject()
.string();
String childMapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("child_type")
.startObject("_parent")
.field("type", "parent_type")
.endObject()
.endObject()
.endObject()
.string();
IndexService indexService = createIndex("test");
indexService
.mapperService()
.merge(
"parent_type",
new CompressedXContent(parentMapping),
MergeReason.MAPPING_UPDATE,
false);
indexService
.mapperService()
.merge(
"child_type", new CompressedXContent(childMapping), MergeReason.MAPPING_UPDATE, false);
// Indexing parent doc:
DocumentMapper parentDocMapper = indexService.mapperService().documentMapper("parent_type");
ParsedDocument doc =
parentDocMapper.parse(
SourceToParse.source("test", "parent_type", "1122", new BytesArray("{}")));
assertEquals(1, getNumberOfFieldWithParentPrefix(doc.rootDoc()));
assertEquals("1122", doc.rootDoc().getBinaryValue("_parent#parent_type").utf8ToString());
// Indexing child doc:
DocumentMapper childDocMapper = indexService.mapperService().documentMapper("child_type");
doc =
childDocMapper.parse(
SourceToParse.source("test", "child_type", "1", new BytesArray("{}")).parent("1122"));
assertEquals(1, getNumberOfFieldWithParentPrefix(doc.rootDoc()));
assertEquals("1122", doc.rootDoc().getBinaryValue("_parent#parent_type").utf8ToString());
}
@Test
public void testDynamicFalse() throws IOException {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.field("dynamic", "false")
.startObject("properties")
.startObject("field1")
.field("type", "string")
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper defaultMapper = MapperTestUtils.newParser().parse(mapping);
ParsedDocument doc =
defaultMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("field1", "value1")
.field("field2", "value2")
.bytes());
assertThat(doc.rootDoc().get("field1"), equalTo("value1"));
assertThat(doc.rootDoc().get("field2"), nullValue());
}
public void testNoDocValues() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("properties")
.startObject("field")
.field("type", "ip")
.field("doc_values", false)
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc =
mapper.parse(
"test",
"type",
"1",
XContentFactory.jsonBuilder().startObject().field("field", "::1").endObject().bytes());
IndexableField[] fields = doc.rootDoc().getFields("field");
assertEquals(1, fields.length);
IndexableField pointField = fields[0];
assertEquals(1, pointField.fieldType().pointDimensionCount());
assertEquals(
new BytesRef(InetAddressPoint.encode(InetAddresses.forString("::1"))),
pointField.binaryValue());
}
public void testDefaultDisabledIndexMapper() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.endObject()
.endObject()
.string();
DocumentMapper docMapper =
createIndex("test").mapperService().documentMapperParser().parse(mapping);
IndexFieldMapper indexMapper = docMapper.rootMapper(IndexFieldMapper.class);
assertThat(indexMapper.enabled(), equalTo(false));
ParsedDocument doc =
docMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("field", "value")
.endObject()
.bytes());
assertThat(doc.rootDoc().get("_index"), nullValue());
assertThat(doc.rootDoc().get("field"), equalTo("value"));
}
private Fields generateTermVectorsFromDoc(TermVectorRequest request, boolean doAllFields)
throws IOException {
// parse the document, at the moment we do update the mapping, just like percolate
ParsedDocument parsedDocument =
parseDocument(indexShard.shardId().getIndex(), request.type(), request.doc());
// select the right fields and generate term vectors
ParseContext.Document doc = parsedDocument.rootDoc();
Collection<String> seenFields = new HashSet<>();
Collection<GetField> getFields = new HashSet<>();
for (IndexableField field : doc.getFields()) {
FieldMapper fieldMapper = indexShard.mapperService().smartNameFieldMapper(field.name());
if (seenFields.contains(field.name())) {
continue;
} else {
seenFields.add(field.name());
}
if (!isValidField(fieldMapper)) {
continue;
}
if (request.selectedFields() == null
&& !doAllFields
&& !fieldMapper.fieldType().storeTermVectors()) {
continue;
}
if (request.selectedFields() != null && !request.selectedFields().contains(field.name())) {
continue;
}
String[] values = doc.getValues(field.name());
getFields.add(new GetField(field.name(), Arrays.asList((Object[]) values)));
}
return generateTermVectors(getFields, request.offsets(), request.perFieldAnalyzer());
}
@Override
public void doTestNoDocValues(String type) throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("properties")
.startObject("field")
.field("type", type)
.field("doc_values", false)
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc =
mapper.parse(
"test",
"type",
"1",
XContentFactory.jsonBuilder().startObject().field("field", 123).endObject().bytes());
IndexableField[] fields = doc.rootDoc().getFields("field");
assertEquals(1, fields.length);
IndexableField pointField = fields[0];
assertEquals(1, pointField.fieldType().pointDimensionCount());
assertEquals(123, pointField.numericValue().doubleValue(), 0d);
}
public void testJoinFieldNotSet() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.endObject()
.endObject()
.string();
DocumentMapper docMapper =
createIndex("test")
.mapperService()
.documentMapperParser()
.parse("type", new CompressedXContent(mapping));
ParsedDocument doc =
docMapper.parse(
SourceToParse.source(
"test",
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("x_field", "x_value")
.endObject()
.bytes()));
assertEquals(0, getNumberOfFieldWithParentPrefix(doc.rootDoc()));
}
public void testDisablingBackcompat() throws Exception {
// before 1.5, disabling happened by setting index:no
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_field_names")
.field("index", "no")
.endObject()
.endObject()
.endObject()
.string();
Settings indexSettings =
ImmutableSettings.builder()
.put(IndexMetaData.SETTING_VERSION_CREATED, Version.V_1_4_2.id)
.build();
DocumentMapper docMapper =
createIndex("test", indexSettings).mapperService().documentMapperParser().parse(mapping);
FieldNamesFieldMapper fieldNamesMapper = docMapper.rootMapper(FieldNamesFieldMapper.class);
assertFalse(fieldNamesMapper.enabled());
ParsedDocument doc =
docMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("field", "value")
.endObject()
.bytes());
assertNull(doc.rootDoc().get("_field_names"));
}
@Test
public void testDynamicTrue() throws IOException {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.field("dynamic", "true")
.startObject("properties")
.startObject("field1")
.field("type", "string")
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper defaultMapper =
createIndex("test").mapperService().documentMapperParser().parse(mapping);
ParsedDocument doc =
defaultMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("field1", "value1")
.field("field2", "value2")
.bytes());
assertThat(doc.rootDoc().get("field1"), equalTo("value1"));
assertThat(doc.rootDoc().get("field2"), equalTo("value2"));
}
public void testPercolatorFieldMapper_noQuery() throws Exception {
addQueryMapping();
ParsedDocument doc =
mapperService
.documentMapper(typeName)
.parse(
"test",
typeName,
"1",
XContentFactory.jsonBuilder().startObject().endObject().bytes());
assertThat(doc.rootDoc().getFields(fieldType.getQueryBuilderFieldName()).length, equalTo(0));
try {
mapperService
.documentMapper(typeName)
.parse(
"test",
typeName,
"1",
XContentFactory.jsonBuilder().startObject().nullField(fieldName).endObject().bytes());
} catch (MapperParsingException e) {
assertThat(
e.getDetailedMessage(), containsString("query malformed, must start with start_object"));
}
}
public void testDynamicFalse() throws IOException {
String mapping =
jsonBuilder()
.startObject()
.startObject("type")
.field("dynamic", "false")
.startObject("properties")
.startObject("field1")
.field("type", "text")
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper defaultMapper =
createIndex("test")
.mapperService()
.documentMapperParser()
.parse("type", new CompressedXContent(mapping));
ParsedDocument doc =
defaultMapper.parse(
"test",
"type",
"1",
jsonBuilder()
.startObject()
.field("field1", "value1")
.field("field2", "value2")
.bytes());
assertThat(doc.rootDoc().get("field1"), equalTo("value1"));
assertThat(doc.rootDoc().get("field2"), nullValue());
}
public void testCompressEnabled() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_source")
.field("compress", true)
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper documentMapper =
createIndex("test", settings).mapperService().documentMapperParser().parse(mapping);
ParsedDocument doc =
documentMapper.parse(
"test",
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("field1", "value1")
.field("field2", "value2")
.endObject()
.bytes());
BytesRef bytes = doc.rootDoc().getBinaryValue("_source");
assertThat(CompressorFactory.isCompressed(new BytesArray(bytes)), equalTo(true));
}
public void testDisabled() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_field_names")
.field("enabled", false)
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper docMapper =
createIndex("test").mapperService().documentMapperParser().parse(mapping);
FieldNamesFieldMapper fieldNamesMapper = docMapper.rootMapper(FieldNamesFieldMapper.class);
assertFalse(fieldNamesMapper.enabled());
ParsedDocument doc =
docMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("field", "value")
.endObject()
.bytes());
assertNull(doc.rootDoc().get("_field_names"));
}
public void testNotIndexed() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("properties")
.startObject("field")
.field("type", "ip")
.field("index", false)
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc =
mapper.parse(
"test",
"type",
"1",
XContentFactory.jsonBuilder().startObject().field("field", "::1").endObject().bytes());
IndexableField[] fields = doc.rootDoc().getFields("field");
assertEquals(1, fields.length);
IndexableField dvField = fields[0];
assertEquals(DocValuesType.SORTED_SET, dvField.fieldType().docValuesType());
}
public void testCustomSettingsBackcompat() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_index")
.field("enabled", true)
.field("store", "yes")
.endObject()
.endObject()
.endObject()
.string();
Settings indexSettings =
Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.V_1_4_2.id).build();
DocumentMapper docMapper =
createIndex("test", indexSettings).mapperService().documentMapperParser().parse(mapping);
IndexFieldMapper indexMapper = docMapper.rootMapper(IndexFieldMapper.class);
assertThat(indexMapper.enabled(), equalTo(true));
assertThat(indexMapper.fieldType().stored(), equalTo(true));
ParsedDocument doc =
docMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("field", "value")
.endObject()
.bytes());
assertThat(doc.rootDoc().get("_index"), equalTo("test"));
assertThat(doc.rootDoc().get("field"), equalTo("value"));
}
@Test
public void testLonLatArrayArrayStored() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("properties")
.startObject("point")
.field("type", "geo_point")
.field("lat_lon", true)
.field("store", "yes")
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper defaultMapper = MapperTestUtils.newParser().parse(mapping);
ParsedDocument doc =
defaultMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.startArray("point")
.startArray()
.value(1.3)
.value(1.2)
.endArray()
.startArray()
.value(1.5)
.value(1.4)
.endArray()
.endArray()
.endObject()
.bytes());
assertThat(doc.rootDoc().getFields("point.lat").length, equalTo(2));
assertThat(doc.rootDoc().getFields("point.lon").length, equalTo(2));
assertThat(doc.rootDoc().getFields("point.lat")[0].numericValue().doubleValue(), equalTo(1.2));
assertThat(doc.rootDoc().getFields("point.lon")[0].numericValue().doubleValue(), equalTo(1.3));
assertThat(doc.rootDoc().getFields("point")[0].stringValue(), equalTo("1.2,1.3"));
assertThat(doc.rootDoc().getFields("point.lat")[1].numericValue().doubleValue(), equalTo(1.4));
assertThat(doc.rootDoc().getFields("point.lon")[1].numericValue().doubleValue(), equalTo(1.5));
assertThat(doc.rootDoc().getFields("point")[1].stringValue(), equalTo("1.4,1.5"));
}
public void testIgnoreMalformed() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("properties")
.startObject("field")
.field("type", "ip")
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ThrowingRunnable runnable =
() ->
mapper.parse(
"test",
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("field", ":1")
.endObject()
.bytes());
MapperParsingException e = expectThrows(MapperParsingException.class, runnable);
assertThat(e.getCause().getMessage(), containsString("':1' is not an IP string literal"));
mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("properties")
.startObject("field")
.field("type", "ip")
.field("ignore_malformed", true)
.endObject()
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper mapper2 = parser.parse("type", new CompressedXContent(mapping));
ParsedDocument doc =
mapper2.parse(
"test",
"type",
"1",
XContentFactory.jsonBuilder().startObject().field("field", ":1").endObject().bytes());
IndexableField[] fields = doc.rootDoc().getFields("field");
assertEquals(0, fields.length);
}
public void testIncludeInObjectBackcompat() throws Exception {
String mapping =
jsonBuilder().startObject().startObject("type").endObject().endObject().string();
Settings settings =
Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.V_1_4_2.id).build();
DocumentMapper docMapper =
createIndex("test", settings).mapperService().documentMapperParser().parse(mapping);
ParsedDocument doc =
docMapper.parse(
"test",
"type",
"1",
XContentFactory.jsonBuilder().startObject().field("_all", "foo").endObject().bytes());
assertNull(doc.rootDoc().get("_all"));
AllField field = (AllField) doc.rootDoc().getField("_all");
// the backcompat behavior is actually ignoring directly specifying _all
assertFalse(field.getAllEntries().fields().iterator().hasNext());
}
@Test
public void testSizeEnabled() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_size")
.field("enabled", true)
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper docMapper = MapperTests.newParser().parse(mapping);
BytesReference source =
XContentFactory.jsonBuilder().startObject().field("field", "value").endObject().bytes();
ParsedDocument doc = docMapper.parse(SourceToParse.source(source).type("type").id("1"));
assertThat(doc.rootDoc().getField("_size").fieldType().stored(), equalTo(false));
assertThat(
doc.rootDoc().getField("_size").tokenStream(docMapper.indexAnalyzer()), notNullValue());
}
@Test
public void testSimpleDisabled() throws Exception {
String mapping =
XContentFactory.jsonBuilder().startObject().startObject("type").endObject().string();
DocumentMapper docMapper = MapperTests.newParser().parse(mapping);
byte[] source =
XContentFactory.jsonBuilder()
.startObject()
.field("field", "value")
.endObject()
.copiedBytes();
ParsedDocument doc =
docMapper.parse(SourceToParse.source(source).type("type").id("1").timestamp(1));
assertThat(doc.rootDoc().getFieldable("_timestamp"), equalTo(null));
}
@Test
public void testSizeNotSet() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.endObject()
.endObject()
.string();
DocumentMapper docMapper = MapperTests.newParser().parse(mapping);
BytesReference source =
XContentFactory.jsonBuilder().startObject().field("field", "value").endObject().bytes();
ParsedDocument doc = docMapper.parse(SourceToParse.source(source).type("type").id("1"));
assertThat(doc.rootDoc().getField("_size"), nullValue());
}
public void initialize(Engine.Searcher docSearcher, ParsedDocument parsedDocument) {
this.docSearcher = docSearcher;
IndexReader indexReader = docSearcher.reader();
LeafReaderContext atomicReaderContext = indexReader.leaves().get(0);
LeafSearchLookup leafLookup = lookup().getLeafSearchLookup(atomicReaderContext);
leafLookup.setDocument(0);
leafLookup.source().setSource(parsedDocument.source());
Map<String, SearchHitField> fields = new HashMap<>();
for (IndexableField field : parsedDocument.rootDoc().getFields()) {
fields.put(field.name(), new InternalSearchHitField(field.name(), Collections.emptyList()));
}
hitContext()
.reset(
new InternalSearchHit(0, "unknown", new StringText(parsedDocument.type()), fields),
atomicReaderContext,
0,
docSearcher.searcher());
}
@Test
public void testIncludeExclude() throws Exception {
String mapping =
XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_source")
.field("includes", new String[] {"path1*"})
.endObject()
.endObject()
.endObject()
.string();
DocumentMapper documentMapper = MapperTests.newParser().parse(mapping);
ParsedDocument doc =
documentMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.startObject("path1")
.field("field1", "value1")
.endObject()
.startObject("path2")
.field("field2", "value2")
.endObject()
.endObject()
.copiedBytes());
Fieldable sourceField = doc.rootDoc().getFieldable("_source");
Map<String, Object> sourceAsMap =
XContentFactory.xContent(XContentType.JSON)
.createParser(
sourceField.getBinaryValue(),
sourceField.getBinaryOffset(),
sourceField.getBinaryLength())
.mapAndClose();
assertThat(sourceAsMap.containsKey("path1"), equalTo(true));
assertThat(sourceAsMap.containsKey("path2"), equalTo(false));
}
public void testQueryWithRewrite() throws Exception {
addQueryMapping();
client().prepareIndex("remote", "type", "1").setSource("field", "value").get();
QueryBuilder queryBuilder =
termsLookupQuery("field", new TermsLookup("remote", "type", "1", "field"));
ParsedDocument doc =
mapperService
.documentMapper(typeName)
.parse(
"test",
typeName,
"1",
XContentFactory.jsonBuilder()
.startObject()
.field(fieldName, queryBuilder)
.endObject()
.bytes());
BytesRef qbSource =
doc.rootDoc().getFields(fieldType.getQueryBuilderFieldName())[0].binaryValue();
assertQueryBuilder(qbSource, queryBuilder.rewrite(indexService.newQueryShardContext()));
}