Package org.apache.jackrabbit.oak.plugins.document.mongo

Class MongoDocumentStore

java.lang.Object
org.apache.jackrabbit.oak.plugins.document.mongo.MongoDocumentStore
All Implemented Interfaces:
DocumentStore
public class MongoDocumentStore extends Object implements DocumentStore
A document store that uses MongoDB as the backend.

  • Field Details

    • DEFAULT_THROTTLING_THRESHOLD

      public static final int DEFAULT_THROTTLING_THRESHOLD
      The threshold value (in hours) after which the document store should start (if enabled) throttling. Default is 2 hours.

      For mongo based document store this value is threshold for the oplog replication window.

    • IN_CLAUSE_BATCH_SIZE

      public static final int IN_CLAUSE_BATCH_SIZE
      See Also:

  • Constructor Details

    • MongoDocumentStore

      public MongoDocumentStore(com.mongodb.client.MongoClient connection, com.mongodb.client.MongoDatabase db, MongoDocumentNodeStoreBuilderBase<?> builder)

  • Method Details

    • getNodeNameLimit

      public int getNodeNameLimit()
      Description copied from interface: DocumentStore
      Return the size limit for node name based on the document store implementation
      Specified by:
      getNodeNameLimit in interface DocumentStore
      Returns:
      node name size limit

    • throttler

      public Throttler throttler()
      Return the Throttler for the underlying store Default is no throttling
      Specified by:
      throttler in interface DocumentStore
      Returns:
      throttler for document store

    • isReadOnly

      public boolean isReadOnly()

    • finalize

      public void finalize() throws Throwable
      Overrides:
      finalize in class Object
      Throws:
      Throwable

    • invalidateCache

      public CacheInvalidationStats invalidateCache()
      Description copied from interface: DocumentStore
      Invalidate the document cache. Calling this method instructs the implementation to invalidate each document from the cache, which is not up to date with the underlying storage at the time this method is called. A document is considered in the cache if DocumentStore.getIfCached(Collection, String) returns a non-null value for a key.

      An implementation is allowed to perform lazy invalidation and only check whether a document is up-to-date when it is accessed after this method is called. However, this also includes a call to DocumentStore.getIfCached(Collection, String), which must only return the document if it was up-to-date at the time this method was called. Similarly, a call to DocumentStore.find(Collection, String) must guarantee the returned document reflects all the changes done up to when invalidateCache() was called.

      In some implementations this method can be a NOP because documents can only be modified through a single instance of a DocumentStore.

      Specified by:
      invalidateCache in interface DocumentStore
      Returns:
      cache invalidation statistics or null if none are available.

    • invalidateCache

      public CacheInvalidationStats invalidateCache(Iterable<String> keys)
      Description copied from interface: DocumentStore
      Invalidate the document cache but only with entries that match one of the keys provided. See DocumentStore.invalidateCache() for the general contract of cache invalidation.
      Specified by:
      invalidateCache in interface DocumentStore
      Parameters:
      keys - the keys of the documents to invalidate.
      Returns:
      cache invalidation statistics or null if none are available.

    • invalidateCache

      public <T extends Document> void invalidateCache(Collection<T> collection, String key)
      Description copied from interface: DocumentStore
      Invalidate the document cache for the given key. See DocumentStore.invalidateCache() for the general contract of cache invalidation.
      Specified by:
      invalidateCache in interface DocumentStore
      Parameters:
      collection - the collection
      key - the key

    • find

      public <T extends Document> T find(Collection<T> collection, String key)
      Description copied from interface: DocumentStore
      Get the document with the given key. This is a convenience method and equivalent to DocumentStore.find(Collection, String, int) with a maxCacheAge of Integer.MAX_VALUE.

      The returned document is immutable.

      Specified by:
      find in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      key - the key
      Returns:
      the document, or null if not found

    • find

      public <T extends Document> T find(Collection<T> collection, String key, int maxCacheAge)
      Description copied from interface: DocumentStore
      Get the document with the key. The implementation may serve the document from a cache, but the cached document must not be older than the given maxCacheAge in milliseconds. An implementation must invalidate a cached document when it detects it is outdated. That is, a subsequent call to DocumentStore.find(Collection, String) must return the newer version of the document.

      The returned document is immutable.

      Specified by:
      find in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      key - the key
      maxCacheAge - the maximum age of the cached document (in ms)
      Returns:
      the document, or null if not found

    • findUncached

      @Nullable protected <T extends Document> T findUncached(Collection<T> collection, String key, org.apache.jackrabbit.oak.plugins.document.mongo.MongoDocumentStore.DocumentReadPreference docReadPref)

    • query

      @NotNull public <T extends Document> @NotNull List<T> query(Collection<T> collection, String fromKey, String toKey, int limit)
      Description copied from interface: DocumentStore
      Get a list of documents where the key is greater than a start value and less than an end value.

      The returned documents are sorted by key and are immutable.

      Specified by:
      query in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      fromKey - the start value (excluding)
      toKey - the end value (excluding)
      limit - the maximum number of entries to return (starting with the lowest key)
      Returns:
      the list (possibly empty)

    • query

      @NotNull public <T extends Document> @NotNull List<T> query(Collection<T> collection, String fromKey, String toKey, String indexedProperty, long startValue, int limit)
      Description copied from interface: DocumentStore
      Get a list of documents where the key is greater than a start value and less than an end value and the given "indexed property" is greater or equals the specified value.

      The indexed property can either be a Long value, in which case numeric comparison applies, or a Boolean value, in which case "false" is mapped to "0" and "true" is mapped to "1".

      The returned documents are sorted by key and are immutable.

      Specified by:
      query in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      fromKey - the start value (excluding)
      toKey - the end value (excluding)
      indexedProperty - the name of the indexed property (optional)
      startValue - the minimum value of the indexed property
      limit - the maximum number of entries to return
      Returns:
      the list (possibly empty)

    • query

      @NotNull public <T extends Document> @NotNull List<T> query(Collection<T> collection, String fromKey, String toKey, String indexedProperty, long startValue, int limit, List<String> projection) throws DocumentStoreException
      Description copied from interface: DocumentStore
      Get a list of documents with only projected fields (as mentioned in projections param) along with "_id" field and where the key is greater than a start value and less than an end value and the given "indexed property" is greater or equals the specified value.

      The indexed property can either be a Long value, in which case numeric comparison applies, or a Boolean value, in which case "false" is mapped to "0" and "true" is mapped to "1".

      The returned documents are sorted by key and are immutable.

      Specified by:
      query in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      fromKey - the start value (excluding)
      toKey - the end value (excluding)
      indexedProperty - the name of the indexed property (optional)
      startValue - the minimum value of the indexed property
      limit - the maximum number of entries to return
      projection - List of projected keys (optional). Keep this empty to fetch all fields on document.
      Returns:
      the list (possibly empty)
      Throws:
      DocumentStoreException - if the operation failed. E.g. because of an I/O error.

    • queryInternal

      @NotNull protected <T extends Document> @NotNull List<T> queryInternal(Collection<T> collection, String fromKey, String toKey, String indexedProperty, long startValue, int limit, List<String> projection, long maxQueryTime)

    • remove

      public <T extends Document> void remove(Collection<T> collection, String key)
      Description copied from interface: DocumentStore
      Remove a document. This method does nothing if there is no document with the given key.

      In case of a DocumentStoreException, the document with the given key may or may not have been removed from the store. It is the responsibility of the caller to check whether it still exists. The implementation however ensures that the result of the operation is properly reflected in the document cache. That is, an implementation could simply evict the document with the given key.

      Specified by:
      remove in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      key - the key

    • remove

      public <T extends Document> void remove(Collection<T> collection, List<String> keys)
      Description copied from interface: DocumentStore
      Batch remove documents with given keys. Keys for documents that do not exist are simply ignored. If this method fails with an exception, then only some of the documents identified by keys may have been removed.

      In case of a DocumentStoreException, the documents with the given keys may or may not have been removed from the store. It may also be possible that only some have been removed from the store. It is the responsibility of the caller to check which documents still exist. The implementation however ensures that the result of the operation is properly reflected in the document cache. That is, an implementation could simply evict documents with the given keys from the cache.

      Specified by:
      remove in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      keys - list of keys

    • remove

      public <T extends Document> int remove(Collection<T> collection, Map<String,Long> toRemove)
      Description copied from interface: DocumentStore
      Batch remove documents with given keys and corresponding equal conditions on NodeDocument.MODIFIED_IN_SECS values. Keys for documents that do not exist are simply ignored. A document is only removed if the corresponding condition is met.

      In case of a DocumentStoreException, the documents with the given keys may or may not have been removed from the store. It may also be possible that only some have been removed from the store. It is the responsibility of the caller to check which documents still exist. The implementation however ensures that the result of the operation is properly reflected in the document cache. That is, an implementation could simply evict documents with the given keys from the cache.

      Specified by:
      remove in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection.
      toRemove - the keys of the documents to remove with the corresponding timestamps.
      Returns:
      the number of removed documents.

    • remove

      public <T extends Document> int remove(Collection<T> collection, String indexedProperty, long startValue, long endValue) throws DocumentStoreException
      Description copied from interface: DocumentStore
      Batch remove documents where the given "indexed property" is within the given range (exclusive) - (startValue, endValue).

      The indexed property is a Long value and numeric comparison applies.

      In case of a DocumentStoreException, the documents with the given keys may or may not have been removed from the store. It may also be possible that only some have been removed from the store. It is the responsibility of the caller to check which documents still exist. The implementation however ensures that the result of the operation is properly reflected in the document cache. That is, an implementation could simply evict documents with the given keys from the cache.

      Specified by:
      remove in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection.
      indexedProperty - the name of the indexed property
      startValue - the minimum value of the indexed property (exclusive)
      endValue - the maximum value of the indexed property (exclusive)
      Returns:
      the number of removed documents.
      Throws:
      DocumentStoreException - if the operation failed. E.g. because of an I/O error.

    • findAndUpdate

      @NotNull public <T extends Document> @NotNull List<T> findAndUpdate(@NotNull @NotNull Collection<T> collection, @NotNull @NotNull List<UpdateOp> updateOps)
      Try to apply all the UpdateOps with at least MongoDB requests as possible. The return value is the list of the old documents (before applying changes). The mechanism is as follows:
      1. For each UpdateOp try to read the assigned document from the cache. Add them to oldDocs.
      2. Prepare a list of all UpdateOps that doesn't have their documents and read them in one find() call. Add results to oldDocs.
      3. Prepare a bulk update. For each remaining UpdateOp add following operation:
        • Find document with the same id and the same mod_count as in the oldDocs.
        • Apply changes from the UpdateOps.
      4. Execute the bulk update.
      If some other process modifies the target documents between points 2 and 3, the mod_count will be increased as well and the bulk update will fail for the concurrently modified docs. The method will then remove the failed documents from the oldDocs and restart the process from point 2. It will stop after 3rd iteration.
      Specified by:
      findAndUpdate in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      updateOps - the update operation List
      Returns:
      the list containing old documents or null if the condition is not met or if the document wasn't found. The order in the result list reflects the order in the updateOps parameter
      See Also:

    • createOrUpdate

      @Nullable public <T extends Document> T createOrUpdate(Collection<T> collection, UpdateOp update) throws DocumentStoreException
      Description copied from interface: DocumentStore
      Atomically checks if the document exists and updates it, otherwise the document is created (aka "upsert"), unless the update operation requires the document to be present (see UpdateOp.isNew()). The returned document is immutable.

      If this method fails with a DocumentStoreException, then the document may or may not have been created or updated. It is the responsibility of the caller to check the result e.g. by calling DocumentStore.find(Collection, String). The implementation however ensures that the result of the operation is properly reflected in the document cache. That is, an implementation could simply evict documents with the given keys from the cache.

      Specified by:
      createOrUpdate in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      update - the update operation (where UpdateOp.Conditions are not allowed)
      Returns:
      the old document or null if it either didn't exist before, or the UpdateOp required the document to be present but UpdateOp.isNew() was false.
      Throws:
      DocumentStoreException - if the operation failed. E.g. because of an I/O error.

    • createOrUpdate

      @Nullable public <T extends Document> @Nullable List<T> createOrUpdate(Collection<T> collection, List<UpdateOp> updateOps)
      Try to apply all the UpdateOps with at least MongoDB requests as possible. The return value is the list of the old documents (before applying changes). The mechanism is as follows:
      1. For each UpdateOp try to read the assigned document from the cache. Add them to oldDocs.
      2. Prepare a list of all UpdateOps that doesn't have their documents and read them in one find() call. Add results to oldDocs.
      3. Prepare a bulk update. For each remaining UpdateOp add following operation:
        • Find document with the same id and the same mod_count as in the oldDocs.
        • Apply changes from the UpdateOps.
      4. Execute the bulk update.
      If some other process modifies the target documents between points 2 and 3, the mod_count will be increased as well and the bulk update will fail for the concurrently modified docs. The method will then remove the failed documents from the oldDocs and restart the process from point 2. It will stop after 3rd iteration.
      Specified by:
      createOrUpdate in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      updateOps - the update operation list
      Returns:
      the list containing old documents or null values if they didn't exist before (see DocumentStore.createOrUpdate(Collection, UpdateOp)), where the order reflects the order in the "updateOps" parameter

    • findAndUpdate

      public <T extends Document> T findAndUpdate(Collection<T> collection, UpdateOp update) throws DocumentStoreException
      Description copied from interface: DocumentStore
      Performs a conditional update (e.g. using UpdateOp.Condition.Type.EXISTS and only updates the document if the condition is true. The returned document is immutable.

      In case of a DocumentStoreException (e.g. when a communication error occurs) the update may or may not have been applied. In this case it is the responsibility of the caller to check whether the update was applied and take appropriate action. The implementation however ensures that the result of the operation is properly reflected in the document cache. That is, an implementation could simply evict the document related to the given update operation from the cache.

      Specified by:
      findAndUpdate in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      update - the update operation with the condition
      Returns:
      the old document or null if the condition is not met or if the document wasn't found
      Throws:
      DocumentStoreException - if the operation failed. E.g. because of an I/O error.
      See Also:

    • create

      public <T extends Document> boolean create(Collection<T> collection, List<UpdateOp> updateOps)
      Description copied from interface: DocumentStore
      Try to create a list of documents. This method returns true iff none of the documents existed before and the create was successful. This method will return false if one of the documents already exists in the store. Some documents may still have been created in the store. An implementation does not have to guarantee an atomic create of all the documents described in the updateOps. It is the responsibility of the caller to check, which documents were created and take appropriate action. The same is true when this method throws DocumentStoreException (e.g. when a communication error occurs). In this case only some documents may have been created.
      Specified by:
      create in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      updateOps - the list of documents to add (where UpdateOp.Conditions are not allowed)
      Returns:
      true if this worked (if none of the documents already existed)

    • prefetch

      public <T extends Document> void prefetch(Collection<T> collection, Iterable<String> keysToPrefetch)
      Description copied from interface: DocumentStore
      optional method indicating the DocumentStore should prefetch, in the most optimal way eg by batching, a bunch of keys as they might soon be needed.
      Specified by:
      prefetch in interface DocumentStore

    • convertFromDBObject

      @Nullable protected <T extends Document> T convertFromDBObject(@NotNull @NotNull Collection<T> collection, @Nullable @Nullable com.mongodb.DBObject n)

    • dispose

      public void dispose()
      Description copied from interface: DocumentStore
      Dispose this instance.
      Specified by:
      dispose in interface DocumentStore

    • getCacheStats

      public Iterable<CacheStats> getCacheStats()
      Specified by:
      getCacheStats in interface DocumentStore
      Returns:
      status information about the cache

    • getMetadata

      public Map<String,String> getMetadata()
      Specified by:
      getMetadata in interface DocumentStore
      Returns:
      description of the underlying storage.

    • getStats

      @NotNull public @NotNull Map<String,String> getStats()
      Description copied from interface: DocumentStore
      Returns statistics about the underlying storage. The information and keys returned by this method are implementation specific, may change between releases or may even depend on deployment aspects. E.g. depending on access rights, the method may return more or less information from the underlying store. This method should only be used for informational or debug purposes.
      Specified by:
      getStats in interface DocumentStore
      Returns:
      statistics about this document store.

    • getIfCached

      public <T extends Document> T getIfCached(Collection<T> collection, String key)
      Description copied from interface: DocumentStore
      Fetches the cached document. If the document is not present in the cache null will be returned. This method is consistent with other find methods that may return cached documents and will return null even when the implementation has a negative cache for documents that do not exist. This method will never return NodeDocument.NULL.
      Specified by:
      getIfCached in interface DocumentStore
      Type Parameters:
      T - the document type
      Parameters:
      collection - the collection
      key - the key
      Returns:
      cached document if present. Otherwise null.

    • setReadWriteMode

      public void setReadWriteMode(String readWriteMode)
      Description copied from interface: DocumentStore
      Set the level of guarantee for read and write operations, if supported by this backend.
      Specified by:
      setReadWriteMode in interface DocumentStore
      Parameters:
      readWriteMode - the read/write mode

    • setStatsCollector

      public void setStatsCollector(DocumentStoreStatsCollector stats)

    • determineServerTimeDifferenceMillis

      public long determineServerTimeDifferenceMillis()
      Specified by:
      determineServerTimeDifferenceMillis in interface DocumentStore
      Returns:
      the estimated time difference in milliseconds between the local instance and the (typically common, shared) document server system. The value can be zero if the times are estimated to be equal, positive when the local instance is ahead of the remote server and negative when the local instance is behind the remote server. An invocation is not cached and typically requires a round-trip to the server (but that is not a requirement).

    • getAmountOfMongoWriteExceptions

      public long getAmountOfMongoWriteExceptions()