Examples with WriteConcern com.mongodb.WriteConcern used on opensource projects

Example 16 with WriteConcern

use of com.mongodb.WriteConcern in project spring-data-mongodb by spring-projects.

the class MongoTemplate method doUpdate.

@SuppressWarnings("ConstantConditions")
protected UpdateResult doUpdate(String collectionName, Query query, UpdateDefinition update, @Nullable Class<?> entityClass, boolean upsert, boolean multi) {
    Assert.notNull(collectionName, "CollectionName must not be null!");
    Assert.notNull(query, "Query must not be null!");
    Assert.notNull(update, "Update must not be null!");
    if (query.isSorted() && LOGGER.isWarnEnabled()) {
        LOGGER.warn(String.format("%s does not support sort ('%s'). Please use findAndModify() instead.", upsert ? "Upsert" : "UpdateFirst", serializeToJsonSafely(query.getSortObject())));
    }
    MongoPersistentEntity<?> entity = entityClass == null ? null : getPersistentEntity(entityClass);
    UpdateContext updateContext = multi ? queryOperations.updateContext(update, query, upsert) : queryOperations.updateSingleContext(update, query, upsert);
    updateContext.increaseVersionForUpdateIfNecessary(entity);
    Document queryObj = updateContext.getMappedQuery(entity);
    UpdateOptions opts = updateContext.getUpdateOptions(entityClass);
    if (updateContext.isAggregationUpdate()) {
        List<Document> pipeline = updateContext.getUpdatePipeline(entityClass);
        MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.UPDATE, collectionName, entityClass, update.getUpdateObject(), queryObj);
        WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
        return execute(collectionName, collection -> {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug(String.format("Calling update using query: %s and update: %s in collection: %s", serializeToJsonSafely(queryObj), serializeToJsonSafely(pipeline), collectionName));
            }
            collection = writeConcernToUse != null ? collection.withWriteConcern(writeConcernToUse) : collection;
            return multi ? collection.updateMany(queryObj, pipeline, opts) : collection.updateOne(queryObj, pipeline, opts);
        });
    }
    Document updateObj = updateContext.getMappedUpdate(entity);
    MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.UPDATE, collectionName, entityClass, updateObj, queryObj);
    WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
    return execute(collectionName, collection -> {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(String.format("Calling update using query: %s and update: %s in collection: %s", serializeToJsonSafely(queryObj), serializeToJsonSafely(updateObj), collectionName));
        }
        collection = writeConcernToUse != null ? collection.withWriteConcern(writeConcernToUse) : collection;
        if (!UpdateMapper.isUpdateObject(updateObj)) {
            Document filter = new Document(queryObj);
            if (updateContext.requiresShardKey(filter, entity)) {
                if (entity.getShardKey().isImmutable()) {
                    filter = updateContext.applyShardKey(entity, filter, null);
                } else {
                    filter = updateContext.applyShardKey(entity, filter, collection.find(filter, Document.class).projection(updateContext.getMappedShardKey(entity)).first());
                }
            }
            ReplaceOptions replaceOptions = updateContext.getReplaceOptions(entityClass);
            return collection.replaceOne(filter, updateObj, replaceOptions);
        } else {
            return multi ? collection.updateMany(queryObj, updateObj, opts) : collection.updateOne(queryObj, updateObj, opts);
        }
    });
}

Example 17 with WriteConcern

use of com.mongodb.WriteConcern in project spring-data-mongodb by spring-projects.

the class MongoTemplate method insertDocument.

@SuppressWarnings("ConstantConditions")
protected Object insertDocument(String collectionName, Document document, Class<?> entityClass) {
    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug(String.format("Inserting Document containing fields: %s in collection: %s", document.keySet(), collectionName));
    }
    return execute(collectionName, collection -> {
        MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.INSERT, collectionName, entityClass, document, null);
        WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
        if (writeConcernToUse == null) {
            collection.insertOne(document);
        } else {
            collection.withWriteConcern(writeConcernToUse).insertOne(document);
        }
        return operations.forEntity(document).getId();
    });
}

Example 18 with WriteConcern

use of com.mongodb.WriteConcern in project spring-data-mongodb by spring-projects.

the class MongoTemplate method doRemove.

@SuppressWarnings("ConstantConditions")
protected <T> DeleteResult doRemove(String collectionName, Query query, @Nullable Class<T> entityClass, boolean multi) {
    Assert.notNull(query, "Query must not be null!");
    Assert.hasText(collectionName, "Collection name must not be null or empty!");
    MongoPersistentEntity<?> entity = getPersistentEntity(entityClass);
    DeleteContext deleteContext = multi ? queryOperations.deleteQueryContext(query) : queryOperations.deleteSingleContext(query);
    Document queryObject = deleteContext.getMappedQuery(entity);
    DeleteOptions options = deleteContext.getDeleteOptions(entityClass);
    MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.REMOVE, collectionName, entityClass, null, queryObject);
    WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
    return execute(collectionName, collection -> {
        maybeEmitEvent(new BeforeDeleteEvent<>(queryObject, entityClass, collectionName));
        Document removeQuery = queryObject;
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(String.format("Remove using query: %s in collection: %s.", serializeToJsonSafely(removeQuery), collectionName));
        }
        if (query.getLimit() > 0 || query.getSkip() > 0) {
            MongoCursor<Document> cursor = new QueryCursorPreparer(query, entityClass).prepare(// 
            collection.find(removeQuery).projection(MappedDocument.getIdOnlyProjection())).iterator();
            Set<Object> ids = new LinkedHashSet<>();
            while (cursor.hasNext()) {
                ids.add(MappedDocument.of(cursor.next()).getId());
            }
            removeQuery = MappedDocument.getIdIn(ids);
        }
        MongoCollection<Document> collectionToUse = writeConcernToUse != null ? collection.withWriteConcern(writeConcernToUse) : collection;
        DeleteResult result = multi ? collectionToUse.deleteMany(removeQuery, options) : collectionToUse.deleteOne(removeQuery, options);
        maybeEmitEvent(new AfterDeleteEvent<>(queryObject, entityClass, collectionName));
        return result;
    });
}

Example 19 with WriteConcern

use of com.mongodb.WriteConcern in project spring-data-mongodb by spring-projects.

the class ReactiveMongoTemplate method doUpdate.

protected Mono<UpdateResult> doUpdate(String collectionName, Query query, @Nullable UpdateDefinition update, @Nullable Class<?> entityClass, boolean upsert, boolean multi) {
    if (query.isSorted() && LOGGER.isWarnEnabled()) {
        LOGGER.warn(String.format("%s does not support sort ('%s'). Please use findAndModify() instead.", upsert ? "Upsert" : "UpdateFirst", serializeToJsonSafely(query.getSortObject())));
    }
    MongoPersistentEntity<?> entity = entityClass == null ? null : getPersistentEntity(entityClass);
    UpdateContext updateContext = multi ? queryOperations.updateContext(update, query, upsert) : queryOperations.updateSingleContext(update, query, upsert);
    updateContext.increaseVersionForUpdateIfNecessary(entity);
    Document queryObj = updateContext.getMappedQuery(entity);
    UpdateOptions updateOptions = updateContext.getUpdateOptions(entityClass);
    Flux<UpdateResult> result;
    if (updateContext.isAggregationUpdate()) {
        List<Document> pipeline = updateContext.getUpdatePipeline(entityClass);
        MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.UPDATE, collectionName, entityClass, update.getUpdateObject(), queryObj);
        WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
        result = execute(collectionName, collection -> {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug(String.format("Calling update using query: %s and update: %s in collection: %s", serializeToJsonSafely(queryObj), serializeToJsonSafely(pipeline), collectionName));
            }
            collection = writeConcernToUse != null ? collection.withWriteConcern(writeConcernToUse) : collection;
            return multi ? collection.updateMany(queryObj, pipeline, updateOptions) : collection.updateOne(queryObj, pipeline, updateOptions);
        });
    } else {
        Document updateObj = updateContext.getMappedUpdate(entity);
        MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.UPDATE, collectionName, entityClass, updateObj, queryObj);
        WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
        result = execute(collectionName, collection -> {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug(String.format("Calling update using query: %s and update: %s in collection: %s", serializeToJsonSafely(queryObj), serializeToJsonSafely(updateObj), collectionName));
            }
            MongoCollection<Document> collectionToUse = prepareCollection(collection, writeConcernToUse);
            if (!UpdateMapper.isUpdateObject(updateObj)) {
                Document filter = new Document(queryObj);
                Mono<Document> deferredFilter;
                if (updateContext.requiresShardKey(filter, entity)) {
                    if (entity.getShardKey().isImmutable()) {
                        deferredFilter = Mono.just(updateContext.applyShardKey(entity, filter, null));
                    } else {
                        deferredFilter = Mono.from(collection.find(filter, Document.class).projection(updateContext.getMappedShardKey(entity)).first()).defaultIfEmpty(updateObj).map(it -> updateContext.applyShardKey(entity, filter, it));
                    }
                } else {
                    deferredFilter = Mono.just(filter);
                }
                ReplaceOptions replaceOptions = updateContext.getReplaceOptions(entityClass);
                return deferredFilter.flatMap(it -> Mono.from(collectionToUse.replaceOne(it, updateObj, replaceOptions)));
            }
            return multi ? collectionToUse.updateMany(queryObj, updateObj, updateOptions) : collectionToUse.updateOne(queryObj, updateObj, updateOptions);
        });
    }
    result = result.doOnNext(updateResult -> {
        if (entity != null && entity.hasVersionProperty() && !multi) {
            if (updateResult.wasAcknowledged() && updateResult.getMatchedCount() == 0) {
                Document updateObj = updateContext.getMappedUpdate(entity);
                if (containsVersionProperty(queryObj, entity))
                    throw new OptimisticLockingFailureException("Optimistic lock exception on saving entity: " + updateObj.toString() + " to collection " + collectionName);
            }
        }
    });
    return result.next();
}

Example 20 with WriteConcern

use of com.mongodb.WriteConcern in project spring-data-mongodb by spring-projects.

the class ReactiveMongoTemplate method insertDocument.

protected Mono<Object> insertDocument(String collectionName, Document dbDoc, Class<?> entityClass) {
    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug(String.format("Inserting Document containing fields: " + dbDoc.keySet() + " in collection: " + collectionName));
    }
    Document document = new Document(dbDoc);
    Flux<InsertOneResult> execute = execute(collectionName, collection -> {
        MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.INSERT, collectionName, entityClass, dbDoc, null);
        WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
        MongoCollection<Document> collectionToUse = prepareCollection(collection, writeConcernToUse);
        return collectionToUse.insertOne(document);
    });
    return Flux.from(execute).last().map(success -> MappedDocument.of(document).getId());
}