Java DocumentOperationResult类代码示例

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
private void rollback(List<StatementDocument> createdDocs,
		List<StatementDocument> voidedDocs) {
	List<Object> bulk = new ArrayList<>(createdDocs.size()
			+ voidedDocs.size());
	for (StatementDocument doc : createdDocs) {
		bulk.add(BulkDeleteDocument.of(doc));
	}
	for (StatementDocument voidedDoc : voidedDocs) {
		voidedDoc.setType(Type.PLAIN);
		bulk.add(voidedDoc);
	}
	if (!bulk.isEmpty()) {
		List<DocumentOperationResult> result = connector.executeBulk(bulk);
		for (DocumentOperationResult docResult : result) {
			if (docResult.isErroneous()) {
				throw new RuntimeException(String.format(
						"rollback failed: %s", result));

			}
		}
	}
}
 

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
@Override
public int deleteAllAnswersForQuestions(final List<String> contentIds) {
	final ViewResult result = db.queryView(createQuery("by_questionid")
			.keys(contentIds));
	final List<BulkDeleteDocument> allAnswers = new ArrayList<>();
	for (final ViewResult.Row a : result.getRows()) {
		final BulkDeleteDocument d = new BulkDeleteDocument(a.getId(), a.getValueAsNode().get("_rev").asText());
		allAnswers.add(d);
	}
	try {
		final List<DocumentOperationResult> errors = db.executeBulk(allAnswers);

		return allAnswers.size() - errors.size();
	} catch (final DbAccessException e) {
		logger.error("Could not bulk delete answers.", e);
	}

	return 0;
}
 

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
@Override
public int deleteByContentIds(final List<String> contentIds) {
	final ViewResult result = db.queryView(createQuery("by_questionid")
			.keys(contentIds));
	final List<BulkDeleteDocument> deleteDocs = new ArrayList<>();
	for (final ViewResult.Row a : result.getRows()) {
		final BulkDeleteDocument d = new BulkDeleteDocument(a.getId(), a.getValueAsNode().get("_rev").asText());
		deleteDocs.add(d);
	}

	try {
		final List<DocumentOperationResult> errors = db.executeBulk(deleteDocs);

		return deleteDocs.size() - errors.size();
	} catch (final DbAccessException e) {
		logger.error("Could not bulk delete answers.", e);
	}

	return 0;
}
 

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
@Override
public int deleteBySessionId(final String sessionId) {
	final ViewResult result = db.queryView(createQuery("by_sessionid_variant_active")
			.startKey(ComplexKey.of(sessionId))
			.endKey(ComplexKey.of(sessionId, ComplexKey.emptyObject()))
			.reduce(false));

	final List<BulkDeleteDocument> deleteDocs = new ArrayList<>();
	for (final ViewResult.Row a : result.getRows()) {
		final BulkDeleteDocument d = new BulkDeleteDocument(a.getId(), a.getValueAsNode().get("_rev").asText());
		deleteDocs.add(d);
	}
	List<DocumentOperationResult> errors = db.executeBulk(deleteDocs);

	return deleteDocs.size() - errors.size();
}
 

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
@Override
public void close() {
	Collection<CouchDbConnector> connectorSet = _connectors.values();
	for (CouchDbConnector connector : connectorSet) {
		List<String> errornousResultsDescriptions = new ArrayList<String>();
		List<DocumentOperationResult> results = connector.flushBulkBuffer();
		for (DocumentOperationResult result : results) {
			if (result.isErroneous()) {
				String id = result.getId();
				String error = result.getError();
				String reason = result.getReason();
				String revision = result.getRevision();
				logger.error("Error occurred while flushing bulk buffer: {}, id: {}, revision: {}, reason: {}",
						new Object[] { error, id, revision, reason });
				errornousResultsDescriptions.add(error);
			}
		}

		if (!errornousResultsDescriptions.isEmpty()) {
			throw new MetaModelException(errornousResultsDescriptions.size() + " out of " + results.size()
					+ " operations in bulk was errornous: " + errornousResultsDescriptions);
		}
	}
}
 

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
protected void executeBulk(Collection<? extends Object> collection) {

        logger.debug(collection.size() + " documents are going to be processed ...");

        List<DocumentOperationResult> results;
        if (allOrNothing) {
            results = db.executeAllOrNothing(collection);
        } else {
            results = db.executeBulk(collection);
        }

        // handle errors
        List<BulkOperationError> errors = new ArrayList<BulkOperationError>();
        List<String> messages = new ArrayList<String>();
        for (DocumentOperationResult result : results) {
            if (result.getError() != null) {
                errors.add(new BulkOperationError(result.getId(), result.getRevision(), result.getError(), result
                        .getReason()));
                messages.add(result.toString());
            }
        }
        if (errors.size() > 0) {
            throw new BulkOperationException(StringUtils.join(messages, ","), errors);
        } else {
            logger.debug("All documents have been processed.");
        }
    }
 

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void writeBulkData() throws FilterException {
	if (updateDataIfExists) {
		timerContextBulkRead.resume();
		Map<String, JsonNode> bulkLoaded = dataRepository.executeBulkGet(bulkDomainIds);
		try {
			for (ObjectNode node : bulkObjects) {
				String domainId = node.at(source.getDomainIdKey()).asText();
				if (bulkLoaded.containsKey(domainId)) {
					JsonNode oldNode = bulkLoaded.get(domainId);
					node.put("_id", oldNode.get("_id").asText());
					node.put("_rev", oldNode.get("_rev").asText());
				}
			}
		} finally {
			timerContextBulkRead.pause();
		}
	}

	timerContextBulkWrite.resume();
	try {
		Collection<DocumentOperationResult> results = dataRepository.executeBulkCreateAndUpdate((List) bulkObjects);
		for (DocumentOperationResult result : results) {
			if (result.isErroneous())
				throw new FilterException("db insertion failed for id " + result.getId() + ", reason: " + result.getReason());
		}
	} finally {
		timerContextBulkWrite.pause();
	}

	bulkObjects.clear();
}
 

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
public Collection<DocumentOperationResult> executeBulkCreateAndUpdate(Collection<JsonNode> data) {
	return connector.executeBulk(data);
}
 

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
@Override
public List<DocumentOperationResult> flushBulkBuffer() {
	throw new UnsupportedOperationException("not implemented");
}
 

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
@Override
public List<DocumentOperationResult> executeBulk(InputStream inputStream) {
	throw new UnsupportedOperationException("not implemented");
}
 

import org.ektorp.DocumentOperationResult; //导入依赖的package包/类
@Override
public List<DocumentOperationResult> executeAllOrNothing(
		InputStream inputStream) {
	throw new UnsupportedOperationException("not implemented");
}