How to use

CountRequest

in

org.elasticsearch.action.count

public CountRequestBuilder(Client client, JsonToString<JsonInput> jsonToString, StringToJson<JsonOutput> stringToJson) {
  super(client, new CountRequest(), jsonToString, stringToJson);
}

public CountRequestBuilder<JsonInput, JsonOutput> indices(String... indices) {
  request.indices(indices);
  return this;
}

/**
 * The minimum score of the documents to include in the count. Defaults to <tt>-1</tt> which means all
 * documents will be included in the count.
 */
public CountRequestBuilder setMinScore(float minScore) {
  request.minScore(minScore);
  return this;
}

@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {
  CountRequest countRequest = new CountRequest(Strings.splitStringByCommaToArray(request.param("index")));
  countRequest.indicesOptions(IndicesOptions.fromRequest(request, countRequest.indicesOptions()));
  if (RestActions.hasBodyContent(request)) {
    countRequest.source(RestActions.getRestContent(request));
  } else {
    QuerySourceBuilder querySourceBuilder = RestActions.parseQuerySource(request);
    if (querySourceBuilder != null) {
      countRequest.source(querySourceBuilder);
  countRequest.routing(request.param("routing"));
  countRequest.minScore(request.paramAsFloat("min_score", DEFAULT_MIN_SCORE));
  countRequest.types(Strings.splitStringByCommaToArray(request.param("type")));
  countRequest.preference(request.param("preference"));
    throw new IllegalArgumentException("terminateAfter must be > 0");
  } else if (terminateAfter > 0) {
    countRequest.terminateAfter(terminateAfter);
  client.search(countRequest.toSearchRequest(), new RestBuilderListener<SearchResponse>(channel) {
    @Override
    public RestResponse buildResponse(SearchResponse response, XContentBuilder builder) throws Exception {

  public SearchRequest toSearchRequest() {
    SearchRequest searchRequest = new SearchRequest(indices());
    searchRequest.indicesOptions(indicesOptions());
    searchRequest.types(types());
    searchRequest.routing(routing());
    searchRequest.preference(preference());
    searchRequest.source(source());
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.size(0);
    if (minScore() != DEFAULT_MIN_SCORE) {
      searchSourceBuilder.minScore(minScore());
    }
    if (terminateAfter() != DEFAULT_TERMINATE_AFTER) {
      searchSourceBuilder.terminateAfter(terminateAfter());
    }
    searchRequest.extraSource(searchSourceBuilder);
    return searchRequest;
  }
}

@Override
public void doRequest(final RestRequest request, final RestChannel channel, final Client client) {
  String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
  CountRequest countRequest = new CountRequest(indices);
  String source = request.param("source");
  if (source != null) {
    countRequest.source(source);
  } else {
    QuerySourceBuilder querySourceBuilder = RestActions.parseQuerySource(request);
    if (querySourceBuilder != null) {
      countRequest.source(querySourceBuilder);
    }
  }
  client.search(countRequest.toSearchRequest(), new RestResponseListener<SearchResponse>(channel) {
    @Override
    public RestResponse buildResponse(SearchResponse countResponse) throws Exception {
      return RestTable.buildResponse(buildTable(request, countResponse), channel);
    }
  });
}

/**
 * The routing values to control the shards that the search will be executed on.
 */
public CountRequestBuilder setRouting(String... routing) {
  request.routing(routing);
  return this;
}

/**
 * The types of documents the query will run against. Defaults to all types.
 */
public CountRequestBuilder setTypes(String... types) {
  request.types(types);
  return this;
}

/**
 * Sets the preference to execute the search. Defaults to randomize across shards. Can be set to
 * <tt>_local</tt> to prefer local shards, <tt>_primary</tt> to execute only on primary shards,
 * _shards:x,y to operate on shards x &amp; y, or a custom value, which guarantees that the same order
 * will be used across different requests.
 */
public CountRequestBuilder setPreference(String preference) {
  request.preference(preference);
  return this;
}

/**
 * The query source to execute.
 */
public CountRequestBuilder setSource(byte[] querySource) {
  request.source(querySource);
  return this;
}

public CountRequestBuilder<JsonInput, JsonOutput> queryBuilder(QueryBuilder queryBuilder) {
  request.query(queryBuilder);
  return this;
}

/**
 * A comma separated list of routing values to control the shards the search will be executed on.
 */
public CountRequestBuilder setRouting(String routing) {
  request.routing(routing);
  return this;
}

public CountRequestBuilder<JsonInput, JsonOutput> types(String... types) {
  request.types(types);
  return this;
}

public CountRequestBuilder<JsonInput, JsonOutput> preference(String preference) {
  request.preference(preference);
  return this;
}

@Override
protected CountRequest beforeExecute(CountRequest request) {
  if (sourceBuilder != null) {
    request.source(sourceBuilder);
  }
  return request;
}

public CountRequestBuilder<JsonInput, JsonOutput> query(JsonInput query) {
  request.query(jsonToString(query));
  return this;
}

public CountRequestBuilder(ElasticsearchClient client, CountAction action) {
  super(client, action, new CountRequest());
}

public CountRequestBuilder<JsonInput, JsonOutput> routing(String... routing) {
  request.routing(routing);
  return this;
}

public CountRequestBuilder<JsonInput, JsonOutput> minScore(float minScore) {
  request.minScore(minScore);
  return this;
}

/**
 * The source to execute.
 */
public CountRequest source(byte[] querySource) {
  return source(querySource, 0, querySource.length);
}