Пример #1
0
  @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();
    }
  }
Пример #2
0
  @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]"));
  }
Пример #3
0
  @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));
    }
  }