Package one.microstream.storage.types

Class Database.Default

java.lang.Object
one.microstream.storage.types.Database.Default
All Implemented Interfaces:
PersistenceStoring, Persister, ObjectSwizzling, Database, DatabasePart
Enclosing interface:
Database
public static final class Database.Default
extends Object
implements Database

  • Constructor Details

  • Method Details

    • databaseName

      public final String databaseName()
      Description copied from interface: DatabasePart
      Returns the identifying name of the Database this part belongs to.
      Specified by:
      databaseName in interface DatabasePart
      Returns:
      the identifying name of the Database.

    • storage

      public final StorageManager storage()
      Specified by:
      storage in interface Database

    • guaranteeNoActiveStorage

      public final Database guaranteeNoActiveStorage()
      Specified by:
      guaranteeNoActiveStorage in interface Database

    • guaranteeActiveStorage

      public final StorageManager guaranteeActiveStorage()
      Specified by:
      guaranteeActiveStorage in interface Database

    • setStorage

      public final StorageManager setStorage​(StorageManager storage)
      Specified by:
      setStorage in interface Database

    • getObject

      public final Object getObject​(long objectId)
      Description copied from interface: Persister
      Retrieves the instance associated with the passed objectId. Retrieving means guaranteeing that the associated instance is returned. If it does not yet exist, it will be created from persisted data, including all non-lazily referenced objects it is connected to.
      Specified by:
      getObject in interface ObjectSwizzling
      Specified by:
      getObject in interface Persister
      Parameters:
      objectId - the objectId defining which instance to return.
      Returns:
      the instance associated with the passed objectId.

    • store

      public final long store​(Object instance)
      Description copied from interface: Persister
      Stores the passed instance in any case and all referenced instances of persistable references recursively, but stores referenced instances only if they are newly encountered (e.g. don't have an id associated with them in the object registry, yet and are therefore required to be handled). This is useful for the common case of just storing an updated instance and potentially newly created instances along with it while skipping all existing (and normally unchanged) referenced instances.

      Specified by:
      store in interface PersistenceStoring
      Specified by:
      store in interface Persister
      Parameters:
      instance - the root instance of the subgraph of required instances to be stored.
      Returns:
      the object id representing the passed instance.

    • storeAll

      public final long[] storeAll​(Object... instances)
      Description copied from interface: Persister
      Convenience method to PersistenceStoring.store(Object) multiple instances. The passed array (maybe implicitely created by the compiler) itself is NOT stored.
      Specified by:
      storeAll in interface PersistenceStoring
      Specified by:
      storeAll in interface Persister
      Parameters:
      instances - multiple root instances of the subgraphs of required instances to be stored.
      Returns:
      an array containing the object ids representing the passed instances.

    • storeAll

      public final void storeAll​(Iterable<?> instances)
      Description copied from interface: Persister
      Convenience method to PersistenceStoring.store(Object) all instances of an Iterable type, usually a collection.
      The passed instance itself is NOT stored.
      Note that this method does not return an array of objectIds, since the amount of instances supplied by the passed Iterable cannot be known until after all instances have been stored and the memory and performance overhead to collect them dynamically would not be worth it in most cases since the returned array is hardly ever needed. If it should be needed, the desired behavior can be easily achieved with a tiny custom-made utility method.
      Specified by:
      storeAll in interface PersistenceStoring
      Specified by:
      storeAll in interface Persister
      Parameters:
      instances - multiple root instances of the subgraphs of required instances to be stored.

    • createLazyStorer

      public final Storer createLazyStorer()
      Description copied from interface: Persister
      Creates a new Storer instance with lazy storing behavior. This means an entity instance encountered while traversing the entity graph is only stored if it is not yet known to the persistence context, i.e. does not have an objectId associated with it in the persistence context's PersistenceObjectRegistry.
      Specified by:
      createLazyStorer in interface Persister
      Returns:
      the newly created Storer instance.

    • createStorer

      public final Storer createStorer()
      Description copied from interface: Persister
      Creates a new Storer instance with default storing behavior. The default is lazy storing. See Persister.createLazyStorer().
      Specified by:
      createStorer in interface Persister
      Returns:
      the newly created Storer instance.

    • createEagerStorer

      public final Storer createEagerStorer()
      Description copied from interface: Persister
      Creates a new Storer instance with eager storing behavior. This means an entity instance encountered while traversing the entity graph is always stored, regardless of if it is already known to the persistence context or not, i.e. does have an objectId associated with it in the persistence context's PersistenceObjectRegistry.

      Note: Eager storing is a dangerous behavior since - depending on the entity graph's referential layout - it can cause the whole entity graph present in the heap to be stored. Therefore, it is stronly advised to instead use lazy storing logic (see Persister.createLazyStorer()) or some other kind of limiting storing logic.

      Specified by:
      createEagerStorer in interface Persister
      Returns:
      the newly created Storer instance.