/** * Set update operation values using given {@link PropertyBox}. * <p> * Each {@link Path} type property of the PropertyBox property set will be setted to its corresponding value in the * PropertyBox. Any previously path binding will be replaced by a new path binding for matching paths. * </p> * <p> * Any path without a value in the PropertyBox will be updated to the <code>null</code> value. * </p> * @param propertyBox propertyBox PropertyBox to use (not null) * @return this * @see #set(PropertyBox, boolean) */ default O set(PropertyBox propertyBox) { return set(propertyBox, true); }
/** * Set the operation property set, i.e. the properties which must be included in the bulk insert operation. * @param <P> Property type * @param properties Property set (not null) * @return this */ @SuppressWarnings({ "rawtypes", "unchecked" }) default <P extends Property> O propertySet(P... properties) { return propertySet(PropertySet.of(properties)); }
/** * Checks whether given {@link WriteOption} is present in this configuration. * @param writeOption The write option to look for (not null) * @return <code>true</code> if the write option is present in this configuration, <code>false</code> otherwise */ default boolean hasWriteOption(WriteOption writeOption) { ObjectUtils.argumentNotNull(writeOption, "Write option must be not null"); return getWriteOptions().contains(writeOption); }
/** * Build a {@link DeleteOptions} instance using given operation configuration. * @param configuration Operation configuration * @return Options */ public static DeleteOptions getDeleteOptions(DatastoreOperationConfiguration configuration) { final DeleteOptions options = new DeleteOptions(); configuration.getWriteOption(CollationOption.class).ifPresent(o -> options.collation(o.getCollation())); return options; }
/** * Build a {@link UpdateOptions} instance using given operation configuration. * @param configuration Operation configuration * @param upsert Set to true if a new document should be inserted if there are no matches to the query filter. * @return Options */ public static UpdateOptions getUpdateOptions(DatastoreOperationConfiguration configuration, boolean upsert) { final UpdateOptions options = new UpdateOptions(); options.bypassDocumentValidation(configuration.hasWriteOption(DocumentWriteOption.BYPASS_VALIDATION)); configuration.getWriteOption(CollationOption.class).ifPresent(o -> options.collation(o.getCollation())); options.upsert(upsert); return options; }
/** * Build a {@link InsertManyOptions} instance using given operation configuration. * @param configuration Operation configuration * @return Options */ public static InsertManyOptions getInsertManyOptions(DatastoreOperationConfiguration configuration) { final InsertManyOptions options = new InsertManyOptions(); options.bypassDocumentValidation(configuration.hasWriteOption(DocumentWriteOption.BYPASS_VALIDATION)); options.ordered(!configuration.hasWriteOption(DocumentWriteOption.UNORDERED)); return options; }
@Override public B withWriteOptions(Set<WriteOption> writeOptions) { getExecutor().withWriteOptions(writeOptions); return getBuilder(); }
@Override public <X extends Expression, R extends Expression> B withExpressionResolver( ExpressionResolver<X, R> expressionResolver) { getExecutor().withExpressionResolver(expressionResolver); return getBuilder(); }
@Override public B withWriteOption(WriteOption writeOption) { getExecutor().withWriteOption(writeOption); return getBuilder(); }
@SuppressWarnings("rawtypes") @Override public B withExpressionResolvers(Iterable<? extends ExpressionResolver> expressionResolvers) { getExecutor().withExpressionResolvers(expressionResolvers); return getBuilder(); }
@Override public BeanOperationResult<T> execute() { return convert(getExecutor().execute(), null); }
/** * Configure a write operation, setting the {@link WriteConcern} if available from write options or context. * @param <T> Collection type * @param collection Mongo collection * @param context Mongo context * @param operation Operation configuration * @return The configured collection */ public static <T> MongoCollection<T> configureWrite(MongoCollection<T> collection, MongoContext<?> context, DatastoreOperationConfiguration operation) { // check write option Optional<WriteConcern> wc = operation.getWriteOption(WriteConcernOption.class).map(wo -> wo.getWriteConcern()); if (!wc.isPresent()) { // use default if available wc = context.getDefaultWriteConcern(); } return wc.map(wrc -> collection.withWriteConcern(wrc)).orElse(collection); }
/** * Set the given {@link Path} to <code>null</code> value. * @param <P> Path type * @param path Path to be updated (not null) * @return this */ default <P> O setNull(Path<P> path) { return set(path, NullExpression.create(path)); }
/** * Build a {@link InsertOneOptions} instance using given operation configuration. * @param configuration Operation configuration * @return Options */ public static InsertOneOptions getInsertOneOptions(DatastoreOperationConfiguration configuration) { final InsertOneOptions options = new InsertOneOptions(); options.bypassDocumentValidation(configuration.hasWriteOption(DocumentWriteOption.BYPASS_VALIDATION)); return options; }
/** * Get the {@link WriteOption} of given type available in this configuration. * @param <WO> WriteOption type * @param type WriteOption type to look for (not null) * @return A set of write options of given type, empty if none */ @SuppressWarnings("unchecked") default <WO extends WriteOption> Set<WO> getWriteOptions(Class<WO> type) { ObjectUtils.argumentNotNull(type, "Write option type be not null"); return getWriteOptions().stream().filter(wo -> type.isAssignableFrom(wo.getClass())).map(wo -> (WO) wo) .collect(Collectors.toSet()); }
@Override public B withWriteOptions(WriteOption... writeOptions) { getExecutor().withWriteOptions(writeOptions); return getBuilder(); }
/** * Configure a write operation, setting the {@link WriteConcern} if available from write options or context. * @param <T> Collection type * @param collection Mongo collection * @param context Mongo context * @param operation Operation configuration * @return The configured collection */ public static <T> MongoCollection<T> configureWrite(MongoCollection<T> collection, MongoContext<?> context, DatastoreOperationConfiguration operation) { // check write option Optional<WriteConcern> wc = operation.getWriteOption(WriteConcernOption.class).map(wo -> wo.getWriteConcern()); if (!wc.isPresent()) { // use default if available wc = context.getDefaultWriteConcern(); } return wc.map(wrc -> collection.withWriteConcern(wrc)).orElse(collection); }
/** * Set given <code>path</code> to given constant value. * @param <T> Path type * @param path Path to be updated (not null) * @param value value to set * @return this * @see #setNull(Path) */ default <T> O set(Path<T> path, T value) { return set(path, (value == null) ? NullExpression.create(path) : ConstantConverterExpression.create(path, value)); }
/** * Check generated document id after an upsert type operation, setting the inserted key using given * {@link OperationResult} builder. * @param builder OperationResult builder * @param documentContext Document context * @param configuration Operation configuration * @param upsertedId Optional upserted id value * @param value Original {@link PropertyBox} value */ @SuppressWarnings("unchecked") public static void checkUpsertedKey(OperationResult.Builder builder, MongoDocumentContext<?> documentContext, DatastoreOperationConfiguration configuration, BsonValue upsertedId, PropertyBox value) { if (upsertedId != null) { final ObjectId oid = upsertedId.asObjectId().getValue(); documentContext.getDocumentIdPath().ifPresent(idp -> { final Object idPropertyValue = documentContext.getDocumentIdResolver().decode(oid, idp.getType()); builder.withInsertedKey(idp, idPropertyValue); // check bring back ids if (configuration.hasWriteOption(DefaultWriteOption.BRING_BACK_GENERATED_IDS)) { documentContext.getDocumentIdProperty().ifPresent(idprp -> { if (value.contains(idprp)) { value.setValue((Property<Object>) idprp, idPropertyValue); } }); } }); } }
/** * Get the {@link WriteOption} of given type, if avaible. * <p> * When more than one {@link WriteOption} of given type is available, the first available one is returned. * </p> * @param <WO> WriteOption type * @param type WriteOption type to look for (not null) * @return Optional write option of given type */ @SuppressWarnings("unchecked") default <WO extends WriteOption> Optional<WO> getWriteOption(Class<WO> type) { ObjectUtils.argumentNotNull(type, "Write option type be not null"); return getWriteOptions().stream().filter(wo -> type.isAssignableFrom(wo.getClass())).map(wo -> (WO) wo) .findFirst(); }