Java DeleteResponse.isFound方法代码示例

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
/**
 * Processes a "delete" request.
 * 
 * @param urlItems Items of the URL
 * @return Result of the delete request, it contains the id of the deleted document
 */
private InterpreterResult processDelete(String[] urlItems) {

  if (urlItems.length != 3 
      || StringUtils.isEmpty(urlItems[0]) 
      || StringUtils.isEmpty(urlItems[1]) 
      || StringUtils.isEmpty(urlItems[2])) {
    return new InterpreterResult(InterpreterResult.Code.ERROR,
                                 "Bad URL (it should be /index/type/id)");
  }

  final DeleteResponse response = client
    .prepareDelete(urlItems[0], urlItems[1], urlItems[2])
    .get();
      
  if (response.isFound()) {
    return new InterpreterResult(
      InterpreterResult.Code.SUCCESS,
      InterpreterResult.Type.TEXT,
      response.getId());
  }
      
  return new InterpreterResult(InterpreterResult.Code.ERROR, "Document not found");
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
/**
 * 删除文档
 * 
 * @param id
 */
public boolean deleteDocById(String docId) {
    try {
        // 删除
        DeleteResponse resp = ESClient.getClient()
                .prepareDelete(this.currentIndexName, this.indexType.getTypeName(), docId)
                .setOperationThreaded(false).execute().actionGet();
        // 刷新
        ESClient.getClient().admin().indices()
                .refresh(new RefreshRequest(this.currentIndexName)).actionGet();
        if (resp.isFound()) {
            log.warn("delete index sunccess,indexname:{},type:{},delete {} items",
                    this.indexType.getIndexName(), this.indexType.getTypeName(), 1);
            return resp.isFound();
        }
    } catch (Exception e) {
        log.error("delete Doc fail,indexname:{},type:{}", this.indexType.getIndexName(),
                this.indexType.getTypeName());
    }
    return false;
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
@Override
public boolean deleteDatetimeValue(String spaceKey, String propertyName) {
	String documentName = prepareValueStoreDocumentName(spaceKey, propertyName);

	if (logger.isDebugEnabled())
		logger.debug("Going to delete datetime value from {} property for space {}. Document name is {}.", propertyName,
				spaceKey, documentName);

	refreshSearchIndex(getRiverIndexName());

	DeleteResponse lastSeqGetResponse = client.prepareDelete(getRiverIndexName(), riverName.name(), documentName)
			.execute().actionGet();
	if (!lastSeqGetResponse.isFound()) {
		if (logger.isDebugEnabled()) {
			logger.debug("{} document doesn't exist in remote river persistent store", documentName);
		}
		return false;
	} else {
		return true;
	}

}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
@Override
public void onResponse(DeleteResponse response) {
    if (!response.isFound()) {
        result.set(TaskResult.ZERO);
    } else {
        result.set(TaskResult.ONE_ROW);
    }
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
@Override
public void remove(String workflowId) {
	try {

		DeleteRequest req = new DeleteRequest(indexName, WORKFLOW_DOC_TYPE, workflowId);
		DeleteResponse response = client.delete(req).actionGet();
		if (!response.isFound()) {
			log.error("Index removal failed - document not found by id " + workflowId);
		}
	} catch (Throwable e) {
		log.error("Index removal failed failed {}", e.getMessage(), e);
		Monitors.error(className, "remove");
	}
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
@Override
public void delete(String id) throws StorageException {
    DeleteResponse response = client.prepareDelete(index, type, id)
            .execute()
            .actionGet();

    if (!response.isFound()) {
        throw new NotFoundException("Unable to delete entity with id " + id + " (not found)");
    }
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
public boolean delete(String backendId, String type, String id, boolean refresh, boolean throwNotFound) {
	DeleteResponse response = internalClient.prepareDelete(//
			toAlias(backendId, type), type, id).setRefresh(refresh).get();

	if (response.isFound())
		return true;
	if (throwNotFound)
		throw Exceptions.notFound(backendId, type, id);

	return false;
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
@Override
public <T extends Indexable> boolean delete(final T document, String index, String type) throws ArchiveException {
    try {
        final DeleteResponse response = client.prepareDelete(index, type, document.getDocumentId())
                .setRefresh(true)
                .execute()
                .actionGet();
        return response.isFound();
    } catch (Exception ex) {
        log.log(Level.SEVERE, "Delete went wrong: " + ex.getMessage());
        ex.printStackTrace();
        throw new ArchiveException("Delete went wrong: " + ex.getMessage());
    }
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
@Override
protected void deleteDocumentWithParams(Map<String, Object> deleteParams) {
    final DeleteRequestBuilder deleteRequestBuilder = prepareDeleteDocument(deleteParams);
    final DeleteResponse deleteResponse = deleteDocumentWithRequest(deleteRequestBuilder);
    if (getLog().isDebugEnabled()) {
        if (!deleteResponse.isFound()) {
            getLog().debug("Could not delete doc with by id: " + deleteParams.get(DELETE_RESOURCE_KEY_ITEM)
                    + " in index builder [" + getName() + "] because the document wasn't found");
        } else {
            getLog().debug("ES deleted a doc with id: " + deleteResponse.getId() + " in index builder ["
                    + getName() + "]");
        }
    }
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
protected void executeBulkRequest(BulkRequestBuilder bulkRequest) {
    BulkResponse bulkResponse = bulkRequest.execute().actionGet();

    getLog().info("Bulk request of batch size: " + bulkRequest.numberOfActions() + " took "
            + bulkResponse.getTookInMillis() + " ms in index builder: " + getName());

    for (BulkItemResponse response : bulkResponse.getItems()) {
        if (response.getResponse() instanceof DeleteResponse) {
            DeleteResponse deleteResponse = response.getResponse();

            if (response.isFailed()) {
                getLog().error("Problem deleting doc: " + response.getId() + " in index builder: " + getName()
                        + " error: " + response.getFailureMessage());
            } else if (!deleteResponse.isFound()) {
                getLog().debug("ES could not find a doc with id: " + deleteResponse.getId()
                        + " to delete in index builder: " + getName());
            } else {
                getLog().debug("ES deleted a doc with id: " + deleteResponse.getId() + " in index builder: "
                        + getName());
            }
        } else if (response.getResponse() instanceof IndexResponse) {
            IndexResponse indexResponse = response.getResponse();

            if (response.isFailed()) {
                getLog().error("Problem updating content for doc: " + response.getId() + " in index builder: "
                        + getName() + " error: " + response.getFailureMessage());
            } else {
                getLog().debug("ES indexed content for doc with id: " + indexResponse.getId()
                        + " in index builder: " + getName());
            }
        }
    }
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
protected void deleteDocumentWithParams(Map<String, Object> deleteParams) {
    final DeleteRequestBuilder deleteRequestBuilder = prepareDeleteDocument(deleteParams);
    final DeleteResponse deleteResponse = deleteDocumentWithRequest(deleteRequestBuilder);

    if (getLog().isDebugEnabled()) {
        if (!deleteResponse.isFound()) {
            getLog().debug("Could not delete doc with by id: " + deleteParams.get(DELETE_RESOURCE_KEY_DOCUMENT_ID)
                    + " in index builder [" + getName() + "] because the document wasn't found");
        } else {
            getLog().debug("ES deleted a doc with id: " + deleteResponse.getId() + " in index builder ["
                    + getName() + "]");
        }
    }
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
public boolean deleteAlert(String term) {
    DeleteResponse response = ElasticsearchConnectionManager.getClient()
            .prepareDelete(ALERT_INDEX, PERCOLATOR_TYPE, term)
            .execute()
            .actionGet();
    return response.isFound();
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
/**
 * 仅仅只删除索引
 * @param index
 * @param type
 * @param id
 */
private static void deleteIndex(String index, String type, String id){
	Client client = createTransportClient();
	DeleteResponse response = client.prepareDelete(index, type, id)
			.execute()
			.actionGet();
	boolean isFound = response.isFound();
	System.out.println("索引是否 存在:"+isFound); // 发现doc已删除则返回true
	System.out.println("****************index ***********************");
	// Index name
	String _index = response.getIndex();
	// Type name
	String _type = response.getType();
	// Document ID (generated or not)
	String _id = response.getId();
	// Version (if it's the first time you index this document, you will get: 1)
	long _version = response.getVersion();
	System.out.println(_index+","+_type+","+_id+","+_version);
	
	//优化索引
	OptimizeRequest optimizeRequest = new OptimizeRequest(index);
    OptimizeResponse optimizeResponse = client.admin().indices().optimize(optimizeRequest).actionGet();
    System.out.println(optimizeResponse.getTotalShards()+","+optimizeResponse.getSuccessfulShards()+","+optimizeResponse.getFailedShards());
    
    //刷新索引
	FlushRequest flushRequest = new FlushRequest(index);
	flushRequest.force(true);
	FlushResponse flushResponse = client.admin().indices().flush(flushRequest).actionGet();
	System.out.println(flushResponse.getTotalShards()+","+flushResponse.getSuccessfulShards()+","+flushResponse.getFailedShards());
	
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
public void deleteDocumentBoard(String id) {
	DeleteResponse response = client.prepareDelete()
			.setIndex(elasticsearchProperties.getIndexBoard())
			.setType(Constants.ES_TYPE_ARTICLE)
			.setId(id)
			.get();

	if (! response.isFound())
		log.info("board id {} is not found. so can't delete it!", id);
}
 

import org.elasticsearch.action.delete.DeleteResponse; //导入方法依赖的package包/类
public void deleteDocumentBoardComment(String id) {

		DeleteResponse response = client.prepareDelete()
				.setIndex(elasticsearchProperties.getIndexBoard())
				.setType(Constants.ES_TYPE_COMMENT)
				.setId(id)
				.get();

		if (! response.isFound())
			log.info("comment id {} is not found. so can't delete it!", id);
	}