Examples with FullDocument com.mongodb.client.model.changestream.FullDocument used on opensource projects

Example 1 with FullDocument

use of com.mongodb.client.model.changestream.FullDocument in project mongo-java-driver by mongodb.

the class DocumentationSamples method testWatch.

@Test
public void testWatch() throws InterruptedException {
    assumeTrue(isDiscoverableReplicaSet() && serverVersionAtLeast(3, 6));
    final MongoCollection<Document> inventory = collection;
    final AtomicBoolean stop = new AtomicBoolean(false);
    Thread thread = new Thread(new Runnable() {

        @Override
        public void run() {
            while (!stop.get()) {
                collection.insertMany(asList(new Document("username", "alice"), new Document()));
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                // ignore
                }
                collection.deleteOne(new Document("username", "alice"));
            }
        }
    });
    thread.start();
    // Start Changestream Example 1
    MongoCursor<ChangeStreamDocument<Document>> cursor = inventory.watch().iterator();
    ChangeStreamDocument<Document> next = cursor.next();
    // End Changestream Example 1
    cursor.close();
    // Start Changestream Example 2
    cursor = inventory.watch().fullDocument(FullDocument.UPDATE_LOOKUP).iterator();
    next = cursor.next();
    // End Changestream Example 2
    cursor.close();
    // Start Changestream Example 3
    BsonDocument resumeToken = next.getResumeToken();
    cursor = inventory.watch().resumeAfter(resumeToken).iterator();
    next = cursor.next();
    // End Changestream Example 3
    cursor.close();
    // Start Changestream Example 4
    List<Bson> pipeline = asList(match(Document.parse("{'fullDocument.username': 'alice'}")), addFields(new Field<String>("newField", "this is an added field!")));
    cursor = inventory.watch(pipeline).iterator();
    next = cursor.next();
    // End Changestream Example 4
    cursor.close();
    stop.set(true);
    thread.join();
}

Example 2 with FullDocument

use of com.mongodb.client.model.changestream.FullDocument in project immutables by immutables.

the class MongoSession method watch.

private <X> Publisher<WatchEvent<X>> watch(StandardOperations.Watch operation) {
    final MongoCollection<X> collection = (MongoCollection<X>) this.collection;
    if (operation.query().hasProjections()) {
        return Flowable.error(new UnsupportedOperationException("Projections are not yet supported with watch operation"));
    }
    ChangeStreamPublisher<X> watch;
    if (!operation.query().filter().isPresent()) {
        // watch without filter
        watch = collection.watch(collection.getDocumentClass());
    } else {
        // prefix all attributes with 'fullDocument.'
        PathNaming naming = path -> "fullDocument." + this.pathNaming.name(path);
        // reuse aggregation pipeline
        AggregationQuery agg = new AggregationQuery(operation.query(), naming);
        watch = collection.watch(agg.toPipeline(), collection.getDocumentClass());
    }
    return Flowable.fromPublisher(watch.fullDocument(FullDocument.UPDATE_LOOKUP)).map(MongoWatchEvent::fromChangeStream);
}

Example 3 with FullDocument

use of com.mongodb.client.model.changestream.FullDocument in project spring-data-mongodb by spring-projects.

the class ReactiveMongoTemplate method changeStream.

@Override
public <T> Flux<ChangeStreamEvent<T>> changeStream(@Nullable String database, @Nullable String collectionName, ChangeStreamOptions options, Class<T> targetType) {
    List<Document> filter = prepareFilter(options);
    FullDocument fullDocument = ClassUtils.isAssignable(Document.class, targetType) ? FullDocument.DEFAULT : FullDocument.UPDATE_LOOKUP;
    return // 
    ReactiveMongoDatabaseUtils.getDatabase(database, mongoDatabaseFactory).map(db -> {
        ChangeStreamPublisher<Document> publisher;
        if (StringUtils.hasText(collectionName)) {
            publisher = filter.isEmpty() ? db.getCollection(collectionName).watch(Document.class) : db.getCollection(collectionName).watch(filter, Document.class);
        } else {
            publisher = filter.isEmpty() ? db.watch(Document.class) : db.watch(filter, Document.class);
        }
        publisher = options.getResumeToken().map(BsonValue::asDocument).map(publisher::resumeAfter).orElse(publisher);
        publisher = options.getCollation().map(Collation::toMongoCollation).map(publisher::collation).orElse(publisher);
        publisher = options.getResumeBsonTimestamp().map(publisher::startAtOperationTime).orElse(publisher);
        return publisher.fullDocument(options.getFullDocumentLookup().orElse(fullDocument));
    }).flatMapMany(publisher -> Flux.from(publisher).map(document -> new ChangeStreamEvent<>(document, targetType, getConverter())));
}

Example 4 with FullDocument

use of com.mongodb.client.model.changestream.FullDocument in project mongo-java-driver by mongodb.

the class ChangeStreamSamples method main.

/**
 * Run this main method to see the output of this quick example.
 *
 * @param args takes an optional single argument for the connection string
 */
public static void main(final String[] args) {
    MongoClient mongoClient;
    if (args.length == 0) {
        // connect to the local database server
        mongoClient = MongoClients.create("mongodb://localhost:27017,localhost:27018,localhost:27019");
    } else {
        mongoClient = MongoClients.create(args[0]);
    }
    // Select the MongoDB database.
    MongoDatabase database = mongoClient.getDatabase("testChangeStreams");
    database.drop();
    sleep();
    // Select the collection to query.
    MongoCollection<Document> collection = database.getCollection("documents");
    /*
         * Example 1
         * Create a simple change stream against an existing collection.
         */
    System.out.println("1. Initial document from the Change Stream:");
    // Create the change stream cursor.
    MongoChangeStreamCursor<ChangeStreamDocument<Document>> cursor = collection.watch().cursor();
    // Insert a test document into the collection.
    collection.insertOne(Document.parse("{username: 'alice123', name: 'Alice'}"));
    ChangeStreamDocument<Document> next = cursor.next();
    System.out.println(next);
    cursor.close();
    sleep();
    /*
         * Example 2
         * Create a change stream with 'lookup' option enabled.
         * The test document will be returned with a full version of the updated document.
         */
    System.out.println("2. Document from the Change Stream, with lookup enabled:");
    // Create the change stream cursor.
    cursor = collection.watch().fullDocument(FullDocument.UPDATE_LOOKUP).cursor();
    // Update the test document.
    collection.updateOne(Document.parse("{username: 'alice123'}"), Document.parse("{$set : { email: 'alice@example.com'}}"));
    // Block until the next result is returned
    next = cursor.next();
    System.out.println(next);
    cursor.close();
    sleep();
    /*
         * Example 3
         * Create a change stream with 'lookup' option using a $match and ($redact or $project) stage.
         */
    System.out.println("3. Document from the Change Stream, with lookup enabled, matching `update` operations only: ");
    // Insert some dummy data.
    collection.insertMany(asList(Document.parse("{updateMe: 1}"), Document.parse("{replaceMe: 1}")));
    // Create $match pipeline stage.
    List<Bson> pipeline = singletonList(Aggregates.match(Filters.or(Document.parse("{'fullDocument.username': 'alice123'}"), Filters.in("operationType", asList("update", "replace", "delete")))));
    // Create the change stream cursor with $match.
    cursor = collection.watch(pipeline).fullDocument(FullDocument.UPDATE_LOOKUP).cursor();
    // Forward to the end of the change stream
    next = cursor.tryNext();
    // Update the test document.
    collection.updateOne(Filters.eq("updateMe", 1), Updates.set("updated", true));
    next = cursor.next();
    System.out.println(format("Update operationType: %s %n %s", next.getUpdateDescription(), next));
    // Replace the test document.
    collection.replaceOne(Filters.eq("replaceMe", 1), Document.parse("{replaced: true}"));
    next = cursor.next();
    System.out.println(format("Replace operationType: %s", next));
    // Delete the test document.
    collection.deleteOne(Filters.eq("username", "alice123"));
    next = cursor.next();
    System.out.println(format("Delete operationType: %s", next));
    cursor.close();
    sleep();
    /**
     * Example 4
     * Resume a change stream using a resume token.
     */
    System.out.println("4. Document from the Change Stream including a resume token:");
    // Get the resume token from the last document we saw in the previous change stream cursor.
    BsonDocument resumeToken = cursor.getResumeToken();
    System.out.println(resumeToken);
    // Pass the resume token to the resume after function to continue the change stream cursor.
    cursor = collection.watch().resumeAfter(resumeToken).cursor();
    // Insert a test document.
    collection.insertOne(Document.parse("{test: 'd'}"));
    // Block until the next result is returned
    next = cursor.next();
    System.out.println(next);
    cursor.close();
}

Example 5 with FullDocument

use of com.mongodb.client.model.changestream.FullDocument in project spring-data-mongodb by spring-projects.

the class ChangeStreamTask method initCursor.

/*
	 * (non-Javadoc)
	 * @see org.springframework.data.mongodb.core.messaging.CursorReadingTask#initCursor(org.springframework.data.mongodb.core.MongoTemplate, org.springframework.data.mongodb.core.messaging.SubscriptionRequest.RequestOptions, java.lang.Class)
	 */
@Override
protected MongoCursor<ChangeStreamDocument<Document>> initCursor(MongoTemplate template, RequestOptions options, Class<?> targetType) {
    List<Document> filter = Collections.emptyList();
    BsonDocument resumeToken = new BsonDocument();
    Collation collation = null;
    FullDocument fullDocument = ClassUtils.isAssignable(Document.class, targetType) ? FullDocument.DEFAULT : FullDocument.UPDATE_LOOKUP;
    BsonTimestamp startAt = null;
    boolean resumeAfter = true;
    if (options instanceof ChangeStreamRequest.ChangeStreamRequestOptions) {
        ChangeStreamOptions changeStreamOptions = ((ChangeStreamRequestOptions) options).getChangeStreamOptions();
        filter = prepareFilter(template, changeStreamOptions);
        if (changeStreamOptions.getFilter().isPresent()) {
            Object val = changeStreamOptions.getFilter().get();
            if (val instanceof Aggregation) {
                collation = ((Aggregation) val).getOptions().getCollation().map(org.springframework.data.mongodb.core.query.Collation::toMongoCollation).orElse(null);
            }
        }
        if (changeStreamOptions.getResumeToken().isPresent()) {
            resumeToken = changeStreamOptions.getResumeToken().get().asDocument();
            resumeAfter = changeStreamOptions.isResumeAfter();
        }
        fullDocument = changeStreamOptions.getFullDocumentLookup().orElseGet(() -> ClassUtils.isAssignable(Document.class, targetType) ? FullDocument.DEFAULT : FullDocument.UPDATE_LOOKUP);
        startAt = changeStreamOptions.getResumeBsonTimestamp().orElse(null);
    }
    MongoDatabase db = StringUtils.hasText(options.getDatabaseName()) ? template.getMongoDbFactory().getMongoDatabase(options.getDatabaseName()) : template.getDb();
    ChangeStreamIterable<Document> iterable;
    if (StringUtils.hasText(options.getCollectionName())) {
        iterable = filter.isEmpty() ? db.getCollection(options.getCollectionName()).watch(Document.class) : db.getCollection(options.getCollectionName()).watch(filter, Document.class);
    } else {
        iterable = filter.isEmpty() ? db.watch(Document.class) : db.watch(filter, Document.class);
    }
    if (!options.maxAwaitTime().isZero()) {
        iterable = iterable.maxAwaitTime(options.maxAwaitTime().toMillis(), TimeUnit.MILLISECONDS);
    }
    if (!resumeToken.isEmpty()) {
        if (resumeAfter) {
            iterable = iterable.resumeAfter(resumeToken);
        } else {
            iterable = iterable.startAfter(resumeToken);
        }
    }
    if (startAt != null) {
        iterable.startAtOperationTime(startAt);
    }
    if (collation != null) {
        iterable = iterable.collation(collation);
    }
    iterable = iterable.fullDocument(fullDocument);
    return iterable.iterator();
}