Class MemoryStore

All Implemented Interfaces:
FederatedServiceResolverClient, NotifyingSail, Sail

public class MemoryStore extends AbstractNotifyingSail implements FederatedServiceResolverClient
An implementation of the Sail interface that stores its data in main memory and that can use a file for persistent storage. This Sail implementation supports single, isolated transactions. This means that changes to the data are not visible until a transaction is committed and that concurrent transactions are not possible. When another transaction is active, calls to startTransaction() will block until the active transaction is committed or rolled back.

The MemoryStore is designed for datasets with fewer than 100,000 triples. The MemoryStore uses hash tables, and when these hash tables fill up it copies the values to larger hash tables. This can cause strain on the garbage collector due to lots of memory being allocated and freed.

  • Field Details

    • logger

      private static final org.slf4j.Logger logger
    • DATA_FILE_NAME

      protected static final String DATA_FILE_NAME
      See Also:
    • SYNC_FILE_NAME

      protected static final String SYNC_FILE_NAME
      See Also:
    • store

      private SailStore store
      Factory/cache for MemValue objects.
    • persist

      private volatile boolean persist
    • dataFile

      private volatile File dataFile
      The file used for data persistence, null if this is a volatile RDF store.
    • syncFile

      private volatile File syncFile
      The file used for serialising data, null if this is a volatile RDF store.
    • dirLock

      private volatile Lock dirLock
      The directory lock, null if this is read-only or a volatile RDF store.
    • contentsChanged

      private volatile boolean contentsChanged
      Flag indicating whether the contents of this repository have changed.
    • syncDelay

      private volatile long syncDelay
      The sync delay.
      See Also:
    • syncSemaphore

      private final Object syncSemaphore
      Semaphore used to synchronize concurrent access to
      invalid reference
      #syncWithLock()
      .
    • syncTimer

      private volatile Timer syncTimer
      The timer used to trigger file synchronization.
    • syncTimerTask

      private volatile TimerTask syncTimerTask
      The currently scheduled timer task, if any.
    • syncTimerSemaphore

      private final Object syncTimerSemaphore
      Semaphore used to synchronize concurrent access to syncTimer and syncTimerTask.
    • evalStratFactory

      private EvaluationStrategyFactory evalStratFactory
    • serviceResolver

      private FederatedServiceResolver serviceResolver
      independent life cycle
    • dependentServiceResolver

      private SPARQLServiceResolver dependentServiceResolver
      dependent life cycle
  • Constructor Details

    • MemoryStore

      public MemoryStore()
      Creates a new MemoryStore.
    • MemoryStore

      public MemoryStore(File dataDir)
      Creates a new persistent MemoryStore. If the specified data directory contains an existing store, its contents will be restored upon initialization.
      Parameters:
      dataDir - the data directory to be used for persistence.
  • Method Details

    • setPersist

      public void setPersist(boolean persist)
    • getPersist

      public boolean getPersist()
    • setSyncDelay

      public void setSyncDelay(long syncDelay)
      Sets the time (in milliseconds) to wait after a transaction was commited before writing the changed data to file. Setting this variable to 0 will force a file sync immediately after each commit. A negative value will deactivate file synchronization until the Sail is shut down. A positive value will postpone the synchronization for at least that amount of milliseconds. If in the meantime a new transaction is started, the file synchronization will be rescheduled to wait for another syncDelay ms. This way, bursts of transaction events can be combined in one file sync.

      The default value for this parameter is 0 (immediate synchronization).

      Parameters:
      syncDelay - The sync delay in milliseconds.
    • getSyncDelay

      public long getSyncDelay()
      Gets the currently configured sync delay.
      Returns:
      syncDelay The sync delay in milliseconds.
      See Also:
    • getEvaluationStrategyFactory

      public EvaluationStrategyFactory getEvaluationStrategyFactory()
      Returns:
      Returns the EvaluationStrategy.
    • setEvaluationStrategyFactory

      public void setEvaluationStrategyFactory(EvaluationStrategyFactory factory)
      Sets the EvaluationStrategy to use.
    • getFederatedServiceResolver

      public FederatedServiceResolver getFederatedServiceResolver()
      Description copied from interface: FederatedServiceResolverClient
      Gets the FederatedServiceResolver used by this client.
      Specified by:
      getFederatedServiceResolver in interface FederatedServiceResolverClient
      Returns:
      Returns the SERVICE resolver.
    • setFederatedServiceResolver

      public void setFederatedServiceResolver(FederatedServiceResolver resolver)
      Overrides the FederatedServiceResolver used by this instance, but the given resolver is not shutDown when this instance is.
      Specified by:
      setFederatedServiceResolver in interface FederatedServiceResolverClient
      Parameters:
      resolver - The SERVICE resolver to set.
    • initializeInternal

      protected void initializeInternal() throws SailException
      Initializes this repository. If a persistence file is defined for the store, the contents will be restored.
      Overrides:
      initializeInternal in class AbstractSail
      Throws:
      SailException - when initialization of the store failed.
    • shutDownInternal

      protected void shutDownInternal() throws SailException
      Description copied from class: AbstractSail
      Do store-specific operations to ensure proper shutdown of the store.
      Specified by:
      shutDownInternal in class AbstractSail
      Throws:
      SailException
    • isWritable

      public boolean isWritable()
      Checks whether this Sail object is writable. A MemoryStore is not writable if a read-only data file is used.
      Specified by:
      isWritable in interface Sail
    • getConnectionInternal

      protected NotifyingSailConnection getConnectionInternal() throws SailException
      Description copied from class: AbstractSail
      Returns a store-specific SailConnection object.
      Specified by:
      getConnectionInternal in class AbstractNotifyingSail
      Returns:
      A connection to the store.
      Throws:
      SailException
    • getValueFactory

      public ValueFactory getValueFactory()
      Description copied from interface: Sail
      Gets a ValueFactory object that can be used to create IRI-, blank node-, literal- and statement objects.
      Specified by:
      getValueFactory in interface Sail
      Returns:
      a ValueFactory object for this Sail object.
    • notifySailChanged

      public void notifySailChanged(SailChangedEvent event)
      Description copied from class: AbstractNotifyingSail
      Notifies all registered SailChangedListener's of changes to the contents of this Sail.
      Overrides:
      notifySailChanged in class AbstractNotifyingSail
    • scheduleSyncTask

      protected void scheduleSyncTask() throws SailException
      Throws:
      SailException
    • cancelSyncTask

      protected void cancelSyncTask()
    • cancelSyncTimer

      protected void cancelSyncTimer()
    • sync

      public void sync() throws SailException
      Synchronizes the contents of this repository with the data that is stored on disk. Data will only be written when the contents of the repository and data in the file are out of sync.
      Throws:
      SailException
    • getSailStore

      SailStore getSailStore()