Java 类com.mongodb.client.model.FindOneAndReplaceOptions 实例源码

protected final FluentFuture<Optional<T>> doReplace(
        final Constraints.ConstraintHost criteria,
        final T document,
        final FindOneAndReplaceOptions options) {

  checkNotNull(criteria, "criteria");
  checkNotNull(document, "document");
  checkNotNull(options, "options");

  return submit(new Callable<Optional<T>>() {
    @Override
    public Optional<T> call() throws Exception {
      @Nullable T result = collection().findOneAndReplace(
          convertToBson(criteria), // query
          document,
          options);

      return Optional.fromNullable(result);
    }
  });

}

@Override
public Dataset write(Dataset dataset) {
  // we populate this on first write and retain it thereafter
  if (isBlank(dataset.getId())) {
    dataset.setId(ObjectId.get().toString());
  }

  Observable<Document> observable =
      getCollection()
          .findOneAndReplace(
              Filters.eq("id", dataset.getId()),
              documentTransformer.transform(dataset),
              new FindOneAndReplaceOptions().upsert(true).returnDocument(ReturnDocument.AFTER));

  return documentTransformer.transform(Dataset.class, observable.toBlocking().single());
}

@Override
public TDocument findOneAndReplace(Bson filter, TDocument arg1, FindOneAndReplaceOptions arg2)
{
    OperationMetric metric = null;
    if (MongoLogger.GATHERER.isEnabled())
    {
        List<String> keyValuePairs = MongoUtilities.getKeyValuePairs(filter);
        String operationName = "Mongo : " + getNamespace().getCollectionName() + " : findOneAndReplace " +
            MongoUtilities.filterParameters(filter).toString();
        metric = startMetric(operationName, keyValuePairs);
        addWriteKeyValuePairs(keyValuePairs);
        if (MongoLogger.isRequestSizeMeasured())
        {
            metric.setProperty(CommonMetricProperties.REQUEST_SIZE_BYTES, Integer.toString(measureDocumentSize(arg1)));
        }
        addWriteConcern(metric);
        addReadConcernAndPreference(metric);
    }

    TDocument retVal = collection.findOneAndReplace(filter, arg1, arg2);

    stopMetric(metric, measureDocumentSizeIfResultSizeEnabled(retVal));

    return retVal;
}

@Test
public void findOneAndReplace()
{
    insertOneWithBulk();

    Document replace = Document.parse(
        "{\"car_id\":\"c7a\",\"name\":\"DELETEME\",\"color\":\"Redaa\",\"cno\":\"H116aa\",\"mfdcountry\":\"India\",\"speed\":53,\"price\":4.5}");

    Assert.assertNotNull(coll.findOneAndReplace(Filters.eq("name", "DELETEME"), replace));

    insertOneWithBulk();

    Assert.assertNotNull(
        coll.findOneAndReplace(Filters.eq("name", "DELETEME"), replace, new FindOneAndReplaceOptions()));

    coll.deleteMany(Filters.eq("name", "DELETEME"));
}

/**
 * Updates the document if the document's ETAG is matching the given etag (conditional put).
 * <p>
 * Using this method requires that the document contains an "etag" field that is updated if
 * the document is changed.
 * </p>
 *
 * @param value    the new value
 * @param eTag     the etag used for conditional update
 * @param maxTime  max time for the update
 * @param timeUnit the time unit for the maxTime value
 * @return {@link UpdateIfMatchResult}
 */
public UpdateIfMatchResult updateIfMatch(final V value,
                                         final String eTag,
                                         final long maxTime,
                                         final TimeUnit timeUnit) {
    final K key = keyOf(value);
    if (key != null) {
        final Bson query = and(eq(AbstractMongoRepository.ID, key), eq(ETAG, eTag));

        final Document updatedETaggable = collectionWithWriteTimeout(maxTime, timeUnit).findOneAndReplace(query, encode(value), new FindOneAndReplaceOptions().returnDocument(AFTER));
        if (isNull(updatedETaggable)) {
            final boolean documentExists = collection()
                    .count(eq(AbstractMongoRepository.ID, key), new CountOptions().maxTime(maxTime, timeUnit)) != 0;
            if (documentExists) {
                return CONCURRENTLY_MODIFIED;
            }

            return NOT_FOUND;
        }

        return OK;
    } else {
        throw new IllegalArgumentException("Key must not be null");
    }
}

/**
 * set timestamp properties (replace) for the given timestamp
 * 
 * @param timestamp
 * @param timestampProperties
 */
public void setTimestampProperties(final Long timestamp, BsonDocument timestampProperties) {
    if (timestampProperties == null)
        timestampProperties = new BsonDocument();
    if (this instanceof ChronoVertex) {
        graph.getVertexEvents().findOneAndReplace(
                new BsonDocument(Tokens.VERTEX, new BsonString(this.id)).append(Tokens.TIMESTAMP,
                        new BsonDateTime(timestamp)),
                Converter.makeTimestampVertexEventDocumentWithoutID(timestampProperties, this.id, timestamp),
                new FindOneAndReplaceOptions().upsert(true));
    } else {
        ChronoEdge e = (ChronoEdge) this;
        graph.getEdgeEvents().findOneAndReplace(
                new BsonDocument(Tokens.OUT_VERTEX, new BsonString(e.getOutVertex().toString()))
                        .append(Tokens.LABEL, new BsonString(e.getLabel()))
                        .append(Tokens.TIMESTAMP, new BsonDateTime(timestamp))
                        .append(Tokens.IN_VERTEX, new BsonString(e.getInVertex().toString())),
                Converter.makeTimestampEdgeEventDocumentWithoutID(timestampProperties, this.id, timestamp),
                new FindOneAndReplaceOptions().upsert(true));
    }
}

@Override
public io.vertx.ext.mongo.MongoClient findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler) {
  requireNonNull(collection, "collection cannot be null");
  requireNonNull(query, "query cannot be null");
  requireNonNull(findOptions, "find options cannot be null");
  requireNonNull(updateOptions, "update options cannot be null");
  requireNonNull(resultHandler, "resultHandler cannot be null");

  JsonObject encodedQuery = encodeKeyWhenUseObjectId(query);

  Bson bquery = wrap(encodedQuery);
  FindOneAndReplaceOptions foarOptions = new FindOneAndReplaceOptions();
  foarOptions.sort(wrap(findOptions.getSort()));
  foarOptions.projection(wrap(findOptions.getFields()));
  foarOptions.upsert(updateOptions.isUpsert());
  foarOptions.returnDocument(updateOptions.isReturningNewDocument() ? ReturnDocument.AFTER : ReturnDocument.BEFORE);

  MongoCollection<JsonObject> coll = getCollection(collection);
  coll.findOneAndReplace(bquery, replace, foarOptions, wrapCallback(resultHandler));
  return this;
}

protected final FluentFuture<Optional<T>> doReplace(
        final Constraints.ConstraintHost criteria,
        final T document,
        final FindOneAndReplaceOptions options) {

  checkNotNull(criteria, "criteria");
  checkNotNull(document, "document");
  checkNotNull(options, "options");

  return submit(new Callable<Optional<T>>() {
    @Override
    public Optional<T> call() throws Exception {
      @Nullable T result = collection().findOneAndReplace(
          convertToBson(criteria), // query
          document,
          options);

      return Optional.fromNullable(result);
    }
  });

}

protected Replacer(
    Repository<T> repository,
    T document,
    Constraints.ConstraintHost criteria,
    Constraints.Constraint ordering) {
  super(repository);
  this.document = checkNotNull(document, "document");
  this.criteria = checkNotNull(criteria, "criteria");
  this.ordering = checkNotNull(ordering, "ordering");
  this.options = new FindOneAndReplaceOptions();
}

public SyncMap saveMapping(SyncMap map) {
    // TODO : check why this is needed
    if (map.getMapId() == null) {
        map.setMapId(new ObjectId());
    }
    return syncMappings.findOneAndReplace(Filters.eq(SyncAttrs.ID, map.getMapId()), map,
            new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER).upsert(true));
}

public SyncEvent saveEvent(SyncEvent event) {
    if (event.getEventId() == null) {
        event.setEventId(new ObjectId());
    }
    return syncEvents.findOneAndReplace(Filters.eq(SyncAttrs.ID, event.getEventId()), event,
            new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER).upsert(true));
}

public SyncConnectionInfo updateConnection(SyncConnectionInfo connInfo) {
    if(connInfo.getConnectionId() == null){
        connInfo.setConnectionId(new ObjectId());
    }
    return connectionInfo.findOneAndReplace(
            Filters.eq(String.valueOf(ConnectionInfoAttributes._id), connInfo.getConnectionId()), connInfo,
            new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER).upsert(true));
}

@Override
   public FindOneAndReplaceOptions toFindOneAndReplace() {
    final FindOneAndReplaceOptions options = new FindOneAndReplaceOptions();
    options.bypassDocumentValidation(!validateDocuments);
    setMaxTime(options);
    setProjection(options);
    options.returnDocument(ret);
    setSort(options);
    options.upsert(upsert);
    return options;
}

@Override
public Observable<TDocument> findOneAndReplace(final Bson filter, final TDocument replacement, final FindOneAndReplaceOptions options) {
    return RxObservables.create(Observables.observe(new Block<SingleResultCallback<TDocument>>() {
        @Override
        public void apply(final SingleResultCallback<TDocument> callback) {
            wrapped.findOneAndReplace(filter, replacement, options, callback);
        }
    }), observableAdapter);
}

@Override
public Publisher<TDocument> findOneAndReplace(final Bson filter, final TDocument replacement, final FindOneAndReplaceOptions options) {
    return new ObservableToPublisher<TDocument>(observe(new Block<SingleResultCallback<TDocument>>() {
        @Override
        public void apply(final SingleResultCallback<TDocument> callback) {
            wrapped.findOneAndReplace(filter, replacement, options, callback);
        }
    }));
}

@Override
public Publisher<TDocument> findOneAndReplace(final ClientSession clientSession, final Bson filter, final TDocument replacement,
                                              final FindOneAndReplaceOptions options) {
    return new ObservableToPublisher<TDocument>(observe(new Block<SingleResultCallback<TDocument>>() {
        @Override
        public void apply(final SingleResultCallback<TDocument> callback) {
            wrapped.findOneAndReplace(clientSession, filter, replacement, options, callback);
        }
    }));
}

protected Replacer(
    Repository<T> repository,
    T document,
    Constraints.ConstraintHost criteria,
    Constraints.Constraint ordering) {
  super(repository);
  this.document = checkNotNull(document, "document");
  this.criteria = checkNotNull(criteria, "criteria");
  this.ordering = checkNotNull(ordering, "ordering");
  this.options = new FindOneAndReplaceOptions();
}

public SyncUserSession saveSession(SyncUserSession userSession) {
    return userSessionCollection.findOneAndReplace(
            Filters.eq(String.valueOf(SessionAttributes._id), userSession.getSessionId()), userSession,
            new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER).upsert(true));
}

public SyncNode updateNodeDetails(SyncNode nodeMapper) {
    return syncNodeMapping.findOneAndReplace(Filters.eq(SyncAttrs.ID, nodeMapper.getId()), nodeMapper,
            new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER).upsert(true));
}

public SyncUser updateUser(SyncUser user) {
    return userDetailsCollection.findOneAndReplace(
            Filters.eq(String.valueOf(UserDetailAttributes._id),user.getUserid()),user,
                    new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER)
                                                  .upsert(true));
}

@Override
public void run() {
    logger.info("OrclToMngSyncWriter started "+Thread.currentThread().getName());
    List<Document> docs = null;
    FindOneAndReplaceOptions options = new FindOneAndReplaceOptions();
    options.upsert(true);
    while(retryCount<5){
        try {
            if(marker.isFailed()){
                releaseResources();
                return;
            }
            waitTime=30000;
            docs = dataBuffer.take();
            if (docs == null || docs.isEmpty()) {
                continue;
            }
            if(collection==null){
                refreshCollectionHandle();
            }
            for(Document doc : docs){
                if(SyncConstants.DELETE.equals(doc.get(SyncConstants.OPERATION))){
                    collection.findOneAndDelete(getFilter(doc));
                    logger.info("Document deleted");
                }else{
                    collection.findOneAndReplace(getFilter(doc), doc, options);
                    logger.info("Document upserted");
                }                   
            }               
        } catch (Exception e) {
            logger.error("Error while upserting document",e);
            collection =null;
            Mailer.sendmail(eventId, String.valueOf(docs), e, Mailer.FAILURE);
            retryCount++;
            waitTime*=retryCount;
            try {
                Thread.sleep(waitTime);
            } catch (InterruptedException e1) {
                logger.error("Thread interuupted in sleep", e1);
            }
        }   
    }
    logger.info("OrclToMngSyncWriter terminated " + Thread.currentThread().getName());
}

private void setSort(final FindOneAndReplaceOptions options) {
    if(sort != null) {
        options.sort(sort);
    }
}

private void setProjection(final FindOneAndReplaceOptions options) {
    if(projection != null) {
        options.projection(projection);
    }
}

private void setMaxTime(final FindOneAndReplaceOptions options) {
    if(maxTime != null) {
        options.maxTime(maxTime.getLeft(), maxTime.getRight());
    }
}

@Override
public Observable<TDocument> findOneAndReplace(final Bson filter, final TDocument replacement) {
    return findOneAndReplace(filter, replacement, new FindOneAndReplaceOptions());
}

@Override
public Publisher<TDocument> findOneAndReplace(final Bson filter, final TDocument replacement) {
    return findOneAndReplace(filter, replacement, new FindOneAndReplaceOptions());
}

@Override
public Publisher<TDocument> findOneAndReplace(final ClientSession clientSession, final Bson filter, final TDocument replacement) {
    return findOneAndReplace(clientSession, filter, replacement, new FindOneAndReplaceOptions());
}

/**
 * Atomically find a document and replace it.
 *
 * @param filter      the query filter to apply the the replace operation
 * @param replacement the replacement document
 * @param options     the options to apply to the operation
 * @return an Observable with a single element the document that was replaced.  Depending on the value of the {@code returnOriginal}
 * property, this will either be the document as it was before the update or as it is after the update.
 * If no documents matched the query filter, then the observer will complete without emitting any items
 */
Observable<TDocument> findOneAndReplace(Bson filter, TDocument replacement, FindOneAndReplaceOptions options);

/**
 * Atomically find a document and replace it.
 *
 * @param filter      the query filter to apply the the replace operation
 * @param replacement the replacement document
 * @param options     the options to apply to the operation
 * @return a publisher with a single element the document that was replaced.  Depending on the value of the {@code returnOriginal}
 * property, this will either be the document as it was before the update or as it is after the update.  If no documents matched the
 * query filter, then null will be returned
 */
Publisher<TDocument> findOneAndReplace(Bson filter, TDocument replacement, FindOneAndReplaceOptions options);

/**
 * Atomically find a document and replace it.
 *
 * @param clientSession the client session with which to associate this operation
 * @param filter      the query filter to apply the the replace operation
 * @param replacement the replacement document
 * @param options     the options to apply to the operation
 * @return a publisher with a single element the document that was replaced.  Depending on the value of the {@code returnOriginal}
 * property, this will either be the document as it was before the update or as it is after the update.  If no documents matched the
 * query filter, then null will be returned
 * @mongodb.server.release 3.6
 * @since 1.7
 */
Publisher<TDocument> findOneAndReplace(ClientSession clientSession, Bson filter, TDocument replacement,
                                       FindOneAndReplaceOptions options);

FindOneAndReplaceOptions toFindOneAndReplace();