@Test
public void testWithDeletes() throws Exception {
String indexName = "xyz";
assertAcked(
prepareCreate(indexName)
.addMapping("parent")
.addMapping("child", "_parent", "type=parent", "count", "type=long"));
List<IndexRequestBuilder> requests = new ArrayList<>();
requests.add(client().prepareIndex(indexName, "parent", "1").setSource("{}"));
requests.add(
client().prepareIndex(indexName, "child", "0").setParent("1").setSource("count", 1));
requests.add(
client().prepareIndex(indexName, "child", "1").setParent("1").setSource("count", 1));
requests.add(
client().prepareIndex(indexName, "child", "2").setParent("1").setSource("count", 1));
requests.add(
client().prepareIndex(indexName, "child", "3").setParent("1").setSource("count", 1));
indexRandom(true, requests);
for (int i = 0; i < 10; i++) {
SearchResponse searchResponse =
client()
.prepareSearch(indexName)
.addAggregation(
children("children")
.childType("child")
.subAggregation(sum("counts").field("count")))
.get();
assertNoFailures(searchResponse);
Children children = searchResponse.getAggregations().get("children");
assertThat(children.getDocCount(), equalTo(4l));
Sum count = children.getAggregations().get("counts");
assertThat(count.getValue(), equalTo(4.));
String idToUpdate = Integer.toString(randomInt(3));
UpdateResponse updateResponse =
client()
.prepareUpdate(indexName, "child", idToUpdate)
.setParent("1")
.setDoc("count", 1)
.get();
assertThat(updateResponse.getVersion(), greaterThan(1l));
refresh();
}
}
@Test
public void testRequiredRoutingMapping_variousAPIs() throws Exception {
client()
.admin()
.indices()
.prepareCreate("test")
.addAlias(new Alias("alias"))
.addMapping(
"type1",
XContentFactory.jsonBuilder()
.startObject()
.startObject("type1")
.startObject("_routing")
.field("required", true)
.endObject()
.endObject()
.endObject())
.execute()
.actionGet();
ensureGreen();
logger.info("--> indexing with id [1], and routing [0]");
client()
.prepareIndex(indexOrAlias(), "type1", "1")
.setRouting("0")
.setSource("field", "value1")
.get();
logger.info("--> indexing with id [2], and routing [0]");
client()
.prepareIndex(indexOrAlias(), "type1", "2")
.setRouting("0")
.setSource("field", "value2")
.setRefresh(true)
.get();
logger.info("--> verifying get with id [1] with routing [0], should succeed");
assertThat(
client()
.prepareGet(indexOrAlias(), "type1", "1")
.setRouting("0")
.execute()
.actionGet()
.isExists(),
equalTo(true));
logger.info("--> verifying get with id [1], with no routing, should fail");
try {
client().prepareGet(indexOrAlias(), "type1", "1").get();
fail();
} catch (RoutingMissingException e) {
assertThat(e.getMessage(), equalTo("routing is required for [test]/[type1]/[1]"));
}
logger.info("--> verifying explain with id [2], with routing [0], should succeed");
ExplainResponse explainResponse =
client()
.prepareExplain(indexOrAlias(), "type1", "2")
.setQuery(QueryBuilders.matchAllQuery())
.setRouting("0")
.get();
assertThat(explainResponse.isExists(), equalTo(true));
assertThat(explainResponse.isMatch(), equalTo(true));
logger.info("--> verifying explain with id [2], with no routing, should fail");
try {
client()
.prepareExplain(indexOrAlias(), "type1", "2")
.setQuery(QueryBuilders.matchAllQuery())
.get();
fail();
} catch (RoutingMissingException e) {
assertThat(e.getMessage(), equalTo("routing is required for [test]/[type1]/[2]"));
}
logger.info("--> verifying term vector with id [1], with routing [0], should succeed");
TermVectorResponse termVectorResponse =
client().prepareTermVector(indexOrAlias(), "type1", "1").setRouting("0").get();
assertThat(termVectorResponse.isExists(), equalTo(true));
assertThat(termVectorResponse.getId(), equalTo("1"));
try {
client().prepareTermVector(indexOrAlias(), "type1", "1").get();
fail();
} catch (RoutingMissingException e) {
assertThat(e.getMessage(), equalTo("routing is required for [test]/[type1]/[1]"));
}
UpdateResponse updateResponse =
client()
.prepareUpdate(indexOrAlias(), "type1", "1")
.setRouting("0")
.setDoc("field1", "value1")
.get();
assertThat(updateResponse.getId(), equalTo("1"));
assertThat(updateResponse.getVersion(), equalTo(2l));
try {
client().prepareUpdate(indexOrAlias(), "type1", "1").setDoc("field1", "value1").get();
fail();
} catch (RoutingMissingException e) {
assertThat(e.getMessage(), equalTo("routing is required for [test]/[type1]/[1]"));
}
logger.info("--> verifying mget with ids [1,2], with routing [0], should succeed");
MultiGetResponse multiGetResponse =
client()
.prepareMultiGet()
.add(new MultiGetRequest.Item(indexOrAlias(), "type1", "1").routing("0"))
.add(new MultiGetRequest.Item(indexOrAlias(), "type1", "2").routing("0"))
.get();
assertThat(multiGetResponse.getResponses().length, equalTo(2));
assertThat(multiGetResponse.getResponses()[0].isFailed(), equalTo(false));
assertThat(multiGetResponse.getResponses()[0].getResponse().getId(), equalTo("1"));
assertThat(multiGetResponse.getResponses()[1].isFailed(), equalTo(false));
assertThat(multiGetResponse.getResponses()[1].getResponse().getId(), equalTo("2"));
logger.info("--> verifying mget with ids [1,2], with no routing, should fail");
multiGetResponse =
client()
.prepareMultiGet()
.add(new MultiGetRequest.Item(indexOrAlias(), "type1", "1"))
.add(new MultiGetRequest.Item(indexOrAlias(), "type1", "2"))
.get();
assertThat(multiGetResponse.getResponses().length, equalTo(2));
assertThat(multiGetResponse.getResponses()[0].isFailed(), equalTo(true));
assertThat(multiGetResponse.getResponses()[0].getFailure().getId(), equalTo("1"));
assertThat(
multiGetResponse.getResponses()[0].getFailure().getMessage(),
equalTo("routing is required for [test]/[type1]/[1]"));
assertThat(multiGetResponse.getResponses()[1].isFailed(), equalTo(true));
assertThat(multiGetResponse.getResponses()[1].getFailure().getId(), equalTo("2"));
assertThat(
multiGetResponse.getResponses()[1].getFailure().getMessage(),
equalTo("routing is required for [test]/[type1]/[2]"));
MultiTermVectorsResponse multiTermVectorsResponse =
client()
.prepareMultiTermVectors()
.add(new TermVectorRequest(indexOrAlias(), "type1", "1").routing("0"))
.add(new TermVectorRequest(indexOrAlias(), "type1", "2").routing("0"))
.get();
assertThat(multiTermVectorsResponse.getResponses().length, equalTo(2));
assertThat(multiTermVectorsResponse.getResponses()[0].getId(), equalTo("1"));
assertThat(multiTermVectorsResponse.getResponses()[0].isFailed(), equalTo(false));
assertThat(multiTermVectorsResponse.getResponses()[0].getResponse().getId(), equalTo("1"));
assertThat(multiTermVectorsResponse.getResponses()[0].getResponse().isExists(), equalTo(true));
assertThat(multiTermVectorsResponse.getResponses()[1].getId(), equalTo("2"));
assertThat(multiTermVectorsResponse.getResponses()[1].isFailed(), equalTo(false));
assertThat(multiTermVectorsResponse.getResponses()[1].getResponse().getId(), equalTo("2"));
assertThat(multiTermVectorsResponse.getResponses()[1].getResponse().isExists(), equalTo(true));
multiTermVectorsResponse =
client()
.prepareMultiTermVectors()
.add(new TermVectorRequest(indexOrAlias(), "type1", "1"))
.add(new TermVectorRequest(indexOrAlias(), "type1", "2"))
.get();
assertThat(multiTermVectorsResponse.getResponses().length, equalTo(2));
assertThat(multiTermVectorsResponse.getResponses()[0].getId(), equalTo("1"));
assertThat(multiTermVectorsResponse.getResponses()[0].isFailed(), equalTo(true));
assertThat(
multiTermVectorsResponse.getResponses()[0].getFailure().getMessage(),
equalTo("routing is required for [test]/[type1]/[1]"));
assertThat(multiTermVectorsResponse.getResponses()[0].getResponse(), nullValue());
assertThat(multiTermVectorsResponse.getResponses()[1].getId(), equalTo("2"));
assertThat(multiTermVectorsResponse.getResponses()[1].isFailed(), equalTo(true));
assertThat(multiTermVectorsResponse.getResponses()[1].getResponse(), nullValue());
assertThat(
multiTermVectorsResponse.getResponses()[1].getFailure().getMessage(),
equalTo("routing is required for [test]/[type1]/[2]"));
}
@Test
public void testUpdate() throws Exception {
createIndex();
ensureGreen();
try {
client()
.prepareUpdate("test", "type1", "1")
.setScript("ctx._source.field++", ScriptService.ScriptType.INLINE)
.execute()
.actionGet();
fail();
} catch (DocumentMissingException e) {
// all is well
}
client().prepareIndex("test", "type1", "1").setSource("field", 1).execute().actionGet();
UpdateResponse updateResponse =
client()
.prepareUpdate("test", "type1", "1")
.setScript("ctx._source.field += 1", ScriptService.ScriptType.INLINE)
.execute()
.actionGet();
assertThat(updateResponse.getVersion(), equalTo(2L));
assertFalse(updateResponse.isCreated());
for (int i = 0; i < 5; i++) {
GetResponse getResponse = client().prepareGet("test", "type1", "1").execute().actionGet();
assertThat(getResponse.getSourceAsMap().get("field").toString(), equalTo("2"));
}
updateResponse =
client()
.prepareUpdate("test", "type1", "1")
.setScript("ctx._source.field += count", ScriptService.ScriptType.INLINE)
.addScriptParam("count", 3)
.execute()
.actionGet();
assertThat(updateResponse.getVersion(), equalTo(3L));
assertFalse(updateResponse.isCreated());
for (int i = 0; i < 5; i++) {
GetResponse getResponse = client().prepareGet("test", "type1", "1").execute().actionGet();
assertThat(getResponse.getSourceAsMap().get("field").toString(), equalTo("5"));
}
// check noop
updateResponse =
client()
.prepareUpdate("test", "type1", "1")
.setScript("ctx.op = 'none'", ScriptService.ScriptType.INLINE)
.execute()
.actionGet();
assertThat(updateResponse.getVersion(), equalTo(3L));
assertFalse(updateResponse.isCreated());
for (int i = 0; i < 5; i++) {
GetResponse getResponse = client().prepareGet("test", "type1", "1").execute().actionGet();
assertThat(getResponse.getSourceAsMap().get("field").toString(), equalTo("5"));
}
// check delete
updateResponse =
client()
.prepareUpdate("test", "type1", "1")
.setScript("ctx.op = 'delete'", ScriptService.ScriptType.INLINE)
.execute()
.actionGet();
assertThat(updateResponse.getVersion(), equalTo(4L));
assertFalse(updateResponse.isCreated());
for (int i = 0; i < 5; i++) {
GetResponse getResponse = client().prepareGet("test", "type1", "1").execute().actionGet();
assertThat(getResponse.isExists(), equalTo(false));
}
// check TTL is kept after an update without TTL
client()
.prepareIndex("test", "type1", "2")
.setSource("field", 1)
.setTTL(86400000L)
.setRefresh(true)
.execute()
.actionGet();
GetResponse getResponse =
client().prepareGet("test", "type1", "2").setFields("_ttl").execute().actionGet();
long ttl = ((Number) getResponse.getField("_ttl").getValue()).longValue();
assertThat(ttl, greaterThan(0L));
client()
.prepareUpdate("test", "type1", "2")
.setScript("ctx._source.field += 1", ScriptService.ScriptType.INLINE)
.execute()
.actionGet();
getResponse = client().prepareGet("test", "type1", "2").setFields("_ttl").execute().actionGet();
ttl = ((Number) getResponse.getField("_ttl").getValue()).longValue();
assertThat(ttl, greaterThan(0L));
// check TTL update
client()
.prepareUpdate("test", "type1", "2")
.setScript("ctx._ttl = 3600000", ScriptService.ScriptType.INLINE)
.execute()
.actionGet();
getResponse = client().prepareGet("test", "type1", "2").setFields("_ttl").execute().actionGet();
ttl = ((Number) getResponse.getField("_ttl").getValue()).longValue();
assertThat(ttl, greaterThan(0L));
assertThat(ttl, lessThanOrEqualTo(3600000L));
// check timestamp update
client()
.prepareIndex("test", "type1", "3")
.setSource("field", 1)
.setRefresh(true)
.execute()
.actionGet();
client()
.prepareUpdate("test", "type1", "3")
.setScript("ctx._timestamp = \"2009-11-15T14:12:12\"", ScriptService.ScriptType.INLINE)
.execute()
.actionGet();
getResponse =
client().prepareGet("test", "type1", "3").setFields("_timestamp").execute().actionGet();
long timestamp = ((Number) getResponse.getField("_timestamp").getValue()).longValue();
assertThat(timestamp, equalTo(1258294332000L));
// check fields parameter
client().prepareIndex("test", "type1", "1").setSource("field", 1).execute().actionGet();
updateResponse =
client()
.prepareUpdate("test", "type1", "1")
.setScript("ctx._source.field += 1", ScriptService.ScriptType.INLINE)
.setFields("_source", "field")
.execute()
.actionGet();
assertThat(updateResponse.getGetResult(), notNullValue());
assertThat(updateResponse.getGetResult().sourceRef(), notNullValue());
assertThat(updateResponse.getGetResult().field("field").getValue(), notNullValue());
// check updates without script
// add new field
client().prepareIndex("test", "type1", "1").setSource("field", 1).execute().actionGet();
updateResponse =
client()
.prepareUpdate("test", "type1", "1")
.setDoc(XContentFactory.jsonBuilder().startObject().field("field2", 2).endObject())
.execute()
.actionGet();
for (int i = 0; i < 5; i++) {
getResponse = client().prepareGet("test", "type1", "1").execute().actionGet();
assertThat(getResponse.getSourceAsMap().get("field").toString(), equalTo("1"));
assertThat(getResponse.getSourceAsMap().get("field2").toString(), equalTo("2"));
}
// change existing field
updateResponse =
client()
.prepareUpdate("test", "type1", "1")
.setDoc(XContentFactory.jsonBuilder().startObject().field("field", 3).endObject())
.execute()
.actionGet();
for (int i = 0; i < 5; i++) {
getResponse = client().prepareGet("test", "type1", "1").execute().actionGet();
assertThat(getResponse.getSourceAsMap().get("field").toString(), equalTo("3"));
assertThat(getResponse.getSourceAsMap().get("field2").toString(), equalTo("2"));
}
// recursive map
Map<String, Object> testMap = new HashMap<>();
Map<String, Object> testMap2 = new HashMap<>();
Map<String, Object> testMap3 = new HashMap<>();
testMap3.put("commonkey", testMap);
testMap3.put("map3", 5);
testMap2.put("map2", 6);
testMap.put("commonkey", testMap2);
testMap.put("map1", 8);
client().prepareIndex("test", "type1", "1").setSource("map", testMap).execute().actionGet();
updateResponse =
client()
.prepareUpdate("test", "type1", "1")
.setDoc(XContentFactory.jsonBuilder().startObject().field("map", testMap3).endObject())
.execute()
.actionGet();
for (int i = 0; i < 5; i++) {
getResponse = client().prepareGet("test", "type1", "1").execute().actionGet();
Map map1 = (Map) getResponse.getSourceAsMap().get("map");
assertThat(map1.size(), equalTo(3));
assertThat(map1.containsKey("map1"), equalTo(true));
assertThat(map1.containsKey("map3"), equalTo(true));
assertThat(map1.containsKey("commonkey"), equalTo(true));
Map map2 = (Map) map1.get("commonkey");
assertThat(map2.size(), equalTo(3));
assertThat(map2.containsKey("map1"), equalTo(true));
assertThat(map2.containsKey("map2"), equalTo(true));
assertThat(map2.containsKey("commonkey"), equalTo(true));
}
}