Examples with Nullable org.springframework.lang.Nullable used on opensource projects

Example 11 with Nullable

use of org.springframework.lang.Nullable in project spring-data-mongodb by spring-projects.

the class MongoTemplate method findById.

@Nullable
@Override
public <T> T findById(Object id, Class<T> entityClass, String collectionName) {
    Assert.notNull(id, "Id must not be null!");
    Assert.notNull(entityClass, "EntityClass must not be null!");
    Assert.notNull(collectionName, "CollectionName must not be null!");
    MongoPersistentEntity<?> persistentEntity = mappingContext.getPersistentEntity(entityClass);
    String idKey = ID_FIELD;
    if (persistentEntity != null) {
        if (persistentEntity.getIdProperty() != null) {
            idKey = persistentEntity.getIdProperty().getName();
        }
    }
    return doFindOne(collectionName, new Document(idKey, id), new Document(), entityClass);
}

Example 12 with Nullable

use of org.springframework.lang.Nullable in project spring-data-mongodb by spring-projects.

the class MongoTemplate method aggregateStream.

@SuppressWarnings("ConstantConditions")
protected <O> CloseableIterator<O> aggregateStream(Aggregation aggregation, String collectionName, Class<O> outputType, @Nullable AggregationOperationContext context) {
    Assert.hasText(collectionName, "Collection name must not be null or empty!");
    Assert.notNull(aggregation, "Aggregation pipeline must not be null!");
    Assert.notNull(outputType, "Output type must not be null!");
    Assert.isTrue(!aggregation.getOptions().isExplain(), "Can't use explain option with streaming!");
    AggregationOperationContext rootContext = context == null ? Aggregation.DEFAULT_CONTEXT : context;
    AggregationOptions options = aggregation.getOptions();
    List<Document> pipeline = aggregation.toPipeline(rootContext);
    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Streaming aggregation: {} in collection {}", serializeToJsonSafely(pipeline), collectionName);
    }
    ReadDocumentCallback<O> readCallback = new ReadDocumentCallback<>(mongoConverter, outputType, collectionName);
    return execute(collectionName, (CollectionCallback<CloseableIterator<O>>) collection -> {
        AggregateIterable<Document> cursor = collection.aggregate(pipeline, Document.class).allowDiskUse(options.isAllowDiskUse()).useCursor(true);
        if (options.getCursorBatchSize() != null) {
            cursor = cursor.batchSize(options.getCursorBatchSize());
        }
        if (options.getCollation().isPresent()) {
            cursor = cursor.collation(options.getCollation().map(Collation::toMongoCollation).get());
        }
        return new CloseableIterableCursorAdapter<>(cursor.iterator(), exceptionTranslator, readCallback);
    });
}

Example 13 with Nullable

use of org.springframework.lang.Nullable in project spring-data-mongodb by spring-projects.

the class ReactiveMongoTemplate method doUpdate.

protected Mono<UpdateResult> doUpdate(final String collectionName, @Nullable Query query, @Nullable Update update, @Nullable Class<?> entityClass, final boolean upsert, final boolean multi) {
    MongoPersistentEntity<?> entity = entityClass == null ? null : getPersistentEntity(entityClass);
    Flux<UpdateResult> result = execute(collectionName, collection -> {
        increaseVersionForUpdateIfNecessary(entity, update);
        Document queryObj = query == null ? new Document() : queryMapper.getMappedObject(query.getQueryObject(), entity);
        Document updateObj = update == null ? new Document() : updateMapper.getMappedObject(update.getUpdateObject(), entity);
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(String.format("Calling update using query: %s and update: %s in collection: %s", serializeToJsonSafely(queryObj), serializeToJsonSafely(updateObj), collectionName));
        }
        MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.UPDATE, collectionName, entityClass, updateObj, queryObj);
        WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
        MongoCollection<Document> collectionToUse = prepareCollection(collection, writeConcernToUse);
        UpdateOptions updateOptions = new UpdateOptions().upsert(upsert);
        query.getCollation().map(Collation::toMongoCollation).ifPresent(updateOptions::collation);
        if (!UpdateMapper.isUpdateObject(updateObj)) {
            return collectionToUse.replaceOne(queryObj, updateObj, updateOptions);
        }
        if (multi) {
            return collectionToUse.updateMany(queryObj, updateObj, updateOptions);
        }
        return collectionToUse.updateOne(queryObj, updateObj, updateOptions);
    }).doOnNext(updateResult -> {
        if (entity != null && entity.hasVersionProperty() && !multi) {
            if (updateResult.wasAcknowledged() && updateResult.getMatchedCount() == 0) {
                Document queryObj = query == null ? new Document() : queryMapper.getMappedObject(query.getQueryObject(), entity);
                Document updateObj = update == null ? new Document() : updateMapper.getMappedObject(update.getUpdateObject(), entity);
                if (dbObjectContainsVersionProperty(queryObj, entity))
                    throw new OptimisticLockingFailureException("Optimistic lock exception on saving entity: " + updateObj.toString() + " to collection " + collectionName);
            }
        }
    });
    return result.next();
}

Example 14 with Nullable

use of org.springframework.lang.Nullable in project spring-data-mongodb by spring-projects.

the class ReactiveMongoTemplate method doRemove.

protected <T> Mono<DeleteResult> doRemove(String collectionName, Query query, @Nullable Class<T> entityClass) {
    if (query == null) {
        throw new InvalidDataAccessApiUsageException("Query passed in to remove can't be null!");
    }
    Assert.hasText(collectionName, "Collection name must not be null or empty!");
    final Document queryObject = query.getQueryObject();
    final MongoPersistentEntity<?> entity = getPersistentEntity(entityClass);
    return execute(collectionName, collection -> {
        Document removeQuey = queryMapper.getMappedObject(queryObject, entity);
        maybeEmitEvent(new BeforeDeleteEvent<T>(removeQuey, entityClass, collectionName));
        MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.REMOVE, collectionName, entityClass, null, removeQuey);
        final DeleteOptions deleteOptions = new DeleteOptions();
        query.getCollation().map(Collation::toMongoCollation).ifPresent(deleteOptions::collation);
        WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
        MongoCollection<Document> collectionToUse = prepareCollection(collection, writeConcernToUse);
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Remove using query: {} in collection: {}.", new Object[] { serializeToJsonSafely(removeQuey), collectionName });
        }
        if (query.getLimit() > 0 || query.getSkip() > 0) {
            FindPublisher<Document> cursor = new QueryFindPublisherPreparer(query, entityClass).prepare(// 
            collection.find(removeQuey)).projection(new Document(ID_FIELD, 1));
            return // 
            Flux.from(cursor).map(// 
            doc -> doc.get(ID_FIELD)).collectList().flatMapMany(val -> {
                return collectionToUse.deleteMany(new Document(ID_FIELD, new Document("$in", val)), deleteOptions);
            });
        } else {
            return collectionToUse.deleteMany(removeQuey, deleteOptions);
        }
    }).doOnNext(deleteResult -> maybeEmitEvent(new AfterDeleteEvent<T>(queryObject, entityClass, collectionName))).next();
}

Example 15 with Nullable

use of org.springframework.lang.Nullable in project spring-data-mongodb by spring-projects.

the class QueryMapper method getMappedValue.

/**
 * Returns the mapped value for the given source object assuming it's a value for the given
 * {@link MongoPersistentProperty}.
 *
 * @param value the source object to be mapped
 * @param property the property the value is a value for
 * @param newKey the key the value will be bound to eventually
 * @return
 */
@Nullable
@SuppressWarnings("unchecked")
protected Object getMappedValue(Field documentField, Object value) {
    if (documentField.isIdField()) {
        if (isDBObject(value)) {
            DBObject valueDbo = (DBObject) value;
            Document resultDbo = new Document(valueDbo.toMap());
            if (valueDbo.containsField("$in") || valueDbo.containsField("$nin")) {
                String inKey = valueDbo.containsField("$in") ? "$in" : "$nin";
                List<Object> ids = new ArrayList<Object>();
                for (Object id : (Iterable<?>) valueDbo.get(inKey)) {
                    ids.add(convertId(id));
                }
                resultDbo.put(inKey, ids);
            } else if (valueDbo.containsField("$ne")) {
                resultDbo.put("$ne", convertId(valueDbo.get("$ne")));
            } else {
                return getMappedObject(resultDbo, Optional.empty());
            }
            return resultDbo;
        } else if (isDocument(value)) {
            Document valueDbo = (Document) value;
            Document resultDbo = new Document(valueDbo);
            if (valueDbo.containsKey("$in") || valueDbo.containsKey("$nin")) {
                String inKey = valueDbo.containsKey("$in") ? "$in" : "$nin";
                List<Object> ids = new ArrayList<Object>();
                for (Object id : (Iterable<?>) valueDbo.get(inKey)) {
                    ids.add(convertId(id));
                }
                resultDbo.put(inKey, ids);
            } else if (valueDbo.containsKey("$ne")) {
                resultDbo.put("$ne", convertId(valueDbo.get("$ne")));
            } else {
                return getMappedObject(resultDbo, Optional.empty());
            }
            return resultDbo;
        } else {
            return convertId(value);
        }
    }
    if (isNestedKeyword(value)) {
        return getMappedKeyword(new Keyword((Bson) value), documentField.getPropertyEntity());
    }
    if (isAssociationConversionNecessary(documentField, value)) {
        return convertAssociation(value, documentField);
    }
    return convertSimpleOrDocument(value, documentField.getPropertyEntity());
}