com.mongodb.async.client.MongoCollectionImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of mongodb-driver-async Show documentation
Show all versions of mongodb-driver-async Show documentation
The MongoDB Asynchronous Driver
/*
* Copyright 2008-present MongoDB, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.mongodb.async.client;
import com.mongodb.MongoBulkWriteException;
import com.mongodb.MongoInternalException;
import com.mongodb.MongoNamespace;
import com.mongodb.MongoWriteConcernException;
import com.mongodb.MongoWriteException;
import com.mongodb.ReadConcern;
import com.mongodb.ReadPreference;
import com.mongodb.WriteConcern;
import com.mongodb.WriteConcernResult;
import com.mongodb.WriteError;
import com.mongodb.async.SingleResultCallback;
import com.mongodb.bulk.BulkWriteResult;
import com.mongodb.bulk.WriteRequest;
import com.mongodb.client.model.AggregationLevel;
import com.mongodb.client.model.BulkWriteOptions;
import com.mongodb.client.model.CountOptions;
import com.mongodb.client.model.CreateIndexOptions;
import com.mongodb.client.model.DeleteOptions;
import com.mongodb.client.model.DropIndexOptions;
import com.mongodb.client.model.EstimatedDocumentCountOptions;
import com.mongodb.client.model.FindOneAndDeleteOptions;
import com.mongodb.client.model.FindOneAndReplaceOptions;
import com.mongodb.client.model.FindOneAndUpdateOptions;
import com.mongodb.client.model.IndexModel;
import com.mongodb.client.model.IndexOptions;
import com.mongodb.client.model.InsertManyOptions;
import com.mongodb.client.model.InsertOneOptions;
import com.mongodb.client.model.RenameCollectionOptions;
import com.mongodb.client.model.ReplaceOptions;
import com.mongodb.client.model.UpdateOptions;
import com.mongodb.client.model.WriteModel;
import com.mongodb.client.model.changestream.ChangeStreamLevel;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.mongodb.internal.client.model.CountStrategy;
import com.mongodb.internal.operation.AsyncOperations;
import com.mongodb.internal.operation.IndexHelper;
import com.mongodb.lang.Nullable;
import com.mongodb.operation.AsyncWriteOperation;
import org.bson.BsonDocument;
import org.bson.BsonValue;
import org.bson.Document;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.conversions.Bson;
import java.util.Collections;
import java.util.List;
import static com.mongodb.assertions.Assertions.notNull;
import static com.mongodb.bulk.WriteRequest.Type.DELETE;
import static com.mongodb.bulk.WriteRequest.Type.INSERT;
import static com.mongodb.bulk.WriteRequest.Type.REPLACE;
import static com.mongodb.bulk.WriteRequest.Type.UPDATE;
import static com.mongodb.client.model.ReplaceOptions.createReplaceOptions;
import static com.mongodb.internal.client.model.CountOptionsHelper.fromEstimatedDocumentCountOptions;
import static java.util.Collections.singletonList;
class MongoCollectionImpl implements MongoCollection {
private final MongoNamespace namespace;
private final Class documentClass;
private final ReadPreference readPreference;
private final CodecRegistry codecRegistry;
private final WriteConcern writeConcern;
private final boolean retryWrites;
private final boolean retryReads;
private final ReadConcern readConcern;
private final OperationExecutor executor;
private final AsyncOperations operations;
MongoCollectionImpl(final MongoNamespace namespace, final Class documentClass, final CodecRegistry codecRegistry,
final ReadPreference readPreference, final WriteConcern writeConcern, final boolean retryWrites,
final boolean retryReads, final ReadConcern readConcern, final OperationExecutor executor) {
this.namespace = notNull("namespace", namespace);
this.documentClass = notNull("documentClass", documentClass);
this.codecRegistry = notNull("codecRegistry", codecRegistry);
this.readPreference = notNull("readPreference", readPreference);
this.writeConcern = notNull("writeConcern", writeConcern);
this.retryWrites = retryWrites;
this.retryReads = retryReads;
this.readConcern = notNull("readConcern", readConcern);
this.executor = notNull("executor", executor);
this.operations = new AsyncOperations(namespace, documentClass, readPreference, codecRegistry, readConcern, writeConcern,
retryWrites, retryReads);
}
@Override
public MongoNamespace getNamespace() {
return namespace;
}
@Override
public Class getDocumentClass() {
return documentClass;
}
@Override
public CodecRegistry getCodecRegistry() {
return codecRegistry;
}
@Override
public ReadPreference getReadPreference() {
return readPreference;
}
@Override
public WriteConcern getWriteConcern() {
return writeConcern;
}
@Override
public ReadConcern getReadConcern() {
return readConcern;
}
@Override
public MongoCollection withDocumentClass(final Class newDocumentClass) {
return new MongoCollectionImpl(namespace, newDocumentClass, codecRegistry, readPreference, writeConcern, retryWrites,
retryReads, readConcern, executor);
}
@Override
public MongoCollection withCodecRegistry(final CodecRegistry codecRegistry) {
return new MongoCollectionImpl(namespace, documentClass, codecRegistry, readPreference, writeConcern, retryWrites,
retryReads, readConcern, executor);
}
@Override
public MongoCollection withReadPreference(final ReadPreference readPreference) {
return new MongoCollectionImpl(namespace, documentClass, codecRegistry, readPreference, writeConcern, retryWrites,
retryReads, readConcern, executor);
}
@Override
public MongoCollection withWriteConcern(final WriteConcern writeConcern) {
return new MongoCollectionImpl(namespace, documentClass, codecRegistry, readPreference, writeConcern, retryWrites,
retryReads, readConcern, executor);
}
@Override
public MongoCollection withReadConcern(final ReadConcern readConcern) {
return new MongoCollectionImpl(namespace, documentClass, codecRegistry, readPreference, writeConcern, retryWrites,
retryReads, readConcern, executor);
}
@Override
@SuppressWarnings("deprecation")
public void count(final SingleResultCallback callback) {
count(new BsonDocument(), callback);
}
@Override
@SuppressWarnings("deprecation")
public void count(final Bson filter, final SingleResultCallback callback) {
count(filter, new CountOptions(), callback);
}
@Override
@SuppressWarnings("deprecation")
public void count(final Bson filter, final CountOptions options, final SingleResultCallback callback) {
executeCount(null, filter, options, CountStrategy.COMMAND, callback);
}
@Override
@SuppressWarnings("deprecation")
public void count(final ClientSession clientSession, final SingleResultCallback callback) {
count(clientSession, new BsonDocument(), callback);
}
@Override
@SuppressWarnings("deprecation")
public void count(final ClientSession clientSession, final Bson filter, final SingleResultCallback callback) {
count(clientSession, filter, new CountOptions(), callback);
}
@Override
@SuppressWarnings("deprecation")
public void count(final ClientSession clientSession, final Bson filter, final CountOptions options,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeCount(clientSession, filter, options, CountStrategy.COMMAND, callback);
}
@Override
public void countDocuments(final SingleResultCallback callback) {
countDocuments(new BsonDocument(), callback);
}
@Override
public void countDocuments(final Bson filter, final SingleResultCallback callback) {
countDocuments(filter, new CountOptions(), callback);
}
@Override
public void countDocuments(final Bson filter, final CountOptions options, final SingleResultCallback callback) {
executeCount(null, filter, options, CountStrategy.AGGREGATE, callback);
}
@Override
public void countDocuments(final ClientSession clientSession, final SingleResultCallback callback) {
countDocuments(clientSession, new BsonDocument(), callback);
}
@Override
public void countDocuments(final ClientSession clientSession, final Bson filter, final SingleResultCallback callback) {
countDocuments(clientSession, filter, new CountOptions(), callback);
}
@Override
public void countDocuments(final ClientSession clientSession, final Bson filter, final CountOptions options,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeCount(clientSession, filter, options, CountStrategy.AGGREGATE, callback);
}
@Override
public void estimatedDocumentCount(final SingleResultCallback callback) {
estimatedDocumentCount(new EstimatedDocumentCountOptions(), callback);
}
@Override
public void estimatedDocumentCount(final EstimatedDocumentCountOptions options, final SingleResultCallback callback) {
executeCount(null, new BsonDocument(), fromEstimatedDocumentCountOptions(options), CountStrategy.COMMAND, callback);
}
private void executeCount(@Nullable final ClientSession clientSession, final Bson filter, final CountOptions options,
final CountStrategy countStrategy, final SingleResultCallback callback) {
executor.execute(operations.count(filter, options, countStrategy), readPreference, readConcern, clientSession, callback);
}
@Override
public DistinctIterable distinct(final String fieldName, final Class resultClass) {
return distinct(fieldName, new BsonDocument(), resultClass);
}
@Override
public DistinctIterable distinct(final String fieldName, final Bson filter, final Class resultClass) {
return createDistinctIterable(null, fieldName, filter, resultClass);
}
@Override
public DistinctIterable distinct(final ClientSession clientSession, final String fieldName,
final Class resultClass) {
return distinct(clientSession, fieldName, new BsonDocument(), resultClass);
}
@Override
public DistinctIterable distinct(final ClientSession clientSession, final String fieldName, final Bson filter,
final Class resultClass) {
notNull("clientSession", clientSession);
return createDistinctIterable(clientSession, fieldName, filter, resultClass);
}
private DistinctIterable createDistinctIterable(@Nullable final ClientSession clientSession, final String fieldName,
final Bson filter, final Class resultClass) {
return new DistinctIterableImpl(clientSession, namespace, documentClass, resultClass, codecRegistry,
readPreference, readConcern, executor, fieldName, filter, retryReads);
}
@Override
public FindIterable find() {
return find(new BsonDocument(), documentClass);
}
@Override
public FindIterable find(final Class resultClass) {
return find(new BsonDocument(), resultClass);
}
@Override
public FindIterable find(final Bson filter) {
return find(filter, documentClass);
}
@Override
public FindIterable find(final Bson filter, final Class resultClass) {
return createFindIterable(null, filter, resultClass);
}
@Override
public FindIterable find(final ClientSession clientSession) {
return find(clientSession, new BsonDocument(), documentClass);
}
@Override
public FindIterable find(final ClientSession clientSession, final Class resultClass) {
return find(clientSession, new BsonDocument(), resultClass);
}
@Override
public FindIterable find(final ClientSession clientSession, final Bson filter) {
return find(clientSession, filter, documentClass);
}
@Override
public FindIterable find(final ClientSession clientSession, final Bson filter, final Class resultClass) {
notNull("clientSession", clientSession);
return createFindIterable(clientSession, filter, resultClass);
}
private FindIterable createFindIterable(@Nullable final ClientSession clientSession, final Bson filter,
final Class resultClass) {
return new FindIterableImpl(clientSession, namespace, documentClass, resultClass, codecRegistry,
readPreference, readConcern, executor, filter, retryReads);
}
@Override
public AggregateIterable aggregate(final List pipeline) {
return aggregate(pipeline, documentClass);
}
@Override
public AggregateIterable aggregate(final List pipeline, final Class resultClass) {
return createAggregateIterable(null, pipeline, resultClass);
}
@Override
public AggregateIterable aggregate(final ClientSession clientSession, final List pipeline) {
return aggregate(clientSession, pipeline, documentClass);
}
@Override
public AggregateIterable aggregate(final ClientSession clientSession, final List pipeline,
final Class resultClass) {
notNull("clientSession", clientSession);
return createAggregateIterable(clientSession, pipeline, resultClass);
}
private AggregateIterable createAggregateIterable(@Nullable final ClientSession clientSession,
final List pipeline,
final Class resultClass) {
return new AggregateIterableImpl(clientSession, namespace, documentClass, resultClass, codecRegistry,
readPreference, readConcern, writeConcern, executor, pipeline, AggregationLevel.COLLECTION, retryReads);
}
@Override
public ChangeStreamIterable watch() {
return watch(Collections.emptyList());
}
@Override
public ChangeStreamIterable watch(final Class resultClass) {
return watch(Collections.emptyList(), resultClass);
}
@Override
public ChangeStreamIterable watch(final List pipeline) {
return watch(pipeline, documentClass);
}
@Override
public ChangeStreamIterable watch(final List pipeline, final Class resultClass) {
return createChangeStreamIterable(null, pipeline, resultClass);
}
@Override
public ChangeStreamIterable watch(final ClientSession clientSession) {
return watch(clientSession, Collections.emptyList());
}
@Override
public ChangeStreamIterable watch(final ClientSession clientSession, final Class resultClass) {
return watch(clientSession, Collections.emptyList(), resultClass);
}
@Override
public ChangeStreamIterable watch(final ClientSession clientSession, final List pipeline) {
return watch(clientSession, pipeline, documentClass);
}
@Override
public ChangeStreamIterable watch(final ClientSession clientSession, final List pipeline,
final Class resultClass) {
notNull("clientSession", clientSession);
return createChangeStreamIterable(clientSession, pipeline, resultClass);
}
private ChangeStreamIterable createChangeStreamIterable(@Nullable final ClientSession clientSession,
final List pipeline,
final Class resultClass) {
return new ChangeStreamIterableImpl(clientSession, namespace, codecRegistry, readPreference, readConcern, executor,
pipeline, resultClass, ChangeStreamLevel.COLLECTION, retryReads);
}
@Override
public MapReduceIterable mapReduce(final String mapFunction, final String reduceFunction) {
return mapReduce(mapFunction, reduceFunction, documentClass);
}
@Override
public MapReduceIterable mapReduce(final String mapFunction, final String reduceFunction,
final Class resultClass) {
return createMapReduceIterable(null, mapFunction, reduceFunction, resultClass);
}
@Override
public MapReduceIterable mapReduce(final ClientSession clientSession, final String mapFunction,
final String reduceFunction) {
return mapReduce(clientSession, mapFunction, reduceFunction, documentClass);
}
@Override
public MapReduceIterable mapReduce(final ClientSession clientSession, final String mapFunction,
final String reduceFunction, final Class resultClass) {
notNull("clientSession", clientSession);
return createMapReduceIterable(clientSession, mapFunction, reduceFunction, resultClass);
}
private MapReduceIterable createMapReduceIterable(@Nullable final ClientSession clientSession,
final String mapFunction, final String reduceFunction,
final Class resultClass) {
return new MapReduceIterableImpl(clientSession, namespace, documentClass, resultClass, codecRegistry,
readPreference, readConcern, writeConcern, executor, mapFunction, reduceFunction);
}
@Override
public void bulkWrite(final List> requests,
final SingleResultCallback callback) {
bulkWrite(requests, new BulkWriteOptions(), callback);
}
@Override
public void bulkWrite(final List> requests, final BulkWriteOptions options,
final SingleResultCallback callback) {
executeBulkWrite(null, requests, options, callback);
}
@Override
public void bulkWrite(final ClientSession clientSession, final List> requests,
final SingleResultCallback callback) {
bulkWrite(clientSession, requests, new BulkWriteOptions(), callback);
}
@Override
public void bulkWrite(final ClientSession clientSession, final List> requests,
final BulkWriteOptions options, final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeBulkWrite(clientSession, requests, options, callback);
}
@SuppressWarnings("unchecked")
private void executeBulkWrite(@Nullable final ClientSession clientSession,
final List> requests,
final BulkWriteOptions options, final SingleResultCallback callback) {
notNull("requests", requests);
executor.execute(operations.bulkWrite(requests, options), readConcern, clientSession, callback);
}
@Override
public void insertOne(final TDocument document, final SingleResultCallback callback) {
insertOne(document, new InsertOneOptions(), callback);
}
@Override
public void insertOne(final TDocument document, final InsertOneOptions options, final SingleResultCallback callback) {
executeInsertOne(null, document, options, callback);
}
@Override
public void insertOne(final ClientSession clientSession, final TDocument document, final SingleResultCallback callback) {
insertOne(clientSession, document, new InsertOneOptions(), callback);
}
@Override
public void insertOne(final ClientSession clientSession, final TDocument document, final InsertOneOptions options,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeInsertOne(clientSession, document, options, callback);
}
private void executeInsertOne(@Nullable final ClientSession clientSession, final TDocument document, final InsertOneOptions options,
final SingleResultCallback callback) {
executeSingleWriteRequest(clientSession, operations.insertOne(document, options), INSERT,
new SingleResultCallback() {
@Override
public void onResult(final BulkWriteResult result, final Throwable t) {
callback.onResult(null, t);
}
});
}
@Override
public void insertMany(final List documents, final SingleResultCallback callback) {
insertMany(documents, new InsertManyOptions(), callback);
}
@Override
public void insertMany(final List documents, final InsertManyOptions options,
final SingleResultCallback callback) {
executeInsertMany(null, documents, options, callback);
}
@Override
public void insertMany(final ClientSession clientSession, final List documents,
final SingleResultCallback callback) {
insertMany(clientSession, documents, new InsertManyOptions(), callback);
}
@Override
public void insertMany(final ClientSession clientSession, final List documents, final InsertManyOptions options,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeInsertMany(clientSession, documents, options, callback);
}
private void executeInsertMany(@Nullable final ClientSession clientSession, final List documents,
final InsertManyOptions options, final SingleResultCallback callback) {
executor.execute(operations.insertMany(documents, options), readConcern, clientSession,
new SingleResultCallback() {
@Override
public void onResult(final BulkWriteResult result, final Throwable t) {
callback.onResult(null, t);
}
});
}
@Override
public void deleteOne(final Bson filter, final SingleResultCallback callback) {
deleteOne(filter, new DeleteOptions(), callback);
}
@Override
public void deleteOne(final Bson filter, final DeleteOptions options, final SingleResultCallback callback) {
executeDelete(null, filter, options, false, callback);
}
@Override
public void deleteOne(final ClientSession clientSession, final Bson filter, final SingleResultCallback callback) {
deleteOne(clientSession, filter, new DeleteOptions(), callback);
}
@Override
public void deleteOne(final ClientSession clientSession, final Bson filter, final DeleteOptions options,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeDelete(clientSession, filter, options, false, callback);
}
@Override
public void deleteMany(final Bson filter, final SingleResultCallback callback) {
deleteMany(filter, new DeleteOptions(), callback);
}
@Override
public void deleteMany(final Bson filter, final DeleteOptions options, final SingleResultCallback callback) {
executeDelete(null, filter, options, true, callback);
}
@Override
public void deleteMany(final ClientSession clientSession, final Bson filter, final SingleResultCallback callback) {
deleteMany(clientSession, filter, new DeleteOptions(), callback);
}
@Override
public void deleteMany(final ClientSession clientSession, final Bson filter, final DeleteOptions options,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeDelete(clientSession, filter, options, true, callback);
}
private void executeDelete(@Nullable final ClientSession clientSession, final Bson filter, final DeleteOptions options,
final boolean multi, final SingleResultCallback callback) {
executeSingleWriteRequest(clientSession,
multi ? operations.deleteMany(filter, options) : operations.deleteOne(filter, options), DELETE,
new SingleResultCallback() {
@Override
public void onResult(final BulkWriteResult result, final Throwable t) {
if (t != null) {
callback.onResult(null, t);
} else {
if (result.wasAcknowledged()) {
callback.onResult(DeleteResult.acknowledged(result.getDeletedCount()), null);
} else {
callback.onResult(DeleteResult.unacknowledged(), null);
}
}
}
});
}
@Override
public void replaceOne(final Bson filter, final TDocument replacement, final SingleResultCallback callback) {
replaceOne(filter, replacement, new ReplaceOptions(), callback);
}
@Override
@SuppressWarnings("deprecation")
public void replaceOne(final Bson filter, final TDocument replacement, final UpdateOptions options,
final SingleResultCallback callback) {
replaceOne(filter, replacement, createReplaceOptions(options), callback);
}
@Override
public void replaceOne(final Bson filter, final TDocument replacement, final ReplaceOptions options,
final SingleResultCallback callback) {
executeReplaceOne(null, filter, replacement, options, callback);
}
@Override
public void replaceOne(final ClientSession clientSession, final Bson filter, final TDocument replacement,
final SingleResultCallback callback) {
replaceOne(clientSession, filter, replacement, new ReplaceOptions(), callback);
}
@Override
@SuppressWarnings("deprecation")
public void replaceOne(final ClientSession clientSession, final Bson filter, final TDocument replacement, final UpdateOptions options,
final SingleResultCallback callback) {
replaceOne(clientSession, filter, replacement, createReplaceOptions(options), callback);
}
@Override
public void replaceOne(final ClientSession clientSession, final Bson filter, final TDocument replacement, final ReplaceOptions options,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeReplaceOne(clientSession, filter, replacement, options, callback);
}
private void executeReplaceOne(@Nullable final ClientSession clientSession, final Bson filter, final TDocument replacement,
final ReplaceOptions options, final SingleResultCallback callback) {
executeSingleWriteRequest(clientSession, operations.replaceOne(filter, replacement, options), REPLACE,
new SingleResultCallback() {
@Override
public void onResult(final BulkWriteResult result, final Throwable t) {
if (t != null) {
callback.onResult(null, t);
} else {
callback.onResult(toUpdateResult(result), null);
}
}
});
}
@Override
public void updateOne(final Bson filter, final Bson update, final SingleResultCallback callback) {
updateOne(filter, update, new UpdateOptions(), callback);
}
@Override
public void updateOne(final Bson filter, final Bson update, final UpdateOptions options,
final SingleResultCallback callback) {
executeUpdate(null, filter, update, options, false, callback);
}
@Override
public void updateOne(final ClientSession clientSession, final Bson filter, final Bson update,
final SingleResultCallback callback) {
updateOne(clientSession, filter, update, new UpdateOptions(), callback);
}
@Override
public void updateOne(final ClientSession clientSession, final Bson filter, final Bson update, final UpdateOptions options,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeUpdate(clientSession, filter, update, options, false, callback);
}
@Override
public void updateOne(final Bson filter, final List update, final SingleResultCallback callback) {
updateOne(filter, update, new UpdateOptions(), callback);
}
@Override
public void updateOne(final Bson filter, final List update, final UpdateOptions options,
final SingleResultCallback callback) {
executeUpdate(null, filter, update, options, false, callback);
}
@Override
public void updateOne(final ClientSession clientSession, final Bson filter, final List update,
final SingleResultCallback callback) {
updateOne(clientSession, filter, update, new UpdateOptions(), callback);
}
@Override
public void updateOne(final ClientSession clientSession, final Bson filter, final List update,
final UpdateOptions options, final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeUpdate(clientSession, filter, update, options, false, callback);
}
@Override
public void updateMany(final Bson filter, final Bson update, final SingleResultCallback callback) {
updateMany(filter, update, new UpdateOptions(), callback);
}
@Override
public void updateMany(final Bson filter, final Bson update, final UpdateOptions options,
final SingleResultCallback callback) {
executeUpdate(null, filter, update, options, true, callback);
}
@Override
public void updateMany(final ClientSession clientSession, final Bson filter, final Bson update,
final SingleResultCallback callback) {
updateMany(clientSession, filter, update, new UpdateOptions(), callback);
}
@Override
public void updateMany(final ClientSession clientSession, final Bson filter, final Bson update, final UpdateOptions options,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeUpdate(clientSession, filter, update, options, true, callback);
}
@Override
public void updateMany(final Bson filter, final List update, final SingleResultCallback callback) {
updateMany(filter, update, new UpdateOptions(), callback);
}
@Override
public void updateMany(final Bson filter, final List update, final UpdateOptions options,
final SingleResultCallback callback) {
executeUpdate(null, filter, update, options, true, callback);
}
@Override
public void updateMany(final ClientSession clientSession, final Bson filter, final List update,
final SingleResultCallback callback) {
updateMany(clientSession, filter, update, new UpdateOptions(), callback);
}
@Override
public void updateMany(final ClientSession clientSession, final Bson filter, final List update,
final UpdateOptions options, final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeUpdate(clientSession, filter, update, options, true, callback);
}
private void executeUpdate(@Nullable final ClientSession clientSession, final Bson filter, final Bson update,
final UpdateOptions options, final boolean multi, final SingleResultCallback callback) {
executeSingleWriteRequest(clientSession,
multi ? operations.updateMany(filter, update, options) : operations.updateOne(filter, update, options), UPDATE,
new SingleResultCallback() {
@Override
public void onResult(final BulkWriteResult result, final Throwable t) {
if (t != null) {
callback.onResult(null, t);
} else {
callback.onResult(toUpdateResult(result), null);
}
}
});
}
private void executeUpdate(@Nullable final ClientSession clientSession, final Bson filter, final List update,
final UpdateOptions options, final boolean multi, final SingleResultCallback callback) {
executeSingleWriteRequest(clientSession,
multi ? operations.updateMany(filter, update, options) : operations.updateOne(filter, update, options), UPDATE,
new SingleResultCallback() {
@Override
public void onResult(final BulkWriteResult result, final Throwable t) {
if (t != null) {
callback.onResult(null, t);
} else {
callback.onResult(toUpdateResult(result), null);
}
}
});
}
@Override
public void findOneAndDelete(final Bson filter, final SingleResultCallback callback) {
findOneAndDelete(filter, new FindOneAndDeleteOptions(), callback);
}
@Override
public void findOneAndDelete(final Bson filter, final FindOneAndDeleteOptions options, final SingleResultCallback callback) {
executeFindOneAndDelete(null, filter, options, callback);
}
@Override
public void findOneAndDelete(final ClientSession clientSession, final Bson filter, final SingleResultCallback callback) {
findOneAndDelete(clientSession, filter, new FindOneAndDeleteOptions(), callback);
}
@Override
public void findOneAndDelete(final ClientSession clientSession, final Bson filter, final FindOneAndDeleteOptions options,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeFindOneAndDelete(clientSession, filter, options, callback);
}
private void executeFindOneAndDelete(@Nullable final ClientSession clientSession, final Bson filter,
final FindOneAndDeleteOptions options, final SingleResultCallback callback) {
executor.execute(operations.findOneAndDelete(filter, options), readConcern, clientSession, callback);
}
@Override
public void findOneAndReplace(final Bson filter, final TDocument replacement, final SingleResultCallback callback) {
findOneAndReplace(filter, replacement, new FindOneAndReplaceOptions(), callback);
}
@Override
public void findOneAndReplace(final Bson filter, final TDocument replacement, final FindOneAndReplaceOptions options,
final SingleResultCallback callback) {
executeFindOneAndReplace(null, filter, replacement, options, callback);
}
@Override
public void findOneAndReplace(final ClientSession clientSession, final Bson filter, final TDocument replacement,
final SingleResultCallback callback) {
findOneAndReplace(clientSession, filter, replacement, new FindOneAndReplaceOptions(), callback);
}
@Override
public void findOneAndReplace(final ClientSession clientSession, final Bson filter, final TDocument replacement,
final FindOneAndReplaceOptions options, final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeFindOneAndReplace(clientSession, filter, replacement, options, callback);
}
private void executeFindOneAndReplace(@Nullable final ClientSession clientSession, final Bson filter, final TDocument replacement,
final FindOneAndReplaceOptions options, final SingleResultCallback callback) {
executor.execute(operations.findOneAndReplace(filter, replacement, options), readConcern, clientSession, callback);
}
@Override
public void findOneAndUpdate(final Bson filter, final Bson update, final SingleResultCallback callback) {
findOneAndUpdate(filter, update, new FindOneAndUpdateOptions(), callback);
}
@Override
public void findOneAndUpdate(final Bson filter, final Bson update, final FindOneAndUpdateOptions options,
final SingleResultCallback callback) {
executeFindOneAndUpdate(null, filter, update, options, callback);
}
@Override
public void findOneAndUpdate(final ClientSession clientSession, final Bson filter, final Bson update,
final SingleResultCallback callback) {
findOneAndUpdate(clientSession, filter, update, new FindOneAndUpdateOptions(), callback);
}
@Override
public void findOneAndUpdate(final ClientSession clientSession, final Bson filter, final Bson update,
final FindOneAndUpdateOptions options, final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeFindOneAndUpdate(clientSession, filter, update, options, callback);
}
@Override
public void findOneAndUpdate(final Bson filter, final List update, final SingleResultCallback callback) {
findOneAndUpdate(filter, update, new FindOneAndUpdateOptions(), callback);
}
@Override
public void findOneAndUpdate(final Bson filter, final List update, final FindOneAndUpdateOptions options,
final SingleResultCallback callback) {
executeFindOneAndUpdate(null, filter, update, options, callback);
}
@Override
public void findOneAndUpdate(final ClientSession clientSession, final Bson filter, final List update,
final SingleResultCallback callback) {
findOneAndUpdate(clientSession, filter, update, new FindOneAndUpdateOptions(), callback);
}
@Override
public void findOneAndUpdate(final ClientSession clientSession, final Bson filter, final List update,
final FindOneAndUpdateOptions options, final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeFindOneAndUpdate(clientSession, filter, update, options, callback);
}
private void executeFindOneAndUpdate(@Nullable final ClientSession clientSession, final Bson filter, final Bson update,
final FindOneAndUpdateOptions options, final SingleResultCallback callback) {
executor.execute(operations.findOneAndUpdate(filter, update, options), readConcern, clientSession, callback);
}
private void executeFindOneAndUpdate(@Nullable final ClientSession clientSession, final Bson filter, final List update,
final FindOneAndUpdateOptions options, final SingleResultCallback callback) {
executor.execute(operations.findOneAndUpdate(filter, update, options), readConcern, clientSession, callback);
}
@Override
public void drop(final SingleResultCallback callback) {
executeDrop(null, callback);
}
@Override
public void drop(final ClientSession clientSession, final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeDrop(clientSession, callback);
}
private void executeDrop(@Nullable final ClientSession clientSession, final SingleResultCallback callback) {
executor.execute(operations.dropCollection(), readConcern, clientSession, callback);
}
@Override
public void createIndex(final Bson key, final SingleResultCallback callback) {
createIndex(key, new IndexOptions(), callback);
}
@Override
public void createIndex(final Bson key, final IndexOptions indexOptions, final SingleResultCallback callback) {
createIndexes(singletonList(new IndexModel(key, indexOptions)), new SingleResultCallback>() {
@Override
public void onResult(final List result, final Throwable t) {
if (t != null) {
callback.onResult(null, t);
} else {
callback.onResult(result.get(0), null);
}
}
});
}
@Override
public void createIndex(final ClientSession clientSession, final Bson key, final SingleResultCallback callback) {
createIndex(clientSession, key, new IndexOptions(), callback);
}
@Override
public void createIndex(final ClientSession clientSession, final Bson key, final IndexOptions indexOptions,
final SingleResultCallback callback) {
createIndexes(clientSession, singletonList(new IndexModel(key, indexOptions)), new SingleResultCallback>() {
@Override
public void onResult(final List result, final Throwable t) {
if (t != null) {
callback.onResult(null, t);
} else {
callback.onResult(result.get(0), null);
}
}
});
}
@Override
public void createIndexes(final List indexes, final SingleResultCallback> callback) {
createIndexes(indexes, new CreateIndexOptions(), callback);
}
@Override
public void createIndexes(final List indexes, final CreateIndexOptions createIndexOptions,
final SingleResultCallback> callback) {
executeCreateIndexes(null, indexes, createIndexOptions, callback);
}
@Override
public void createIndexes(final ClientSession clientSession, final List indexes,
final SingleResultCallback> callback) {
createIndexes(clientSession, indexes, new CreateIndexOptions(), callback);
}
@Override
public void createIndexes(final ClientSession clientSession, final List indexes,
final CreateIndexOptions createIndexOptions, final SingleResultCallback> callback) {
notNull("clientSession", clientSession);
executeCreateIndexes(clientSession, indexes, createIndexOptions, callback);
}
private void executeCreateIndexes(@Nullable final ClientSession clientSession, final List indexes,
final CreateIndexOptions createIndexOptions, final SingleResultCallback> callback) {
executor.execute(operations.createIndexes(indexes, createIndexOptions), readConcern, clientSession,
new SingleResultCallback() {
@Override
public void onResult(final Void result, final Throwable t) {
if (t != null) {
callback.onResult(null, t);
} else {
callback.onResult(IndexHelper.getIndexNames(indexes, codecRegistry), null);
}
}
});
}
@Override
public ListIndexesIterable listIndexes() {
return listIndexes(Document.class);
}
@Override
public ListIndexesIterable listIndexes(final Class resultClass) {
return createListIndexesIterable(null, resultClass);
}
@Override
public ListIndexesIterable listIndexes(final ClientSession clientSession) {
return listIndexes(clientSession, Document.class);
}
@Override
public ListIndexesIterable listIndexes(final ClientSession clientSession, final Class resultClass) {
notNull("clientSession", clientSession);
return createListIndexesIterable(clientSession, resultClass);
}
private ListIndexesIterable createListIndexesIterable(@Nullable final ClientSession clientSession,
final Class resultClass) {
return new ListIndexesIterableImpl(clientSession, namespace, resultClass, codecRegistry, readPreference, executor,
retryReads);
}
@Override
public void dropIndex(final String indexName, final SingleResultCallback callback) {
dropIndex(indexName, new DropIndexOptions(), callback);
}
@Override
public void dropIndex(final String indexName, final DropIndexOptions dropIndexOptions, final SingleResultCallback callback) {
executeDropIndex(null, indexName, dropIndexOptions, callback);
}
@Override
public void dropIndex(final Bson keys, final SingleResultCallback callback) {
dropIndex(keys, new DropIndexOptions(), callback);
}
@Override
public void dropIndex(final Bson keys, final DropIndexOptions dropIndexOptions, final SingleResultCallback callback) {
executeDropIndex(null, keys, dropIndexOptions, callback);
}
@Override
public void dropIndex(final ClientSession clientSession, final String indexName, final SingleResultCallback callback) {
dropIndex(clientSession, indexName, new DropIndexOptions(), callback);
}
@Override
public void dropIndex(final ClientSession clientSession, final String indexName, final DropIndexOptions dropIndexOptions,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeDropIndex(clientSession, indexName, dropIndexOptions, callback);
}
@Override
public void dropIndex(final ClientSession clientSession, final Bson keys, final SingleResultCallback callback) {
dropIndex(clientSession, keys, new DropIndexOptions(), callback);
}
@Override
public void dropIndex(final ClientSession clientSession, final Bson keys, final DropIndexOptions dropIndexOptions,
final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeDropIndex(clientSession, keys, dropIndexOptions, callback);
}
@Override
public void dropIndexes(final SingleResultCallback callback) {
dropIndexes(new DropIndexOptions(), callback);
}
@Override
public void dropIndexes(final DropIndexOptions dropIndexOptions, final SingleResultCallback callback) {
dropIndex("*", dropIndexOptions, callback);
}
@Override
public void dropIndexes(final ClientSession clientSession, final SingleResultCallback callback) {
dropIndexes(clientSession, new DropIndexOptions(), callback);
}
@Override
public void dropIndexes(final ClientSession clientSession, final DropIndexOptions dropIndexOptions,
final SingleResultCallback callback) {
dropIndex(clientSession, "*", dropIndexOptions, callback);
}
private void executeDropIndex(@Nullable final ClientSession clientSession, final Bson keys,
final DropIndexOptions dropIndexOptions, final SingleResultCallback callback) {
executor.execute(operations.dropIndex(keys, dropIndexOptions), readConcern, clientSession, callback);
}
private void executeDropIndex(@Nullable final ClientSession clientSession, final String indexName,
final DropIndexOptions dropIndexOptions, final SingleResultCallback callback) {
executor.execute(operations.dropIndex(indexName, dropIndexOptions), readConcern, clientSession, callback);
}
@Override
public void renameCollection(final MongoNamespace newCollectionNamespace, final SingleResultCallback callback) {
renameCollection(newCollectionNamespace, new RenameCollectionOptions(), callback);
}
@Override
public void renameCollection(final MongoNamespace newCollectionNamespace, final RenameCollectionOptions options,
final SingleResultCallback callback) {
executeRenameCollection(null, newCollectionNamespace, options, callback);
}
@Override
public void renameCollection(final ClientSession clientSession, final MongoNamespace newCollectionNamespace,
final SingleResultCallback callback) {
renameCollection(clientSession, newCollectionNamespace, new RenameCollectionOptions(), callback);
}
@Override
public void renameCollection(final ClientSession clientSession, final MongoNamespace newCollectionNamespace,
final RenameCollectionOptions options, final SingleResultCallback callback) {
notNull("clientSession", clientSession);
executeRenameCollection(clientSession, newCollectionNamespace, options, callback);
}
private void executeRenameCollection(@Nullable final ClientSession clientSession, final MongoNamespace newCollectionNamespace,
final RenameCollectionOptions options, final SingleResultCallback callback) {
executor.execute(operations.renameCollection(newCollectionNamespace, options), readConcern, clientSession, callback);
}
private void executeSingleWriteRequest(@Nullable final ClientSession clientSession,
final AsyncWriteOperation writeOperation,
final WriteRequest.Type type, final SingleResultCallback callback) {
executor.execute(writeOperation, readConcern, clientSession, new SingleResultCallback() {
@Override
public void onResult(final BulkWriteResult result, final Throwable t) {
if (t instanceof MongoBulkWriteException) {
MongoBulkWriteException e = (MongoBulkWriteException) t;
if (e.getWriteErrors().isEmpty()) {
callback.onResult(null,
new MongoWriteConcernException(e.getWriteConcernError(),
translateBulkWriteResult(type,
e.getWriteResult()),
e.getServerAddress()));
} else {
callback.onResult(null, new MongoWriteException(new WriteError(e.getWriteErrors().get(0)),
e.getServerAddress()));
}
} else {
callback.onResult(result, t);
}
}
});
}
private WriteConcernResult translateBulkWriteResult(final WriteRequest.Type type, final BulkWriteResult writeResult) {
switch (type) {
case INSERT:
return WriteConcernResult.acknowledged(writeResult.getInsertedCount(), false, null);
case DELETE:
return WriteConcernResult.acknowledged(writeResult.getDeletedCount(), false, null);
case UPDATE:
case REPLACE:
return WriteConcernResult.acknowledged(writeResult.getMatchedCount() + writeResult.getUpserts().size(),
writeResult.getMatchedCount() > 0,
writeResult.getUpserts().isEmpty()
? null : writeResult.getUpserts().get(0).getId());
default:
throw new MongoInternalException("Unhandled write request type: " + type);
}
}
private UpdateResult toUpdateResult(final com.mongodb.bulk.BulkWriteResult result) {
if (result.wasAcknowledged()) {
BsonValue upsertedId = result.getUpserts().isEmpty() ? null : result.getUpserts().get(0).getId();
return UpdateResult.acknowledged(result.getMatchedCount(), (long) result.getModifiedCount(), upsertedId);
} else {
return UpdateResult.unacknowledged();
}
}
}