import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
@DeleteMapping(value = "/{id}")
public ResponseEntity delete(@PathVariable String id) throws IOException {
    LOG.info("Try to delete document {}", id);
    counterService.increment("counter.calls.document.id.delete");
    if (client.prepareDelete("steckbrief", "steckbrief", id).execute().actionGet().isFound()) {
        new DeleteByQueryRequestBuilder(client, DeleteByQueryAction.INSTANCE)
                .setIndices("changeset")
                .setTypes("changeset")
                .setQuery(QueryBuilders.matchQuery("document", id))
                .execute()
                .actionGet();
        LOG.info("Deleted document {} successfully", id);
        return ResponseEntity.noContent().build();
    }
    else {
        LOG.warn("Could not delete document {}", id);
        return ResponseEntity.notFound().build();
    }
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
public static String explain(ActionRequestBuilder actionRequest) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, SQLFeatureNotSupportedException {
	XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON).prettyPrint();

	if (actionRequest instanceof SearchRequestBuilder) {
		((SearchRequestBuilder) actionRequest).internalBuilder().toXContent(builder, ToXContent.EMPTY_PARAMS);
	} else if (actionRequest instanceof DeleteByQueryRequestBuilder) {
		// access private method to get the explain...
		DeleteByQueryRequestBuilder deleteRequest = ((DeleteByQueryRequestBuilder) actionRequest);
		Method method = deleteRequest.getClass().getDeclaredMethod("sourceBuilder");
		method.setAccessible(true);
		QuerySourceBuilder sourceBuilder = (QuerySourceBuilder) method.invoke(deleteRequest);
		sourceBuilder.toXContent(builder, ToXContent.EMPTY_PARAMS);
	} else {
		throw new SQLFeatureNotSupportedException(String.format("Failed to explain class %s", actionRequest.getClass().getName()));
	}

	return builder.string();
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
@Override
public void delete(String query, String type, EzSecurityToken userToken) throws TException {
    final Stopwatch watch = LoggingUtils.createStopWatch();

    final VisibilityFilterConfig filterConfig =
            new VisibilityFilterConfig(VISIBILITY_FIELD, EnumSet.of(Permission.READ, Permission.WRITE));

    final DeleteByQueryRequestBuilder builder = client.prepareDeleteByQuery(indexName).setQuery(
            QueryBuilders.filteredQuery(parseQuery(query), getVisibilityFilter(userToken, filterConfig)));

    if (!StringUtils.isEmpty(type)) {
        builder.setTypes(type);
    }
    builder.get();
    // Refresh immediately on deletes
    forceIndexRefresh();
    LoggingUtils.stopAndLogStopWatch(logger, watch, "Delete And Refresh");
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
private void deleteOldFiles(String repo, List<String> projectsUpdated) {
        String cutoffDate = DevSearchDateFormat.format(lastIndexDateForProjects);
		LOG.info("deleting all previously indexed files for {}::{} with cutoff {}",repo, projectsUpdated, cutoffDate);
        for (String projectName : projectsUpdated) {
            // Not terribly efficient, but terms query has a size limit.
            DeleteByQueryRequestBuilder deleteRequest = esClient.prepareDeleteByQuery(codeIndex)
                .setTypes(DOC_TYPE)
                .setQuery(QueryBuilders.boolQuery()
//                        .must(QueryBuilders.inQuery("project", projectsUpdated))
                        .must(QueryBuilders.termQuery("project", projectName))
                        .must(QueryBuilders.termQuery("repo", repo))
                        .mustNot(QueryBuilders.rangeQuery("lastIndexed").gte(cutoffDate)));
            DeleteByQueryResponse response = deleteRequest.execute().actionGet();
            checkForFailures(projectName, response);
        }
        LOG.info("done deleting all previously indexed files");
	}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
@Override
public Completable clearIndex(String indexName) {
	return Completable.create(sub -> {
		long start = System.currentTimeMillis();
		if (log.isDebugEnabled()) {
			log.debug("Clearing index {" + indexName + "}");
		}

		DeleteByQueryRequestBuilder builder = new DeleteByQueryRequestBuilder(getSearchClient(), DeleteByQueryAction.INSTANCE);
		builder.setIndices(indexName).setQuery(QueryBuilders.matchAllQuery()).execute().addListener(new ActionListener<DeleteByQueryResponse>() {
			public void onResponse(DeleteByQueryResponse response) {
				if (log.isDebugEnabled()) {
					log.debug("Clearing index {" + indexName + "}. Duration " + (System.currentTimeMillis() - start) + "[ms]");
				}
				sub.onComplete();
			};

			@Override
			public void onFailure(Throwable e) {
				if (e instanceof IndexNotFoundException) {
					if (log.isDebugEnabled()) {
						log.debug("Clearing index failed since the index does not exists. We ignore this error", e);
					}
					sub.onComplete();
				} else {
					log.error("Clearing index {" + indexName + "} failed. Duration " + (System.currentTimeMillis() - start) + "[ms]", e);
					sub.onError(e);
				}
			}
		});

	});
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
@Override
public DeleteByQueryRequestBuilder explain() throws SqlParseException {
	this.request = client.prepareDeleteByQuery();
	request.setListenerThreaded(false);

	setIndicesAndTypes();
	setWhere(delete.getWhere());
	return request;
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
public DeleteByQueryResponse deleteDocuments(String index, String type, String querySource) throws ElasticSearchException, EsServerException {
	
	DeleteByQueryRequestBuilder rb = getClient().prepareDeleteByQuery(index);
	rb.setQuery(querySource);
	rb.setTypes(type);
	return rb.execute().actionGet();
	
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
protected void addQ(DeleteByQueryRequestBuilder builder, BoolFilterBuilder boolFilter) {
    if (types.length > 0) {
        builder.setTypes(types);
    }
    if (query.getQ() != null && !query.getQ().isEmpty()) {
        boolFilter.must(queryFilter(queryString(query.getQ()).defaultOperator(Operator.AND)));
    }
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
@Override
public DeleteByQueryRequestBuilder deleteRequest() {
    DeleteByQueryRequestBuilder builder = client.prepareDeleteByQuery(indices);
    BoolFilterBuilder boolFilter = boolFilter();
    addQ(builder, boolFilter);
    addFilters(boolFilter);
    addBbox(boolFilter);
    setFilter(builder, boolFilter);
    return builder;
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
private void deleteOldProjects(String repo) {
       String cutoffDate = DevSearchDateFormat.format(lastIndexDateForProjects);
	LOG.info("deleting all projects in {} last indexed before {}",repo, cutoffDate);
	DeleteByQueryRequestBuilder deleteRequest = esClient.prepareDeleteByQuery(codeIndex)
		.setTypes(PROJECT_TYPE)
		.setQuery(QueryBuilders.boolQuery()
				.must(QueryBuilders.termQuery("repo", repo))
				.mustNot(QueryBuilders.rangeQuery("lastIndexed").gte(cutoffDate)));
	DeleteByQueryResponse response = deleteRequest.execute().actionGet();
       checkForFailures(repo, response);
	
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
private void deleteOldProjectFiles(Project project) {
    String cutoffDate = DevSearchDateFormat.format(lastIndexDateForProjects);
    LOG.info("deleting all files from project {} last indexed before {}",project.getId(), cutoffDate);
    DeleteByQueryRequestBuilder deleteRequest = esClient.prepareDeleteByQuery(codeIndex)
            .setTypes(DOC_TYPE)
            .setQuery(QueryBuilders.boolQuery()
                    .must(QueryBuilders.termQuery("repo", project.getRepo()))
                    .must(QueryBuilders.termQuery("project", project.getName()))
                    .mustNot(QueryBuilders.rangeQuery("lastIndexed").gte(cutoffDate)));
    DeleteByQueryResponse response = deleteRequest.execute().actionGet();


    checkForFailures(project.getId(), response);
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
protected void setFilter(DeleteByQueryRequestBuilder builder, BoolFilterBuilder boolFilter) {
    if (boolFilter.hasClauses()) {
        builder.setQuery(filteredQuery(matchAllQuery(), boolFilter));
    }
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
@Override
public void deleteByQuery(Query query) throws Exception {
    DeleteByQueryRequestBuilder builder = createConverter(query).deleteRequest();
    DeleteByQueryResponse response = builder.execute().actionGet();
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
@Override
public void deletePortletDocuments(
        SearchContext searchContext, String portletId)
        throws SearchException {

    try {
        Client client = getClient();

        DeleteByQueryRequestBuilder deleteByQueryRequestBuilder = new DeleteByQueryRequestBuilder(client, DeleteByQueryAction.INSTANCE);
        
        deleteByQueryRequestBuilder.setIndices(Utilities.getIndexName(searchContext));

        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

        boolQueryBuilder.must(
                QueryBuilders.termQuery(Field.PORTLET_ID, portletId));

        deleteByQueryRequestBuilder.setQuery(boolQueryBuilder);

        Future<DeleteByQueryResponse> future =
                deleteByQueryRequestBuilder.execute();

        future.get();


    } catch (Exception e) {
    	_log.debug("Unable to delete portlet document with id " + portletId + "with error: " +  e.getMessage());
        throw new SearchException(
                "Unable to delete data for portlet " + portletId, e);
    }
}
 

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder; //导入依赖的package包/类
DeleteByQueryRequestBuilder deleteRequest();