@Override
public SqlElasticDeleteByQueryRequestBuilder explain() throws SqlParseException {
	this.request = new DeleteByQueryRequestBuilder(client, DeleteByQueryAction.INSTANCE);

	setIndicesAndTypes();
	setWhere(delete.getWhere());

	// maximum number of processed documents
	if (delete.getRowCount() > -1) {
		request.size(delete.getRowCount());
	}

	// set conflicts param
	updateRequestWithConflicts();

       SqlElasticDeleteByQueryRequestBuilder deleteByQueryRequestBuilder = new SqlElasticDeleteByQueryRequestBuilder(request);
	return deleteByQueryRequestBuilder;
}
 

@Override
public void deleteByQuery(List<String> indices, DeleteByQueryOptions options, Handler<AsyncResult<com.hubrick.vertx.elasticsearch.model.DeleteByQueryResponse>> resultHandler) {
    final DeleteByQueryRequestBuilder deleteByQueryRequestBuilder = new DeleteByQueryRequestBuilder(client, DeleteByQueryAction.INSTANCE);

    deleteByQueryRequestBuilder.source(indices.toArray(new String[indices.size()]));
    if (options != null) {
        populateSearchRequestBuilder(deleteByQueryRequestBuilder.source(), options);
        if (options.getMaxRetries() != null) deleteByQueryRequestBuilder.setMaxRetries(options.getMaxRetries());
        if (options.getSlices() != null) deleteByQueryRequestBuilder.setSlices(options.getSlices());
        if (options.getWaitForActiveShards() != null)
            deleteByQueryRequestBuilder.waitForActiveShards(ActiveShardCount.from(options.getWaitForActiveShards()));
        if (options.getConflicts() != null)
            deleteByQueryRequestBuilder.abortOnVersionConflict(Optional.ofNullable(options.getConflicts()).map(e -> !Conflicts.PROCEED.equals(e)).orElse(true));
        if (options.getRequestsPerSecond() != null)
            deleteByQueryRequestBuilder.setRequestsPerSecond(options.getRequestsPerSecond());
    }

    deleteByQueryRequestBuilder.execute(new ActionListener<BulkByScrollResponse>() {
        @Override
        public void onResponse(BulkByScrollResponse deleteByQueryResponse) {
            resultHandler.handle(Future.succeededFuture(mapToDeleteByQueryResponse(deleteByQueryResponse)));
        }

        @Override
        public void onFailure(Exception t) {
            handleFailure(resultHandler, t);
        }
    });
}
 

public void clearIndices(Elasticsearch7SearchIndex searchIndex) throws Exception {
    String[] indices = searchIndex.getClient().admin().indices().prepareGetIndex().execute().get().indices();
    for (String index : indices) {
        if (index.startsWith(ES_INDEX_NAME) || index.startsWith(ES_EXTENDED_DATA_INDEX_NAME_PREFIX)) {
            LOGGER.info("clearing test index: %s", index);
            BulkByScrollResponse response = new DeleteByQueryRequestBuilder(searchIndex.getClient(), DeleteByQueryAction.INSTANCE)
                .source(index)
                .filter(QueryBuilders.matchAllQuery())
                .get();
            LOGGER.info("removed %d documents", response.getDeleted());
        }
    }
}
 

/**
 * Delete all data using DeleteByQuery.
 * @param indexName the index to delete
 * @param typeName the type to delete
 */
public static void deleteQuery(String indexName, String typeName) {

       DeleteByQueryRequestBuilder deleteQueryBuilder = new DeleteByQueryRequestBuilder(client, DeleteByQueryAction.INSTANCE);
       deleteQueryBuilder.request().indices(indexName);
       if (typeName!=null) {
           deleteQueryBuilder.request().getSearchRequest().types(typeName);
       }
       deleteQueryBuilder.filter(QueryBuilders.matchAllQuery());
       deleteQueryBuilder.get();
       System.out.println(String.format("Deleted index %s and type %s", indexName, typeName));

   }
 

public SqlElasticDeleteByQueryRequestBuilder(DeleteByQueryRequestBuilder deleteByQueryRequestBuilder) {
    this.deleteByQueryRequestBuilder = deleteByQueryRequestBuilder;
}