Examples with Collation org.springframework.data.mongodb.core.query.Collation used on opensource projects

Example 16 with Collation

use of org.springframework.data.mongodb.core.query.Collation in project spring-data-mongodb by spring-projects.

the class AbstractReactiveMongoQueryUnitTests method shouldApplyCollationParameter.

// DATAMONGO-1854
@Test
void shouldApplyCollationParameter() {
    Collation collation = Collation.of("en_US");
    // 
    createQueryForMethod("findWithCollationParameterByFirstName", String.class, Collation.class).executeBlocking(new Object[] { "dalinar", collation });
    ArgumentCaptor<Query> captor = ArgumentCaptor.forClass(Query.class);
    verify(withQueryMock).matching(captor.capture());
    assertThat(captor.getValue().getCollation()).contains(collation);
}

Example 17 with Collation

use of org.springframework.data.mongodb.core.query.Collation in project spring-data-mongodb by spring-projects.

the class AbstractReactiveMongoQueryUnitTests method shouldApplyDynamicAnnotatedCollationAsDocument.

// DATAMONGO-1854
@Test
void shouldApplyDynamicAnnotatedCollationAsDocument() {
    // 
    createQueryForMethod("findWithCollationUsingPlaceholderByFirstName", String.class, Object.class).executeBlocking(new Object[] { "dalinar", new Document("locale", "en_US") });
    ArgumentCaptor<Query> captor = ArgumentCaptor.forClass(Query.class);
    verify(withQueryMock).matching(captor.capture());
    assertThat(captor.getValue().getCollation().map(Collation::toDocument)).contains(Collation.of("en_US").toDocument());
}

Example 18 with Collation

use of org.springframework.data.mongodb.core.query.Collation in project spring-data-mongodb by spring-projects.

the class AbstractReactiveMongoQueryUnitTests method collationParameterShouldOverrideAnnotation.

// DATAMONGO-1854
@Test
void collationParameterShouldOverrideAnnotation() {
    Collation collation = Collation.of("de_AT");
    // 
    createQueryForMethod("findWithWithCollationParameterAndAnnotationByFirstName", String.class, Collation.class).executeBlocking(new Object[] { "dalinar", collation });
    ArgumentCaptor<Query> captor = ArgumentCaptor.forClass(Query.class);
    verify(withQueryMock).matching(captor.capture());
    assertThat(captor.getValue().getCollation()).contains(collation);
}

Example 19 with Collation

use of org.springframework.data.mongodb.core.query.Collation in project spring-data-mongodb by spring-projects.

the class MongoTemplate method doUpdate.

protected UpdateResult doUpdate(final String collectionName, final Query query, final Update update, @Nullable final Class<?> entityClass, final boolean upsert, final 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!");
    return execute(collectionName, new CollectionCallback<UpdateResult>() {

        public UpdateResult doInCollection(MongoCollection<Document> collection) throws MongoException, DataAccessException {
            MongoPersistentEntity<?> entity = entityClass == null ? null : getPersistentEntity(entityClass);
            increaseVersionForUpdateIfNecessary(entity, update);
            UpdateOptions opts = new UpdateOptions();
            opts.upsert(upsert);
            Document queryObj = new Document();
            if (query != null) {
                queryObj.putAll(queryMapper.getMappedObject(query.getQueryObject(), entity));
                query.getCollation().map(Collation::toMongoCollation).ifPresent(opts::collation);
            }
            Document updateObj = update == null ? new Document() : updateMapper.getMappedObject(update.getUpdateObject(), entity);
            if (multi && update.isIsolated() && !queryObj.containsKey("$isolated")) {
                queryObj.put("$isolated", 1);
            }
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Calling update using query: {} and update: {} in collection: {}", serializeToJsonSafely(queryObj), serializeToJsonSafely(updateObj), collectionName);
            }
            MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.UPDATE, collectionName, entityClass, updateObj, queryObj);
            WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
            collection = writeConcernToUse != null ? collection.withWriteConcern(writeConcernToUse) : collection;
            if (!UpdateMapper.isUpdateObject(updateObj)) {
                return collection.replaceOne(queryObj, updateObj, opts);
            } else {
                if (multi) {
                    return collection.updateMany(queryObj, updateObj, opts);
                } else {
                    return collection.updateOne(queryObj, updateObj, opts);
                }
            }
        }
    });
}

Example 20 with Collation

use of org.springframework.data.mongodb.core.query.Collation in project spring-data-mongodb by spring-projects.

the class MongoTemplate method mapReduce.

@Override
public <T> MapReduceResults<T> mapReduce(Query query, String inputCollectionName, String mapFunction, String reduceFunction, @Nullable MapReduceOptions mapReduceOptions, Class<T> entityClass) {
    Assert.notNull(query, "Query must not be null!");
    Assert.notNull(inputCollectionName, "InputCollectionName must not be null!");
    Assert.notNull(entityClass, "EntityClass must not be null!");
    Assert.notNull(reduceFunction, "ReduceFunction must not be null!");
    Assert.notNull(mapFunction, "MapFunction must not be null!");
    String mapFunc = replaceWithResourceIfNecessary(mapFunction);
    String reduceFunc = replaceWithResourceIfNecessary(reduceFunction);
    MongoCollection<Document> inputCollection = getAndPrepareCollection(doGetDatabase(), inputCollectionName);
    // MapReduceOp
    MapReduceIterable<Document> result = inputCollection.mapReduce(mapFunc, reduceFunc, Document.class);
    if (query != null && result != null) {
        if (query.getLimit() > 0 && mapReduceOptions.getLimit() == null) {
            result = result.limit(query.getLimit());
        }
        if (query.getMeta() != null && query.getMeta().getMaxTimeMsec() != null) {
            result = result.maxTime(query.getMeta().getMaxTimeMsec(), TimeUnit.MILLISECONDS);
        }
        result = result.sort(getMappedSortObject(query, entityClass));
        result = result.filter(queryMapper.getMappedObject(query.getQueryObject(), Optional.empty()));
    }
    Optional<Collation> collation = query.getCollation();
    if (mapReduceOptions != null) {
        Optionals.ifAllPresent(collation, mapReduceOptions.getCollation(), (l, r) -> {
            throw new IllegalArgumentException("Both Query and MapReduceOptions define a collation. Please provide the collation only via one of the two.");
        });
        if (mapReduceOptions.getCollation().isPresent()) {
            collation = mapReduceOptions.getCollation();
        }
        if (!CollectionUtils.isEmpty(mapReduceOptions.getScopeVariables())) {
            result = result.scope(new Document(mapReduceOptions.getScopeVariables()));
        }
        if (mapReduceOptions.getLimit() != null && mapReduceOptions.getLimit().intValue() > 0) {
            result = result.limit(mapReduceOptions.getLimit());
        }
        if (mapReduceOptions.getFinalizeFunction().filter(StringUtils::hasText).isPresent()) {
            result = result.finalizeFunction(mapReduceOptions.getFinalizeFunction().get());
        }
        if (mapReduceOptions.getJavaScriptMode() != null) {
            result = result.jsMode(mapReduceOptions.getJavaScriptMode());
        }
        if (mapReduceOptions.getOutputSharded().isPresent()) {
            result = result.sharded(mapReduceOptions.getOutputSharded().get());
        }
    }
    result = collation.map(Collation::toMongoCollation).map(result::collation).orElse(result);
    List<T> mappedResults = new ArrayList<T>();
    DocumentCallback<T> callback = new ReadDocumentCallback<T>(mongoConverter, entityClass, inputCollectionName);
    for (Document document : result) {
        mappedResults.add(callback.doWith(document));
    }
    return new MapReduceResults<T>(mappedResults, new Document());
}