/** * Creates a filter that preforms a logical OR of the provided list of filters. * * @param filters the list of filters to and together * @return the filter * @mongodb.driver.manual reference/operator/query/or $or */ public static Bson or(final Bson... filters) { return or(asList(filters)); }
@Override public void upgrade() { final FindIterable<Document> documentsWithMissingFields = collection.find(or(not(exists(ContentPack.FIELD_META_ID)), not(exists(ContentPack.FIELD_META_REVISION)))); for (Document document : documentsWithMissingFields) { final ObjectId objectId = document.getObjectId("_id"); LOG.debug("Found document with missing \"id\" or \"rev\" field with ID <{}>", objectId); final String id = document.get("id", objectId.toHexString()); final int rev = document.get("rev", 0); document.put("id", id); document.put("rev", rev); final UpdateResult updateResult = collection.replaceOne(eq("_id", objectId), document); if (updateResult.wasAcknowledged()) { LOG.debug("Successfully updated document with ID <{}>", objectId); } else { LOG.error("Failed to update document with ID <{}>", objectId); } } } }
/** * Creates a filter that preforms a logical OR of the provided list of filters. * * @param filters the list of filters to and together * @return the filter * @mongodb.driver.manual reference/operator/query/or $or */ public static Bson or(final Bson... filters) { return or(asList(filters)); }
@Override public Bson visitOr(final Stream<Bson> disjoints) { return Filters.or(disjoints.collect(Collectors.toList())); } }
@Override public Bson visitOr(final Stream<Bson> disjoints) { return Filters.or(disjoints.collect(Collectors.toList())); } }
private Optional<Bson> visitAndOrNor(final Stream<Optional<Bson>> components) { final List<Bson> filters = components .flatMap(filter -> filter.map(Stream::of).orElse(Stream.empty())) .collect(Collectors.toList()); if (filters.isEmpty()) { return Optional.empty(); } else { return Optional.of(Filters.or(filters)); } }
private Bson createManagedTypeQuery(Set<ManagedType> managedTypes, boolean aggregate) { List<Bson> classFilters = managedTypes.stream().map( managedType -> { if (managedType instanceof ValueObjectType) { return createValueObjectTypeQuery(managedType); } else { return createEntityTypeQuery(aggregate, managedType); } }).collect(toImmutableList()); return Filters.or(classFilters); }
private Bson createManagedTypeQuery(Set<ManagedType> managedTypes, boolean aggregate) { List<Bson> classFilters = managedTypes.stream().map( managedType -> { if (managedType instanceof ValueObjectType) { return createValueObjectTypeQuery(managedType); } else { return createEntityTypeQuery(aggregate, managedType); } }).collect(toImmutableList()); return Filters.or(classFilters); }
private Bson getAcquireLockQuery(String lockKey, String owner, boolean onlyIfSameOwner) { final Bson expiresAtCond = Filters.lt(LockEntry.EXPIRES_AT_FIELD, new Date()); final Bson ownerCond = Filters.eq(LockEntry.OWNER_FIELD, owner); final Bson orCond = onlyIfSameOwner ? Filters.or(ownerCond) : Filters.or(expiresAtCond, ownerCond); return Filters .and(Filters.eq(LockEntry.KEY_FIELD, lockKey), Filters.eq(LockEntry.STATUS_FIELD, LockStatus.LOCK_HELD.name()), orCond); }
private Bson createSnapshotIdentifiersQuery(Collection<SnapshotIdentifier> snapshotIdentifiers) { List<Bson> descFilters = snapshotIdentifiers.stream().map( snapshotIdentifier -> Filters.and( createIdQuery(snapshotIdentifier.getGlobalId()), createVersionQuery(snapshotIdentifier.getVersion()) )).collect(toImmutableList()); return Filters.or(descFilters); }
@Override public BsonFilterExpression visit(NullFilter filter, MongoResolutionContext<?> context) { // not exists or it is not null return resolveFieldName(filter.getLeftOperand(), context) .map(fn -> Filters.or(Filters.not(Filters.exists(fn)), Filters.type(fn, BsonType.NULL))) .map(bson -> BsonFilterExpression.create(bson)).orElse(null); }
private Bson createSnapshotIdentifiersQuery(Collection<SnapshotIdentifier> snapshotIdentifiers) { List<Bson> descFilters = snapshotIdentifiers.stream().map( snapshotIdentifier -> Filters.and( createIdQuery(snapshotIdentifier.getGlobalId()), createVersionQuery(snapshotIdentifier.getVersion()) )).collect(toImmutableList()); return Filters.or(descFilters); }
@Override public Function<Boolean, Optional<Bson>> visitNor(final Stream<Function<Boolean, Optional<Bson>>> negativeDisjoints) { return buildCompositeBsonCreator(negativeDisjoints, isPostive -> !isPostive, children -> Filters.nor(Filters.and(children)), children -> Filters.nor(Filters.or(children))); }
@Override public Function<Boolean, Optional<Bson>> visitNor(final Stream<Function<Boolean, Optional<Bson>>> negativeDisjoints) { return buildCompositeBsonCreator(negativeDisjoints, isPostive -> !isPostive, children -> Filters.nor(Filters.and(children)), children -> Filters.nor(Filters.or(children))); }
private static Bson createInitialMatchStageWithDeleted(final Criteria filterCriteria, final Criteria aclCriteria, final Criteria globalPolicyGrantsCriteria) { final Bson authorization = or(CreateBsonVisitor.apply(globalPolicyGrantsCriteria), CreateBsonVisitor.apply(aclCriteria)); return match(and(authorization, CreateBsonVisitor.apply(filterCriteria))); }
private static Bson createInitialMatchStageWithDeleted(final Criteria filterCriteria, final Criteria aclCriteria, final Criteria globalPolicyGrantsCriteria) { final Bson authorization = or(CreateBsonVisitor.apply(globalPolicyGrantsCriteria), CreateBsonVisitor.apply(aclCriteria)); return match(and(authorization, CreateBsonVisitor.apply(filterCriteria))); }
private static Bson createInitialMatchStageWithNonDeleted(final Criteria filterCriteria, final Criteria aclCriteria, final Criteria globalPolicyGrantsCriteria) { final Bson authorization = or(CreateBsonVisitor.apply(globalPolicyGrantsCriteria), CreateBsonVisitor.apply(aclCriteria)); return match(and(authorization, filterNotDeleted(), CreateBsonVisitor.apply(filterCriteria))); }
private static Bson filterWithLowerThingRevisionOrLowerPolicyRevision(final String thingId, final long revision, final long policyRevision) { // In case of a policy update, it is ok when the current thing revision is equal to new one (must not be // less than! final Bson thingLowerRevision = lt(FIELD_REVISION, revision); final Bson policyLowerRevision = and( lt(FIELD_POLICY_REVISION, policyRevision), lte(FIELD_REVISION, revision)); return and(eq(FIELD_ID, thingId), or(thingLowerRevision, policyLowerRevision)); }
@Override public boolean isRecoveryNeeded() { Bson query = Filters.and( Filters.eq(ClusterNodeInfo.STATE, ClusterNodeInfo.ClusterNodeState.ACTIVE.name()), Filters.or( Filters.lt(ClusterNodeInfo.LEASE_END_KEY, clock.getTime()), Filters.eq(ClusterNodeInfo.REV_RECOVERY_LOCK, ClusterNodeInfo.RecoverLockState.ACQUIRED.name()) ) ); return getClusterNodeCollection().find(query).iterator().hasNext(); }
@Override public boolean isRecoveryNeeded() { Bson query = Filters.and( Filters.eq(ClusterNodeInfo.STATE, ClusterNodeInfo.ClusterNodeState.ACTIVE.name()), Filters.or( Filters.lt(ClusterNodeInfo.LEASE_END_KEY, clock.getTime()), Filters.eq(ClusterNodeInfo.REV_RECOVERY_LOCK, ClusterNodeInfo.RecoverLockState.ACQUIRED.name()) ) ); return getClusterNodeCollection().find(query).iterator().hasNext(); }